Interpolation de Lagrange (Python)
Objectif du code : Estimer la valeur d’une fonction inconnue en un point donné (X), à partir de
plusieurs points connus ((x_i, y_i)). C’est une méthode d’interpolation polynomiale qui construit
un polynôme passant par tous les points.
📐 Principe mathématique :
On construit un polynôme de Lagrange (L(X)) qui passe exactement par les points donnés. Ce
polynôme est une combinaison linéaire des valeurs (y_i) pondérées par des fonctions de base
(_i(X)) appelées polynômes de Lagrange.
𝑛−1
𝑋 − 𝑥𝑗
𝐿(𝑋) = ∑ 𝑦𝑖 ⋅ ℓ𝑖 (𝑋) où ℓ𝑖 (𝑋) = ∏
𝑥𝑖 − 𝑥𝑗
𝑖=0 𝑗≠𝑖
Chaque (_i(X)) vaut 1 en (x_i) et 0 en tous les autres (x_j).
🧠 Explication du code ligne par ligne :
def lagrange_intr(x, y, X):
Déclaration de la fonction lagrange_intr. Elle prend en entrée :
• x : liste des abscisses (x_0, x_1, …, x_{n-1}) (valeurs connues)
• y : liste des ordonnées (y_0, y_1, …, y_{n-1}) (valeurs connues)
• X : point où on veut estimer la valeur de la fonction (f(X))
n = len(x)
n est le nombre total de points donnés (longueur de la liste x).
L = 0
Initialisation de la somme L. Cette variable contiendra le résultat final de l’interpolation,
c’est-à-dire l’estimation de (f(X)).
for i in range(n):
Boucle principale sur tous les indices i, allant de 0 à n-1. Pour chaque i, on va calculer le
polynôme (_i(X)) et multiplier par (y_i).
Lg = 1
Initialisation de la variable Lg, qui contiendra le produit (_i(X)) pour l’indice courant i.
for j in range(n):
Deuxième boucle, imbriquée dans la première. Elle va parcourir tous les indices j pour
calculer le produit défini dans (_i(X)).
if j != i:
On évite le cas j == i car on ne doit pas diviser par zéro (et le terme () n’existe pas pour (j =
i)).
Lg *= (X - x[j]) / (x[i] - x[j])
Mise à jour de Lg en multipliant avec le terme (). Ce produit construit (_i(X)).
L += y[i] * Lg
On ajoute à L le terme (y_i _i(X)). On répète cette opération pour chaque i, donc à la fin L
contient la somme (y_i _i(X)).
return L
La fonction retourne L, c’est-à-dire la valeur estimée de (f(X)) par interpolation.
🧪 Exemple complet utilisé dans le code :
x = [0, 1, 2]
y = [0, 2, 4]
X = 1.5
print(lagrange_intr(x, y, X)) # Affiche 3.0
Cela signifie :
• On connaît que (f(0) = 0), (f(1) = 2), (f(2) = 4)
• On cherche une estimation de (f(1.5))
• Le résultat est 3.0, donc le point (1.5, 3.0) appartient au polynôme interpolé.
✅ Avantages :
• Pas besoin de connaître l’expression exacte de la fonction.
• Fournit une estimation précise si la fonction est bien représentée par un polynôme.
⚠️ Inconvénients :
• Instable pour un grand nombre de points (phénomène de Runge).
• Si on change un seul point, il faut tout recalculer.
📌 Applications pratiques :
• Interpolation de données expérimentales
• Estimation de valeurs manquantes
• Graphiques et animations (approximation de trajectoires)