MP, PSI et la TSI

Résolution numérique des équations différentielles

En analyse, il existe des procédés de résolution numérique pour les équations différentielles. En effet la résolution explicite, par quadrature est rarement possible.

La première méthode numérique fut introduite en 1768 par Leonhard Euler. Depuis un grand nombre de techniques ont été développées : elles se basent sur la discrétisation de l'intervalle d'étude en un certain nombre de pas. Suivant le type de formule utilisé pour approcher les solutions, on distingue les méthodes numériques à un pas ou à pas multiples, explicites ou implicites.

Télécharger le cours

Plan :

I.      Equations différentielles du premier ordre

1.     Méthode d'Euler pour les équations différentielles ordinaires

1.1.      Dérivation de la méthode d'Euler

2.     Runge-Kutta 2ème ordre

2.1.      Méthode de Heun

2.2.      Point milieu

2.3.      Méthode de Ralston

3.     Runge-Kutta 4ème Ordre

II.     Equations différentielles d’ordre supérieur


Code source en python


from scipy.integrate import odeint
import numpy as np
import matplotlib.pyplot as plt

def Euler(f,t0,tn,y0,n):
    h=(tn-t0)/n
    x=np.linspace(t0,tn,n)
    y=[0]*n
    y[0]=y0
    for i in range(n-1):
        y[i+1]=y[i]+h*f(y[i],x[i])
    return (x,np.array(y))

def Heun(f,t0,tn,y0,n):
    h=(tn-t0)/n
    x=np.linspace(t0,tn,n)
    y=[0]*n
    y[0]=y0
    for i in range(n-1):
	k1=f(y[i],x[i])
        k2=f(y[i]+k1*h,x[i]+h)
        y[i+1]=y[i]+0.5*(k1+k2)*h
    return (x,np.array(y))

def Point_milieu(f,t0,tn,y0,n):
    h=(tn-t0)/n
    x=np.linspace(t0,tn,n)
    y=[0]*n
    y[0]=y0
    for i in range(n-1):
        k1=f(y[i],x[i])
        k2=f(y[i]+0.5*k1*h,x[i]+0.5*h)
        y[i+1]=y[i]+k2*h
    return (x,np.array(y))

def Ralston(f,t0,tn,y0,n):
    h=(tn-t0)/n
    x=np.linspace(t0,tn,n)
    y=[0]*n
    y[0]=y0
    for i in range(n-1):
        k1=f(y[i],x[i])
        k2=f(y[i]+(3/4)*h*f(y[i],x[i]),x[i]+(3/4)*h)
        y[i+1]=y[i]+((1/3)*k1+(2/3)*k2)*h
    return (x,np.array(y))

def RK4(f,t0,tn,y0,n):
    h=(tn-t0)/n
    x=np.linspace(t0,tn,n)
    y=[0]*n
    y[0]=y0
    for i in range(n-1):
        k1=f(y[i],x[i])
        k2=f(y[i]+0.5*k1*h,x[i]+0.5*h)
        k3=f(y[i]+0.5*k2*h,x[i]+0.5*h)
        k4=f(y[i]+k3*h,x[i]+h)
        y[i+1]=y[i]+(1/6)*(k1+2*k2+2*k3+k4)*h
    return (x,np.array(y))

Exemple Pendule

g=9.98
l=0.5
def pendule(y,x):
   global g,l
   return np.array([y[1],-(g/l)*np.sin(y[0])])

y0=np.array([0.5,1])
(x,y)=RK4(pendule,0,3,y0,1000)
plt.plot(x,y) # pour tracer un seul courbe il faut faire plt.plot(x,y[:,0])
plt.show()
Partager ce cours avec tes amis :
Rédigé par Mostafa Sedoki
Professeur d'Informatique dans les CPGE

Cours Similaires :