Corrigé de la feuille de TP N° 1 (EDO)

FASSI FIHRI Abdelkader

December 4, 2023

0.1 Exercice 1 (Euler explicite)

On cherche à mettre en œuvre la méthode d’Euler explicite pour la résolution numérique du prob-
𝑦′ (𝑡) = 𝑓(𝑡, 𝑦(𝑡)), 𝑡 ∈ [0, 𝑇 ]
lème de Cauchy {
𝑦(0) = 𝑦0
Elle consiste, pour un pas ℎ donné, à construire une suite d’approximations (𝑦𝑛 ) de la solution 𝑦
aux temps 𝑡𝑛 = 𝑛ℎ, par la formule 𝑦𝑛+1 = 𝑦𝑛 + ℎ𝑓(𝑡𝑛 , 𝑦𝑛 ). Par la suite, on utilise l’exemple modèle
𝑦′ = 𝑡 − 𝑡𝑦 avec la condition initiale 𝑦(0) = 2.
−𝑡2
La solution exacte de cet exemple est donnée par 𝑦(𝑡) = 1 + 𝑒 2 .
A la fin de cette série de TP vous trouvez le programme principal, le programme du schéma d’Euler
explicite et le programme de la fonction f.
1. Tester le programme et interpréter la figure affichée

[1]: #Schema Euler Explicite : fonction "SchemaExp"

#
def SchemaExp(f,u0,t0,T,N):
h=(T-t0)/N
t=np.linspace(t0,T,N+1)
u=np.zeros(N+1)
u[0]=u0
for i in range(N):
u[i+1]=u[i]+h*f(t[i],u[i])
return t,u

[2]: #programme de la fonction f

#
def fonct(t,u):
return t-t*u

[3]: # Programme principal

import numpy as np
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = [16, 8]
T=2.
t0=0
u0=2.
N=10

1
 h=T/N
t,u=SchemaExp(fonct,u0,t0,T,N)
#ue = solext(t) # doit etre programme
#er=np.linalg.norm((ue-u),ord=np.inf)
plt.plot(t,u,color='k',ls='--',marker='*',label="solution approchée")
#plt.plot(t,ue,color='b',ls=':',label="solution exacte")
plt.xlabel('time')
plt.ylabel('solution u')
plt.title('Solution approchee par Euler explicite')
plt.legend()
plt.show()

Le programme fourni permet de tracer la solution approchée par la méthode d’Euler explicite du
problème de Cauchy ci-desus en considérant une subdivion de l’intervalle [0,2] en 10 sous-intervalles
(N=10).
2. Programmer la solution exacte, puis calculer l’erreur d’approximation;

[4]: #programme de la solution exacte

#
def solext(t):
return 1+np.exp(-t**2/2)

[5]: ue = solext(t) # doit etre programme

er=np.linalg.norm((ue-u),ord=np.inf)
print(ue-u)

[ 0. -0.01980133 -0.03688365 -0.04792979 -0.05106696 -0.04633078

-0.0355369 -0.02162866 -0.00775932 0.00355699 0.01095659]

2
 3. Tracer les deux solutions sur la même figure;

[6]: plt.plot(t,u,color='k',ls='--',label="solution approchée")

plt.plot(t,ue,color='b',ls=':',label="solution exacte")
plt.xlabel('time')
plt.ylabel('solution u')
plt.title('Solution approchee par Euler explicite')
plt.legend()
plt.show()

4. Effectuer des simulations pour différentes valeurs du pas ℎ (ℎ = 𝑇 /𝑁 avec 𝑁 = 10 ∶ 10 ∶ 1000);

[7]: N=1000
t=np.linspace(t0,T,N+1)
ue = solext(t)
plt.plot(t,ue,color='b',ls=':',label="solution exacte")
for N in range(10,1001,100):
h=T/N
t,u=SchemaExp(fonct,u0,t0,T,N)
if N < 100:
plt.plot(t,u,color='k',label="N="+str(N))
plt.xlabel('time')
plt.ylabel('solution u')
plt.title('Solution approchee par Euler explicite')
plt.legend()
plt.show()

3
 5. Tracer la courbe du log des erreurs d’approximation en fonction du log des pas h;

[8]: list_err=[]
list_h=[]
for N in range(10,1001,10):
h=T/N
list_h.append(h)
t,u=SchemaExp(fonct,u0,t0,T,N)
ue = solext(t)
er=np.linalg.norm(abs(ue-u),ord=np.inf)
list_err.append(er)
#
plt.loglog(list_h,list_err,color='k',label="Erreur")
plt.xlabel('h')
plt.ylabel('Erreur')
plt.title('Erreur en fonction de h')
plt.legend()
plt.show()

4
 6. Quel est l’ordre obtenue numériquement du schéma d’Euler explicite. L’ordre numérique est
la pente de la droite de la régression linéaire des points.

[9]: # Calcul de l’ordre numerique

lh = np.log(list_h)
ler=np.log(list_err)
# ler : liste des erreurs correspondantes à lh
print(np.polyfit(lh,ler,1))

[ 1.01003568 -1.41156624]
La droite de regression est une droite de pente 1. On retrouve ainsi que la méthode d’Euler explicite
est une méthode d’ordre 1.

0.2 Exercice 2 (Euler point milieu)

On utilise ici l’exemple modèle précédent y�(t) = t − ty(t), y(0) = 2. La solution exacte est donnée
−𝑡2
par 𝑦(𝑡) = 1 + 𝑒 2 .
Le schéma d’Euler point milieu consiste à construire une suite d’approximations (𝑦𝑛 ) de la solution y
𝑦 1 = 𝑦𝑛 + ℎ2 𝑓(𝑡𝑛 , 𝑦𝑛 )
de la façon suivante : { 𝑛+ 2 1. Ecrire une fonction “EulerPointMilieu”
𝑦𝑛+1 = 𝑦𝑛 + ℎ𝑓(𝑡𝑛 + ℎ2 , 𝑦𝑛+ 1 ).
2
qui permet de calculer la solution approchée 𝑦𝑛 par la méthode d’Euler point milieu.

[10]: #Schema Euler point milieu : fonction "EulerPointMilieu"

#
def EulerPointMilieu(f,u0,t0,T,N):
h=(T-t0)/N
t=np.linspace(t0,T,N+1)
u=np.zeros(N+1)

5
 u[0]=u0
for i in range(N):
uu=u[i]+0.5*h*f(t[i],u[i])
u[i+1]=u[i]+h*f(t[i]+0.5*h,uu)
return t,u

2. Tracer les deux solutions approchées (Euler explicite et point milieu) et la solution exacte sur
la même figure

[13]: import numpy as np

import matplotlib.pyplot as plt
T=10.
t0=2.
u0=1.+np.exp(-2)
N=50
h=(T-t0)/N
t1,u1=SchemaExp(fonct,u0,t0,T,N)
ue = solext(t1)
t2,u2=EulerPointMilieu(fonct,u0,t0,T,N)
plt.plot(t1,u1,color='k',ls='--',label="Euler Explicite")
plt.plot(t1,ue,color='b',ls=':',label="solution exacte")
plt.plot(t1,u2,color='r',ls='-',label="Euler Point Milieu")
plt.xlabel('time')
plt.ylabel('solution u')
plt.title('Solution approchee par Euler explicite et Euler Point Milieu')
plt.legend()
plt.show()

6
 3. Déterminer numériquement l’ordre de la méthode d’Euler point milieu.

[14]: list_err=[]
list_h=[]
for N in range(50,1001,10):
h=T/N
list_h.append(h)
t,u=EulerPointMilieu(fonct,u0,t0,T,N)
ue = solext(t)
er=np.linalg.norm(abs(ue-u),ord=np.inf)
list_err.append(er)
#
plt.loglog(list_h,list_err,color='k',label="Erreur")
plt.xlabel('h en log')
plt.ylabel('Erreur en log')
plt.title('Erreur en fonction de h de la méthode Euler Point Milieu')
plt.legend()
plt.show()

# Calcul de l’ordre numerique

lh = np.log(list_h)
ler=np.log(list_err)
# ler : liste des erreurs correspondantes à lh
print(np.polyfit(lh,ler,1))

[ 2.05365172 -3.6983164 ]
On retrouve numériquement que l’ordre de la méthode d’Euler Point Milieu est donc 2.