I. IntroductionAprès les polynômes d'interpolation de Lagrange vus comme des vecteurs, on s'intéresse maintenant aux polynômes de Lagrange vus comme les vecteurs d'une base orthonormée.
On va d'abord montrer que la famille de polynômes de Lagrange (l0, l1, …, ln) forme une base orthonormée d'un espace vectoriel.
Ensuite, on va reprendre notre classe Polynome_lagrange crée précédemment pour y ajouter des méthodes afin notamment d'évaluer le produit scalaire et le coefficient de corrélation portant sur ces vecteurs.
Enfin, on va tester ces nouvelles fonctions dans l'environnement Python.
II. Base orthonormée
D'après Wikipedia, en géométrie vectorielle, une base orthonormale ou base orthonormée d'un espace euclidien ou hermitien est une base de cet espace vectoriel constituée de vecteurs de norme 1 et orthogonaux deux à deux. Dans une telle base, les coordonnées d'un vecteur quelconque de l'espace sont égales aux produits scalaires respectifs de ce vecteur par chacun des vecteurs de base, et le produit scalaire de deux vecteurs quelconques a une expression canonique en fonction de leurs coordonnées.
II-A. Repère orthonormé
Soit An un espace affine euclidien associé à l'espace vectoriel euclidien En et O un point quelconque de An, alors un repère affine :
R = (O, e1, e2, ..., en)
est dit orthonormal (ou orthonormé) si sa base associée B = (e1, e2, ..., en) est elle-même orthonormale.
II-B. Produit scalaire canonique
Dans un espace Rn, espace euclidien de dimension n, on appelle produit scalaire canonique de Rn l'application qui, aux vecteurs y = (y1, y2, …, yn) et z = (z1, z2, …, zn) de Rn associe la quantité :
On sait aussi que si deux vecteurs sont orthogonaux leur produit scalaire est nul.
Le produit scalaire peut être utilisé pour déterminer le travail d'une force lors d'un déplacement : le travail de la force F selon le trajet u est le produit scalaire de ces deux vecteurs. Si maintenant F et u sont orthogonaux, la force F n'est pas "efficace" sur le déplacement u et le produit scalaire correspondant au travail de la force F selon le trajet u est nul.
II-C. Norme
Dans un espace Rn, la norme d'un vecteur y = (y1, y2, …, yn) est donnée par :
II-D. Coefficient de corrélation
Les deux séries de valeurs Y(y1, …, yn) et Z(z1, …, zn) peuvent être considérées comme des vecteurs dans un espace à n dimensions. Remplaçons-les par des vecteurs centrés : Y'(y1 − my, …, yn − my) et Z'(z1 − mz, …, zn − mz) où my et mz représentent respectivement les moyennes des y et des z.
Le produit scalaire entre ces vecteurs est donné par la formule suivante (produit scalaire normé) :
Y'∙Z' = ‖Y'‖∙‖Z'‖∙cos(α) = cov(Y, Z) où cov(Y, Z) représente la covariance de Y et Z.
Le cosinus de l'angle α entre ces vecteurs est alors tel que :
cos(α) = Y'∙Z' / (‖Y'‖∙‖Z'‖) = cov(Y, Z) / (‖Y'‖∙‖Z'‖)
Il s'agit du coefficient de corrélation compris entre -1 et +1 qui donne une indication sur le degré de corrélation linéaire entre deux variables.
Si le coefficient est proche de -1 ou +1 les variables sont très fortement corrélées, s'il est proche de 0 elles sont très peu liées.
Bien sûr, du point de vue géométrique, on ne parle pas de « corrélation linéaire » : le coefficient de corrélation a toujours un sens, quelle que soit sa valeur entre –1 et 1. Il nous renseigne de façon précise, non pas tant sur le degré de dépendance entre les variables, que sur leur distance angulaire dans un espace à n dimensions : si le coefficient vaut -1 ou +1 les deux vecteurs sont colinéaires et s'il est égal à 0 les vecteurs sont orthogonaux.
III. Polynômes d'interpolation de Lagrange
Soit n + 1 points (x0, y0), …, (xn, yn) (avec les xi des réels distincts deux à deux).
Le polynôme d'interpolation de Lagrange de degré au plus n qui passe par ces points est défini par :
III-A. Espace des polynômes
L étant une combinaison linéaire de polynômes de degré n, il est de degré au plus n et appartient donc à l'ensemble ℝn[X].
Étant donné n + 1 réels distincts x0, …, xn, l'ensemble des polynômes que l'on peut construire avec la famille de polynômes (l0, l1, …, ln) constitue un espace vectoriel muni de deux lois :
- une loi de composition interne « + », appelée addition ou somme vectorielle ;
- une loi de composition externe à gauche « • », appelée multiplication par un scalaire.
III-B. Base des polynômes
On se donne à nouveau n + 1 réels distincts x0, …, xn. Pour tout polynôme P appartenant à un espace ℝn[X] des polynômes, si on pose yi = P(xi), P étant le polynôme d'interpolation correspondant aux points, il est égal au polynôme L défini précédemment.
On a alors :
Et donc (l0, l1, …, ln) forme une famille génératrice de ℝn[X] et son cardinal (égal à n + 1) est égal à la dimension de l'espace.
Par exemple, en choisissant P = 1 ou P = X, on obtient :
On peut remarquer également que le polynôme nul P = 0 est tel que :
Cela implique nécessairement que :
On en déduit que cette famille génératrice (l0, l1, …, ln) est également libre, et par conséquent c'est une base de l'espace des polynômes qu'elle engendre.
De plus, les polynômes de Lagrange notés lj(x) et définis précédemment sont tels que :
Si maintenant on se donne 3 réels distincts x0, x1 et x2, dans l'espace ℝ2[X] engendré par la famille (l0, l1, l2), on obtient :
Par conséquent, cette famille forme une base dont les vecteurs de norme 1 sont orthogonaux deux à deux (leur produit scalaire est nul), et elle constitue donc une base orthonormée de ℝ2[X]. Plus généralement, la famille génératrice (l0, l1, …, ln) forme une base orthonormée de ℝn[X].
Si vous souhaitez avoir plus d'information sur le sujet je vous invite à consulter la page Wikipedia Interpolation lagrangienne.
III-C. Produit scalaire
Considérons maintenant le produit scalaire des polynômes P et Q appartenant au même espace Rn de dimension n+1 et défini par :
III-D. Norme
Dans un espace de dimension n+1, la norme du polynôme P est donnée par :
III-E. Coefficient de corrélation
Les deux séries de valeurs Y(y0, …, yn) et Z(z0, …, zn) peuvent être considérées comme des vecteurs dans un espace à n+1 dimensions. Remplaçons-les par des vecteurs centrés : Y'(y0 − my, …, yn − my) et Z'(z0 − mz, …, zn − mz).
Le produit scalaire entre ces vecteurs est donné par la formule suivante (produit scalaire normé) :
Y'∙Z' = ‖Y'‖∙‖Z'‖∙cos(α) = cov(Y, Z)
Il vient donc :
cos(α) = Y'∙Z' / (‖Y'‖∙‖Z'‖) = cov(Y, Z) / (‖Y'‖∙‖Z'‖)
Il s'agit à nouveau du coefficient de corrélation compris entre -1 et +1 qui donne une indication sur le degré de corrélation linéaire entre Y et Z, ou du point de vue géométrique, sur l'écart angulaire entre ces deux vecteurs.
IV. Implémentation en Python
Comme on a pu le montrer dans un précédent billet, ces polynômes d'interpolation peuvent donc être vus comme des vecteurs sur lesquels on peut réaliser les opérations d'addition et de multiplication par un scalaire.
Ils peuvent être définis en Python à l'aide d'une classe permettant ensuite de créer ces objets mathématiques et de réaliser des opérations entre eux. On va d'ailleurs ajouter aux opérations d'addition et de multiplication par un scalaire, des méthodes permettant d'évaluer la norme d'un vecteur, mais aussi le produit scalaire et le coefficient de corrélation entre deux vecteurs :
IV-A. Produit scalaire
Pour réaliser le produit scalaire entre 2 polynômes appartenant au même espace, nous devons ajouter une méthode __matmul__() à notre classe qui va permettre de surcharger l'opérateur « @ » :
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 | import numpy as np class Polynome_lagrange: ... def __matmul__(self, other): # méthode permettant de réaliser le produit scalaire entre les polynômes self et other # (y0, ..., yn)⋅(z0, ..., zn) = y0⋅z0 + ... + yn⋅zn # si other est un objet de la classe Polynome_lagrange if isinstance(other, Polynome_lagrange): # si les 2 vecteurs self et other sont définis dans la même base (l0, l1, ..., ln) if self.x==other.x: # calcul du produit scalaire des vecteurs self.y et other.y ps = self.y @ other.y # renvoie la valeur du produit scalaire return ps else: # sinon print("Les deux vecteurs ne sont pas définis dans la même base !") else: # sinon print("Le produit scalaire doit porter sur deux objets de la classe Polynome_lagrange !") |
Python dispose depuis sa version 3.5 d'un opérateur @ permettant d'évaluer le produit scalaire de deux vecteurs numpy.
Pour tester notre opérateur « @ » portant sur 2 objets de la classe Polynome_lagrange, nous ajoutons ces lignes de code :
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | # création du 1er objet de la classe Polynome_lagrange p1 = Polynome_lagrange(x=[0, 1, 2], y=[1, 2, 1]) # création du 2e objet de la classe Polynome_lagrange p2 = Polynome_lagrange(x=[0, 1, 2], y=[-1, 1, -1]) # affiche les expressions des polynômes p1 et p2 print("p1 =", p1) print("p2 =", p2) print() # affiche l'appartenance de p1 et p2 à leur espace vectoriel : R2[X], Base = [L0, L1, L2], x = [0, 1, 2] print("p1 ∈ " + p1.espace() + ", Base = " + p1.base()) print("p2 ∈ " + p2.espace() + ", Base = " + p2.base()) print() # calcul du produit scalaire de p1 et p2 ps = (p1 @ p2) # affiche la valeur du produit scalaire de p1 et p2 print("p1⋅p2 = {0}".format(ps)) |
Le code affiche :
p1 = 1∙L0(X) + 2∙L1(X) + 1∙L2(X)
p2 = -1∙L0(X) + 1∙L1(X) + -1∙L2(X)
p1 ∈ ℝ2[X], Base = (L0, L1, L2), x = [0, 1, 2]
p2 ∈ ℝ2[X], Base = (L0, L1, L2), x = [0, 1, 2]
p1⋅p2 = 0
IV-B. Norme
Le calcul de la norme d'un polynôme d'interpolation de Lagrange défini dans une base (l0, l1, ..., ln) se fait grâce à cette nouvelle méthode :
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 | import numpy as np class Polynome_lagrange: ... def norme(self): # méthode permettant d'évaluer la norme du vecteur self défini dans la base (l0, l1, ..., ln) # norme((y0, ..., yn)) = (y0*y0 + ... + yn*yn)^0.5 # calcul de la norme du vecteur self.y n = np.linalg.norm(self.y) # renvoie la valeur de la norme du vecteur return n |
La fonction norm du sous-module numpy.linalg permet de calculer la norme d'un vecteur selon la formule définie précédemment.
Pour tester notre méthode portant sur un objet de la classe Polynome_lagrange, nous ajoutons ces lignes de code :
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | # création de l'objet de la classe Polynome_lagrange p = Polynome_lagrange(x=[0, 1, 2], y=[1, 1, 1]) # affiche l'expression du polynôme p print("p =", p) print() # affiche l'appartenance de p à leur espace vectoriel : R2[X], Base = [L0, L1, L2], x = [0, 1, 2] print("p ∈ " + p.espace() + ", Base = " + p.base()) print() # calcul la norme de p n = p.norme() # affiche la valeur de la norme de p print("norme(p) = {0}".format(n)) |
L'exécution du code affiche :
p = 1∙L0(X) + 1∙L1(X) + 1∙L2(X)
p ∈ ℝ2[X], Base = (L0, L1, L2), x = [0, 1, 2]
norme(p) = 1.7320508075688772
IV-C. Coefficient de corrélation
Le calcul du coefficient de corrélation entre deux vecteurs appartenant au même espace vectoriel s'effectue avec cette méthode :
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | import numpy as np class Polynome_lagrange: ... def coef_corr(self, other): # méthode permettant d'évaluer le coefficient de corrélation entre self et other # si other est un objet de la classe Polynome_lagrange if isinstance(other, Polynome_lagrange): # si les 2 vecteurs self et other sont définis dans la même base (l0, l1, ..., ln) if self.x==other.x: # calcul du coefficient de corrélation entre self.y et other.y r = round(np.corrcoef(self.y, other.y)[0, 1], 12) # renvoi du coefficient de corrélation return r else: # sinon print("Les deux vecteurs ne sont pas définis dans la même base !") else: # sinon print("Le coefficient de corrélation doit porter sur deux objets de la classe Polynome_lagrange !") |
La fonction corrcoef du module numpy permet de calculer le coefficient de corrélation de deux vecteurs suivant la formule présentée plus haut. Ce coefficient donne notamment une indication sur l'écart angulaire entre les deux vecteurs.
Testons maintenant notre méthode :
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 | # création du 1er objet de la classe Polynome_lagrange p1 = Polynome_lagrange(x=[0, 1, 2], y=[1, 2, 5]) # création du 2e objet de la classe Polynome_lagrange p2 = Polynome_lagrange(x=[0, 1, 2], y=[1, 3, 9]) # affiche les expressions des polynômes p1 et p2 print("p1 =", p1) print("p2 =", p2) print() # affiche l'appartenance de p1 et p2 à leur espace vectoriel : R2[X], Base = (L0, L1, L2), x = [0, 1, 2] print("p1 ∈ " + p1.espace() + ", Base = " + p1.base()) print("p2 ∈ " + p2.espace() + ", Base = " + p2.base()) print() # calcul du coefficient de corrélation entre p1 et p2 r = p1.coef_corr(p2) # affiche la valeur du coefficient de corrélation print("coef_corr(p1,⋅p2) = {0}".format(r)) |
L'exécution du code affiche :
p1 = 1∙L0(X) + 2∙L1(X) + 5∙L2(X)
p2 = 1∙L0(X) + 3∙L1(X) + 9∙L2(X)
p1 ∈ ℝ2[X], Base = (L0, L1, L2), x = [0, 1, 2]
p2 ∈ ℝ2[X], Base = (L0, L1, L2), x = [0, 1, 2]
coef_corr(p1,⋅p2) = 1.0
Dans ce test le polynôme p1 correspond en fait à la fonction polynomiale y(x) = 1 + x2 définie sur l'intervalle [0, 2] et p2 à la fonction z(x) = 1 + 2x2 définie sur ce même intervalle. Le résultat donne donc un coefficient de corrélation entre Y et Z égal à 1 indiquant que ces deux variables sont linéairement corrélées. En effet, à partir des fonctions polynomiales on peut facilement obtenir la relation linéaire Z = 2Y - 1.
Du point de vue géométrique, ce coefficient égal à 1 indique que les deux vecteurs sont colinéaires.
IV-D. Module
On présente pour finir le module complet pour effectuer les différents tests :
| Code Python : | Sélectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 | import numpy as np class Polynome_lagrange(): def __init__(self, x, y): # méthode constructeur de la classe # si les deux listes ont la même taille if len(x)==len(y): # on définit la liste de valeurs en x permettant d'obtenir la famille de polynômes (l0, l1, ..., ln) représentant une base dans ℝn[X] self.x = x # on définit le tableau de valeurs en y représentant les coordonnées du vecteur (tableau numpy) self.y = np.array(y) else: # sinon print("Les deux listes de valeurs x et y doivent avoir la même dimension !") def __str__(self): # permet d'afficher le polynôme sous la forme y0*L0(X) + ... + yn*Ln(X) Lx = '' # parcours des y for j in range(len(self.y)): Lx += str(self.y[j]) + "∙L" + str(j) + "(X)" + " + " return Lx[:-3] def espace(self): # retourne l'espace vectoriel du polynôme self : R2[X] n = len(self.x)-1 # retourne l'espace vectoriel du polynôme d'interpolation de Lagrange return "ℝ{0}[X]".format(n) def base(self): # retourne la base de polynômes de self : (L0, L1, L2), x = [0, 1, 2] n = len(self.x)-1 base = "" # parcours des indices des polynômes de lagrange Li for i in range(n+1): base += "L" + str(i) + ", " # création de la famille : (L0, L1, L2) base = "(" + base[:-2] + ")" # retourne la base du polynôme d'interpolation de Lagrange return "{0}, x = {1}".format(base, self.x) def __add__(self, other): # méthode permettant de redéfinir l'opérateur « + » pour 2 polynômes d'interpolation de Lagrange ou 2 vecteurs : # (y0, ..., yn) + (z0, ..., zn) = (y0 + z0, ..., yn + zn) # si other est un objet de la classe Polynome_lagrange if isinstance(other, Polynome_lagrange): # si les 2 vecteurs self et other sont définis dans la même base (l0, l1, ..., ln) if self.x==other.x: # addition des 2 vecteurs self.y et other.y (2 tableaux numpy) y = self.y + other.y # renvoie le polynômes résultat de l'addition des 2 polynômes self et other return Polynome_lagrange(self.x, y) else: # sinon print("Les deux vecteurs ne sont pas définis dans la même base !") else: # sinon print("Le produit scalaire doit porter sur deux objets de la classe Polynome_lagrange !") def __mul__(self, s): # méthode permettant de multiplier other par un scalaire s. # s*(y0, ..., yn) = (s*y0, ..., s*yn) # multiplication du vecteur self.y par le scalaire s y = s*self.y # renvoie le polynôme d'interpolation de Lagrange résultat de la multiplication de self par le scalaire s return Polynome_lagrange(self.x, y) def __matmul__(self, other): # méthode permettant de réaliser le produit scalaire entre les polynômes self et other # (y0, ..., yn)⋅(z0, ..., zn) = y0⋅z0 + ... + yn⋅zn # si other est un objet de la classe Polynome_lagrange if isinstance(other, Polynome_lagrange): # si les 2 vecteurs self et other sont définis dans la même base (l0, l1, ..., ln) if self.x==other.x: # calcul du produit scalaire des vecteurs self.y et other.y ps = self.y @ other.y # renvoie la valeur du produit scalaire return ps else: # sinon print("Les deux vecteurs ne sont pas définis dans la même base !") else: # sinon print("Le produit scalaire doit porter sur deux objets de la classe Polynome_lagrange !") def norme(self): # méthode permettant d'évaluer la norme du vecteur self défini dans la base (l0, l1, ..., ln) # norme((y0, ..., yn)) = (y0*y0 + ... + yn*yn)^0.5 # calcul de la norme du vecteur self.y n = np.linalg.norm(self.y) # renvoie la valeur de la norme du vecteur return n def coef_corr(self, other): # méthode permettant d'évaluer le coefficient de corrélation entre self et other # si other est un objet de la classe Polynome_lagrange if isinstance(other, Polynome_lagrange): # si les 2 vecteurs self et other sont définis dans la même base (l0, l1, ..., ln) if self.x==other.x: # calcul du coefficient de corrélation entre self.y et other.y r = round(np.corrcoef(self.y, other.y)[0, 1], 12) # renvoi du coefficient de corrélation return r else: # sinon print("Les deux vecteurs ne sont pas définis dans la même base !") else: # sinon print("Le coefficient de corrélation doit porter sur deux objets de la classe Polynome_lagrange !") def __eq__(self, other): # méthode permettant de redéfinir l'opérateur « == » pour 2 polynômes d'interpolation de Lagrange # renvoie True si les bases et les listes de coordonnées des vecteurs sont identiques return (self.x==other.x) and np.array_equal(self.y,other.y) def __call__(self, X): # permet d'évaluer le polynôme d'interpolation de Lagrange en fonction de X et des valeurs de x et y # initialisation de la variable Lx Lx = 0 # parcours des y for j in range(len(self.y)): lj = 1 # parcours des x for i in range(len(self.x)): if i!=j: lj *= (X - self.x[i])/(self.x[j] - self.x[i]) # ajour de la valeur de lj*y[j] à Lx Lx +=self.y[j]*lj # renvoie la valeur de Lx return Lx # fonction lambda permettant de changer le type d'appel pour évaluer le coefficient de corrélation # r = p1.coef_corr(p2) -> r = coef_corr(p1, p2) coef_corr = lambda p1,p2 : p1.coef_corr(p2) print("IV-A. Évaluation du produit scalaire de deux polynômes\n") # création du 1er objet de la classe Polynome_lagrange p1 = Polynome_lagrange(x=[0, 1, 2], y=[1, 2, 1]) # création du 2e objet de la classe Polynome_lagrange p2 = Polynome_lagrange(x=[0, 1, 2], y=[-1, 1, -1]) # affiche les expressions des polynômes p1 et p2 print("p1 =", p1) print("p2 =", p2) print() # affiche l'appartenance de p1 et p2 à leur espace vectoriel : R2[X], Base = (L0, L1, L2), x = [0, 1, 2] print("p1 ∈ " + p1.espace() + ", Base = " + p1.base()) print("p2 ∈ " + p2.espace() + ", Base = " + p2.base()) print() # calcul du produit scalaire de p1 et p2 ps = (p1 @ p2) # affiche la valeur du produit scalaire de p1 et p2 print("p1⋅p2 = {0}".format(ps)) print();print() print("IV-B. Évaluation de la norme d'un polynôme\n") # création de l'objet de la classe Polynome_lagrange p = Polynome_lagrange(x=[0, 1, 2], y=[1, 1, 1]) # affiche l'expression du polynôme p print("p =", p) print() # affiche l'appartenance de p à leur espace vectoriel : R2[X], Base = (L0, L1, L2), x = [0, 1, 2] print("p ∈ " + p.espace() + ", Base = " + p.base()) print() # calcul la norme de p n = p.norme() # affiche la valeur de la norme de p print("norme(p) = {0}".format(n)) print();print() print("IV-C. Évaluation du coefficient de corrélation entre deux vecteurs\n") # création du 1er objet de la classe Polynome_lagrange p1 = Polynome_lagrange(x=[0, 1, 2], y=[1, 2, 5]) # création du 2e objet de la classe Polynome_lagrange p2 = Polynome_lagrange(x=[0, 1, 2], y=[1, 3, 9]) # affiche les expressions des polynômes p1 et p2 print("p1 =", p1) print("p2 =", p2) print() # affiche l'appartenance de p1 et p2 à leur espace vectoriel : R2[X], Base = (L0, L1, L2), x = [0, 1, 2] print("p1 ∈ " + p1.espace() + ", Base = " + p1.base()) print("p2 ∈ " + p2.espace() + ", Base = " + p2.base()) print() # calcul du coefficient de corrélation entre p1 et p2 #r = p1.coef_corr(p2) r = coef_corr(p1, p2) # affiche la valeur du coefficient de corrélation print("coef_corr(p1,⋅p2) = {0}".format(r)) |
V. Conclusion
Après avoir montré que la famille des polynômes de Lagrange (l0, l1, …, ln) constitue une base orthonormée de l'espace des polynômes ℝn[X], on a pu expliquer comment évaluer le produit scalaire et le coefficient de corrélation entre ces vecteurs.
Ensuite, on a pu également ajouter ces nouvelles opérations à notre classe Polynome_Lagrange pour enfin les tester dans l'environnement Python.
Sources :
https://fr.wikipedia.org/wiki/Base_orthonorm%C3%A9e
https://fr.wikipedia.org/wiki/Base_canonique
https://fr.wikipedia.org/wiki/Produit_scalaire
https://fr.wikipedia.org/wiki/Produi...aire_canonique
https://fr.wikipedia.org/wiki/Corr%C...(statistiques)
https://fr.wikipedia.org/wiki/Covariance
https://fr.wikipedia.org/wiki/Interp...n_lagrangienne
https://docs.python.org/fr/3/library/operator.html