TP : Résolution numérique des EDO

Partie 1
Soient I = [0, T] un intervalle de IR et f : I × IR → IR une fonction continue et considérons le problème
suivant :
Trouver une fonction réelle de classe C1 (I) : x : t 7−→ x(t) telle que
 0
x (t) = f(t, x(t)), ∀t ∈ I,
(P)
x(0) = x0 .
Si f est Lipschitzienne par rapport à la deuxième variable, le problème posé ci-dessus admet une unique
solution.
Le problème P est appelé un problème de Cauchy.
On considère tn = nh, pour n = 0, · · · , N avec h = T/N et N un entier naturel donné, une
discrétisation de I et notons xn une approximation de x(tn ).
L’ensemble {x0 , x1 , · · · , xN } représente la solution numérique de l’équation (P).
Pour résoudre P on propose d’étudier les méthodes numériques dites à un pas données par :

xn+1 = xn + hΦ(tn , xn , h)
x(0) = x0 .

avec Φ une fonction quelconque de I × IR × IR à valeurs dans IR

La méthode est dite convergente si :

| xn − x(tn ) |6 Ch, ∀n = 0, · · · , N.

On dit que la méthode à un pas converge à l’ordre p si :

max | x(tn ) − xn |6 Chp .

16n6N

Méthode d’Euler Explicite :


xn+1 = xn + hf(tn , xn ), n = 0, · · · , N − 1,
x(0) = x0 .

Code Matlab de la fonction Euler Explicite

function [t,x]=eulerexpli(f,x0,T,N)
h=T/N;
t=0:h:T;
x=zeros(1,N+1);
x(1)=x0;
for n=1:N
x(n+1)=x(n)+h*f(t(n),x(n));
end

Page 1 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
Méthode de Heun :
hh
( i
xn+1 = xn + f (tn , xn ) + f (tn + h, xn + hf(tn , xn )) , n = 0, · · · , N − 1,
2
x(0) = x0 .
Code Matlab de la fonction Heun

function [t,x]=heun(f,x0,T,N)
h=T/N;
t=0:h:T;
x=zeros(1,N+1);
x(1)=x0;
for n=1:N
fc=f(t(n),x(n));
x(n+1)=x(n)+h/2*(fc+f(t(n+1),x(n)+h*fc));
end
Les méthodes d’Euler explicite et de Heun sont dites explicites car elles permettent de calculer xn+1 à
partir de xn et elles sont respectivement d’ordre 1 et 2.

Exercice 1 : On considère le problème suivant :

x0 (t) = −tx2 (t), ∀t ∈ I = [0, 4],



x(0) = 2.

2
La solution exacte est g(t) = .
1 + t2
1. Résoudre ce problème à l’aide des méthodes ( Euler explicite et Heun) pour N = 10 et N = 20.
Représenter dans chaque cas les solutions obtenues ainsi que la solution exacte sur un même
graphique. Calculer la norme de l’erreur commise par les deux méthodes
2. Pour déterminer numériquement l’ordre de convergence des deux méthodes, on considère dif-
férentes valeurs de N = 2k , k = 4, · · · , 10.
3. Représenter graphiquement en échelle logarithmique l’erreur

max | x(tn ) − xn |
06n6N

en fonction de h et déduire l’ordre de l’erreur pour les 2 méthodes.

~

 Solution 1 close all, clear all clc;

%% Question 1
f=@(t,x) -t.*x.*x ; % La fonction du probleme
g=@(t)2./(1+t.*t); % La solution exacte

%% N=10
[t1 x1]=eulerexpli(f,2,4,10);

Page 2 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
[t1 x2]=heun(f,2,4,10);
z1=g(t1); % La solution exacte au points ti
subplot(2,1,1)
plot(t1,x1,'r',t1,x2,'b',t1,z1,'--k')
legend('Euler Explicite','Heun','Exacte');
title('Representation de la Solution pour N=10');
xlabel('Temps');
%% N=20
[t2 x3]=eulerexpli(f,2,4,20);
[t2 x4]=heun(f,2,4,20);
z2=g(t2); % La solution exacte au points ti
subplot(2,1,2)
plot(t2,x3,'r',t2,x4,'b',t2,z2,'--k')
legend('Euler Explicite','Heun','Exacte');
title('Representation de la Solution pour N=20');
xlabel('Temps');

%% La norme de l'erreur commise

ee10=norm(z1-x1,Inf); % erreur de Euler pour N=10 norme infini
ee20=norm(z2-x3,Inf); %% erreur de Euler pour N=20
eh10=norm(z1-x2,Inf); % erreur de Heun pour N=10
eh20=norm(z2-x4,Inf); %% erreur de Heun pour N=20

fprintf("L'erreur commise par le shéma de Euler pour N=10 est : %f \n",ee10);

fprintf("L'erreur commise par le shéma de Heun pour N=10 est : %f \n \n",eh10);

fprintf("L'erreur commise par le shéma de Euler pour N=20 est : %f \n",ee20);

fprintf("L'erreur commise par le shéma de Heun pour N=20 est : %f \n",eh20);

Pour l’ordre de convergence on part du fait que si une méthode est d’ordre p alors on peut écrire
l’erreur :
e = |x(tn ) − xn | = Chp
Ainsi
ln(e) = ln(C) + p ln(h)
On trace le graphe de ln(e) en fonction de ln(h) et on déduit p.

%% L'ordre des deux methodes

N=10;
for k=1:10
h(k)=4/N; % h=T/N
[t yy1]=eulerexpli(f,2,4,N);
[t,yy2]=heun(f,2,4,N);
exact=g(t);
err1(k)=norm(yy1-exact,Inf); % norme infinie
err2(k)=norm(yy2-exact,Inf);
N=2*N;
end
figure(2)
loglog(h,err1,'-s',h,err2,'-s')
legend('Euler','Heun')

Page 3 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
 axis([0 1 0 1])
grid on

%% Pour avoir l'equation de la droite obtenue

P1=polyfit(log(h),log(err1),1)
P2=polyfit(log(h),log(err2),1)

Méthode d’Euler Implicite :


xn+1 = xn + hf(tn+1 , xn+1 ), n = 0, · · · , N − 1,
x(0) = x0 .

Dans cette méthode, le calcul de xn+1 est définie implicitement, à chaque étape il faut résoudre
l’équation
g(xn+1 ) = xn+1 − xn − hf(tn + h, xn+1 ) = 0
On utilise par exemple la méthode de Newton vue au TP1 et qui prend x0 = xn comme donnée initiale.
La méthode de Newton correspondante à la fonction g ci-dessus est donnée par :

% la méthode de newton appliquée à la fonction g de la méthode d'euler

% implicite
function [x]=newtonmodif(f,df,x0,y,t,h,prec)
x=x0-(x0-y-h*f(t,x0))/(1-h*df(t,x0));
while(abs(x-x0)>prec)
x0=x;
x=x0-(x0-y-h*f(t,x0))/(1-h*df(t,x0));
end

En utilisant la fonction matlab précédente on écrit le code de la fonction d’Euler Implicite :

Code Matlab de la fonction d’Euler Implicite :

function [t,x]=eulerimpli(f,df,x0,T,N)
h=T/N;
t=0:h:T;
x=zeros(1,N+1);
x(1)=x0;
prec=10^-4;
for n=1:N
x0=x(n);
x(n+1)=newtonmodif(f,df,x0,x(n),t(n+1),h,prec);
end

Exercice 2 A l’aide de la méthode Euler Implicite, résoudre le problème de l’exercice 1 pour

différentes valeur de N et visualiser dans un même graphique la solution obtenue et la solution
exacte.
~

Page 4 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
  Solution 2 close all, clear all, clc;
f=@(t,x) -t.*x.*x ; % La fonction du probleme
df=@(t,x) -2*t.*x; % La derviee
g=@(t) 2./(1+t.*t); % La solution exacte
%%
[t1 x1]=eulerimpli(f,df,2,4,10); % N=10
[t2 x2]=eulerimpli(f,df,2,4,20); % N=20

z1=g(t1);
z2=g(t2);

subplot(2,1,1)
plot(t1,x1,'r',t1,z1,'--k')
axis ([0 4 0 3])
legend('Euler Implicite','Exacte');
title('Representation de la Solution pour N=10');
xlabel('Temps');
subplot(2,1,2)
plot(t2,x2,'r',t2,z2,'--k')
axis ([0 4 0 3])
legend('Euler Implicite','Exacte');
title('Representation de la Solution pour N=20');
xlabel('Temps');

%Erreur

error1=norm(z1-x1,inf) % N=10
error2=norm(z2-x2,inf) %N=20

A-Stabilité
On va s’intéresser dans cette section au comportement de la solution numérique quand la variable tend
vers l’infini. On dira qu’une méthode numérique est absolument stable, si, pour le pas h fixé, la solution
xn du schéma reste bornée quand n tend vers l’infini. Pour évaluer cette propriété de stabilité on regarde
la réponse du schéma au problème test suivant (TLS test linéaire standard). λ > 0 un réel positif
 0
x (t) = −λx(t), ∀t > 0,
P1
x(0) = x0 .
dont la solution est x(t) = x0 e−λt .
Stabilité des méthodes d’Euler :
Pour le TLS le schéma d’Euler explicite peut s’écrire sous la forme
xn+1 = xn + h(−λxn ) = (1 − λh)xn = (1 − λh)n+1 x0
Ainsi la méthode d’Euler explicite est A-stable si et seulement si h < 2/λ.
Le schéma d’Euler implicite s’écrit sous la forme :
xn+1 = xn + h(−λxn+1 ) ⇒ xn+1 = (1 + λh)−n x0
Ainsi, xn → 0 quand n → +∞, et la méthode d’Euler implicite est stable sans condition sur h.
Page 5 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
 Exercice 3 Considérons le problème

x0 (t) = −x(t), ∀t > 0,



x(0) = 1.

Dans ce cas la condition de stabilité pour Euler explicite est h < 2.

Pour T = 30, h = T/14, h = T/15 et h = T/60, visualiser les solutions obtenues à l’aide de la
méthode d’Euler Explicite. Commenter les résultats obtenus. ~

 Solution 3 close all, clear all, clc;

f=@(t,x) - x ;
g=@(t) exp(-t);

% T= 30, N=14 h=30/14

[t1 x1]=eulerexpli(f,1,30,14);

% T= 30, N=15, h=2

[t2 x2]=eulerexpli(f,1,30,15);

%T=30, N=60 h=1/2

[t3 x3]=eulerexpli(f,1,30,60);

%Solution exacte
z=g(t3);

%Graphes
plot(t1,x1,'r',t2,x2,'g',t3,x3,'b',t3,z,'+k','LineWidth',2);
legend('h>2','h=2','h<2','Exacte')

%%%%%% commentaire
%%
% pour h=30/14 > 2 dans ce cas la condition de stabilite n'est pas
%satisfaite, la solution oscille et tend vers l'infini
% pour h=30/60=1/2, dans ce cas la condition de stabilite est satisfaite la ...
solution tend vers 0

Méthode de Runge-Kutta : L’objectif des méthodes de Runge-Kutta est d’augmenter l’ordre des
schémas numériques au moyen des évaluations de f(t, y(t)) intermédiaires. Les méthodes de Runge-
Kutta d’ordre 2 sont données par :

 k1 = f(tk , xk )
k2 = f(tk + αh, xk + βhk1 )
xk+1 = xk + c1 hk1 + c2 hk2


avec
c1 + c2 = 1, αc1 = 1/2, βc2 = 1/2.
Page 6 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
Code Matlab de Runge-Kutta 2 pour c1 = 1/2 :

function [t x]=rung2edo(f,x0,T,N)
h=T/N;
t=0:h:T;
n=length(t);
%c1=0.5;% schema de HEUN
c1=0.5;
c2=1-c1;
alpha=0.5/c1;
beta=0.5/c2;
x=ones(n,1)*x0;
for i=1:n-1
k1=f(t(i),x(i));
k2=f(t(i)+alpha*h,x(i)+beta*h*k1);
x(i+1)=x(i)+c1*h*k1+c2*h*k2;
end
La méthode de Runge-Kutta d’ordre 4 la plus célèbre est donnée par le tableau :

0 0
1 1
2 2
0
1 1
2
0 2
0
1 0 0 1 0

1 2 2 1
6 6 6 6
k1 = f(tk , xk )
h h
k2 = f(tk + , xk + k1 )
2 2
h h
k3 = f(tk + , xk + k2 )
2 2
k4 = f(tk + h, xk + hk3 )
h
xk+1 = xk + (k1 + 2k2 + 2k3 + k4 )
6
Code Matlab de Runge-kutta 4 :

function [t x]=rung4edo(f,x0,T,N)
h=T/N;
t=0:h:T;
n=length(t);
x=ones(n,1)*x0;
for i=1:n-1
k1=f(t(i),x(i));
k2=f(t(i)+1/2*h,x(i)+1/2*h*k1);
k3=f(t(i)+1/2*h,x(i)+1/2*h*k2);
k4=f(t(i)+h,x(i)+h*k3);
x(i+1)=x(i)+1/6*h*(k1+2*k2+2*k3+k4);
end

Page 7 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
Exercice 4 : Considérons le problème suivant :
  
0 1
x (t) = −x(t) − cos(t) , ∀t ∈ [0, 2],

10
x(0) = 1.


dont la solution exacte est donnée par x(t) = e−0,1t+sin(t) .

1. Calculer numériquement la solution du problème ci-dessus en utilisant Runge-kutta d’ordre 2
et d’ordre 4 pour N = 8 et N = 16.
2. Tracer les courbe de la solution approchée et la solution exacte.
3. Pour différentes valeurs de N = 2k , k = 2, · · · , 10 calculer les erreurs commises par les deux
méthodes.
~

 Solution 4 close all, clear all, clc;

f=@(t,x) -x*(0.1-cos(t));
g=@(t) exp(-0.1*t+sin(t)); % Solution exacte
%% N=8
N=8;
[t1 x1]=rung2edo(f,1,2,N);
[t1 x2]=rung4edo(f,1,2,N);
z1=g(t1);
figure(1);
plot(t1,x1,'r',t1,x2,'b',t1,z1,'+k')
legend('Runge-kutta 2','Runge-Kutta 4','Exacte');
title('Representation de la Solution pour N=8');
xlabel('N');

%% N=16
N=16;
[t2 x3]=rung2edo(f,1,2,N);
[t2 x4]=rung4edo(f,1,2,N);
z2=g(t2);
figure(2);
plot(t2,x3,'r',t2,x4,'b',t2,z2,'+k')
legend('Runge-kutta 2','Runge-Kutta 4','Exacte');
title('Representation de la Solution pour N=16');
xlabel('N');
%% Erreurs
N=2;
err1=zeros(10,1);
err2=zeros(10,1);
for k=1:10
N=2*N;
[t yy1]=rung2edo(f,1,2,N);
[t,yy2]=rung4edo(f,1,2,N);
exact=g(t);
err1(k)=norm(yy1-exact');

Page 8 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
 err2(k)=norm(yy2-exact');
end
format long;
table(err1,err2, 'VariableNames',{'Erreur Runge 2','Erreur Runge 4'})

Partie 2 rappel
Problème : on cherche à résoudre un système d’équations différentielles ordinaires (EDO, en anglais
ODE) du premier ordre :
 0

 x1 = f 1 (x1 , x2 , ..., xn , t)
x 0 = f (x , x , ..., x , t)

2 2 1 2 n


 ...
 0
xn = f 3 (x1 , x2 , ..., xn , t)
avec les conditions initiales xi 0 (0) = xi0 pour i = 1...n.
Rappelons que tout système ou équation différentielle d’ordre supérieur peut se ramener simplement
à cette forme canonique, utilisée dans tous les solveurs d’EDO.
La définition d’un tel système repose sur la définition de n fonctions de n + 1 variables. Ces fonctions
devront être programmées dans une fonction MATLAB sous la forme canonique suivante :

function sol = f (y, t)

sol(1) = une expression de y(1), y(2) ... y(n) et t

...
sol(n) = une expression de y(1), y(2) ... y(n) et t

sol = sol(:);

end
Les xi et les xi 0 sont regroupés dans des vecteurs, ce qui fait que la forme de cette fonction est
exploitable quel que soit le nombre d’équations du système différentiel.
La dernière ligne est nécessaire car la fonction doit renvoyer un vecteur colonne et non un vecteur
ligne.
Ensuite, pour résoudre cette équation différentielle, il faut appeler un solveur et lui transmettre au
minimum :
• le nom de la fonction.
• les bornes d’intégration (tmin et tmax ).
• les conditions initiales.
Le solveur fournit en sortie un vecteur colonne représentant les instants d’intégration t , et une
matrice dont la première colonne représente les x1 calculés à ces instants, la deuxième les x2 , et la
nième les xn .
L’appel du solveur prend donc en général la forme suivante :

Page 9 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
[t, y] = ode45 ('f', [tmin tmax], [y10 y20 ... yn0] );
y1 = y(:,1);
y2 = y(:,2);
...
yn = y(:,n);
plot(t, y1, t, y2) % par exemple on trace y1(t) et y2(t)

Les lignes x1 = ... servent à extraire les différentes fonctions xi dans des colonnes simples.
Les principales fonctions de MATLAB qui permettent la résolution des équations différentielles sont :
• ode23 : Méthode de Runge-Kutta d’ordre 2,3.
• ode45 : Méthode de Runge-Kutta d’ordre 4,5 (la plus utilisée)
MATLAB prend une erreur relative max de 10−4 par défaut, et qu’il est toujours possible de modifier
cette valeur, ainsi que bien d’autres paramètres grâce à la routine de gestion des options odeset.
Exercice 5 : Exemple.
On considère le problème (
y0 = 1 + y2
y(0) = 0.

1. Calculer la solution sur l’intervalle [0, 1.5].

2. La solution exacte de ce problème est y(x) = tan(x). Représenter dans un même diagramme
la solution exacte et la solution approchée calculée plus haut.
~

 Solution 5 Nous suivons le plan suivant

• Nous commençons par définir la fonction qui donne le problème de Cauchy, c’est à dire f(x, y) =
1 + y2 . Notez qu’il faut bien définir une fonction de deux variables x et y, même si on n’en
utilise une seule.
• Ensuite, nous résolvons le système en mettant la solution dans les vecteurs x et y.

% On definit la fonction
function sol=fct(x,y)
sol = 1+y.^2;
end

% On resoud l equation diff

[x,y] = ode45('fct',[0 1.5],0);

% On trace les deux graphes

X = 0:0.001:1.5;
Y = tan(X);

plot(x,y,'o',X,Y)

grid on;
legend('Solution','tan(X)')
title('EDO');

Page 10 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
xlabel('Axe des x');
ylabel('Axe des y');

Exercice 6 : On considère le problème

(
y0 = x2 + y2 /4
y(0) = 0.2

1. Calculer la solution sur l’intervalle [0, 1.5].

2. Représenter, dans un même diagramme, le graphe de la solution y et celui de sa dérivée y0 .
~

 Solution 6 function sol=fct2(x,y)

sol = x.^2+(y.^2)/4;
end

%%%%%
clear all;
clc;

[x,y] = ode45('fct2',[0 1.5],0.2);

z = fct2(x,y); % Calcule de la derivee y'=f(x,y)

plot(x,y,x,z,'o')

legend('f(x)','f''(x)')
title('EDO');
xlabel('Axe des x');
ylabel('Axe des y');

Exercice 7 : Résoudre l’équation :


00 0
y + by + a(1 + εcos(t))y = 0

y(0) = 10−2

 0
y (0) = 10−1
où a , b et ε sont des paramètres.
Prendre a = 0.1, b = 0.2 et ε = 1 et poser x1 = y et x2 = y0 , pour trouver la forme canonique.
Résoudre cette équation dans l’intervalle [0, 5π]
Tracer dans la même figure les graphes de x1 , de y0 ainsi que de y en fonction de y0 .
~

Page 11 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
 Solution 7 En posant x1 = y et x2 = y0 , on se ramène à la forme canonique :
(
x1 0 = x2
x2 0 = −bx2 − a(1 + εcos(t))x1

Ecrivons la fonction fct4.m définissant cette équation dans un fichier fct4.m. On passera les
paramètres de l’équation dans une directive global :

function sol = fct3 (t, y)

global a b epsilon

sol(1) = y(2);
sol(2) = -b*y(2) -a*(1+epsilon*cos(t))*y(1);
sol = sol(:);

end

global a b epsilon

% Parametres
a = 0.1;
b = 0.2;
epsilon=1;

% Temps final
tfinal = 5*pi;

% Conditions initiales
y01 = 1e-2;
y02 = 1e-1;

[t,y] = ode45('fct3', [0 tfinal], [y01 y02]); % Resolution

y1 = y(:,1); % Extraction de y1 et y2
y2 = y(:,2);

subplot(2,2,1)
plot(t,y1) % y1 fonction du temps
% (represente y(t) pour l'EDO originale)
subplot(2,2,2)
plot(t,y2) % y2 fonction du temps
% (repr?sente dy(t)/dt pour l'EDO originale)
subplot(2,1,2)
plot(y1,y2) % Plan y2 en fct de y1

Il est possible de définir le système d’équations différentielles à résoudre par l’intermédiaire d’une
fonction anonyme et non pas avec une fonction externe.
Avec une fonction anonyme, l’exemple précédent est résolu ainsi :

Page 12 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020
a=0.1;
b=0.2;
epsilon=1;
%
fct4= @(t,y) [y(2); -b*y(2)-a*(1+epsilon*cos(t))*y(1)];
[t,y] = ode45(fct4, [0 5*pi], [1e-2 1e-1]);
%
y1 = y(:,1); % Extraction de y1 et y2
y2 = y(:,2);

subplot(2,2,1)
plot(t,y1) % y1 fonction du temps
% (represente y(t) pour l'EDO originale)
subplot(2,2,2)
plot(t,y2) % y2 fonction du temps
% (represente dy(t)/dt pour l'EDO originale)
subplot(2,1,2)
plot(y1,y2) % Plan y2 en fct de y1

Devoir
1. Implémenter la méthode de Runge-kutta d’ordre 3 du cours.
2. Programmer la méthode Crank-Nicolson.
3. Comparer les méthodes : Runge-kutta d’ordre 2,3, 4 et Crank-Nicolson.

Page 13 de 13
A.ELGHAZI - O.NOUISSER, Date: 17 mai 2020