Équations différentielles en Python, méthodes d'Euler et de Runge-Kutta : cours et exercices corrigés d'informatique de prépa (MPSI, PCSI, TSI, Maroc)
Résoudre numériquement un problème de Cauchy y' = F(t, y) : méthodes d'Euler explicite et implicite, Runge-Kutta d'ordre 2 (point milieu, Heun) et d'ordre 4, vues comme des intégrales approchées sur chaque pas et programmées en Python ; effet du pas, ordre mesuré, stabilité, comparaison dans les mêmes conditions. Équations d'ordre 2 et systèmes sur un vecteur d'état, fonction odeint de scipy, applications d'ingénierie (circuits, mécanique, épidémies, séchage).
- 16méthodes
- 35exercices corrigés
- 3problèmes
- 16pièges
- 60figures
Pour résoudre numériquement un problème de Cauchy , , on découpe en pas de longueur et l'on avance pas à pas en approchant, sur chaque pas, l'intégrale de la pente. La méthode d'Euler explicite suit la tangente, ; la méthode d'Euler implicite prend la pente à la fin du pas ; les méthodes de Runge-Kutta calculent plusieurs pentes dans le pas : deux pour le point milieu et la méthode de Heun, quatre pour la méthode de Runge-Kutta d'ordre 4, avec les poids 1, 2, 2, 1 sur 6. Quand le nombre de pas double, l'erreur est divisée par environ 2 pour Euler, 4 pour les méthodes d'ordre 2 et 16 pour Runge-Kutta d'ordre 4, si la solution est assez régulière. Ce chapitre suit la partie « Équations différentielles ordinaires » de la section « Ingénierie numérique » du programme marocain d'informatique de première année, la même en MPSI, en PCSI et en TSI ; il n'est pas ouvert aux classes françaises. Il apprend à écrire la fonction F, à compter les pas et les instants sans erreur, à programmer chaque méthode en Python, à visualiser l'effet du pas, à comparer les méthodes à pas égal et à nombre de calculs égal, à reconnaître un pas trop grand, à résoudre une équation d'ordre 2 ou un système sur un vecteur d'état numpy, et à utiliser la fonction odeint de scipy.integrate. Tu y trouves des méthodes pas à pas, des exercices corrigés, dont plusieurs tirés de sujets du CNC, de CCINP, de Centrale-Supélec, d'e3a et de la Banque PT, et trois problèmes, dont la partie de calcul numérique du CNC 2021, filière MP, et le problème de calcul scientifique du CNC 2016.
Ce que tu sauras faire
Une loi d'évolution dit à quelle vitesse une grandeur change : la charge d'un condensateur, la vitesse d'un mobile freiné, la concentration d'un réactif, le nombre de malades d'une épidémie, la teneur en eau d'un produit qui sèche. On connaît alors la dérivée de la grandeur en fonction du temps et de la grandeur elle-même, et l'on cherche la grandeur. On ne sait écrire la solution que dans quelques cas ; ailleurs, on la calcule pas à pas. Ce chapitre présente les méthodes d'Euler et de Runge-Kutta, les programme, mesure leur précision et les compare. À la fin de ce chapitre, tu dois savoir :
- écrire un problème de Cauchy sous la forme et programmer la fonction
F; - découper l'intervalle de temps sans erreur de comptage : pas, instants ;
- programmer les méthodes d'Euler explicite et implicite, de Runge-Kutta d'ordre 2 (point milieu, Heun) et d'ordre 4 ;
- visualiser l'effet du pas sur la précision et mesurer l'ordre d'une méthode ;
- comparer la précision des méthodes dans les mêmes conditions : même équation, même pas, même nombre de calculs ;
- reconnaître un pas trop grand et choisir un pas ;
- ramener une équation d'ordre 2 ou un système à un système d'ordre 1 sur un vecteur d'état, et le résoudre ;
- utiliser la fonction
odeintdu modulescipy.integrate; - appliquer ces méthodes à des problèmes d'ingénierie et contrôler une simulation.
L'essentiel : Le problème et la grille Extrait gratuit
- Problème de Cauchy : , , sur ; en Python,
F(t, y), le temps d'abord. - pas de longueur , instants ; .
- Instants calculés par
t0 + k * h(fonctiontemps), jamais en ajoutant ; nombre de pas parround, jamaisint. - « points » : pas ;
np.linspace(t0, tf, n + 1); « sur » : est une durée.
Une méthode du chapitre Extrait gratuit
Au concours national commun et dans beaucoup de sujets : la formule du schéma est donnée, avec le nom de la fonction, l'ordre de ses paramètres et ce qu'elle renvoie.
On recopie la signature exactement. On lit ce que représente chaque paramètre : peut être une durée ( sur ) ; un nombre de pas ou de points. Un schéma à deux pas a besoin de et : l'énoncé dit comment calculer (souvent un pas d'Euler).
- Recopier la signature et noter le rôle de chaque paramètre.
- Calculer le pas et le nombre de pas à partir des paramètres ; prévoir la liste des instants.
- Traduire la formule ligne par ligne, une pente par variable.
- Démarrer un schéma à deux pas comme l'indique l'énoncé ; renvoyer les deux listes demandées.
- Tester sur ou sur une équation dont on connaît la solution.
def ralston(f, t0, T, y0, N):
h = T / N # T : durée, N pas
tt = [t0]
Y = [y0]
for i in range(N):
p1 = f(tt[i], Y[i])
p2 = f(tt[i] + 2 * h / 3, Y[i] + 2 * h / 3 * p1)
Y.append(Y[i] + h * (p1 / 4 + 3 * p2 / 4))
tt.append(t0 + (i + 1) * h)
return tt, Y
« La fonction respecte la signature imposée ; étant la durée de l'intervalle, le pas vaut et le dernier instant . »
Un énoncé donne le schéma avec , , et la signature ralston(f, t0, T, y0, N). On le programme comme ci-dessus et l'on teste sur , , , :
import math
def ralston(f, t0, T, y0, N):
h = T / N
tt = [t0]
Y = [y0]
for i in range(N):
p1 = f(tt[i], Y[i])
p2 = f(tt[i] + 2 * h / 3, Y[i] + 2 * h / 3 * p1)
Y.append(Y[i] + h * (p1 / 4 + 3 * p2 / 4))
tt.append(t0 + (i + 1) * h)
return tt, Y
def f7(t, y):
return -y
tt, Y = ralston(f7, 0.0, 1.0, 1.0, 10)
print(len(tt), tt[10], Y[10], math.exp(-1))
tt2, Y2 = ralston(f7, 0.0, 1.0, 1.0, 20)
e10 = abs(Y[10] - math.exp(-1))
e20 = abs(Y2[20] - math.exp(-1))
print(e10 / e20)
Le programme affiche :
11 1.0 0.3685409848335518 0.36787944117144233
4.155934052137471
L'erreur est de avec 10 pas, et elle est divisée par environ 4 quand on passe à 20 pas : c'est une méthode d'ordre 2.
- Changer le nom ou l'ordre des paramètres imposés.
- Prendre pour l'instant final quand c'est une durée (ou l'inverse) : les deux ne coïncident que si .
- Avancer par
while tt[i] < t0 + T: la boucle peut dépasser quand n'est pas entier ; compter les pas avec un entier.
Exercices 19, 20, 21, 30 ; problèmes 1 et 2.
Un exercice corrigé Extrait gratuit
On résout , où , , et sont des nombres, avec . Le sujet donne le programme suivant, où dt est le pas et nbdt le nombre de pas ; la ligne dy=dy+... est à compléter (le sujet numérote ses lignes ; la numérotation n'est pas reproduite ici). Il parle de « méthode d'Euler à deux pas » : le schéma d'Euler est un schéma à un pas (la valeur suivante ne dépend que de la valeur présente) ; le sujet veut sans doute dire qu'il traite les deux grandeurs et .
import numpy as np
def derivee2(y,dy):
ddy=(f-c*y-b*dy)/a
return ddy
def Euler_ordre2(dt,nbdt):
y=[0] #condition init. nulle
dy=[0] #condition init. nulle
for i in range(nbdt):
dy=dy+... #a completer
y=y+[y[i]+dt*dy[i]]
return y
- (Question Q11.) Écrire la ligne à compléter.
- (Question ajoutée.) Avec , , , (valeurs choisies), la solution exacte est . Calculer avec 100, 1 000 et 10 000 pas et l'erreur commise.
- (Question ajoutée.) La concaténation
dy + [...]recopie toute la liste à chaque tour. Réécrire la fonction avecappendet dire ce que l'on gagne.
- Méthode 3 : , avec donné par
derivee2. - Méthode 8 : les deux listes avancent ensemble ; la ligne donnée pour
yutilisedy[i], la valeur de l'instant .
Sur le modèle de la ligne qui suit, que doit-on ajouter à la liste dy ? Avec quelles valeurs calcule-t-on l'accélération ? Pour l'erreur, comment doit-elle évoluer quand le nombre de pas est multiplié par 10, si la méthode est d'ordre 1 ? Et combien coûte, en tout, une concaténation répétée à chaque tour ?
-
La ligne est
dy=dy+[dy[i]+dt*derivee2(y[i],dy[i])]: comme poury, on ajoute à la liste la valeur suivante, calculée avec les valeurs de l'instant .
import math
a, b, c, f = 1, 2, 5, 5
def derivee2(y, dy):
return (f - c * y - b * dy) / a
def Euler_ordre2(dt, nbdt):
y = [0]
dy = [0]
for i in range(nbdt):
dy = dy + [dy[i] + dt * derivee2(y[i], dy[i])]
y = y + [y[i] + dt * dy[i]]
return y
ex = 1 - math.exp(-5) * (math.cos(10)
+ 0.5 * math.sin(10))
for nb in [100, 1000, 10000]:
y = Euler_ordre2(5 / nb, nb)
print(nb, y[nb], y[nb] - ex)
Le programme affiche :
100 1.009483015882817 0.0019966036856802205
1000 1.007722902834801 0.00023649063766417733
10000 1.0075102705650665 2.385836792972995e-05
L'erreur est divisée par 10 environ quand le nombre de pas est multiplié par 10 : la méthode d'Euler est d'ordre 1.
def Euler_ordre2_append(dt, nbdt):
y = [0]
dy = [0]
for i in range(nbdt):
dy.append(dy[i] + dt * derivee2(y[i], dy[i]))
y.append(y[i] + dt * dy[i])
return y
ya = Euler_ordre2_append(0.05, 100)
print(ya == Euler_ordre2(0.05, 100))
Le programme affiche :
True
Les résultats sont identiques. Mais dy + [...] crée une nouvelle liste et recopie les éléments déjà calculés : sur pas, cela fait de l'ordre de copies, un coût quadratique, alors que append ajoute en temps constant, pour un coût total linéaire.
Euler sur un ordre 2 : deux listes, chaque nouvelle valeur calculée avec les valeurs de l'instant ; append plutôt que la concaténation. Voir les méthodes 8 et 3.
Le cours détaillé, toute la fiche « L'essentiel », 16 méthodes, 16 pièges corrigés, la carte mentale, 35 exercices corrigés, 3 problèmes de concours, les fiches à mémoriser et l'assistant qui répond à tes questions. Les trois premiers chapitres de chaque matière sont offerts avec un compte d’essai gratuit.
Ouvrir l'essai gratuitVoir les offresPlan du cours
- 1. Introduire les équations différentielles ordinaires
- 1.1 Une loi d'évolution
- 1.2 Le problème de Cauchy
- 1.3 Écrire la fonction
F - 1.4 Une solution peut cesser d'exister
- 2. Discrétiser le temps
- 2.1 Des pas et des instants
- 2.2 Calculer les instants à partir de
- 2.3 Compter des points ou des pas
- 2.4 Une valeur approchée
- 3. L'idée commune : intégrer la pente sur un pas
- 3.1 Un pas, une intégrale
- 3.2 Une méthode d'intégration pour chaque schéma
- 3.3 Quand ne dépend que de
- 4. La méthode d'Euler explicite
- 4.1 Suivre la tangente
- 4.2 L'erreur commise sur un pas
- 5. La méthode d'Euler implicite
- 5.1 La pente à la fin du pas
- 5.2 Le cas d'une équation linéaire
- 5.3 Le cas général : une équation à résoudre à chaque pas
- 5.4 Bilan
- 6. Les méthodes de Runge-Kutta d'ordre 2
- 6.1 La méthode du point milieu
- 6.2 La méthode de Heun
- 6.3 Deux méthodes différentes
- 7. La méthode de Runge-Kutta d'ordre 4
- 7.1 Quatre pentes
- 7.2 Contrôler un programme de Runge-Kutta d'ordre 4
- 7.3 Retour aux méthodes d'intégration
- 8. L'effet du pas et la comparaison des méthodes
- 8.1 Quelle erreur mesurer
- 8.2 L'ordre d'une méthode
- 8.3 Visualiser l'effet du pas
- 8.4 Comparer dans les mêmes conditions
- 8.5 Les limites
- 9. La stabilité, vue sur un exemple
- 9.1 Un pas trop grand
- 9.2 Le facteur d'un pas
- 9.3 Choisir un pas en sciences industrielles
- 10. Équations d'ordre 2 et systèmes
- 10.1 Le vecteur d'état
- 10.2 Des tableaux, pas des listes
- 10.3 Les méthodes sur un vecteur d'état
- 10.4 Toutes les pentes avant la mise à jour
- 10.5 Un exemple : l'oscillateur sans frottement
- 10.6 La forme matricielle
- 11. La fonction
odeint- 11.1 Appeler
odeint - 11.2 Un exemple : l'oscillateur de Van der Pol
- 11.3 Trois pièges
- 11.4 Ce que fait
odeint - 11.5 La fonction
solve_ivp
- 11.1 Appeler
- 12. Applications à des problèmes d'ingénierie
- 12.1 Des modèles et leur état
- 12.2 Exploiter une simulation
- 13. Quand une simulation ment
- 13.1 Des nombres là où il n'y a pas de solution
- 13.2 Un modèle qui cesse d'être valable
- 13.3 Les contrôles d'une simulation
- 14. Ce que le sujet fournit
- 15. Histoire et suite
- 15.1 D'Euler à Runge et Kutta
- 15.2 Ce qui vient ensuite
Les méthodes du chapitre
Chaque méthode est une fiche : quand l'utiliser, le rappel de cours, les étapes, la rédaction attendue sur la copie, un exemple traité, les erreurs à éviter.
- Écrire un problème de Cauchy et programmer la fonction
F - Construire la grille des instants
- Programmer la méthode d'Euler explicite
- Programmer la méthode d'Euler implicite
- Programmer une méthode de Runge-Kutta d'ordre 2 sans confondre point milieu et Heun
- Programmer la méthode de Runge-Kutta d'ordre 4 et la contrôler
- Programmer un schéma donné par l'énoncé, à signature imposée
- Ramener une équation d'ordre 2 ou un système à un système d'ordre 1
- Mettre à jour un vecteur d'état sans erreur
- Valider un programme de simulation
- Mesurer l'ordre d'une méthode
- Comparer des méthodes dans les mêmes conditions
- Choisir un pas et le justifier
- Utiliser
odeint, etsolve_ivpdocumentée - Exploiter une simulation
- Reconnaître qu'une simulation ment
Les exercices corrigés
Chaque exercice a ses indications, sa correction rédigée et ce qu'il faut en retenir.
Application directe (14)
- Quatre méthodes à la main
- La bille d'un analyseur de coagulation
- Quand F ne dépend que de t
- Écrire la fonction F
- Les récurrences d'Euler d'un système
- Une ligne à compléter
- Trouver l'erreur : boucles et nombre de pas
- Trouver l'erreur : Heun, point milieu, Runge-Kutta 4
- Euler implicite à la main
- Trois erreurs avec odeint
- Le looping
- La suspension d'une moto
- Une cinétique à trois espèces
- Le 100 m d'un sprinteur
Entraînement (16)
- Quatre courbes pour une même équation
- Mesurer l'ordre sur une équation à solution connue
- Démasquer une solution exacte fausse
- L'ordre des affectations dans un oscillateur amorti
- Le prédicteur-correcteur d'Adams
- La méthode de Nyström et son instabilité
- Le filtre RC : Euler, puis Heun
- Le refroidissement d'un télescope spatial : choisir le pas
- La climatisation d'une pièce : Euler sous forme matricielle
- Le pendule qui fait le tour
- Le projectile freiné par l'air
- Un réacteur qui s'emballe
- L'objet qui décolle d'une demi-sphère
- Euler implicite par la méthode de Newton
- Une solution qui n'existe plus
- Discrétiser un filtre analogique par la méthode d'Euler
Approfondissement (5)
- Le schéma de Verlet et l'énergie
- Le facteur d'un pas et la stabilité
- Un circuit raide
- Extrapolation de Richardson
- Une voile poussée par la lumière
Les problèmes de concours
Des extraits de sujets réels, corrigés en entier, avec la durée conseillée et les méthodes mobilisées.
- Un virus en quatre compartiments : Euler, Heun et Runge-Kutta d'ordre 4
- Le circuit RLC : Euler, Heun et odeint
- Euler, Euler implicite, Heun et un schéma qui conserve l'énergie
Questions fréquentes
Comment programmer la méthode d'Euler en Python ?
On écrit d'abord la fonction F(t, y) qui renvoie la dérivée, le temps en premier. Avec pas, et les instants , calculés à partir de l'entier et jamais en ajoutant à chaque tour. On part de la liste Y = [y0], puis, pour k in range(n), on ajoute Y[k] + h * F(T[k], Y[k]). La fonction fait évaluations de , son coût est linéaire, et elle renvoie la liste des instants et celle des valeurs approchées. Un premier test : avec constante, la méthode est exacte.
Quelle est la formule de la méthode de Runge-Kutta d'ordre 4 ?
On calcule quatre pentes dans le pas : , , , , puis . Chaque pas coûte quatre évaluations de , mais à nombre d'évaluations égal la méthode reste de loin plus précise qu'Euler. Une faute de recopie dans une pente ne produit aucune erreur de syntaxe : on contrôle le programme sur constante, sur un polynôme de degré 3 en , et par le rapport des erreurs, voisin de 16 quand le nombre de pas double.
Quelle différence entre la méthode de Heun et la méthode du point milieu ?
Les deux sont d'ordre 2 et évaluent deux fois par pas, mais elles ne prennent pas la seconde pente au même endroit. Le point milieu fait un demi-pas d'Euler et avance d'un pas entier avec la pente du milieu : c'est l'idée de la méthode du point milieu en intégration. Heun fait un pas d'Euler entier pour prévoir , calcule la pente en , puis avance avec la moyenne des deux pentes : c'est l'idée de la méthode des trapèzes. Elles ne donnent pas les mêmes nombres. Dans un sujet, une fonction nommée RK2 désigne la méthode que le sujet définit.
Comment choisir le pas dans la méthode d'Euler ?
Un pas trop grand ne donne pas seulement un résultat moins précis : il peut fausser l'allure. Pour , chaque pas d'Euler explicite multiplie par : la suite décroît sans osciller si , oscille si et diverge si , alors que la méthode d'Euler implicite reste stable quel que soit le pas. On prend un pas petit devant le plus court temps caractéristique du système, puis on vérifie en divisant le pas par deux : le résultat doit à peine changer. Un pas minuscule ne sert à rien : le temps de calcul croît et les arrondis s'accumulent.
Comment utiliser odeint pour une équation d'ordre 2 en Python ?
On ramène l'équation à un système d'ordre 1 sur le vecteur d'état , avec deux conditions initiales. Après from scipy.integrate import odeint, l'appel odeint(G, Y0, T) résout : la fonction reçoit l'état d'abord et le temps ensuite, et renvoie un tableau de pentes. T est la liste des instants voulus, et le résultat a la forme (len(T), p), même pour une seule équation : la grandeur est S[:, 0]. Dans la fonction, on emploie np.sin et non math.sin. Une fonction écrite F(t, y) passée à odeint donne un résultat faux sans message pour une seule équation, et une erreur pour un système ; on l'enveloppe par def G(Y, t): return F(t, Y).
Qu'est-ce qui tombe sur les équations différentielles au CNC ?
L'épreuve d'informatique du CNC a posé ce thème en 2016, 2018 et 2021 : Euler, Heun et odeint sur un circuit RLC, un schéma d'Adams, la méthode de Nyström, Euler, Heun ou Runge-Kutta d'ordre 4 sur un modèle d'épidémie. La formule du schéma est toujours donnée, avec une signature imposée qui renvoie les instants et les valeurs ; le pas s'y écrit souvent sur , étant une durée, et les conditions initiales se lisent parfois sur une figure. On programme la formule telle qu'elle est écrite, en respectant les noms et l'ordre des paramètres, puis on met l'équation sous forme de système et on trace.
Comment y accéder
Ce chapitre fait partie de l'accès complet. Les trois premiers chapitres de chaque matière (deux par bloc en économie et droit, en management et gestion) sont offerts avec un compte d'essai gratuit. Créer un compte d'essai ou se connecter. Pour l'accès complet et les tarifs, vois les offres.