2D_09_ex.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapitre 9 : Description du mouvement                                           \n",
    "## Activité 4 : Feux d'artifice\n",
    "Correction"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Le programme suivant permet de représenter les positions successives d'une fusée \"High Bombe\" tirée avec un angle de tir de 83° du tir jusqu'à l'explosion de la bombe 4 secondes après le tir sachant que les coordonnées $x(t)$ et $y(t)$ (exprimées en mètre) de chaque position s'écrivent en fonction du temps $t$ en seconde :\n",
    "\n",
    ">$x(t) = 4{,}63 \\times t$  \n",
    ">$y(t) = -4{,}9 \\times t^{2} + 37{,}7 \\times t$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Objectifs**\n",
    "\n",
    "Les objectifs de l'activité sont les suivants :\n",
    "- choisir le nombre de positions successives à représenter et l'intervalle de temps ∆t les séparant (**question a**);\n",
    "- découvrir les instructions permettant d'afficher la représentation graphique des positions successives de la fusée (**question b**);\n",
    "- manipuler les différents objets (listes et tableaux de nombres) utilisés pour la représentation graphique (**questions b, c et d**)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Préliminaires**\n",
    "\n",
    "En langage de programmation python, lorsque le module d'instructions graphiques ```pyplot``` de la bibliotèque ```matplotlib``` est importé en ```plt``` , la représentation graphique d'une courbe en 2D, se fait grâce à l'instruction :\n",
    ">```plt.plot(x,y,paramètres)```\n",
    "\n",
    "où ```x``` et ```y``` sont des objets contenant les abscisses et les ordonnées des points à représenter et où ```paramètres``` précise l'aspect des points et/ou de la courbe.\n",
    "\n",
    "Selon que les objets ```x``` et ```y``` sont des listes (type \"list\") ou des tableaux (type \"array\" de la bibliothèque ```numpy```) de nombres, la syntaxe pour les générer diffère.  \n",
    "Ces syntaxes sont étudiées séparément dans les questions b, c et d."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Chaque cellule doit être exécutée après avoir été éventuellement complétée selon les consignes à l'aide de la fiche méthode accessible en fin de manuel.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!/usr/bin/python\n",
    "# -*- coding: utf-8 -*-\n",
    "\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Question a**\n",
    "\n",
    "Demander d'entrer le nombre de positions à représenter et l'affecter à la variable ```n```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input('Nombre de positions à représenter n= '))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Entrer la formule permettant de calculer ```deltat``` (en s) entre 2 positions successives.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deltat=4/(n-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valider la formule précédente à l'aide d'un calcul en fonction de ```n``` et de ```deltat``` pour vérifier que la durée du mouvement est de 4s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(n-1)*deltat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Question b : Syntaxe utilisant des listes de nombres générées avec la boucle ```for``` et l'instruction ```list.append()```**\n",
    "\n",
    "**1.**   Création des listes ```t```, ```x``` et ```y``` à l'aide de la boucle ```for``` et de l'instruction ```list.append()```.\n",
    "\n",
    "*Remarques* :  \n",
    "```range(n)``` est la liste des n premiers entiers de 0 à n-1 inclus.  \n",
    "```list.append(nombre)``` insère  *nombre* en dernière position de la liste nommée *list*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = []                          # Initialise une liste t vide pour le domaine des dates\n",
    "for i in range(n):              # pour chaque position i...\n",
    "    t.append(i*deltat)          # ... calculer la date (en s) et l'insérer en fin de liste \n",
    "    \n",
    "    \n",
    "x,y = [],[]                     # Initialiser 2 listes x et y vides, une pour les abscissses, une pour les ordonnées\n",
    "\n",
    "for ti in t:                    # pour chaque date ti de la liste t...\n",
    "    x.append(4.63*ti)           # ... calculer l'abscisse (en m) et l'insérer en fin de liste\n",
    "    y.append(-4.9*ti**2+37.7*ti)# ... calculer l'ordonnée (en m) et l'insérer en fin de liste"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valider les intructions précédentes en affichant les listes ```t```, ```x``` et ```y```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t,x,y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.** Affichage des positions successives de la fusée dans la fenêtre graphique à partir des listes ```x``` et ```y```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('Trajectoire y=f(x)') # Titre du graphe\n",
    "plt.xlabel('x(en m)')           # Nom de l'axe des abscisses\n",
    "plt.ylabel('y(en m)')           # Nom de l'axe des ordonnées\n",
    "plt.grid()                      # Ajout d'une grille de fond\n",
    "plt.axis('equal')               # Repère orthonormé\n",
    "plt.plot(x,y,'ro',ms=2)         # Nuage des points d'abscisses dans x et d'ordonnées dans y rouge 'r', forme'o', taille 2\n",
    "plt.show()                      # Affiche la figure "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Question c : Syntaxe utilisant des listes en compréhension**\n",
    "\n",
    "**1.**   Création de la liste ```t_1```, en \"compréhension\" puis création des listes ```x_1``` et ```y_1```  \"en compréhension\" à partir de la liste ```t_1```.\n",
    "\n",
    "*Remarques* :  \n",
    "Créer une liste \"en compréhension\" est un moyen rapide de générer une liste.  \n",
    "Il s'agit de définir la liste sur une seule ligne de code, entre crochets, en utilisant la boucle ```for```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_1 = [i*deltat for i in range(n)]        # Créer la liste des dates des positions (en s)\n",
    "\n",
    "x_1 = [4.63*ti for ti in t_1]             # Créer la liste des abscissses des positions (en m)\n",
    "y_1 = [-4.9*ti**2+37.7*ti for ti in t_1]  # Créer la liste des ordonnées des positions (en m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valider les intructions précédentes en affichant les listes ```t_1```, ```x_1``` et ```y_1```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_1,x_1,y_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.** Affichage des positions successives de la fusée dans la fenêtre graphique à partir des listes ```x_1``` et ```y_1```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('Trajectoire y=f(x)') # Titre du graphe\n",
    "plt.xlabel('x(en m)')           # Nom de l'axe des abscisses\n",
    "plt.ylabel('y(en m)')           # Nom de l'axe des ordonnées\n",
    "plt.grid()                      # Ajout d'une grille de fond\n",
    "plt.axis('equal')               # Repère orthonormé\n",
    "plt.plot(x_1,y_1,'ro',ms=2)     # Nuage des points d'abscisses dans x_1 et d'ordonnées dans y_1 rouge 'r', forme'o', taille 2\n",
    "plt.show()                      # Affiche la figure "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Question d : Syntaxe utilisant des tableaux de nombres**\n",
    "\n",
    "**1.**   Création du tableau de nombres ```t_2``` à l'aide de l'instruction ```np.linspace()``` puis création des tableaux ```x_2``` et ```y_2``` à partir du tableau ```t_2```.\n",
    "\n",
    "*Remarques* :  \n",
    "```np.linspace(a,b,n)``` est le tableau de nombres comportant ```n``` valeurs régulièrement espacées de ```a``` inclus à ```b``` inclus.     \n",
    "Une opération mathématique appliquée à un tableau de nombres renvoie le tableau des résultats de l'opération appliquée à chaque élément du tableau."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_2 = np.linspace(0,4,n)            # Créer le tableau t_2 des dates des positions (en s)\n",
    "\n",
    "x_2 = 4.63*t_2                      # Créer le tableau x_2 des abscisses des positions (en m)\n",
    "y_2 = -4.9*t_2**2+37.7*t_2          # Créer le tableau y_2 des ordonnées des positions (en m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valider les intructions précédentes en affichant les tableaux ```t_2```, ```x_2``` et ```y_2```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t_2,x_2,y_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.** Affichage des positions successives de la fusée dans la fenêtre graphique à partir des tableaux ```x_2``` et ```y_2```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.title('Trajectoire y=f(x)') # Titre du graphe\n",
    "plt.xlabel('x(en m)')           # Nom de l'axe des abscisses\n",
    "plt.ylabel('y(en m)')           # Nom de l'axe des ordonnées\n",
    "plt.grid()                      # Ajout d'une grille de fond\n",
    "plt.axis('equal')               # Repère orthonormé\n",
    "plt.plot(x_2,y_2,'ro',ms=2)     # Nuage des points d'abscisses dans x_2 et d'ordonnées dans y_2 rouge 'r', forme'o', taille 2\n",
    "plt.show()                      # Affiche la figure "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Format de la Cellule Texte Brut",
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}