Méthode de Newton-Gregory (différences descendantes)

Objectifs d'apprentissage

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

• Calculer les différences finies descendantes
• Construire une table de différences
• Appliquer la formule de Newton-Gregory pour l'interpolation
• Estimer l'erreur d'interpolation à partir des différences
• Passer efficacement d'un polynôme de degré à

Prérequis

• Polynômes de Lagrange
• Notion de pas constant (intervalles équidistants)

Motivation

Limitations de la méthode de Lagrange

La formule de Lagrange présente un inconvénient majeur : si on ajoute un nouveau point de données, il faut tout recalculer depuis le début. La méthode de Newton-Gregory résout ce problème en construisant le polynôme de manière incrémentale.

Avantages de Newton-Gregory

• Passage facile du degré au degré
• Structure récursive permettant d'estimer l'erreur
• Particulièrement adaptée aux données à pas constant

Différences finies descendantes

Définition

Pour une fonction tabulée aux points équidistants avec un pas , les différences descendantes sont définies récursivement :

Différence d'ordre 0 (valeur de la fonction) :

Différence d'ordre 1 :

Différence d'ordre 2 :

Différence d'ordre n :

Construction de la table de différences

Exemple : table de sin(x)

Considérons avec et :

Calcul des différences

Différences d'ordre 1 :

Différences d'ordre 2 :

Et ainsi de suite pour les ordres supérieurs.

Formule de Newton-Gregory descendante

Variable réduite

Pour simplifier l'écriture, on introduit la variable réduite :

Cette variable mesure « combien de pas » on s'est déplacé depuis :

• Si , on est en
• Si , on est en
• Si , on est à mi-chemin entre et

Coefficient binomial généralisé

La notation binomiale généralisée étend la formule classique aux valeurs non entières :

C'est un produit de facteurs consécutifs au numérateur, divisé par .

Exemples de calcul :

• (par convention)

La formule

Le polynôme d'interpolation de Newton-Gregory est :

Ou de manière compacte :

Lecture : Le polynôme est une somme pondérée des différences , où les poids sont les coefficients binomiaux évalués en .

Exemple : calcul de sin(0.8)

Données

Utilisons la table de sin(x) avec , .

Pour :

Polynôme de degré 2

Avec les valeurs :

Polynôme de degré 3

Pour améliorer la précision, ajoutons le terme de degré 3 :

Comparaison

Le passage au degré 3 a réduit l'erreur d'un facteur 10.

Estimation de l'erreur

Sans connaître la fonction exacte

Un avantage majeur de Newton-Gregory est qu'on peut estimer l'erreur sans connaître la fonction .

L'erreur du polynôme de degré est approximativement :

C'est simplement le terme suivant dans le développement !

Exemple

Pour , l'erreur estimée est :

L'erreur réelle était 0.00290, l'estimation est donc raisonnable.

Exemple complet : estimation d'erreur avec F(x)

Reprenons l'exemple de la leçon précédente (Lagrange). Soit la fonction tabulée aux points :

Les points sont équidistants avec et . Nous voulons estimer .

Étape 1 : Construire la table de différences

Calcul des différences :

Étape 2 : Calculer la variable réduite

Étape 3 : Polynôme de degré 2 et estimation de l'erreur

Calculons d'abord en utilisant les 3 premiers points :

Avec :

Estimation de l'erreur de par le terme suivant :

L'erreur estimée est donc environ (en valeur absolue).

Étape 4 : Polynôme de degré 3 et son erreur

Pour , on ajoute le terme de degré 3 :

Arrondissons : .

Estimation de l'erreur de : Pour estimer l'erreur de , il faudrait calculer le terme suivant :

Or, pour calculer , il faudrait un 5ème point de données (car nécessite 5 valeurs). Avec seulement 4 points, nous ne pouvons pas estimer l'erreur de .

Synthèse : Ce qu'illustre cet exemple :

• On calcule avec 3 points
• L'estimation de l'erreur de est
• En passant à , on ajoute simplement ce terme d'erreur :

L'important ici est de comprendre le principe :

1. On calcule avec points
2. L'erreur est estimée par
3. Si cette erreur est trop grande, on passe à en ajoutant simplement ce terme

Formule d'erreur théorique

Énoncé

Si est fois continûment dérivable, l'erreur exacte est :

où est dans l'intervalle contenant et les points d'interpolation.

Lien avec les différences

On peut montrer que :

Ce qui justifie l'estimation empirique .

Forme polynomiale explicite

Développement

La formule de Newton-Gregory peut être développée sous forme polynomiale standard. Pour avec les données de sin(x) :

Cette forme est utile pour l'évaluation efficace du polynôme par la méthode de Horner.

Algorithme Python

Structure de l'implémentation

L'algorithme se décompose en trois fonctions :

1. table_differences : Construit la table triangulaire des différences en appliquant récursivement la définition .

2. binomial_s : Calcule le coefficient binomial généralisé de manière incrémentale, évitant le calcul explicite des factorielles.

3. newton_gregory : Assemble le polynôme et estime l'erreur.

import numpy as np

def table_differences(f_values):
  """
  Construit la table des différences descendantes.

  La table est une structure triangulaire :
      table[k][i] = Δ^k f_i

  Exemple pour 5 valeurs :
      table[0] = [f_0, f_1, f_2, f_3, f_4]      (5 éléments)
      table[1] = [Δf_0, Δf_1, Δf_2, Δf_3]       (4 éléments)
      table[2] = [Δ²f_0, Δ²f_1, Δ²f_2]          (3 éléments)
      table[3] = [Δ³f_0, Δ³f_1]                 (2 éléments)
      table[4] = [Δ⁴f_0]                        (1 élément)

  Paramètres:
      f_values : liste des valeurs [f_0, f_1, ..., f_n]

  Retourne:
      table : liste de listes, table[k][i] = Δ^k f_i
  """
  n = len(f_values)
  # Créer une table triangulaire : n-k éléments à l'ordre k
  table = [[0.0] * (n - k) for k in range(n)]

  # Ordre 0 : les valeurs elles-mêmes (Δ⁰f_i = f_i)
  table[0] = list(f_values)

  # Ordres supérieurs : Δ^k f_i = Δ^(k-1) f_(i+1) - Δ^(k-1) f_i
  for k in range(1, n):
      for i in range(n - k):
          table[k][i] = table[k-1][i+1] - table[k-1][i]

  return table

def binomial_s(s, k):
  """
  Calcule le coefficient binomial généralisé C(s, k) = s(s-1)...(s-k+1) / k!

  Utilise une formule incrémentale pour éviter les grands nombres :
      C(s, k) = C(s, k-1) * (s - k + 1) / k

  Paramètres:
      s : valeur réelle (variable réduite)
      k : ordre (entier >= 0)

  Retourne:
      C(s, k) : coefficient binomial (peut être négatif si s non entier)
  """
  if k == 0:
      return 1.0

  result = 1.0
  for j in range(k):
      # Multiplie par (s - j) / (j + 1) à chaque étape
      # Cela calcule s/1 * (s-1)/2 * (s-2)/3 * ... * (s-k+1)/k
      result *= (s - j) / (j + 1)

  return result

def newton_gregory(x_points, f_values, x):
  """
  Interpolation par la formule de Newton-Gregory descendante.

  Hypothèse : les points x_points sont ÉQUIDISTANTS.

  Paramètres:
      x_points : abscisses équidistantes [x_0, x_1, ..., x_n]
      f_values : ordonnées correspondantes [f_0, f_1, ..., f_n]
      x : point où évaluer le polynôme

  Retourne:
      (valeur, erreur_estimee) :
          - valeur : P_n(x)
          - erreur_estimee : |C(s, n+1) * Δ^(n+1) f_0| (si disponible)
  """
  n = len(x_points) - 1
  h = x_points[1] - x_points[0]  # Pas supposé constant
  x0 = x_points[0]
  s = (x - x0) / h  # Variable réduite

  # Étape 1 : Construire la table de différences
  table = table_differences(f_values)

  # Étape 2 : Calculer P_n(x) = Σ C(s,k) * Δ^k f_0
  result = 0.0
  for k in range(n + 1):
      result += binomial_s(s, k) * table[k][0]

  # Étape 3 : Estimer l'erreur par le terme suivant (si on a assez de données)
  erreur = 0.0
  if len(table) > n + 1 and len(table[n+1]) > 0:
      erreur = abs(binomial_s(s, n + 1) * table[n + 1][0])

  return result, erreur

# === Exemple d'utilisation ===
x_data = np.array([0.1, 0.5, 0.9, 1.3, 1.7])  # Pas h = 0.4
f_data = np.array([0.09983, 0.47943, 0.78333, 0.96356, 0.99166])  # sin(x)

x_eval = 0.8

# Afficher la table de différences
table = table_differences(f_data)
print("Table de différences :")
for k, row in enumerate(table):
  print(f"  Δ^{k} f : {[f'{v:.5f}' for v in row]}")

# Interpolation avec différents degrés
for degre in range(1, 5):
  valeur, err = newton_gregory(x_data[:degre+1], f_data[:degre+1], x_eval)
  exact = np.sin(x_eval)
  print(f"\nDegré {degre}: P_{degre}({x_eval}) = {valeur:.6f}")
  print(f"  Erreur réelle = {abs(exact - valeur):.6f}")
  if err > 0:
      print(f"  Erreur estimée = {err:.6f}")

Comparaison avec Lagrange

Résumé

• Les différences finies descendantes se calculent récursivement
• La formule de Newton-Gregory utilise ces différences avec la variable réduite
• Avantage majeur : passer de degré à n'ajoute qu'un seul terme
• L'erreur peut être estimée par le terme suivant :
• La méthode nécessite des points équidistants

Pour aller plus loin

La prochaine leçon présentera les différences divisées, qui généralisent les différences finies au cas de points non équidistants. Nous étudierons également le phénomène d'instabilité des polynômes de degré élevé.