Polynômes de Lagrange

Objectifs d'apprentissage

À la fin de cette leçon, vous serez en mesure de :

• Construire les polynômes de base de Lagrange
• Appliquer la formule de Lagrange pour l'interpolation linéaire et quadratique
• Calculer un polynôme d'interpolation pour des données tabulées
• Estimer l'erreur d'interpolation à l'aide de la formule d'erreur

Prérequis

• Introduction à l'interpolation et collocation
• Manipulation de produits et de sommes

L'idée de Lagrange

Motivation

Dans la leçon précédente, nous avons vu que construire le polynôme de collocation nécessite de résoudre un système d'équations linéaires. Joseph-Louis Lagrange a proposé une méthode plus élégante : construire directement le polynôme comme une combinaison linéaire de polynômes de base spéciaux.

Principe

On cherche à écrire le polynôme d'interpolation sous la forme :

où les sont des polynômes de base à déterminer.

Cas linéaire (n = 1)

Construction des polynômes de base

Pour deux points et , on cherche :

Les polynômes et doivent satisfaire :

• et
• et

Ainsi, en :

Et en :

Formules explicites

Vérification :

Exemple numérique

Soit les points et .

Le polynôme d'interpolation est :

Cas quadratique (n = 2)

Construction des polynômes de base

Pour trois points , les polynômes de base sont :

Chaque vaut 1 en et 0 aux autres points.

Formule générale de Lagrange

Énoncé

Pour points , le polynôme de Lagrange est :

où les polynômes de base de Lagrange sont :

Lecture de la formule

La notation signifie « le produit pour tous les indices de 0 à , sauf ». Autrement dit, pour construire , on multiplie tous les facteurs en omettant celui où (qui donnerait , indéfini).

Exemple concret : Pour (3 points), le polynôme s'écrit :

On a omis le terme dans le produit.

Exemple complet : interpolation de F(x)

Considérons la table de valeurs suivante :

Interpolation linéaire (2 points)

Utilisons les points et pour estimer .

Donc .

Interpolation quadratique (3 points)

Utilisons les points .

Le polynôme est :

Après simplification :

Donc .

Interpolation cubique (4 points)

En utilisant les 4 points , on obtient après calcul :

Vérification que passe bien par les 4 points :

Donc

Formule d'erreur d'interpolation

Théorème

Soit une fonction fois continûment dérivable sur l'intervalle contenant les points . L'erreur d'interpolation en un point est :

où est un point (inconnu) dans l'intervalle contenant et tous les .

Interprétation

L'erreur dépend de deux facteurs :

1. La dérivée -ième de : Plus est « lisse » (dérivées petites), plus l'erreur est faible. Une fonction très oscillante aura des dérivées d'ordre élevé grandes, donc une erreur potentiellement importante.

2. Le produit : Ce terme s'annule exactement aux points d'interpolation (l'erreur y est nulle par construction) et croît en s'éloignant de ces points.

Remarques sur le comportement de l'erreur

1. Cas d'une fonction polynomiale

Si est elle-même un polynôme de degré , alors pour tout . Dans ce cas, l'erreur est exactement nulle : le polynôme d'interpolation coïncide avec .

2. Danger de l'extrapolation

Lorsqu'on évalue le polynôme en un point extérieur à l'intervalle , le produit devient grand car tous les facteurs ont le même signe :

C'est pourquoi l'extrapolation (estimer en dehors des données) est généralement peu fiable.

3. Erreur nulle aux points de collocation

Par construction, pour tout point de collocation. Cela se retrouve dans la formule : le produit s'annule quand .

Le problème pratique : on ne connaît pas f !

En pratique, si on connaissait la fonction et ses dérivées, on n'aurait pas besoin d'interpoler ! La formule d'erreur semble donc inutilisable. Cependant, cette formule reste précieuse dans plusieurs situations :

Cas 1 : La fonction est connue analytiquement

Parfois, on dispose d'une formule pour , mais son évaluation est coûteuse (intégrale, série, équation différentielle). On construit alors une table de valeurs et on interpole. Dans ce cas, on peut calculer les dérivées et borner l'erreur.

Cas 2 : On connaît une borne sur les dérivées

Même sans connaître exactement, on peut parfois majorer ses dérivées. Par exemple :

• Pour des données physiques « lisses », on suppose que pour une constante raisonnable
• On obtient alors une borne d'erreur :

Cas 3 : Estimation empirique avec Newton-Gregory

La méthode de Newton-Gregory (leçon suivante) offre une alternative pratique : on estime l'erreur par le terme suivant du développement, sans connaître . C'est souvent la méthode privilégiée en pratique.

Exemple : estimation d'erreur pour sin(x)

Données

Considérons la table de avec un pas :

Interpolation quadratique en x = 0.8

Utilisons les 3 premiers points : .

Après calcul, on obtient .

La valeur exacte est .

L'erreur réelle est donc : .

Bornes d'erreur théoriques

Pour , la dérivée troisième est .

Sur l'intervalle : .

Le produit .

L'erreur est bornée par :

Notre erreur réelle (0.0029) est bien inférieure à cette borne.

Algorithme Python

Principe de l'implémentation

L'algorithme traduit directement la formule de Lagrange en code :

1. Fonction lagrange_basis : Calcule un polynôme de base en multipliant tous les facteurs pour .

2. Fonction lagrange_interpolation : Calcule en sommant les contributions de chaque point.

import numpy as np

def lagrange_basis(x_points, i, x):
  """
  Calcule le i-ème polynôme de base de Lagrange π_i(x).

  Implémente la formule :
      π_i(x) = ∏_{j≠i} (x - x_j) / (x_i - x_j)

  Paramètres:
      x_points : tableau des abscisses [x_0, x_1, ..., x_n]
      i : indice du polynôme de base à calculer
      x : point où évaluer π_i

  Retourne:
      π_i(x) : valeur du i-ème polynôme de base en x
  """
  n = len(x_points)
  result = 1.0

  for j in range(n):
      if j != i:  # On exclut j = i du produit
          # Multiplie par le facteur (x - x_j) / (x_i - x_j)
          result *= (x - x_points[j]) / (x_points[i] - x_points[j])

  return result

def lagrange_interpolation(x_points, y_points, x):
  """
  Calcule P_n(x) par la formule de Lagrange.

  Implémente la formule :
      P_n(x) = Σ_{i=0}^{n} f_i · π_i(x)

  Paramètres:
      x_points : abscisses des points d'interpolation [x_0, ..., x_n]
      y_points : ordonnées correspondantes [f_0, ..., f_n]
      x : point où évaluer le polynôme interpolant

  Retourne:
      P_n(x) : valeur interpolée au point x

  Note:
      Les abscisses x_points doivent être distinctes (pas de doublon).
  """
  n = len(x_points)
  result = 0.0

  # Somme sur tous les points de données
  for i in range(n):
      # Ajoute la contribution f_i · π_i(x)
      result += y_points[i] * lagrange_basis(x_points, i, x)

  return result

# === Exemple d'utilisation ===
# Interpolation de sin(x) avec 3 points (interpolation quadratique)

x_data = np.array([0.1, 0.5, 0.9])  # Abscisses connues
y_data = np.array([0.09983, 0.47943, 0.78333])  # sin(x) aux abscisses

x_eval = 0.8  # Point où on veut estimer sin(x)
p_x = lagrange_interpolation(x_data, y_data, x_eval)
exact = np.sin(x_eval)

print(f"P_2({x_eval}) = {p_x:.6f}")
print(f"sin({x_eval}) = {exact:.6f}")
print(f"Erreur = {abs(exact - p_x):.6f}")

Avantages et inconvénients

Résumé

• La formule de Lagrange exprime le polynôme d'interpolation comme combinaison linéaire de polynômes de base
• Chaque polynôme de base vaut 1 en et 0 aux autres points
• La formule d'erreur permet d'estimer la précision de l'interpolation
• L'erreur dépend de la dérivée -ième de et de la distance aux points d'interpolation

Pour aller plus loin

La prochaine leçon présentera la méthode de Newton-Gregory, qui utilise les différences finies pour construire le polynôme d'interpolation de manière incrémentale. Cette approche permet d'ajouter facilement des points sans tout recalculer.