You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
245 lines
8.2 KiB
245 lines
8.2 KiB
|
|
import numpy as np
|
|
np.set_printoptions(suppress=True) # (pour mieux arrondir à 0 lors des print)
|
|
from numpy.polynomial.polynomial import polyval
|
|
|
|
import math
|
|
|
|
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()
|
|
|
|
|
|
#################################################################################################
|
|
###
|
|
### EXERCICE 3 : Interpolation polynômiale en 2D
|
|
###
|
|
#################################################################################################
|
|
|
|
|
|
### Mise en jambes : afficher une courbe paramétrée polynomiale
|
|
###############################################################
|
|
|
|
# Rappel de la séance du TP2 :
|
|
#
|
|
# Une *courbe paramétrée polynômiale* est une courbe paramétrée
|
|
# (P(t), Q(t))
|
|
# dont les 2 fonctions de coordonnées sont polynômiales.
|
|
#
|
|
# - La variable "t" s'appelle le **paramètre** de la courbe.
|
|
# - Chaque valeur de t définit UN point, dont l'abscisse vaut P(t) et l'ordonnée vaut Q(t).
|
|
# - La courbe est obtenue en représentant les points associés à TOUTES les valeurs de t.
|
|
|
|
|
|
# Cas particulier : Lorsque P et Q sont des polynômes de degré <=2, la courbe résultante est une parabole:
|
|
p = [1,1,1]
|
|
q = [-3,2,4]
|
|
t = np.linspace(-5,5,200)
|
|
Pt = polyval(t,p)
|
|
Qt = polyval(t,q)
|
|
plt.figure()
|
|
plt.plot(Pt,Qt)
|
|
|
|
stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
print("-"*80)
|
|
|
|
|
|
# Lorsque le degré est >=3, par contre, la courbe peut ressembler un peu à n'importe quoi :
|
|
|
|
print('''Représentez la courbe paramétrée polynômiale
|
|
(P(t),Q(t))
|
|
associée aux polynômes
|
|
P(X) = 1 -4X + 2X^2 + X^3
|
|
Q(X) = 2 +7X + 2X^2 - X^4
|
|
pour le paramètre t dans l'intervalle [-2,2].''')
|
|
|
|
TODO()
|
|
|
|
stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
print("-"*80)
|
|
|
|
|
|
print('''Représentez la courbe paramétrée polynômiale
|
|
(P(t),Q(t))
|
|
associée aux polynômes
|
|
P(X) = 7 - 3X + X^3
|
|
Q(X) = 12X -9X^2 + 2X^3
|
|
pour le paramètre t dans l'intervalle [-1,3].''')
|
|
|
|
TODO()
|
|
|
|
# Nota : Remarquez que cette courbe présente une particularité : un POINT DE REBROUSSEMENT.
|
|
# Cette situation survient lorsque les dérivées des 2 fonctions de coordonnées s'annulent *en même temps* : P'(t)=0 et Q'(t)=0.
|
|
|
|
stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
print("-"*80)
|
|
|
|
|
|
### Interpolation polynômiale en 2D
|
|
###################################
|
|
|
|
# On se donne un certain nombre de points cibles **en 2D**.
|
|
# Pour être plus lisible, on donne maintenant ces points comme des COUPLES successifs de la forme (x,y)
|
|
|
|
cibles = (1,3), (4,-1), (0,2)
|
|
N = len(cibles) # (ici, N=3, mais votre code doit être robuste si cette valeur change)
|
|
|
|
print('''Fabriquez
|
|
-une liste "x" contenant les ABSCISSES de tous les points cible,
|
|
-une liste "y" contenant les ORDONNÉES de tous les points cible.''')
|
|
|
|
# (suggestion, utilisez la syntaxe "spéciale python" x = [ ..... for c in cibles ] )
|
|
|
|
x = TODO()
|
|
y = TODO()
|
|
print("x=\n",x,"\ny=\n",y)
|
|
|
|
# On peut maintenant afficher les points cibles:
|
|
plt.figure()
|
|
plt.plot(x,y,linestyle='none',marker='o')
|
|
|
|
stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
print("-"*80)
|
|
|
|
|
|
# L'INTERPOLATION POLYNÔMIALE EN 2D consiste à fabriquer une courbe polynômiale
|
|
# (P(t),Q(t))
|
|
# qui **passe par tous les points cibles**, à certaines valeurs imposées du paramètre t.
|
|
# Dans notre cas, on décide que les valeurs imposées du paramètre sont
|
|
# t=1, t=2, ..., t=N
|
|
# C'est-à-dire que nos polynômes P et Q doivent vérifier
|
|
# t=1 -> point cible (x1,y1) -> P(1)=x1 et Q(1)=y1
|
|
# t=2 -> point cible (x2,y2) -> P(2)=x2 et Q(2)=y2
|
|
# ...
|
|
# t=N -> point cible (xN,yN) -> P(N)=xN et Q(N)=yN
|
|
|
|
print('''Trouvez
|
|
- l'unique polynôme P de degré N-1 qui interpole les N abscisses x, aux temps t=1,2,...,N.
|
|
- l'unique polynôme Q de degré N-1 qui interpole les N ordonnées y, aux temps t=1,2,...,N.
|
|
''')
|
|
|
|
# Indice : utilisez la fonction interpol définie à l'exercice 2
|
|
|
|
TODO()
|
|
p = TODO()
|
|
q = TODO()
|
|
|
|
stop_ici() # -------------- Supprimez cette ligne pour passer à la suite ------------------
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
print("-"*80)
|
|
|
|
|
|
print('''Dans la même figure que précédemment, tracez la courbe paramétrée
|
|
(P(t),Q(t))
|
|
lorsque le paramètre t varie sur l'intervalle [1,N].
|
|
Vérifiez que vous interpolez correctement les 3 points cibles.
|
|
''')
|
|
|
|
# Remarque : ici, N=3 points cibles s'interpolent par des polynômes P et Q de degré 2.
|
|
# La courbe résultante est donc une parabole.
|
|
|
|
TODO()
|
|
|
|
stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
print("-"*80)
|
|
|
|
|
|
print('''Encapsulez votre code des questions précédentes dans une fonction, qui:
|
|
- prend N points en entrée (sous la forme d'une liste "cibles" contenant les N couples (xi,yi) à interpoler)
|
|
- calcule l'unique courbe polynômiale interpolatrice de degré N-1 telle que
|
|
P(1)=x1, Q(1)=y1
|
|
...
|
|
P(N)=xN, Q(N)=yN
|
|
- TRACE la courbe résultante, pour le pramètre t dans l'intervalle [1,N].
|
|
''')
|
|
|
|
# Remarque: votre fonction doit uniquement tracer la courbe résultante, pas marquer les points à interpoler (car en général on ne veut pas les voir).
|
|
|
|
def trace_interpol(cibles):
|
|
N = TODO()
|
|
TODO() # (plusieurs lignes)
|
|
plt.plot(TODO())
|
|
|
|
|
|
### Test de votre fonction :
|
|
|
|
# N points à interpoler (aux temps t=1,2,...,N)
|
|
cibles = (1,3),(4,-1),(0,2),(-1,-3),(0,0)
|
|
|
|
plt.figure()
|
|
# Représentation graphique des points...
|
|
plt.plot([c[0] for c in cibles],[c[1] for c in cibles],linestyle='None',marker='o')
|
|
# ...et de leur interpolation polynômiale :
|
|
trace_interpol(cibles) # (la fonction que vous venez d'écrire)
|
|
|
|
stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
print("-"*80)
|
|
|
|
print('''Modifiez votre fonction "trace_interpol" précédente avec l'astuce suivante:
|
|
|
|
def trace_interpol(cibles,**kwargs)
|
|
......
|
|
......
|
|
plt.plot(....,**kwargs)
|
|
|
|
Cette astuce permet de passer à la fonction "trace interpol" n'importe quel argument clé/valeur (du genre linestyle='truc') et de le transmettre à la fonction plt.plot. Ainsi, vous pourrez par exemple appeler
|
|
|
|
trace_interpol(cibles, color='red', linestyle='dashed')
|
|
''')
|
|
|
|
|
|
### Test de votre fonction modifiée (sur les mêmes cibles que précédemment) :
|
|
|
|
plt.figure()
|
|
plt.plot([c[0] for c in cibles],[c[1] for c in cibles],linestyle='None',marker='o')
|
|
# Interpolation polynômiale avec le style modifiable :
|
|
trace_interpol(cibles, color='red',linestyle='dashed')
|
|
|
|
stop_ici() # -------------- Supprimez cette ligne pour passer à la suite --------------
|
|
|
|
# --------------------------------------------------------------------------------------
|
|
print("-"*80)
|
|
|
|
|
|
print('''Et voilà, la partie 1 est presque finie !
|
|
|
|
Votre fonction "trace_interpol" vous offre maintenant un moyen concret de tracer des courbes en 2D, en les "contrôlant" à l'aide de quelques points de passage dont vous spécifiez les coordonnées.
|
|
|
|
Pour terminer le TP, utilisez votre fonction "trace_interpol" et essayez de reproduire l'une des figures données dans le sujet pdf. (À moins que vous préfériez inventer votre propre dessin!)''')
|
|
|
|
plt.close('all')
|
|
|
|
TODO()
|
|
|
|
stop_ici()
|
|
|