User

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 (l₀, l₁, …, l_n) 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 A_n un espace affine euclidien associé à l'espace vectoriel euclidien E_n et O un point quelconque de A_n, alors un repère affine :

R = (O, e₁, e₂, ..., e_n)

est dit orthonormal (ou orthonormé) si sa base associée B = (e₁, e₂, ..., e_n) est elle-même orthonormale.


II-B. Produit scalaire canonique

Dans un espace Rⁿ, espace euclidien de dimension n, on appelle produit scalaire canonique de Rⁿ l'application qui, aux vecteurs y = (y₁, y₂, …, y_n) et z = (z₁, z₂, …, z_n) de Rⁿ 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 Rⁿ, la norme d'un vecteur y = (y₁, y₂, …, y_n) est donnée par :




II-D. Coefficient de corrélation

Les deux séries de valeurs Y(y₁, …, y_n) et Z(z₁, …, z_n) peuvent être considérées comme des vecteurs dans un espace à n dimensions. Remplaçons-les par des vecteurs centrés : Y'(y₁ − m_y, …, y_n − m_y) et Z'(z₁ − m_z, …, z_n − m_z) où m_y et m_z 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 (x₀, y₀), …, (x_n, y_n) (avec les x_i 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 x₀, …, x_n, l'ensemble des polynômes que l'on peut construire avec la famille de polynômes (l₀, l₁, …, l_n) 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 x₀, …, x_n. Pour tout polynôme P appartenant à un espace ℝ_n[X] des polynômes, si on pose y_i = P(x_i), 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 (l₀, l₁, …, l_n) 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 (l₀, l₁, …, l_n) 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 l_j(x) et définis précédemment sont tels que :



Si maintenant on se donne 3 réels distincts x₀, x₁ et x₂, dans l'espace ℝ₂[X] engendré par la famille (l₀, l₁, l₂), 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 ℝ₂[X]. Plus généralement, la famille génératrice (l₀, l₁, …, l_n) 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 R_n 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(y₀, …, y_n) et Z(z₀, …, z_n) peuvent être considérées comme des vecteurs dans un espace à n+1 dimensions. Remplaçons-les par des vecteurs centrés : Y'(y₀ − m_y, …, y_n − m_y) et Z'(z₀ − m_z, …, z_n − m_z).

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 - 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 (l₀, l₁, ..., l_n) 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 + x² définie sur l'intervalle [0, 2] et p2 à la fonction z(x) = 1 + 2x² 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 (l₀, l₁, …, l_n) 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