Méthodes de Runge-Kutta

Objectifs d'apprentissage

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

• Comprendre pourquoi une seule pente (Euler) ne suffit pas
• Construire l'idée de combiner plusieurs pentes pour mieux approximer
• Appliquer la méthode RK4 classique pas à pas
• Comprendre le concept de pas adaptatif avec RK-Fehlberg

Prérequis

• Méthode d'Euler et Euler modifiée
• Développement de Taylor
• Notion d'ordre de précision

Limites d'Euler : une seule évaluation de la pente

La méthode d'Euler évalue la pente $f(t_n, y_n)$ au point de départ et la suppose constante sur tout l'intervalle $[t_n, t_n + h]$. Or, sur cet intervalle, la pente varie — d'autant plus que $h$ est grand.

La méthode de Taylor corrige ce problème en intégrant les dérivées successives $y'', y''', \ldots$, mais cela nécessite de dériver $f(t, y)$ analytiquement, ce qui est souvent coûteux ou impraticable.

Principe des méthodes de Runge-Kutta. Au lieu de calculer des dérivées de $f$, on évalue $f$ en plusieurs points de l'intervalle $[t_n, t_n + h]$, puis on combine ces évaluations avec des poids appropriés. On obtient ainsi une approximation de la pente moyenne sur l'intervalle, sans jamais avoir à dériver $f$.

Runge-Kutta d'ordre 2 (RK2)

Lien avec Euler modifiée

La méthode d'Euler modifiée de la leçon précédente est le cas le plus simple de Runge-Kutta. Rappelons son principe :

1. Évaluer la pente $k_1 = f(t_n, y_n)$ au début
2. Faire un pas d'Euler complet pour prédire $\tilde{y} = y_n + h \cdot k_1$
3. Évaluer la pente $k_2 = f(t_n + h,\, \tilde{y})$ à ce point prédit
4. Prendre la moyenne des deux pentes : $y_{n+1} = y_n + \frac{h}{2}(k_1 + k_2)$

En utilisant deux évaluations de $f$ au lieu d'une, on passe de l'ordre $O(h)$ à l'ordre $O(h^2)$.

Formulation générale

On peut écrire cette famille de méthodes sous la forme :

avec $k_1 = h\,f(t_n, y_n)$ et $k_2 = h\,f(t_n + \alpha h,\, y_n + \beta k_1)$.

En développant par Taylor et en identifiant les termes, on obtient les conditions :

Ce système de 3 équations pour 4 inconnues admet une infinité de solutions. Trois choix classiques :

La méthode d'Euler modifiée correspond au Type I. Ces variantes diffèrent par le choix du point intermédiaire où évaluer $k_2$, mais elles sont toutes d'ordre 2.

Runge-Kutta d'ordre 4 (RK4)

Principe

Avec 2 évaluations, on atteint l'ordre 2. En augmentant le nombre d'évaluations de $f$, on peut atteindre des ordres plus élevés. Avec 4 évaluations bien choisies, on atteint l'ordre 4 — c'est la méthode RK4 classique, la plus utilisée en pratique.

Construction des 4 pentes

On évalue la pente à 4 endroits de l'intervalle $[t_n, t_n + h]$ : au début, deux fois au milieu (avec des prédictions différentes), et à la fin.

Pente au début :

C'est la pente évaluée au point de départ, identique à celle d'Euler.

Première pente au milieu :

On utilise $k_1$ pour prédire la valeur de $y$ au milieu de l'intervalle, puis on évalue $f$ à ce point prédit :

Deuxième pente au milieu :

On reprend la même procédure, mais en utilisant $k_2$ comme prédicteur. Puisque $k_2$ est une meilleure estimation de la pente que $k_1$, le point prédit sera légèrement différent :

Pente à la fin :

On utilise $k_3$ pour prédire la valeur de $y$ à la fin de l'intervalle :

Combinaison :

Les quatre pentes sont combinées par une moyenne pondérée. Les pentes au milieu ont un poids double, conformément à la règle de Simpson :

Cette formule est d'ordre 4 : l'erreur locale est en $O(h^5)$, et l'erreur globale en $O(h^4)$.

Visualisation : construction des pentes

La visualisation ci-dessous décompose RK4 en 5 étapes. À chaque étape, la flèche pointillée montre la prédiction qui détermine le point d'évaluation suivant, et le trait plein montre la pente évaluée à ce point.

Processus de raffinement

Chaque pente corrige la précédente :

• $k_1$ : pente au début (identique à Euler)
• $k_2$ : pente au milieu, estimée à partir de la prédiction de $k_1$
• $k_3$ : pente au milieu, estimée à partir de la prédiction (plus précise) de $k_2$
• $k_4$ : pente à la fin, estimée à partir de la prédiction de $k_3$

Ce processus itératif permet à la combinaison pondérée de capturer la courbure de la solution sur l'intervalle.

Exemple : RK4 sur $y' = -ty^2$

On applique RK4 à l'équation $y' = -ty^2$, $y(0) = 1$, avec $h = 0.1$.

Calcul du premier pas

$t_0 = 0$, $y_0 = 1$

La valeur exacte est $y(0.1) = 0.99502488$, soit une erreur de l'ordre de $2 \times 10^{-8}$.

Résultats sur plusieurs pas

Avec seulement 4 évaluations de $f$ par pas, RK4 atteint une précision de l'ordre de $10^{-7}$ — bien meilleure qu'Euler modifiée ($10^{-5}$).

Coût et efficacité

Diviser $h$ par 2 divise l'erreur par $2^4 = 16$ pour RK4, ce qui donne un rapport coût/précision très favorable.

Comparaison visuelle : erreurs Euler vs RK2 vs RK4

Estimation d'erreur et pas adaptatif

RK4 ne fournit pas d'estimation de l'erreur commise à chaque pas. On ne sait donc pas a priori si le pas $h$ choisi est approprié.

Principe du pas adaptatif

Pour estimer l'erreur, on calcule deux approximations d'ordres différents sur le même pas. Si elles sont proches, le pas est suffisant ; sinon, on le réduit.

RK-Fehlberg (RKF45)

La méthode de Fehlberg utilise 6 évaluations de $f$ pour obtenir simultanément une approximation d'ordre 4 et une d'ordre 5. La différence entre les deux fournit une estimation de l'erreur $E$.

Le pas est ensuite ajusté selon :

où l'exposant $1/5$ provient de l'ordre 5 de la méthode. Si $E > \text{tol}$, on réduit $h$ et on refait le pas. Si $E \ll \text{tol}$, on augmente $h$ pour les pas suivants.

C'est l'approche implémentée dans les solveurs d'EDO standards, notamment scipy.integrate.solve_ivp en Python.

Algorithme RK4

def rk4(f, t0, y0, h, n_steps):
  """
  Méthode de Runge-Kutta d'ordre 4.

  Paramètres:
      f: fonction f(t, y) = y'
      t0, y0: conditions initiales
      h: pas de discrétisation
      n_steps: nombre de pas

  Retourne:
      t, y: tableaux des valeurs
  """
  t = [t0]
  y = [y0]

  for j in range(n_steps):
      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)

  return t, y

Résumé

• Euler utilise 1 pente (au début) → ordre 1
• RK2 utilise 2 pentes → ordre 2. L'Euler modifiée en est un cas particulier
• RK4 utilise 4 pentes (début, 2× milieu, fin) → ordre 4. C'est le standard en pratique
• Les pentes se construisent l'une à partir de l'autre : chaque évaluation utilise la prédiction de la précédente
• RK-Fehlberg ajoute une estimation d'erreur pour adapter automatiquement le pas

Pour aller plus loin

Dans la prochaine leçon, nous verrons les méthodes à pas multiples (Adams, Adams-Moulton), qui réutilisent les évaluations des pas précédents au lieu de tout recalculer à chaque pas.