keyboard_arrow_down Résolution numérique des EDO

1. Introduction aux EDO et besoin des méthodes numériques

Une EDO est une équation reliant une fonction inconnue y(t) à ses dérivées. Le
problème standard est le problème de Cauchy :
′
y (t) = f (t, y(t))
{
y(t0 ) = y0

But : Trouver une approximation de y(t) sur un intervalle [t0 , tf ] quand une solution
analytique est impossible.

2. Concepts clés
a. Discrétisation
tf −t0
On découpe l'intervalle en N pas de temps h =
N

Grille temporelle : tn = t0 + n ⋅ h

Solution approchée : yn ≈ y(tn )

b. Erreurs

Erreur locale : Commise à chaque pas

Erreur globale : Accumulation sur tout l'intervalle

c. Stabilité et convergence

Une méthode est stable si les erreurs ne s'amplifient pas

Convergence : limh→0 max |yn − y(tn )| = 0

keyboard_arrow_down 3. Schémas numériques classiques

a. Méthode d'Euler explicite

Idée : Approximation de la dérivée par une différence finie.

Formule : yn+1 = yn + h ⋅ f (tn , yn )

Ordre : 1 (erreur locale en O(h2 ), globale en O(h))

b. Méthode d'Euler implicite

Formule : yn+1 = yn + h ⋅ f (tn+1 , yn+1 )

Nécessite de résoudre une équation (souvent non-linéaire) pour yn+1

Plus stable pour les problèmes raides
4. Guide d'implémentation en Python
a. Structure générale

def solve_edo(methode, f, y0, t_span, h):

t = [Link](t_span[0], t_span[1] + h, h)
y = [Link](len(t))
y[0] = y0
for n in range(len(t)-1):
y[n+1] = methode(f, t[n], y[n], h)
return t, y

b. Exemple pour Euler explicite

def euler(f, t, y, h):

return y + h * f(t, y)

Pour chaque exercice, identifiez :

Le schéma numérique à utiliser

La fonction f (t, y)
Le pas h optimal
Les conditions initiales

En maîtrisant ces concepts, vous pourrez résoudre des EDO complexes rencontrées
en physique, biologie ou finance.

Exercice 1 : Méthode d'Euler explicite Résoudre l'EDO y ′ = −2y avec y(0) = 1

sur [0, 2] en implémentant la méthode d'Euler. Comparer avec la solution exacte

y(t) = e
−2t
et tracer les deux courbes.

1 import numpy as np
2 import [Link] as plt
3
4 def solve_edo(methode, f, y0, t_span, h):
5 t = [Link](t_span[0], t_span[1] + h, h)
6 y = [Link](len(t))
7 y[0] = y0
8 for n in range(len(t)-1):
9 y[n+1] = methode(f, t[n], y[n], h)
10 return t, y
11
12 def euler(f, t, y, h):
13 return y + h * f(t, y)
14
15 # Définition de l'EDO
16 f = lambda t, y: -2*y
17 t_euler, y_euler = solve_edo(euler, f, 1, (0, 2), 0.1)
 18
19 # Solution exacte
20 t_exact = [Link](0, 2, 100)
21 y_exact = [Link](-2 * t_exact)
22
23 # Visualisation
24 [Link](t_euler, y_euler, 'o-', label='Euler')
25 [Link](t_exact, y_exact, 'k-', label='Exacte')
26 [Link]()
27 [Link]()

keyboard_arrow_down c. Schéma de Heun (Runge-Kutta d'ordre 2)

~
y = yn + h ⋅ f (tn , yn )
n+1
Prédicteur-Correcteur : { h ~
yn+1 = yn + (f (tn , yn ) + f (tn+1 , y ))
2 n+1

Ordre : 2

Exercice 2 : Schéma de Heun (Euler amélioré) Implémenter le schéma de Heun

pour résoudre y ′ = y − t
2
+ 1 avec y(0) = 0.5 sur [0, 2]. Comparer avec la
solution exacte y(t) = (t + 1)
2
− 0.5e
t
.

1 def heun(f, t, y, h):

2 k1 = f(t, y)
3 k2 = f(t + h, y + h*k1)
4 return y + h * (k1 + k2) / 2
5
6 f_heun = lambda t, y: y - t**2 + 1
7 t_heun, y_heun = solve_edo(heun, f_heun, 0.5, (0, 2), 0.1)
8
 9 # Solution exacte
10 y_exact_heun = (t_heun + 1)**2 - 0.5 * [Link](t_heun)
11
12 # Visualisation
13 [Link](t_heun, y_heun, 's-', label='Heun')
14 [Link](t_heun, y_exact_heun, 'k-', label='Exacte')
15 [Link]()
16 [Link]()

keyboard_arrow_down Transformation des EDO d'ordre supérieur

Une EDO d'ordre m peut être transformée en un système de m EDO d'ordre 1 :

′
′′ 2
y = v
y + ω y = 0 ⇒ {
′ 2
v = −ω y

keyboard_arrow_down d. Méthode de Runge-Kutta d'ordre 4 (RK4)

k1 = h ⋅ f (tn , yn )

k2 = h ⋅ f (tn + h/2, yn + k1 /2)

k3 = h ⋅ f (tn + h/2, yn + k2 /2)

Étapes intermédiaires :
k4 = h ⋅ f (tn + h, yn + k3 )

1
yn+1 = yn + (k1 + 2k2 + 2k3 + k4 )
6
Ordre : 4

Exercice 3 : Méthode de Runge-Kutta d'ordre 4 (RK4) Utiliser RK4 pour résoudre

l'oscillateur harmonique y ′′ + ω y = 0² en la transformant en un système d'EDO du
premier ordre. Prendre ω = 3, y(0) = 1, y'(0) = 0.

1 def rk4_system(f, t, y, h):

2 k1 = f(t, y)
3 k2 = f(t + h/2, y + h/2 * k1)
4 k3 = f(t + h/2, y + h/2 * k2)
5 k4 = f(t + h, y + h * k3)
6 return y + h/6 * (k1 + 2*k2 + 2*k3 + k4)
7
8 # Transformation en système d'EDO
9 omega = 3
10 f_harmonic = lambda t, y: [Link]([y[1], -omega**2 * y[0]])
11
12 # Adaptation de solve_edo pour les systèmes vectoriels
13 def solve_edo_system(methode, f, y0, t_span, h):
14 t = [Link](t_span[0], t_span[1] + h, h)
15 y = [Link]((len(t), len(y0)))
16 y[0] = y0
17 for n in range(len(t)-1):
18 y[n+1] = methode(f, t[n], y[n], h)
19 return t, y
20
21 t_rk4, y_rk4 = solve_edo_system(rk4_system, f_harmonic, [1, 0], (0
22
23 # Visualisation de la position y(t)
24 [Link](t_rk4, y_rk4[:, 0], '^-', label='RK4')
25 [Link]('Oscillateur harmonique')
26 [Link]('t')
27 [Link]('y(t)')
28 [Link]()
keyboard_arrow_down e. Méthodes multipas (Adams-Bashforth)

Utilisent les k précédents points pour calculer yn+1

Exemple Adams-Bashforth à 2 pas :
h
yn+1 = yn + (3f (tn , yn ) − f (tn−1 , yn−1 ))
2

Nécessite une initialisation (ex: Euler)

Exercice 5 : Méthode d'Adams-Bashforth à 2 pas Implémenter cette méthode

multipas pour y ′ = 1 + y/t avec y(1) = 2 sur [1, 2]. Utiliser Euler pour initialiser le
premier pas.

1 def adams_bashforth_2(f, t, y, h, f_prev):

2 return y + h/2 * (3*f(t, y) - f_prev)
3
4 # Initialisation manuelle avec Euler
5 t_span = (1, 2)
6 h = 0.1
7 t_ab = [Link](t_span[0], t_span[1] + h, h)
8 y_ab = [Link](len(t_ab))
9 y_ab[0] = 2
10
11 # Premier pas avec Euler
12 f_ab = lambda t, y: 1 + y/t
13 y_ab[1] = euler(f_ab, t_ab[0], y_ab[0], h)
14
15 # Itération avec Adams-Bashforth
 16 for n in range(1, len(t_ab)-1):
17 f_prev = f_ab(t_ab[n-1], y_ab[n-1])
18 y_ab[n+1] = adams_bashforth_2(f_ab, t_ab[n], y_ab[n], h, f_pre
19
20 [Link](t_ab, y_ab, 'x-', label='Adams-Bashforth 2')
21 [Link]('Exercice 5')
22 [Link]()
23 [Link]()

keyboard_arrow_down f. Méthodes implicites (Adams-Moulton)

Combinaison avec des méthodes explicites pour un schéma prédicteur-

correcteur
Exemple Euler + Adams-Moulton :
~
é
Pr dicteur (Euler) : y
n+1
= yn + hf (tn , yn )
{
h ~
Correcteur : yn+1 = yn + (f (tn , yn ) + f (tn+1 , y n+1 ))
2

Exercice 6 : Schéma prédicteur-correcteur (Euler + Adams-Moulton) Combiner

Euler explicite comme prédicteur et Adams-Moulton d'ordre 1 comme correcteur pour
résoudre y ′ = y cos(t) avec y(0) = 1 .

1 def predictor_corrector(f, t, y, h):

2 y_pred = y + h * f(t, y) # Euler explicite
3 y_corr = y + h/2 * (f(t, y) + f(t + h, y_pred)) # Adams-Moult
4 return y_corr
5
 6 f_pc = lambda t, y: y * [Link](t)
7 t_pc, y_pc = solve_edo(predictor_corrector, f_pc, 1, (0, 5), 0.1)
8
9 [Link](t_pc, y_pc, '*-', label='Prédicteur-Correcteur')
10 [Link]('Exercice 6')
11 [Link]()
12 [Link]()

keyboard_arrow_down 4. Problèmes raides et stabilité

Problème raide : Échelles de temps multiples (ex: y ′ = −100y )

Méthodes implicites : Meilleure stabilité (ex: Euler implicite)
Condition de stabilité : Pour Euler explicite, |1 + hλ| < 1 (λ = valeur propre)

Exercice 7 : Méthode d'Euler implicite Résoudre y ′ = −100y (problème raide)

avec y(0) = 1 en utilisant la méthode d'Euler implicite. Comparer la stabilité avec
Euler explicite pour h = 0.1 et h = 0.2.

1 def euler_implicit(f, t, y, h):

2 return y / (1 + 100*h) # Solution analytique pour y' = -λy
3
4 f_implicit = lambda t, y: -100*y
5 t_implicit, y_implicit = solve_edo(euler_implicit, f_implicit, 1,
6
7 [Link](t_implicit, y_implicit, 's-', label='Euler implicite')
8 [Link]('Problème raide')
 9 [Link]()
10 [Link]()

1 import numpy as np
2 import [Link] as plt
3
4 def solve_edo(methode, f, y0, t_span, h):
5 t = [Link](t_span[0], t_span[1] + h, h)
6 y = [Link](len(t))
7 y[0] = y0
8 for n in range(len(t)-1):
9 y[n+1] = methode(f, t[n], y[n], h)
10 return t, y
11
12 def euler(f, t, y, h):
13 return y + h * f(t, y)
14
15 # Définition de l'EDO
16 f = lambda t, y: -100*y
17 t_euler, y_euler = solve_edo(euler, f, 1, (0, 0.5), 0.1)
18
19 # Solution exacte
20 #t_exact = [Link](0, 2, 100)
21 #y_exact = [Link](-2 * t_exact)
22
23 # Visualisation
24 [Link](t_euler, y_euler, 'o-', label='Euler explicite')
25 #[Link](t_exact, y_exact, 'k-', label='Exacte')
26 [Link]()
27 [Link]()
Exercice 4 : Méthode du point milieu Résoudre y ′ = 2ty avec y(0) = 1 sur [0, 1]
2

en utilisant le schéma du point milieu. Comparer avec la solution exacte y(t) = e

t
.

1 def midpoint(f, t, y, h):

2 k1 = f(t, y)
3 k2 = f(t + h/2, y + h/2 * k1)
4 return y + h * k2
5
6 f_midpoint = lambda t, y: 2 * t * y
7 t_mid, y_mid = solve_edo(midpoint, f_midpoint, 1, (0, 1), 0.1)
8
9 # Solution exacte
10 y_exact_mid = [Link](t_mid**2)
11
12 # Visualisation
13 [Link](t_mid, y_mid, 'd-', label='Point milieu')
14 [Link](t_mid, y_exact_mid, 'k-', label='Exacte')
15 [Link]()
16 [Link]()
keyboard_arrow_down 7. Analyse d'erreur

Ordre de convergence : Si Erreur ≈ Ch

p
, la méthode est d'ordre p
Calcul pratique : Erreur = max |yn − yexact (tn )|

8. Applications aux exercices proposés

Exercice 1 & 7 : Comparer Euler explicite/implicite via la stabilité
Exercice 3 : Transformer y ′′ 2
+ ω y = 0 en système pour utiliser RK4
Exercice 5 : Initialiser Adams-Bashforth avec Euler
Exercice 6 : Implémenter une boucle prédicteur-correcteur

Conclusion
Cette théorie fournit les outils pour :

1. Choisir un schéma adapté (précision, stabilité)

2. Implémenter les méthodes en Python
3. Analyser les résultats (erreur, convergence)

Conseils :

Utiliser des pas temporels variables pour explorer la stabilité

Calculer l'erreur globale par rapport à la solution exacte
Généraliser les implémentations en fonctions réutilisables
Étudier l'ordre de convergence via des analyses d'erreur
Ces exercices couvrent les méthodes classiques (Euler, RK4), les schémas multipas
(Adams), les méthodes implicites, et la gestion de problèmes raides.

1 import numpy as np
2 import [Link] as plt
3
4 def euler(f, t, y, h):
5 k1 = f(t, y)
6 return y + h *k1
7
8 # Transformation en système d'EDO
9 omega = 3
10 f_harmonic = lambda t, y: [Link]([y[1], -omega**2 * y[0]])
11
12 # Adaptation de solve_edo pour les systèmes vectoriels
13 def solve_edo_system(methode, f, y0, t_span, h):
14 t = [Link](t_span[0], t_span[1] + h, h)
15 y = [Link]((len(t), len(y0)))
16 y[0] = y0
17 for n in range(len(t)-1):
18 y[n+1] = methode(f, t[n], y[n], h)
19 return t, y
20
21 t_rk4, y_rk4 = solve_edo_system(euler, f_harmonic, [1, 0], (0, 4*n
22
23 # Visualisation de la position y(t)
24 [Link](t_rk4, y_rk4[:, 0], '-', label='RK4')
25 [Link](t_rk4, [Link](omega*t_rk4), '-', label='RK4')
26 [Link]('Oscillateur harmonique')
27 [Link]('t')
28 [Link]('y(t)')
29 [Link]()