MP, PSI et la TSI

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

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 M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :