antoine.perederii
2 years ago
parent
6dd90cc088
commit
5eb72589b3
@ -0,0 +1,48 @@
|
||||
-- DROP TABLE IF EXISTS FAIRE, INTERVENTION, REPARATION, TECHNICIEN, CLIENT CASCADE;
|
||||
DROP TABLE FAIRE;
|
||||
DROP TABLE INTERVENTION;
|
||||
DROP TABLE REPARATION;
|
||||
DROP TABLE TECHNICIEN;
|
||||
DROP TABLE CLIENT;
|
||||
|
||||
|
||||
CREATE TABLE CLIENT (
|
||||
noClient numeric PRIMARY KEY,
|
||||
nom varchar(30) NOT NULL,
|
||||
prenom varchar(30) NOT NULL,
|
||||
rue varchar(30) NOT NULL,
|
||||
codePostal char(5) NOT NULL,
|
||||
ville varchar(30) NOT NULL,
|
||||
noTelephone char(10) NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE TECHNICIEN (
|
||||
noEmploye numeric PRIMARY KEY,
|
||||
nom varchar(30) NOT NULL,
|
||||
prenom varchar(30) NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE INTERVENTION (
|
||||
noIntervention numeric PRIMARY KEY,
|
||||
date date NOT NULL,
|
||||
noClient numeric NOT NULL REFERENCES CLIENT(noClient),
|
||||
noEmploye numeric NOT NULL REFERENCES TECHNICIEN(noEmploye)
|
||||
);
|
||||
|
||||
CREATE TABLE REPARATION (
|
||||
codeReparation numeric PRIMARY KEY,
|
||||
designation varchar(30) NOT NULL,
|
||||
prix numeric(6,2) NOT NULL
|
||||
);
|
||||
|
||||
CREATE TABLE FAIRE (
|
||||
noIntervention numeric NOT NULL REFERENCES INTERVENTION(noIntervention),
|
||||
codeReparation numeric NOT NULL REFERENCES REPARATION(codeReparation),
|
||||
PRIMARY KEY (noIntervention, codeReparation)
|
||||
);
|
||||
|
||||
INSERT INTO CLIENT VALUES (1, 'DUPONT', 'Jean', 'Rue des Lilas', '75001', 'Paris', '0123456789');
|
||||
INSERT INTO CLIENT VALUES (2, 'DURAND', 'Marie', 'Rue des Roses', '63002', 'Clermont-Ferrand', '0234567890');
|
||||
INSERT INTO CLIENT VALUES (3, 'DUPOND', 'Pierre', 'Rue des Marguerites', '63003', 'Clermont-Ferrand', '0345678901');
|
||||
|
||||
SELECT * FROM CLIENT WHERE ville='Clermont-Ferrand' ORDER BY noTelephone;
|
||||
@ -0,0 +1,127 @@
|
||||
import numpy as np
|
||||
np.set_printoptions(suppress=True) # (pour mieux arrondir à 0 lors des print)
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
# Fonction de "fin temporaire" pendant l'avancée du TP. Attend une frappe Entrée, puis quitte le script.
|
||||
|
||||
def stop_ici():
|
||||
input()
|
||||
exit()
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
# Tous les passages indiqués "TODO()" sont à remplacer par vos soins
|
||||
|
||||
def TODO():
|
||||
print("à vous!")
|
||||
stop_ici()
|
||||
|
||||
|
||||
#################################################################################################
|
||||
###
|
||||
### EXERCICE 1 : Résolution de systèmes linéaires avec Numpy
|
||||
###
|
||||
#################################################################################################
|
||||
|
||||
|
||||
print("Bonjour et bonne année ! Pour ce TP vous aurez également besoin d'une feuille et d'un stylo.")
|
||||
print("Merci à vous aussi !!! Ah, il va donc falloir que je le sorte de mon sac ?!?!? Vous vous rendez ompte de cet effort productif !!!")
|
||||
|
||||
# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("-"*80)
|
||||
|
||||
print("Veuillez s'il-vous-plaît compléter et signer le texte suivant.")
|
||||
|
||||
declaration = '''
|
||||
Je déclare par la présente disposer d'une feuille et d'un stylo, et décharger mon enseignant de math de toute incompréhension relative à l'absence de l'un ou l'autre de ces deux objets.
|
||||
|
||||
Fait à Aubière le XX/XX [dater] en un exemplaire, et signé par l'étudiant.e
|
||||
XXX [signature]
|
||||
'''
|
||||
|
||||
print(declaration)
|
||||
|
||||
# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("Merci, j'en prends bonne note :)")
|
||||
print("-"*80)
|
||||
|
||||
|
||||
# Numpy permet de résoudre des systèmes linéaires, par exemple en calculant des MATRICES INVERSES.
|
||||
|
||||
A = np.array( [ [1,-4,2] , [3,3,6] , [-2,-1,0] ] )
|
||||
M = np.linalg.inv(A) # nota : "linalg" signifie "algèbre linéaire" (le vrai nom de la théorie des matrices)
|
||||
print("A=\n",A)
|
||||
print("M=\n",M)
|
||||
|
||||
# Vérification :
|
||||
print("A*M=\n",A.dot(M))
|
||||
print("M*A=\n",M.dot(A))
|
||||
|
||||
# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("-"*80)
|
||||
|
||||
|
||||
# Des agriculteurs conditionnent leurs légumes sous la forme de quatre "paniers" destinés à différentes préparations culinaires.
|
||||
# Voici les contenus de chaque panier :
|
||||
|
||||
# Panier : "Pot-au-feu" "Potée" "Boeuf bourguignon" "Chou farci"
|
||||
# Patates (kg) 0 1 2 0
|
||||
# Chou (unités) 0 0.5 0 1
|
||||
# Carottes (kg) 1 1 1 0
|
||||
# Oignons (kg) 0.25 0.25 0.25 0.25
|
||||
|
||||
# Question : Les agriculteurs ont récolté 540 kg de patates, 220 choux, 340 kg de carottes et 130 kg d'oignons. Afin d'écouler toute leur production, combien doivent-ils préparer de panier de chaque type ?
|
||||
|
||||
print('''(Question papier) Montrez que le problème des agriculteurs constitue un système linéaire, de la forme
|
||||
A * v = b
|
||||
où
|
||||
A est la matrice des coefficients
|
||||
b est le vecteur du second membre
|
||||
v est le vecteur des inconnues
|
||||
|
||||
Précisez le contenu de la matrice A et du vecteur b''')
|
||||
|
||||
# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("-"*80)
|
||||
|
||||
# On va à présent résoudre ce système avec Numpy.
|
||||
|
||||
print("Rentrez les paramètres du système linéaire (A et b), sous forme de np.array")
|
||||
A = np.array( [ [0 , 1, 2, 0] , [0, 0.5, 0, 1] , [1, 1, 1, 0] , [0.25, 0.25, 0.25, 0.25]] )
|
||||
b = np.array( [ [540] , [220] , [340] , [130]] )
|
||||
print("A=\n",A)
|
||||
print("b=\n",b.reshape(-1,1))
|
||||
|
||||
# stop_ici() # -------------- Supprimez cette ligne pour passer à la suite ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("-"*80)
|
||||
|
||||
print("Trouvez avec Numpy la solution du système.")
|
||||
|
||||
v = np.linalg.inv(A).dot(b) # .dot() est le produit matriciel
|
||||
print("v=\n",v.reshape(-1,1))
|
||||
|
||||
# Vérification:
|
||||
if not np.allclose (A.dot(v), b):
|
||||
print('Erreur, v n''est la solution du système A*v=b')
|
||||
|
||||
# stop_ici()
|
||||
|
||||
print(f'''Conclusion : les agriculteurs doivent préparer:
|
||||
{v[0]} paniers \"pot-au-feu\"
|
||||
{v[1]} paniers \"potée\"
|
||||
{v[2]} paniers \"boeuf bourguignon\"
|
||||
{v[3]} paniers \"chou farci\"''')
|
||||
|
||||
|
||||
# Voilà pour la mise en jambes !
|
||||
# Pour la suite, retenez bien comment on résout un système linéaire avec Numpy.
|
||||
|
||||
@ -0,0 +1,244 @@
|
||||
|
||||
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()
|
||||
|
||||
@ -0,0 +1,168 @@
|
||||
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()
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
# 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}, annotation_clip=False)
|
||||
|
||||
|
||||
|
||||
#################################################################################################
|
||||
###
|
||||
### EXERCICE 4 : Interpolation d'Hermite en 1D
|
||||
###
|
||||
#################################################################################################
|
||||
|
||||
|
||||
|
||||
# Comme expliqué dans le sujet pdf, le but est de trouver un polynôme qui passe par des points imposés
|
||||
# (==> c'est ça, l'interpolation) mais avec la contrainte additionnelle que le polynôme doit aussi
|
||||
# respecter des **valeurs imposées pour sa dérivée** aux mêmes points.
|
||||
|
||||
|
||||
# Pour le moment, on se donne uniquement 2 points d'interpolation, aux abscisses t=1 et t=2.
|
||||
|
||||
### Cibles (aux points t=1,2)
|
||||
ys = 2,5 # ordonnées
|
||||
ds = 4,-3 # nombres dérivés
|
||||
|
||||
# Affichage du problème à résoudre : 2 points cible, ainsi que leurs *dérivées* cible:
|
||||
|
||||
plt.close('all')
|
||||
plt.figure()
|
||||
plt.title("Le problème d'interpolation à résoudre")
|
||||
plt.xlabel('t')
|
||||
plt.ylabel('P(t)')
|
||||
for i in range(0,2):
|
||||
plt.plot(i+1,ys[i],marker='o',color='blue')
|
||||
h = 0.2 # écart h de l'approximation affine (détermine la longueur de la flèche)
|
||||
myfleche(i+1, ys[i], h, h*ds[i])
|
||||
plt.axis('equal') # (essayer aussi avec cette ligne commentée, parfois le résultat est mieux)
|
||||
|
||||
print('''(Question papier) On cherche un polynôme P(X) de degré 3
|
||||
P(X) = u + v.X + w.X^2 + z.X^3
|
||||
qui INTERPOLE ces 2 points ET les 2 dérivées correspondantes, c'est-à-dire qui vérifie
|
||||
|
||||
P(t)=y et P'(t)=d
|
||||
|
||||
pour chacun des 2 points cible. Soit, ici :
|
||||
P(1) = 2
|
||||
P(2) = 5
|
||||
P'(1) = 4
|
||||
P'(2) = -3
|
||||
Montrez que ces 4 équations constituent un *système linéaire* sur les 4 coefficients inconnus (u,v,w,z).
|
||||
Précisez la matrice de ce système (appelons-la A), et le vecteur du second membre (appelons-le b).
|
||||
''')
|
||||
|
||||
A = TODO()
|
||||
b = TODO()
|
||||
|
||||
stop_ici() # ---------- Supprimez cette ligne une fois que le code avant fonctionne ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("-"*80)
|
||||
|
||||
|
||||
print("Trouvez le polynôme P (c'est-à-dire, les coefficients u,v,w,z) recherchés.")
|
||||
|
||||
p = TODO()
|
||||
|
||||
stop_ici() # ---------- Supprimez cette ligne une fois que le code avant fonctionne ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("-"*80)
|
||||
|
||||
|
||||
print("Dans la même figure que précédemment, représentez le graphe du polynôme P. Vérifiez qu'il INTERPOLE bien les 2 points imposés avec les 2 valeurs de dérivée imposées.")
|
||||
|
||||
# Discrétisation de l'intervalle [1,2] en 200 points, puis représentation de P(t) sur cet intervalle:
|
||||
TODO()
|
||||
|
||||
stop_ici() # ---------- Supprimez cette ligne une fois que le code avant fonctionne ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("-"*80)
|
||||
|
||||
|
||||
print('''Testez votre code avec d'autres valeurs pour les cibles "ys" et "ds" choisies
|
||||
plus haut (mais toujours avec 2 points uniquement, car vous n'avez pas encore
|
||||
implémenté la version générale).
|
||||
Vérifiez que votre interpolation fonctionne bien à chaque fois.
|
||||
|
||||
(Indice si cela ne fonctionne pas : définissez-vous le vecteur b de manière suffisamment générique ?)''')
|
||||
|
||||
stop_ici() # ---------- Supprimez cette ligne une fois que le code avant fonctionne ------------------
|
||||
|
||||
# --------------------------------------------------------------------------------------
|
||||
print("-"*80)
|
||||
|
||||
|
||||
### Une fonction d'interpolation d'Hermite (pour seulement 2 points)
|
||||
####################################################################
|
||||
|
||||
|
||||
print('''Encapsulez votre code des questions précédentes dans une fonction, qui:
|
||||
- prend en entrée une liste d'ordonnées ys=[y1,y2] et une liste de dérivées ts=[t1,t2]
|
||||
- renvoie l'unique polynôme interpolateur de degré 3 tel que
|
||||
P(1) = y1
|
||||
P(2) = y2
|
||||
P'(1) = t1
|
||||
P'(2) = t2
|
||||
''')
|
||||
|
||||
def interpol_hermite(ys,ds):
|
||||
TODO()
|
||||
return p
|
||||
|
||||
# Test de votre fonction:
|
||||
|
||||
### Cibles (aux instants t=1,2)
|
||||
ys = 3,5 # ordonnées
|
||||
ds = -4,-3 # nombres dérivés
|
||||
|
||||
plt.close('all')
|
||||
plt.figure()
|
||||
plt.title("Test de la fonction interpol_hermite")
|
||||
for i in range(0,2):
|
||||
plt.plot(i+1,ys[i],marker='o',color='blue')
|
||||
h = 0.2 # écart h de l'approximation affine (détermine la longueur de la flèche)
|
||||
myfleche(i+1, ys[i], h, h*ds[i])
|
||||
t = np.linspace(1,2,200)
|
||||
p = interpol_hermite(ys,ds)
|
||||
plt.plot(t,polyval(t,p))
|
||||
plt.axis('equal') # (essayer aussi avec cette ligne commentée, parfois le résultat est mieux)
|
||||
plt.xlabel('t')
|
||||
plt.ylabel('P(t)')
|
||||
|
||||
########################################
|
||||
input()
|
||||
|
||||
|
||||
Binary file not shown.
Loading…
Reference in new issue