2 Méthodes d’Euler

(1)

I NTÉGRATION NUMÉRIQUE DES ÉQUATIONS DIFFÉRENTIELLES DU PREMIER ORDRE

T P 4 - SIM-NUM-3

1 Introduction

1.1 Objectif

OBJECTIF :

L’objectif de ce tp est de calculer une solution ap- prochée du problème de Cauchy suivant :









y^′(x) = −y

x, ∀x∈[1,10]

y(1) = 1 (1)

qui admet y(x)= 1

x comme solution exacte.

Il s’agit alors d’écrire sous Python , le programme permettant de ré- soudre numériquement ce problème à partir des méthodes suivantes :

• méthode d’Euler explicite

• méthode d’Euler implicite

• méthode de Heun (RK2)

• méthode de Runge Kutta d’ordre 4 (RK4)

• utilisation de la bibliothèque (Python ou Scilab)

1 2 3 4 5 6 7 8 9 10

0 0.5 1

y1(x)= 1 x y3(x)= 3 x y₆(x)= 6 x y8(x)= 8 x y10(x)= 10 x

FIGURE1 – Fonctions yk(x)= k

x avec pour k=1, yksolution du problème de Cauchy (1).

LYCÉECARNOT(DIJON) 1/4 INFO-MPSI-1 - TP 4 - SIM-NUM-3

(2)

1.2 Rappel du cas général

Le problème de Cauchy consiste à trouver les fonctions Y de [0,T ]→R^N, telles que :









 dY

dt =F(t,Y) Y(t0)=Y0

où t0∈[0,T ] et Y0∈R^Nsont des données.

Dans le problème posé (1) :

t → x

Y → y(x) F(t,Y) → −y

x t₀ → x₀=1 Y₀ → 1

Les méthodes de résolution numérique des équations différentielles sont basées sur des techniques d’estimation de l’inté- grale de la fonction F.

On s’intéressera dans ce tp aux méthodes de résolution à un pas qui se mettent sous la forme générale :









Y_i+1=Y_i+h.Φ(t,Y,h) Y(t0)=Y0

oùΦest donné par la méthode.

1.3 Arguments

Pour construire une fonction permettant de trouver les (y_i)ⁿ₀, il est possible de choisir différents types d’arguments. On peut :

• entrer les bornes a, b et le nombre de points n. ¹ ^def EulerExp(f,y0,a,b,n):

• entrer les bornes a, b et le pas h. ¹ ^def EulerExp(f,y0,a,b,h):

• entrer la borne de gauche a, le nombre de points n et le pas h. ¹ ^def EulerExp(f,y0,a,n,h):

• entrer un vecteur de points en abscisses. ¹ ^def EulerExp(f,y0,X):

Nous opterons pour le dernier cas qui permet d’intégrer le premier cas avec linspace ou le deuxième avec arange :

1 EulerExp(f,y0,numpy.linspace(a,b,n)): 1 EulerExp(f,y0,numpy.arange(a,b+h,h)):

2 Méthodes d’Euler

2.1 Méthode d’Euler explicite

(3)

Dans la méthode d’Euler explicite, la fonction d’approximation au pas i estΦ=F(t_i,Y_i).

Q - 1 : Programmer la méthode d’Euler explicite dans le cas à une dimension i,e où F et Y sont des scalaires.

La relation de récurrence non simplifiée permettant de résoudre (1) est alors :

yi+1 =yi+h. −yi

x_i

!

=y0. 1−h 1+i.h

Quelque soit h∈R⁺, y_itend vers 0 quand i tend l’infini.

Q - 2 : Que se passe-t-il si h=1, h>1 et h∈[0,1[ ?

Q - 3 : Appliquer le programme précédent à la fonction f (x,y)= −y

x dans les trois cas précédents. Comparer avec les valeurs obtenues en calculant directement les (y_i)ⁿ₀par la formule de récurrence donnée précédemment.

Q - 4 : Tracer l’évolution de l’erreur de consistance en fonction des (xi)ⁿ₀pour différents pas h.

2.2 Méthode d’Euler implicite

Dans la méthode d’Euler explicite, la fonction d’approximation au pas i estΦ=F(ti+1,Yi+1).

La relation de récurrence dans le cas à une dimension est : y_i+1=y_i+h.f (x_i+1,y_i+1) Il s’agit alors de résoudre à chaque itération l’équation :

gi(Y)=0 avec gi(Y)=yi+h.f (xi+1,Y)−Y et g^′_i(Y)=h.∂f (xi+1,Y)

∂Y −1

La résolution sera faites à l’aide de la fonction scipy.optimize.newton .

Q - 5 : Programmer la méthode d’Euler implicite avec prise en compte de la dérivée dans les arguments.

1 def EulerImp(f,fp,y0,X): avec f p la fonction dérivée de f , y0 la valeur initiale et X le vecteur constitués des points (xi)ⁿ₀.

Pour la récurrence, on pourra utiliser la ligne suivante :

1 newton(lambda Y:y[i-1]+h.f(X[i],Y)-Y,y[i-1],lambda Y:h.fp(X[i],Y)-1)

3 Méthode de Runge Kutta

La méthode générale de Runge Kutta consiste à déterminerΦà partir d’approximations successives. On choisit

Φ(t,Y,h)= Xq

m=1

ω_m.k_m(t,Y,h) avec k₁(t,Y,h)=F(t,Y)

pour m≥2, k_m(t,Y,h)=F(t+α_m.h,Y+

m−1

X

j=1

β_{m j}.k_j(t,Y,h))

(4)

3.1 Méthode de Heun (RK2)

Pour cette méthode, q=2 Le relation de récurrence est Yi+1=Yi+ h

2.F(t_i,Yi)+h

2.F(t_i+h,Yi+h.F(t_i,Yi)).

On a donc prisΦ(τ,Y,h)= k₁+k₂

2 avec : k₁=F(t_i,Y_i) et k₂ =F(t_i+h,Y_i+h.k₁).

Dans le cas scalaire :

y_i+1=y_i+ h 2.





 f (x_i,y_i)

| {z } k1

+f (x_i+h,y_i+h.

k1

z }| { f (x_i,y_i))

| {z } k2







Q - 6 : Construire la fonction Heun( f,y0,X) relative à la méthode de Heun détaillée précédemment.

Q - 7 : Déterminer expérimentalement l’ordre de la méthode.

3.2 Méthode de Runge Kutta 4 (RK4)

La fonctionΦestΦ(t,Y,h)= 1

6.(k₁+2.k₂+2.k₃+k₄) avec quatre évaluations successives de F : k₁(t,Y,h) = F(t,Y)

k2(t,Y,h) = F(t+h 2,Y+ h

2.k₁(t,Y,h)) k3(t,Y,h) = F(t+h

2,Y+ h

2.k2(t,Y,h)) k₄(t,Y,h) = F(t+h,Y+h.k₃(t,Y,h))

⇒

k1(x,Y,h) = f (xi,yi) k₂(x,Y,h) = f x_i+ h

2,y_i+ h

2.k₁(t,Y,h)

!

k3(x,Y,h) = f xi+ h 2,yi+ h

2.k2(t,Y,h)

!

k₄(x,Y,h) = f (x_i+h,y_i+h.k₃(t,Y,h))

d’où y_i+1 =y_i+h

6.(k₁+2.k₂+2.k₃+k₄)

Q - 8 : Construire la fonction RK4( f,y0,X) relative à la méthode de Runge Kutta 4 détaillée précédemment.

4 Synthèse

La résolution du problème (1) est implémenté dans le module scipy. Il suffit d’appeler la fonction scipy.integrate.odeint pour l’utiliser. Cette fonction est optimisée par rapport à celle que nous venons de créer.

Q - 9 : Comparer graphiquement les solutions approchées calculées par chacune des méthodes.

Q - 10 : Comparer les erreurs de consistance et les vitesses de convergences des différentes méthodes ainsi que les temps de calculs.