I – Rappels sur les Equations Différentielles Ordinaires

Résolution Numérique
I-1 Programmation
I-1-1 Méthode d’EULER
Cas d’une EDO du premier ordre dont la forme mathématique est :
𝑑𝑑𝑑𝑑
𝑑𝑑𝑑𝑑
= 𝑓𝑓(𝑥𝑥, 𝑦𝑦). A partir de la connaissance de la valeur de 𝑦𝑦 = 𝑦𝑦0 pour une
𝑑𝑑𝑑𝑑
valeur de 𝑥𝑥 = 𝑥𝑥0 , on peut calculer la valeur de 𝑑𝑑𝑑𝑑
en ce point, soit
𝑑𝑑𝑑𝑑
(𝑑𝑑𝑑𝑑 )0. La valeur estimée de y pour 𝑥𝑥 = 𝑥𝑥0 + 𝑑𝑑𝑑𝑑 sera prise égale à
𝑑𝑑𝑑𝑑
𝑦𝑦0 + 𝑑𝑑𝑑𝑑 = 𝑦𝑦0 + (𝑑𝑑𝑑𝑑 )0 𝑑𝑑𝑑𝑑.
En appelant h le pas d’intégration on obtient la forme itérative :
𝑦𝑦𝑖𝑖+1 = 𝑦𝑦𝑖𝑖 + 𝑑𝑑𝑦𝑦𝑖𝑖 = 𝑦𝑦𝑖𝑖 + ℎ 𝑓𝑓(𝑥𝑥𝑖𝑖 , 𝑦𝑦𝑖𝑖 )
On remarquera que les valeurs estimées obtenus seront d’autant plus proches des valeurs exactes que le pas
h est plus petit.
Programme méthode d’Euler
function [t,u]=feuler(odefun,tspan,y0,Nh,varargin ) % [T,Y] = FEULER(ODEFUN,TSPAN,Y0 ,NH,P1,P2 ,...)
%FEULER Résout une équation différentielle avec la % passe
% méthode d’Euler explicite. % les paramètres supplémentaires P1,P2 ,.. à la
% [T,Y]=FEULER(ODEFUN,TSPAN,Y0,NH) avec % fonction ODEFUN de la maniere suivante:
% TSPAN=[T0,TF] % ODEFUN(T,Y,P1 ,P2...).
% intègre le système d’équations différentielles h=(tspan(2)-tspan(1))/Nh;
% y’=f(t,y) du temps T0 au temps TF avec la y=y0(:); % crée toujours un vecteur colonne
% condition w=y; u=y.’;
% initiale Y0 en utilisant la méthode d’Euler tt=linspace (tspan(1),tspan(2),Nh+1);
% explicite sur une grille de NH intervalles for t = tt(1:end -1)
% équi-distribués. La fonction ODEFUN(T,Y) doit w=w+h*feval(odefun,t,w,varargin {:});
% retourner un vecteur, correspondant à f(t,y), u = [u; w.’];
% de même dimension que Y. end
% Chaque ligne de la solution Y correspond t=tt;
% à un temps du vecteur colonne T. return

I-1-2 Méthode de Runge Kutta RK4

𝑑𝑑𝑑𝑑
Pour l’équation différentielle 𝑑𝑑𝑑𝑑 = 𝑓𝑓(𝑥𝑥, 𝑦𝑦) la méthode RK4 utilise plusieurs points intermédiaires pour calculer
la valeur de 𝑦𝑦𝑖𝑖+1 à partir de la valeur de 𝑦𝑦𝑖𝑖 .
ℎ
Au point A d’abscisse 𝑥𝑥𝑖𝑖 + 2 la valeur de l’ordonnée est obtenue à partir de :
𝑑𝑑𝑑𝑑 ℎ 𝑘𝑘1
𝑦𝑦𝑖𝑖𝑖𝑖 = 𝑦𝑦𝑖𝑖 + � � ∗ = 𝑦𝑦𝑖𝑖 + ⇒ 𝑘𝑘1 = ℎ ∗ 𝑓𝑓(𝑥𝑥𝑖𝑖 , 𝑦𝑦𝑖𝑖 )
𝑑𝑑𝑑𝑑 𝑖𝑖 2 2
De la même manière on obtient :
𝑑𝑑𝑑𝑑 ℎ 𝑘𝑘2 ℎ 𝑘𝑘1
𝑦𝑦𝑖𝑖𝑖𝑖 = 𝑦𝑦𝑖𝑖 + � � ∗ = 𝑦𝑦𝑖𝑖 + ⇒ 𝑘𝑘2 = ℎ ∗ 𝑓𝑓 �𝑥𝑥𝑖𝑖 + , 𝑦𝑦𝑖𝑖 + �
𝑑𝑑𝑑𝑑 𝑖𝑖𝑖𝑖 2 2 2 2
𝑑𝑑𝑑𝑑 ℎ 𝑘𝑘2
𝑦𝑦𝑖𝑖𝑖𝑖 = 𝑦𝑦𝑖𝑖 + � � ∗ ℎ = 𝑦𝑦𝑖𝑖 + 𝑘𝑘3 ⇒ 𝑘𝑘3 = ℎ ∗ 𝑓𝑓 �𝑥𝑥𝑖𝑖 + , 𝑦𝑦𝑖𝑖 + �
𝑑𝑑𝑑𝑑 𝑖𝑖𝑖𝑖 2 2
𝑑𝑑𝑑𝑑
𝑦𝑦𝑖𝑖𝑖𝑖 = 𝑦𝑦𝑖𝑖 + � � ∗ ℎ = 𝑦𝑦𝑖𝑖 + 𝑘𝑘4 ⇒ 𝑘𝑘4 = ℎ ∗ 𝑓𝑓(𝑥𝑥𝑖𝑖 + ℎ, 𝑦𝑦𝑖𝑖 + 𝑘𝑘3 )
𝑑𝑑𝑑𝑑 𝑖𝑖𝑖𝑖
On obtient finalement :
1
𝑦𝑦𝑖𝑖+1 = 𝑦𝑦𝑖𝑖 + [𝑘𝑘1 + 2𝑘𝑘2 + 2𝑘𝑘3 + 𝑘𝑘4 ]
6
Programme Runge-Kutta
function [t ,U ]= RK4 ( fichier ,n ,eta , interv ) K2 = feval ( fichier ,t(i)+h/2 , U2 );
h =( interv (2) - interv (1) )/n; U3 = U1 +h /2* K2 ;
t= interv (1) :h: interv (2) ; K3 = feval ( fichier ,t(i)+h/2 , U3 );
U (: ,1) = eta ; U4 = U1 +h* K3 ;
for i =1: n K4 = feval ( fichier ,t(i)+h , U4 );
U1 =U(: ,i); U(: ,i +1) = U1 +h /6*( K1 +2* K2 +2* K3 + K4 );
K1 = feval ( fichier ,t(i) ,U1 ); End
U2 = U1 +h /2* K1 ;

I-2 Calcul Numérique dans Matlab

ode45 , ode23 , ode123
[T,Y] = solver(odefun,tspan,y0)
[T,Y] = solver(odefun,tspan,y0,options)

Il faut d'abord savoir que les fonctions ode résolvent les EDs de premier ordre, et aussi qu'elles n'expriment pas
les résultats sous forme d'expressions mathématique ; elles renvoient un vecteur colonne représentant la
variable "T" (temps en générale) et une matrice "Y" dont les colonnes sont les solutions.
La fonction ode45 est la première fonction à essayer
Considérons le système : 𝑦𝑦′1 = 𝑓𝑓1 (𝑦𝑦1 , 𝑦𝑦2 … .. 𝑦𝑦𝑛𝑛 , 𝑡𝑡)
𝑦𝑦 ′ 2 = 𝑓𝑓2 (𝑦𝑦1 , 𝑦𝑦2 … .. 𝑦𝑦𝑛𝑛 , 𝑡𝑡)
….
𝑦𝑦 ′ 𝑛𝑛 = 𝑓𝑓𝑛𝑛 (𝑦𝑦1 , 𝑦𝑦2 … .. 𝑦𝑦𝑛𝑛 , 𝑡𝑡)

Avec les conditions initiales : 𝑦𝑦1 (0) = 𝑦𝑦10 , 𝑦𝑦2 (0) = 𝑦𝑦20 … 𝑦𝑦𝑛𝑛 (0) = 𝑦𝑦𝑛𝑛0
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. Puisqu’une équation différentielle d’ordre m est
équivalente à un système de m équations différentielles d’ordre 1.

Exemple : Equation différentielle ordinaire du deuxième ordre

𝑑𝑑2 𝑦𝑦(𝑡𝑡) 𝑑𝑑𝑑𝑑(𝑡𝑡) 𝑑𝑑𝑑𝑑(𝑡𝑡0 )
Pour l’équation différentielle 𝑑𝑑𝑡𝑡 2
= 𝑓𝑓 �𝑡𝑡, 𝑦𝑦(𝑡𝑡), � 𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎 𝑦𝑦(𝑡𝑡0 ) = 𝑐𝑐1 𝑒𝑒𝑒𝑒 = 𝑐𝑐2
𝑑𝑑𝑑𝑑 𝑑𝑑𝑑𝑑
𝑑𝑑𝑑𝑑(𝑡𝑡)
On pose 𝑦𝑦1 (𝑡𝑡) = 𝑦𝑦(𝑡𝑡) 𝑒𝑒𝑒𝑒 𝑦𝑦2 (𝑡𝑡) = 𝑑𝑑𝑑𝑑
𝑑𝑑𝑦𝑦1 (𝑡𝑡)
= 𝑦𝑦2 (𝑡𝑡) 𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎 𝑦𝑦1 (𝑡𝑡0 ) = 𝑐𝑐1
𝑑𝑑𝑑𝑑
On obtient alors le système � 𝑑𝑑𝑦𝑦2 (𝑡𝑡)
= 𝑓𝑓(𝑡𝑡, 𝑦𝑦1 (𝑡𝑡), 𝑦𝑦2 (𝑡𝑡)) 𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎 𝑦𝑦2 (𝑡𝑡0 ) = 𝑐𝑐2
𝑑𝑑𝑑𝑑

On voit donc que la définition d'un tel système repose sur la définition de fonctions de variables. Ces
fonctions devront être programmées dans une fonction MATLAB sous la forme canonique suivante :
function ypoint = f (y, t)
ypoint(1) = f1(y(1), y(2) ... y(n) , t)
...
ypoint(n) = fn(y(1), y(2) ... y(n) , t)
ypoint = ypoint(:);
end
On remarquera que les 𝑦𝑦𝑖𝑖 et les 𝑦𝑦′𝑖𝑖 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 ( et ).
• Les conditions initiales.

Le solveur fournit en sortie un vecteur colonne représentant les instants d'intégration , et une matrice dont la
première colonne représente les les 𝑦𝑦1 calculés à ces instants, la deuxième les 𝑦𝑦2 et la nième les 𝑦𝑦𝑛𝑛 .

L'appel du solveur prend donc en général la forme suivante :

[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)
plot(y1,y2) % ou bien y2(y1) (plan de phase pour les oscillateurs)

Les lignes y1 = ... servent à extraire les différentes fonctions 𝑦𝑦𝑖𝑖 dans des colonnes simples
On a utilisé ici ode45 qui est un Runge-Kutta-Merson imbriqué d'ordre 4 et 5. C'est le plus courant et celui par
lequel il faut commencer, mais il en existe d'autres, en particulier ode15s adapté aux systèmes raides.

Exemple :
𝑦𝑦 ′′ + 0.5𝑦𝑦 ′ + 2𝑦𝑦 = 0 𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎 𝑦𝑦(0) = 2 𝑒𝑒𝑒𝑒 𝑦𝑦 ′ (0) = 0
On pose 𝑦𝑦1 = 𝑦𝑦 𝑒𝑒𝑒𝑒 𝑦𝑦2 = 𝑦𝑦′
On obtient 𝑦𝑦′1 = 𝑦𝑦2 𝑒𝑒𝑒𝑒 𝑦𝑦′2 = −0.5𝑦𝑦2 − 2𝑦𝑦1 𝑎𝑎𝑎𝑎𝑎𝑎𝑎𝑎 𝑦𝑦1 (0) = 2 𝑒𝑒𝑒𝑒 𝑦𝑦2 (0) = 0
On crée la fonction :
function dy=equasys(t,y)
dy(1)=y(2) ;
dy(2)=-0.5*y(2)-2*y(1) ;
dy=dy(:) ;
end
On utilise la commande [t,y]=ode45('equasys',[0 10],[2 0]) et on obtient :
t= …
0 9.5868
0.0000 9.7245
0.0001 9.8623
0.0002 10.0000

y= …
2.0000 0 0.1524 -0.1833
2.0000 -0.0001 0.1253 -0.2081
2.0000 -0.0001 0.0955 -0.2237
2.0000 -0.0002 0.0641 -0.2300
Pour l'erreur maximale admissible, relative ou absolue, MATLAB prend une erreur relative max de 10−3 par
défaut, et il est toujours possible de modifier cette valeur, ainsi que bien d'autres paramètres grâce à la routine
de gestion des options odeset.
Exemple :
Soit le système :

On crée la fonction Matlab sysedo représentant ce système :

function dy = sysedo(t,y)
dy = zeros(3,1); % a column vector
dy(1) = y(2) * y(3);
dy(2) = -y(1) * y(3);
dy(3) = -0.51 * y(1) * y(2);
On résout le système dans l’intervalle [0,12s] en modifiant les tolérances :
options = odeset('RelTol',1e-4,'AbsTol',[1e-4 1e-4 1e-5]);
[T,Y] = ode45(@sysedo,[0 12],[0 1 1],options);
plot(T,Y(:,1),'-',T,Y(:,2),'-.',T,Y(:,3),'.')

I-3 Calcul symbolique avec Matlab

I-3-1 Dérivation
diff(F), diff(F,var), diff(F,n), diff(F,var,n), diff(F,var1,...,varN)
Exemples :
a) syms x c) syms x y
f(x) = sin(x^2); diff(x*cos(x*y), y, 2)
df = diff(f) ans =
-x^3*cos(x*y)
df(x) =2*x*cos(x^2)
d) syms x y
b) syms x t diff(diff(x*y))
diff(sin(x*t^2)) ans =
ans = 1
t^2*cos(t^2*x)

e) syms x y f) syms x y
diff(x*sin(x*y), x, y) diff(x*sin(x*y), x, x, x, y)
ans = ans =
2*x*cos(x*y) - x^2*y*sin(x*y) x^2*y^3*sin(x*y) - 6*x*y^2*cos(x*y) - 6*y*sin(x*y)

I-3-2 Integration
int(expr,var), int(expr,var,a,b)
Exemples :
syms x syms x z syms x
int(-2*x/(1 + x^2)^2) int(x/(1 + z^2), z) int(x*log(1 + x), 0, 1)
ans = ans = ans =
1/(x^2 + 1) x*atan(z) ¼

4
I-3-3 Résolution des équations différentielles
S = dsolve(eqn) ; S = dsolve(eqn,cond) ; Y = dsolve(eqns) ; Y = dsolve(eqns,conds)
Exemples :
a) dsolve('Dy = y + 1','x')
ans =
-1 + exp(x) _C1

b) syms y(x);
dsolve(diff(y) == y + 1) and
ans =
-1 + exp(x) _C1

c) dsolve('D2y = x*y','x')
ans =
3*(1/6 x y + _C1 x + _C2)

d) syms y(x)
dsolve(diff(y, 2) == x*y)
ans =
3*(1/6 x y + _C1 x + _C2)

e) syms a b y(t)
dsolve(diff(y) == a*y, y(0) == b)
ans = b*exp(a*t)

f) syms x(t) y(t)

z = dsolve(diff(x) == y, diff(y) == -x)
z=
y: [1x1 sym]
x: [1x1 sym]
z.x
ans =
C12*cos(t) + C11*sin(t)
z.y
ans =
C11*cos(t) - C12*sin(t)

g) syms a y(x)
dsolve(diff(y) == a/(y^2 + 1))
Warning: Explicit solution could not be found;
implicit solution returned.
ans =
RootOf(z^3 + 3*z - 3*a*x - 3*C36, z)