Calcul Scientifique

Fili` ere : MP CPGE LOK Mekn` es
Classes : MP3 et MP4 - ´ Equations diff´erentielles Octobre 2019
´
Equations diff´erentielles
3 Introduction
Les ´equations diff´erentielles ordinaires (EDO) apparaissent tr`es souvent dans la mod´elisation de la physique
et des sciences de l’ing´enieur. Trouver la solution d’une EDO ou d’un syst`eme d’EDO est ainsi un probl`eme
courant, souvent difficile ou impossible `a r´esoudre de facon analytique. Il est alors n´ecessaire de recourir `a des
m´ethodes num´eriques pour r´esoudre ces ´equations diff´erentielles.
La m´ethode d’Euler est une proc´edure num´erique qui permet de r´esoudre de fa¸con approximative des ´equations
diff´erentielles ordinaires du premier ordre avec condition initiale. Elle a le m´erite d’ˆetre simple `a comprendre et
`a programmer.
3.1 Contexte
Dans le d´ebut de cette partie, on consid´erera l’exemple suivant :
(y0= 2ty2sur [0,2]
y(0) = 0.2
3.2 Principe
On consid`ere une ´equation diff´erentielle du type y’=F(t,y) o`u F est une fonction `a deux variables.
Soit y une solution de l’´equation diff´erentielle. Pour h petit, on peut ´ecrire : y0(t) = y(t+h)−y(t)
h
Dans le cas de l’exemple, on a F(t,y) = .............. et donc y(t+h) = ......................
Pour i∈[0, n] on pose ti= ......................................, le n-i`eme point de la subdivision ainsi cr´e´ee
3.3 M´ethode
On cherche `a repr´esenter sur l’intervalle [a, b] la solution approch´ee de l’´equation y’=F(t,y) telle que y(a)=c.
La m´ethode consiste `a construire une suite de points (tn, yn)∈IN approchant les points r´eels de la courbe de
la solution f.
•On souhaite obtenir une approximation de y(ti) pour tout entier i entre 0 et n.
On a au d´epart y(a)=c. On a donc un premier point de coordonn´ees (t0,y0).
On approche y(t1) par le nombre y1 avec la formule : y(t1) = y(t0) + hy0(t0) = y0+hF (t0, y0). On a alors un
deuxi`eme point de coordonn´ees (t1, y1)...etc
A l’´etape i (i ∈[1,n-1]), on a donc : ti+1 =................. et yi+1 =.........................
3.4 Application `a la main
Effectuer `a la main la r´esolution approch´ee de l’´equation y0= 2ty2sur [0,2] avec y(0) = 0.2 pour n= 4
Tracer la courbe obtenue.
5

3.5 Impl´ementation en langage Python
1def Euler_ordre_1_explicite(F,a,b,n,y0):
2y=y0
3Y=[y]
4t=a
5T=[t]
6h=(b-a)/n
7for iin range(n):
8y=y+h*F(t,y)
9t=t+h
10 Y.append(y)
11 T.append(t)
12 return T,Y
6

4 M´ethode Euler implicite
4.1 Introduction
Dans l’approximation par la m´ethode Euler explicite, on dit que la surface des rectangles form´es entre les in-
stants tiet ti+1 est calcul´ee en utilisant la m´ethode du rectangle gauche.
Dans la m´ethode Euler implicite, on utilise la m´ethode du rectangle droit, ce qui nous donne :
y(ti+1) = y(ti) + h∗F(ti+1, y(ti+1))
Le probl`eme de cette ´equation est qu’elle met en oeuvre, en seconde membre une fonction du membre y(ti+1)
qu’on cherche `a calculer. Ceci nous ram`ene `a la r´esolution d’une ´equation de la forme f(x) = 0 qu’on d´ej`a vu
quelques m´ethodes de r´esolution
4.2 Impl´ementation en langage Python
1from scipy.optimize import fsolve
2def Euler_ordre_1_implicite(F,a,b,n,y0):
3y,t=y0,a
4Y,T=[y],[t]
5h=(b-a)/n
6for iin range(1,n+1):
7y=fsolve(lambda y:Y[i-1]+h*F(T[i],y)-y,0.01)
8t=t+h
9Y.append(y)
10 T.append(t)
11 return T,Y
5 M´ethode de Heun
5.1 Principe
Pour tenter d’am´eliorer l’´eficacit´e de la m´ethode d’Euler, on peut envisager d’am´eliorer l’approximation de
d´epart : y(ti+1) = yi+hF (ti, yi) par : y(ti+1) = y(ti) + h
2(F(ti, yi) + F(ti+1, yi+1)) qui est implicite au sens o`u
elle fait intervenir la valeur de yi+1 qu’on cherche `a approcher, en rempla¸cant dans cette formule, le terme yi+1
par l’approximation de d´epart : y(ti+1) = yi+hF (ti, yi) on obtient la formule explicite :
y(ti+1) = yi+h∗F(ti+ (h/2), yi+ (h/2) ∗F(ti, yi))
Cette approximation est appel´ee : approximation par la m´ethode de Heun
5.2 Impl´ementation en langage Python
1def Heun_ordre_1(F,a,b,n,y0):
2y,t=y0,a
3Y,T=[y],[t]
4h=(b-a)/n
5for iin range(1,n+1):
6y=y+h*F(t+(h/2),y+(h/2)*F(t,y))
7t=t+h
8Y.append(y)
9T.append(t)
10 return T,Y
7

6 M´ethode de Runge-Kutta4 (RK4)
6.1 Principe
Les m´ethodes de Runge-Kutta sont des m´ethodes d’analyse num´erique d’approximation de solutions d’´equations
diff´erentielles. Elles ont ´et´e nomm´ees ainsi en l’honneur des math´ematiciens Carl Runge et Martin Wilhelm
Kutta lesquels ´elabor`erent la m´ethode en 1901.
Ces m´ethodes reposent sur le principe de l’it´eration, c’est-`a-dire qu’une premi`ere estimation de la solution est
utilis´ee pour calculer une seconde estimation, plus pr´ecise, et ainsi de suite.
Dans cette m´ethode, on calcul les termes suivants :
a=F(ti, yi)
b=F(ti+h
2, yi+a 2)
c=F(ti+h
2, yi+b 2)
d=F(ti+h, yi+c)
et on approxime la valeur de yi+1 par la formule : yi+1 =a+2∗b+2∗c+d
6
6.2 Impl´ementation en langage Python
1def RK4_ordre_1(F,a,b,n,y0):
2y,t=y0,a
3Y,T=[y],[t]
4h=(b-a)/n
5for iin range(1,n+1):
6a=h*F(t,y)
7b=h*F(t+h/2,y+a/2)
8c=h*F(t+h/2,y+b/2)
9d=h*F(t+h,y+c)
10 y=y+(1/6)*(a+2*b+2*c+d)
11 t=t+h
12 Y.append(y)
13 T.append(t)
14 return T,Y
7 M´ethode odeint
La m´ethode odeint du module scipy.integrate impl´emente la d´emarche Euler pour la r´esolution des ´equation
diff´erentielles d’ordre 1 (Probl`eme de Cauchy)
Elle prend en argument la fonction F, la condition initiale y0et une liste de temps commen¸cant `a t0. Par
exemple, pour r´esoudre y0=ysur [0,1] avec y(0) = 1. On pourra ´ecrire le script suivant :
1from scipy.integrate import odeint
2import numpy as np
3import matplotlib.pyplot as plt
4def F(y,t):
5return y
6temps = np.linspace(0, 1, 10)
7Y = odeint(F, 1, temps)
8plt.plot(temps,Y)
9plt.show()
8 Simulation
Comparer les m´ethode illustr´ees dans les sections pr´ec´edentes pour r´esoudre les EDO suivantes :
1. (y0(x) + y(x) =cos(x)
y(0) =3
La solution alg´ebrique est donn´ee par la formule :
y(x) = 1
2(cos(x) + sin(x)+5e−x)
8
2. (y0(x) =xy2(x)
y(0) =2
De mˆeme on peut observer que : y(x) = 2
1
−
x2

Corrige de l’equation 1
1import numpy as np
2import scipy.integrate as sp
3from scipy.optimize import fsolve
4import matplotlib.pyplot as plt
5def Euler_ordre1_explicit(F,a,b,y0,n):
6y,t,Y,T,h=y0,a,[y0],[a],(b-a)/n
7for iin range(n):
8y=y+h*F(t,y)
9t=t+h
10 Y.append(y)
11 T.append(t)
12 return T,Y
13 def Heun(F,a,b,y0,n):
14 y,t,Y,T,h=y0,a,[y0],[a],(b-a)/n
15 for iin range(n):
16 x=y+(h/2)*F(t,y)
17 y=y+h*F(t+(h/2), x)
18 t=t+h
19 Y.append(y)
20 T.append(t)
21 return T,Y
22 def RK4(F,a,b,y0,n):
23 y,t,Y,T,h=y0,a,[y0],[a],(b-a)/n
24 for iin range(n):
25 x1=h*F(t,y)
26 x2=h*F(t+h/2,y+x1/2)
27 x3=h*F(t+h/2,y+x2/2)
28 x4=h*F(t+h,y+x3)
29 y=y+(1/6)*(x1+2*x2+2*x3+x4)
30 t=t+h
31 Y.append(y)
32 T.append(t)
33 return T,Y
34 def F(t,y):
35 return -y+np.cos(t)
36 def SolExacte(T):
37 Y=[]
38 for xin T:
39 Y.append( 0.5*(np.cos(x)+np.sin(x)+5*np.exp(-x)))
40 return Y
41 T1,Y1=Euler_ordre1_explicit(F,0,1,3,50)
42 T2,Y2=Heun(F,0,1,3,50)
43 T3,Y3=RK4(F,0,1,3,50)
44 Y4=sp.odeint(F,3,T1)
45 Y5=SolExacte(T1)
46
47 plt.plot(T1,Y1,’b-.’,label=’Euler␣explicite’)
48 plt.plot(T1,Y5,’g-s’,label=’Solution␣exacte’)
49 plt.plot(T1,Y2,’y-h’,label=’Heun’)
50 plt.plot(T1,Y3,’ro’,label=’RK4’)
51 plt.plot(T1,Y3,’c-x’,label=’odeint’)
9
´ ´
52 plt.grid()
53 plt.legend()
54 plt.show()