022 - Résolution des équations différentielles - Premier Ordre

September 3, 2023

1 Méthode d’Euler où n désigne le nombre de subdivisions

d’intervalles
[1]: def euler(F,a,b,y0,n):
T=[a]
Y=[y0]
h=(b-a)/n
for i in range(1,n+1):
T.append(a+i*h)
y=Y[i-1]+h*F(T[i-1],Y[i-1])
Y.append(y)
return T,Y

2 Méthode d’Euler où n désigne le nombre des éléments de

l’intervalle
[2]: def euler2(F,t0,h,y0,n):
T=[t0]
Y=[y0]
for i in range(1,n):
T.append(t0+i*h)
y=Y[i-1]+h*F(T[i-1],Y[i-1])
Y.append(y)
return T,Y

3 Application de la méthode d’euler

[3]: # Soit L'équation différentielle suivante (E) : 5Y'(t) - Y(t)² = 6 pour tout t␣
↪dans [0,1] avec Y(0) = 1

# 1 - L'equation différentielle peut elle être résolu à l'aide de la méthode␣

↪d'Euler ? Justifier ?

# 2 - Au cas où elle peut être résolu, écrire le programme python qui résout␣
↪l'équation et qui affiche la liste des temps (abscisses)

# et la liste des solutions (ordonnées) pour n=50.

1
 # NB : La fonction euler est définie, on ne demande pas de la redéfinir, on␣
↪doit l'utiliser.

[4]: # 1 - (E) <==> Y'(t) = (Y(t)² + 6)/5 = F(t,Y(t)) avec F(x,y) = (y²+6)/5
# Donc l'équation peut être résolue à l'aide de la méthode d'Euler

[5]: # 2 -
# Premièrement on définit la fonction F
def F(x,y):
return (y**2+6)/5
# On fait appel à la fonction euler
T = euler(F,0,1,1,50)
print("La liste des abscisses est :",T[0])
print("La liste des solutions est :",T[1])

La liste des abscisses est : [0, 0.02, 0.04, 0.06, 0.08, 0.1, 0.12, 0.14, 0.16,
0.18, 0.2, 0.22, 0.24, 0.26, 0.28, 0.3, 0.32, 0.34, 0.36, 0.38, 0.4, 0.42, 0.44,
0.46, 0.48, 0.5, 0.52, 0.54, 0.56, 0.58, 0.6, 0.62, 0.64, 0.66, 0.68,
0.7000000000000001, 0.72, 0.74, 0.76, 0.78, 0.8, 0.8200000000000001, 0.84, 0.86,
0.88, 0.9, 0.92, 0.9400000000000001, 0.96, 0.98, 1.0]
La liste des solutions est : [1, 1.028, 1.056227136, 1.084689599051291,
1.1133958051564512, 1.142354406032211, 1.1715743003881358, 1.2010646457534555,
1.230834870886571, 1.2608946888041326, 1.2912541104691504, 1.3219234591803644,
1.35291338570809, 1.3842348842250025, 1.415899309083824, 1.4479183924976804,
1.4803042631830126, 1.5130694660294037, 1.5462269828655257, 1.5797902543956914,
1.6137732033872259, 1.6481902591951085, 1.683056383717131, 1.718387098880215,
1.754198515766607, 1.790507365497478, 1.8273310320010807, 1.8646875868031372,
1.902595825988648, 1.9410753094969257, 1.98014640292548, 2.0198303220335547,
2.0601491801527794, 2.1011260387307162, 2.1427849612532452, 2.1851510708139377,
2.228250611623055, 2.272111014775849, 2.3167609686297124, 2.3622304941727768,
2.4085510258031757, 2.4557554979787657, 2.5038784382421775, 2.552956067176154,
2.60302640589988, 2.6541293917791284, 2.706307003092352, 2.759603393472299,
2.8140650370293545, 2.8697408851598785, 2.9266825361517115]

4 Autres méthodes
4.1 Méthode de Runge-Kutta d’ordre 2 (Appelée aussi méthode de Heun)
La méthode est basée sur la formule suivante

[6]: def runge_kutta2(F,a,b,n,y0):

h=(b-a)/n
T=[a+i*h for i in range(n+1)]
Y=[y0]
for i in range(1,n+1):
k1=F(T[i-1],Y[i-1])
k2=F(T[i-1]+h,Y[i-1]+h*k1)
y=Y[i-1]+(h/2)*(k1+k2)

2
 Y.append(y)
return T,Y

4.2 Méthode de Runge-Kutta d’ordre 4

La méthode est basée sur la formule suivante

[7]: def runge_kutta4(F,a,b,n,y0):

h=(b-a)/n
T=[a+i*h for i in range(n+1)]
Y=[y0]
for i in range(1,n+1):
c=h/2
k1=F(T[i-1],Y[i-1])
k2=F(T[i-1]+c,Y[i-1]+c*k1)
k3=F(T[i-1]+c,Y[i-1]+c*k2)
k4=F(T[i-1]+h,Y[i-1]+h*k3)
y=Y[i-1]+(h/6)*(k1+2*k2+2*k3+k4)
Y.append(y)
return T,Y