Chapitre - Equation differentielle

25/03/2019
I. Les équations scalaires d’ordre 1
1. Introduction
Soit n ∈ N* et U un ouvert de RxR . Une équation différentielle
d’ordre 1 (résolue) est une équation de la forme :
y'(t) = F(y(t), t)
Résolution approchée d’équations
différentielles
Ingénierie numérique et simulation
1
HICHAM HATIMI
www.hatimi.net
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
Principe :
 On cherche à résoudre sur [a, b] l’équation de la forme:
y'( t) = f( y( t), t) avec y( t0) = y0
 Si y(t) est de classe C1 alors, connaissant y(ti), on peut évaluer de
façon approché, y(ti+1) par son développement de Taylor à l’ordre
1:
y(ti+1) = y(ti) + y'(ti)*(ti+1 − ti)
 Soit en posant h = ti+1 − ti et avec y’(ti) = f(y(ti), ti) :
y(ti+1) = y(ti) + f(y(ti), ti)*h
 Connaissant y(a), on évalue par itérations successives les valeurs
approchées de la fonction y(t) :
[y(a), y(a + h), y(a + 2h), y(a + 3h)...y(b − h), y(b)]
3
2
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
 Interprétation
géométrique :
4
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
 Implémentation
de la méthode d’Euler en Python :
############Solution 1 en utilisant les listes############
def Euler(f,a,b,y0,h) :
y=y0
t=a
yi =[y0]
ti =[a]
while t+h <= b :
y =y+ h * f(y,t)
t=t+h
yi.append(y)#On peut faire yi=yi+[y]
ti.append(t)
return ti, yi
5
où F est une application continue sur U à valeurs dans Rn et où la
fonction inconnue y est de classe C1 sur un certain intervalle de R, à
valeurs dans Rn.
Dans le cas où n = 1, on parle d’une equation différentielle
scalaire ; dans le cas general, on obtient un système différentiel.
Si (t0, y0) ∈ U, résoudre le problème de Cauchy en (t0, y0), c’est trouver
un couple (I, y) où I est un intervalle de R et où y est une fonction de
classe C1 de I dans Rn tels que :
y(t0) = y0 et ∀t ∈ I y'(t) = F(y(t), t)
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
 Exemple d'utilisation 1 :
import numpy as np
import matplotlib.pyplot as pl
######Definir la fonction F
def F(y,t) :
return y
h=(5-0)/50#51 point
y0=1
#La fonction Euler de Solution 1
L= Euler(F,0,5,y0,h)
pl.plot(L[0],L[1])
pl.xlabel('temps')
pl.ylabel('y(t) ')
pl.show()
6
1
25/03/2019
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
#######Solution 2 en utilisant les listes ##########
def Euler(f,a,b,y0,h) :
y=y0
t=a
yi=[y0]
ti =[a]
n=int((b-a)/h)
for i in range(1,n+1) :
y =y+ h * f(y,t)
t=t+h
yi.append(y)
ti.append(t)
return ti, yi
7
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
Code en utilisant le module numpy:
############Solution 3#### ########
def Euler(f,a,b,y0,n) :
#générer un vecteur de n+1 valeurs
y=np.array([0]*(n+1),dtype='float')
#générer le vecteur t=[t0,t1,... ,tn]
t=np.linspace(a,b,n+1)
y[0]=y0
h=(b-a)/n
for i in range(1,n+1) :
y[i]=y[i-1]+h*f(y[i-1],t[i-1])
return y
9
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
############Solution 4#### ########
#Entrée : une fonction f, la condition initiale y0 et un
vecteur t=[t0,t1,..,tn-1]
#Sortie : y un vecteur qui contient la solution de l’équation
def Euler(f,y0,t) :
n=len(t)
y=np.array([y0]*n,dtype='float')
for i in range(n-1) :
y[i+1]=y[i]+(t[i+1]-t[i] )*f(y[i],t[i])
return y
11
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
 Exemple d'utilisation 2 :
import numpy as np
import matplotlib.pyplot as pl
######Definir la fonction F
def F(y,t) :
return y
h=(5-0)/50
y0=1
#La fonction Euler de Solution 2
L= Euler(F,0,5,y0,h)
pl.plot(L[0],L[1])
pl.xlabel('temps')
pl.ylabel('y(t) ')
pl.show()
8
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
 Exemple d'utilisation 3 :
import numpy as np
import matplotlib.pyplot as pl
######Definir la fonction F
def F(y,t) :
return y
t= np.linspace(0, 5, 51)
y0=1
#La fonction Euler de Solution 3
y= Euler(F,0,5,y0,50)
pl.plot(t,y)
pl.xlabel('temps')
pl.ylabel('y(t) ')
pl.show()
10
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler
 Exemple d'utilisation 4 :
import numpy as np
import matplotlib.pyplot as pl
######Definir la fonction F
def F(y,t) :
return y
t= np.linspace(0, 5, 51)
y0=1
#La fonction Euler de Solution 3
y= Euler(F,y0,t)
pl.plot(t,y)
pl.xlabel('temps')
pl.ylabel('y(t) ')
pl.show()
12
2
25/03/2019
I. Les équations scalaires d’ordre 1
2. La méthode d’Euler

Exemple d'utilisation 2 :
Considérons l’équation différentielle du premier ordre relative à la charge d’un
condensateur :
C=1e-6
R=1e3
tau=R*C
E=6
u0=0
def equation(u,t) :
y=-u/tau+E/tau
return y
t= np.linspace(0,5*tau,1000)
#La fonction Euler donnée dans sol 4
y=Euler(equation,u0,t)
pl.plot(t,y)
pl.show()
13
I. Les équations scalaires d’ordre 1
3. La méthode de Heun, ou RK2
 Implémentation de la méthode RK2
####Solution en utilisant les listes#
def Heun(F, a, b, y0, n) :
h= (b - a)/n
X = [a]
t=a
Y = [y0]
y = y0
for k in range(0, n) :
k1= F(y, t)
k2=F(y+h*k1,t+h)
y = y + h*(k1+k2)/2
t=t+h
X.append(t)
Y.append(y)
return X, Y
14
I. Les équations scalaires d’ordre 1
3. La méthode de Heun, ou RK2
I. Les équations scalaires d’ordre 1
4) La méthode de Runge-Kutta (ou RK4)
#########Solution en utilisa nt le module numpy#########
import numpy as np
def Heun(f,y0,t) :
n = len(t)
y = np.array( [ y0 ] * n,dtype='float' )
for i in range(n-1) :
h=t[i+1] - t[i]
k1= f( y[i],t[ i] )
k2 = f( y[i] + k1*h,t[i+1])
y[i+1] = y[i] + h*( k1 + k2 ) / 2.0
return y
L'équation de Runge-Kutta (ou RK4) :
15
I. Les équations scalaires d’ordre 1
4) La méthode de Runge-Kutta (ou RK4)
#########Solution en utilisant les listes#########
def RK4(F, a, b, y0, n) :
h= (b - a) / n
h2= h/ 2
X = [a]
t=a
Y = [y0]
y = y0
for k in range(0, n) :
K1 = F(t, y)
K2 = F(t + h2, y + h2* K1)
K3 = F(t + h2, y + h2* K2)
K4 = F(t + h, y + h* K3)
y = y + h* (K1 + 2 * K2 + 2 * K3 +K4) / 6
t=t+h
X.append(t)
Y.append(y)
return X, Y
17
yn+1=yn +h* (k1+2k2+2k3+k4)/6
Sachant que :
k1=f(xn,yn)
k2=f(xn+h/2,yn+hk1/2)
k3=f(xn+h/2,yn+hk2/2)
k4=f(xn+h,yn+hk3)
16
I. Les équations scalaires d’ordre 1
4) La méthode de Runge-Kutta (ou RK4)
#######Solution en utilisa nt le mo dule numpy#####
import numpy as np
def RK4(f,y0, t ) :
n = len( t )
y = np.array( [ y0 ] * n,dtype='float' )
for i in range( n - 1 ) :
h = t[i+1] - t[i]
k1 = f(y[i], t[i] )
k2 = f( y[i] + h* k1/2, t[i] + 0.5 * h )
k3 = f( y[i] + h* k2/2, t[i] + 0.5 * h )
k4 = f( y[i] + h*k3, t[i+1] )
y[i+1] = y[i] + h*( k1 + 2.0 * ( k2 + k3 ) + k4 ) / 6.0
return y
18
3
25/03/2019
Les équations scalaires d’ordre 1
La fonction o deint
I. Les équations scalaires d’ordre 1
5) La fonction odeint
I. Les équations scalaires d’ordre 1
Le module scipy.integrate fournit la fonction odeint qui est un ”mix” de
Runge Kutta d’ordre 4 avec des méthodes à pas adaptatif. La fonction odeint
permet de résoudre les équations différentielles du premier ordre et du
deuxième ordre.
Exemple 1 d’utilisation de la fonction odeint. Considérons l’équation
différentielle du premier ordre
Syntaxe et utilisation
from scipy.integrate import odeint
Ys=odeint(f,CondInit,t)
 f pointe sur la fonction CONNUE f dans y’(t)=f(y(t),t). Attention : le premier
argument de f est la fonction vectorielle inconnue y.
 CondInit pointe sur le vecteur des conditions initiales.
y(t0)= [y1(t0), y2(t0), ....yn(t0)]
 t pointe sur les points définissant le découpage de l’intervalle de résolution
I = [t0 ; t0 + T]
La solution Ys contient les valeurs des solutions approchées sur les différents
points indiques de I
19
5) La fonction odeint
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
def F(y,t) :
return y
t= np.linspace(0, 5, 50)
y= odeint(F, 1, t)
pl.plot(t,y)
pl.show()
20
II. Les équations différentielles d’ordre 2
1. Représentation matricielle
II. Les équations différentielles d’ordre 2
2. La méthode d’Euler
L’objectif est de résoudre l’équation différentielle du second ordre:
y’’ =f(y,y’,t)
Y= [y(t) ,y’(t)]
Y’=F(Y , t) = [y’(t) , f( y, y’,t) ]=[Y[1],f(Y[0],Y[1],t)]
def F(Y,t) :
return np.array([Y[1],f(Y[0],Y[1],t)])
def Euler2(F,a,b,Y0,n) :
h=(b-a)/n
t=np.linspace(a,b,n+1)
SY=np.array([[0.0,0.0] for i in range(n+1)])
SY[0]=Y0
for i in range(1,n+1) :
SY[i]=SY[i-1]+ h*F(SY[i-1],t[i-1])
return SY
21
22
II. Les équations différentielles d’ordre 2
2. La méthode d’Euler
II. Les équations différentielles d’ordre 2
2. La méthode d’Euler
Exemple Considérons l’équation différentielle du second
ordre
def F(Y,t) :
return np.array([Y[1],0.5*(1-Y[0]*Y[0])*Y[1]-Y[0]])
def Euler2(F,a,b,Y0,n) :
h=(b-a)/n
t=np.linspace(a,b,n+1)
SY=np.array([[0.0,0.0] for i in range(n+1)])
SY[0]=Y0
for i in range(1,n+1) :
SY[i]=SY[i-1]+ h*F(SY[i-1],t[i-1])
return SY
t=np.linspace(0,100,1000)
Y0=[0,0.1]
y= Euler2(F,0,100,Y0,999)
pl.plot(t,y)
x’’ =f(x,x’,t)
X= [x(t) ,x’(t)]
X’ =F(X(t),t)
X(t0)= [x(t0) ,x’(t0)]
F(X , t) = [x’(t) , f( x, x’,t) ]=[X[1],0.5*(1-X[0]**2)*X[1]-X[0]]
23
24
4
25/03/2019
II. Les équations différentielles d’ordre 2
3. Fonction odeint pour l'ordre 2
import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as pl
def F(Y,t) :
return [Y[1],0.5*(1-Y[0]**2)*Y[1]-Y[0]]
init=[0,0.1]
t=np.linspace(0,100,1000)
y=odeint(F,init,t)
pl.plot(t,y[:,0])
pl.show()
25
5