Méthodes à pas multiples (Adams et Adams-Moulton)

Objectifs d'apprentissage

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

• Distinguer les méthodes à pas unique des méthodes à pas multiples
• Appliquer les formules d'Adams-Bashforth (ouvertes)
• Appliquer les formules d'Adams-Moulton (prédiction-correction)
• Comparer l'efficacité des différentes méthodes numériques

Prérequis

• Méthodes de Runge-Kutta
• Interpolation polynomiale (Chapitre 4)
• Polynôme de Newton-Gregory

Classification des méthodes

Pas unique vs pas multiples

Méthodes ouvertes vs fermées

Principe des méthodes d'Adams

L'idée est de construire un polynôme d'interpolation passant par les points et de l'intégrer pour approximer :

où est le polynôme de Newton-Gregory descendant.

Formules d'Adams-Bashforth (ouvertes)

Ces formules utilisent l'extrapolation — le polynôme est construit sur des points à gauche de .

Adams-Bashforth d'ordre 2

Utilise et :

Adams-Bashforth d'ordre 3

Utilise , et :

Adams-Bashforth d'ordre 4

Utilise , , et :

Formules d'Adams-Moulton (fermées)

Ces formules utilisent l'interpolation — le polynôme inclut le point .

Adams-Moulton d'ordre 3

Adams-Moulton d'ordre 4

Schéma prédiction-correction (Adams-Moulton)

Principe

1. Prédicteur (Adams-Bashforth) : estimer
2. Correcteur (Adams-Moulton) : affiner avec

Adams-Moulton d'ordre local

Mesure de la précision

On peut estimer l'erreur en comparant la valeur prédite et la valeur corrigée :

Algorithme

def adams_moulton(f, t0, y0, h, n_steps):
  """
  Méthode d'Adams-Moulton (prédicteur-correcteur) d'ordre 4.

  Nécessite un amorçage par RK4 pour les 4 premières valeurs.
  """
  # Amorçage avec RK4
  t = [t0]
  y = [y0]

  for j in range(3):  # 3 pas RK4 pour obtenir y0, y1, y2, y3
      tj, yj = t[-1], y[-1]
      k1 = h * f(tj, yj)
      k2 = h * f(tj + h/2, yj + k1/2)
      k3 = h * f(tj + h/2, yj + k2/2)
      k4 = h * f(tj + h, yj + k3)
      y_next = yj + (k1 + 2*k2 + 2*k3 + k4) / 6
      t.append(tj + h)
      y.append(y_next)

  # Calcul des f initiaux
  F = [f(t[i], y[i]) for i in range(4)]

  # Adams-Moulton pour les pas suivants
  for n in range(3, n_steps):
      tn = t[-1]
      yn = y[-1]

      # Prédicteur (Adams-Bashforth ordre 4)
      y_pred = yn + (h/24) * (55*F[-1] - 59*F[-2] + 37*F[-3] - 9*F[-4])

      # Correcteur (Adams-Moulton ordre 4)
      f_pred = f(tn + h, y_pred)
      y_corr = yn + (h/24) * (9*f_pred + 19*F[-1] - 5*F[-2] + F[-3])

      t.append(tn + h)
      y.append(y_corr)
      F.append(f(t[-1], y[-1]))
      F.pop(0)  # Garder seulement les 4 derniers

  return t, y

Tableau comparatif de TOUTES les méthodes

Voici une comparaison complète sur l'ÉD fil rouge , , avec :

Avantages et inconvénients

Résumé

• Les méthodes à pas multiples réutilisent les valeurs des pas précédents
• Adams-Bashforth (ouvertes) : extrapolation, utilisées comme prédicteur
• Adams-Moulton (fermées) : interpolation, utilisées comme correcteur
• Le schéma prédicteur-correcteur combine les deux pour l'ordre global avec seulement 2 évaluations de
• L'amorçage se fait par Runge-Kutta

Pour aller plus loin

Dans la prochaine leçon, nous verrons comment adapter ces méthodes aux systèmes d'ÉD et aux ÉD d'ordre supérieur.