IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Voir le flux RSS

User

[Actualité] Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée

Noter ce billet
par , 30/10/2024 à 12h14 (4710 Affichages)
I. Introduction

Aprè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é :

Nom : produit_scalaire_canonique.png
Affichages : 4449
Taille : 1,9 Ko

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 :

Nom : norme.png
Affichages : 1946
Taille : 2,9 Ko


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)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 :

Nom : polynome_interpolation_lagrange.png
Affichages : 1964
Taille : 9,3 Ko


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 :

Nom : polynome_interpolation_lagrange2.png
Affichages : 1954
Taille : 2,1 Ko

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 :

Nom : egalites_polynomes.png
Affichages : 1963
Taille : 2,7 Ko

On peut remarquer également que le polynôme nul P = 0 est tel que :

Nom : polynome_nul.png
Affichages : 1971
Taille : 2,3 Ko

Cela implique nécessairement que :

Nom : coefficients_nuls.png
Affichages : 1965
Taille : 1,8 Ko

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 :

Nom : Lj(xi).png
Affichages : 1940
Taille : 1,8 Ko

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 :

Nom : vecteurs_base.png
Affichages : 1941
Taille : 2,7 Ko

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 :

Nom : produit_scalaire.png
Affichages : 1944
Taille : 3,4 Ko


III-D. Norme

Dans un espace de dimension n+1, la norme du polynôme P est donnée par :

Nom : norme2.png
Affichages : 1943
Taille : 3,3 Ko


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 :

Nom : classe_polynome_lagrange.png
Affichages : 1948
Taille : 11,5 Ko


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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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 - Visualiser dans une fenêtre à part
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

Envoyer le billet « Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée » dans le blog Viadeo Envoyer le billet « Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée » dans le blog Twitter Envoyer le billet « Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée » dans le blog Google Envoyer le billet « Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée » dans le blog Facebook Envoyer le billet « Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée » dans le blog Digg Envoyer le billet « Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée » dans le blog Delicious Envoyer le billet « Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée » dans le blog MySpace Envoyer le billet « Les polynômes de Lagrange vus comme les vecteurs d'une base orthonormée » dans le blog Yahoo

Commentaires

  1. Avatar de Zeeraptor
    • |
    • permalink
    les polynômes d'interpolation de Lagrange vus comme des vecteurs
    polynômes de Lagrange vus comme les vecteurs d'une base orthonormée

    Quelle est la différence?
  2. Avatar de User
    • |
    • permalink
    Bonjour,

    Plus simplement, le polynôme d'interpolation (de Lagrange) se construit ainsi :

    L(X) = y0.l0(X) + y1.l1(X) + ... + yn.ln(X)

    Dans le cas général, ce polynôme d'interpolation peut-être vu comme un vecteur de composantes (y0, y1, ..., yn) de l'espace Rn[X].

    Il est construit avec la famille de polynômes de Lagrange (l0, l1, ..., ln) qui forme une base orthonormée de cette espace et ceux-ci peuvent donc être vus comme les vecteurs de cette base orthonormée.

    Cordialement
  3. Avatar de Zeeraptor
    • |
    • permalink
    Citation Envoyé par User
    Bonjour,

    Plus simplement, le polynôme d'interpolation (de Lagrange) se construit ainsi :

    L(X) = y0.l0(X) + y1.l1(X) + ... + yn.ln(X)

    Dans le cas général, ce polynôme d'interpolation peut-être vu comme un vecteur de composantes (y0, y1, ..., yn) de l'espace Rn[X].

    Il est construit avec la famille de polynômes de Lagrange (l0, l1, ..., ln) qui forme une base orthonormée de cette espace et ceux-ci peuvent donc être vus comme les vecteurs de cette base orthonormée.

    Cordialement
    Ce que j'ai vu,c'est qu'un vecteur est forcément orthonormé

    Quelle est la plus intuitive façon de te servir des polynômes...Expliques le d'une façon simplifiée s'il te plaît...Sinon une personne lambda ne peut avoir envie d’être matheux si on ne lui dit pas a quoi cela sert

    En gros,quelles sont les domaines d'utilisation?

    Cordialement
    Mis à jour 09/11/2024 à 22h44 par Zeeraptor
  4. Avatar de User
    • |
    • permalink
    Bonjour,

    En résumé :

    I. Sur le plan des maths et des applications, je montre dans les deux billets comment construire le polynôme d'interpolation à partir d'une série de points (issus par exemple d'une expérience). En gros, on estime les valeurs intermédiaires de celles données par l'expérience, les applications sont donc nombreuses, dans ce lien quelques exemples :

    https://fr.wikipedia.org/wiki/Interp...e#Applications

    Sous l'angle des vecteurs, on met aussi en évidence des propriétés et des opérations communes entre les polynômes d'interpolation et les vecteurs classiques (addition, multiplication par un scalaire, produit scalaire, etc.).

    On fait également indirectement le lien entre une variable statistique (série de mesures statistiques..) et un vecteur défini par ses composantes.

    II. Concernant la partie programmation et implémentation en Python, dans le 1er billet je montre comment créer une classe permettant de représenter des vecteurs définis dans une base, puis comment réaliser des opérations comme l'addition entre deux vecteurs à l'aide de la surcharge d'opérateur.

    Dans le 2nd billet on propose d'ajouter à cette classe des opérations comme le produit scalaire (avec la surcharge d'opérateur) ou le calcul du coefficient de corrélation entre des vecteurs de même base orthonormée.

    Tout ceci accompagné d'exemples de code en Python permettant de créer ces objets vecteurs et de réaliser des opérations entre eux.

    Cordialement
  5. Avatar de Zeeraptor
    • |
    • permalink
    En gros,cette méthode d'interpolation te permet d'approcher la perfection en terme d'interpolation....des courbes très progressives et naturellement belles...Celles qui permettent de conserver un max de vitesse dans la trajectoire

    Il y a asservissement en boucle ouverte
    Mis à jour 14/11/2024 à 23h47 par Zeeraptor