import numpy as np np.set_printoptions(suppress=True) # (pour mieux arrondir à 0 lors des print) import math from numpy.polynomial.polynomial import polyval import matplotlib.pyplot as plt # On active le "mode interactif" de pyplot. Ainsi, les plt.show() ne sont plus nécessaires. plt.ion() # -------------------------------------------------------------------------------------- # Fonction de "fin temporaire" pendant l'avancée du TP. Attend une frappe Entrée, puis quitte le script. def stop_ici(): plt.pause(0.1) # nécessaire pour que matplotlib ait le temps d'afficher les figures input() exit() # -------------------------------------------------------------------------------------- # Tous les passages indiqués "TODO()" sont à remplacer par vos soins def TODO(): print("à vous!") stop_ici() # -------------------------------------------------------------------------------------- # Cette petite fonction sert à tracer les flèches avec une syntaxe un peu plus intuitive que le code matplotlib de base. # - xdepart, ydepart : coordonnées du point d'attache de la flèche # - xfleche, yfleche : longueurs de la flèche en x et en y def myfleche(xdepart, ydepart, xfleche, yfleche): plt.annotate("", (xdepart+xfleche,ydepart+yfleche) , (xdepart,ydepart), arrowprops={'color':'red','shrink': 0,'width':0.02} ) ################################################################################################# ### ### EXERCICE 2 : représenter graphiquement l'approximation affine d'une courbe paramétrée ### ################################################################################################# ################################################################################# # Rappel de la séance du TP2 ################################################################################# # # Une *courbe paramétrée* est un ensemble de points de la forme # Point(t) = (f(t), g(t)) # lorsque la variable t parcourt un certain intervalle donné. # # - La variable "t" s'appelle le **paramètre** de la courbe. # - Chaque valeur de t définit UN point, dont l'abscisse vaut f(t) et l'ordonnée vaut g(t). # - La courbe est obtenue en représentant les points associés à TOUTES les valeurs de t. ################################################################################# print('''Représentez la courbe paramétrée (f(t),g(t)) associée aux fonctions polynômiales f(t) = 1 -4.t + 2.t^2 + 2.t^3 g(t) = 2 +7.t + t^2 - t^3 - t^4 pour le paramètre t dans l'intervalle [-2,2].''') # Discrétisation de l'intervalle [-2,2] sur 200 points : t = np.linspace(-2,2,200) # Calcul de f(t), g(t) aux points correspondants : ft = 1 -4*t + 2*t**2 + 2*t**3 gt = 2 +7*t + t**2 - t**3 - t**4 # Représentation de la courbe paramétrée : plt.figure() plt.plot(ft,gt) # ou # t = np.linspace(-2,2,200) deja defini en haut f=[1,-4,2,2] g=[2,7,1,-1,-1] ftt=polyval(t,f) gtt=polyval(t,g) plt.figure() plt.plot(ftt,gtt) stop_ici() # ---------- Supprimez cette ligne une fois que le code précédent fonctionne ------------------ # -------------------------------------------------------------------------------------- print("-"*80) ################################################################################# # Approximation affine pour une courbe paramétrée ################################################################################# # # L'approximation affine de la courbe paramétrée au point t s'écrit # # f(t+h) ~= f(t) + h.f'(t) [en abscisses] # g(t+h) ~= g(t) + h.g'(t) [en ordonnées] # # On va représenter cette approximation affine par une FLÈCHE. # # - La flèche démarre du point "t" sur le graphe # Point(t) = ( f(t) , g(t) ) # # - La flèche a des longueurs (en abscisses et en ordonnées) de valeurs respectives # fleche = ( h.f'(t) , h.g'(t) ) # # Avec ces notations, l'approximation affine ci-dessus peut se réécrire # Point(t+h) ~= Point(t) + fleche # # c'est-à-dire que "fleche" représente l'évolution (approximative) de la courbe # lorsque le point d'intérêt passe du paramètre "t" à "t+h". # # Graphiquement, "fleche" est tangente à la courbe au point "t", et sa longueur # représente la quantité d'évolution de la courbe du point "t" au point "t+h". ################################################################################# print('''(Question papier) Trouvez l'expression des fonctions dérivées f'(t) et g'(t) de la question précédente.''') stop_ici() # ---------- Supprimez cette ligne une fois que le code précédent fonctionne ------------------ # -------------------------------------------------------------------------------------- print("-"*80) print('''Déduisez-en la valeur des 4 nombres f(1), g(1), f'(1), g'(1), et rentrez-les ci-dessous.''') f1 = TODO() g1 = TODO() fprime1 = TODO() gprime1 = TODO() stop_ici() # ---------- Supprimez cette ligne une fois que le code précédent fonctionne ------------------ # -------------------------------------------------------------------------------------- print("-"*80) print('''Le code ci-dessous trace la flèche associée aux 4 valeurs que vous avez calculées à la question précédente. Déterminez graphiquement si la flèche est bien à l'endroit et dans la direction où elle devrait. Si la flèche n'est pas là où elle devrait, c'est que votre calcul de f(1),g(1),f'(1) ou g'(1) était faux. Dans ce cas, corrigez-le et relancez le code. ''') plt.plot(f1,g1,marker='o',color='blue') # marque le point de paramètre "t" avec un cercle h = 0.5 # écart "h" de l'approximation affine (fixe la proportionnalité gobale de la flèche) myfleche(f1, g1, h*fprime1, h*gprime1) # trace la flèche stop_ici() # ---------- Supprimez cette ligne une fois que le code précédent fonctionne ------------------ # -------------------------------------------------------------------------------------- print("-"*80) print('''Calculez de même les approximations affines pour la courbe aux points t = -2, -1.5, -1, ...., 1.5, 2 et représentez-les par autant de flèches.''') for t in TODO(): TODO() # (plusieurs lignes) print('''Vérification: toutes les flèches rouges sont-elles bien *tangentes* à la courbe ? Si oui, passez à la suite. Si non, qu'avez-vous oublié ? ''')