1

Matlab et l’analyse numérique

Table des matières et la solution sera

( b1
I Introduction 1 x1 = a1,1
1
Pi−1
xi = ai,i (bi − ai,j xj ).
II Analyse numérique 1 j=1
II-A Méthodes directes de résolutions des Le code matlab associé :
systèmes linéaires . . . . . . . . . . . 1
II-A1 Méthode de Gauss . . . . . 1
II-A2 Méthode LU . . . . . . . . 2 function x=triang(A,b)
II-A3 Décompostion de Cholesky 2 x(1)=b(1)/A(1,1) ;
II-B Calcul des valeurs propres . . . . . . 2 for i=2 :size(A,1)
II-B1 Méthode de puissance . . . 2
som=b(i) ;
II-B2 Méthode de puissance inverse 3
for j=1 :i-1
II-C Discrétisation de l’EDP . . . . . . . . 3
som=som-A(i,j)*x(j) ;
III Recherches Opérationnelles 3 end
III-A Méthode de simplexe . . . . . . . . . 3 x(i)=som/A(i,i) ;
III-B Théorie des graphes . . . . . . . . . . 4 end
III-B1 Algorithme de Kruskal . . 4
III-B2 Algorithme de Ford . . . . 4 1) Méthode de Gauss: Il y a 4 principes fondamentales
dans la résolution des systèmes linéaires, la solution x ne
I. Introduction change pas lorsque on :
– permute 2 lignes
Matlab est un logiciel de calcul et de visualisation, – permute 2 colonnes
dont les entitées de base sont des matrices. Matlab est – divise par un même terme non nul les éléments d’une
une abréviation de Matrix Laboratory. Il est un langage ligne
interprété : il propose des facilités de programmation et – ajoute ou retranche à une ligne un certain nombre de
de visualisation, ainsi qu’un grand nombre de fonctions fois une autre ligne
réalisant diverses méthodes numériques. La meilleure façon Donc on a intérêt à transformer le système linéaire en un
d’apprendre à utiliser ce logiciel est de l’utiliser vous même, système équivalent facile à résoudre : triangulaire. Soit le
en faisant des essais, en commettant des erreurs et en système à 4 inconnus suivant :
essayant de comprendre les messages d’erreur qui vous
seront renvoyés. 2x1 + 4x2 − 2x3 = −6


x1 + 3x2 + x4 = 0

II. Analyse numérique  3x1 − x2 + x3 + 2x4 = 8

A. Méthodes directes de résolutions des systèmes linéaires −x1 − x2 + 2x3 + x4 = 6
Considérons le système linéaire Ax = b avec le cas simple Le pivot dans ce cas est le coefficient de x1 dans la
A inversible diagonale : première ligne (pivot = 2). Donc pour éliminer les coeffi-
cients de x1 dans les autres lignes on effectue l’opération
a1,1 0 0 ... 0 x1 b1
    
ai,1
suivante pour chaque ligne :Li = Li − pivot L1 et on obtient :
 0 a2,2 0 ... 0   x 2   b2 
 ... =
... ... ... ...   ...   ...  
2x1 + 4x2 − 2x3 = −6
0 ... 0 0 an,n xn bn

0 + x2 + x3 + x4 = 3


la solution sera xi = abi,i

i
avec i ∈ [1, n]. Le programme  0 − 7x2 + 4x3 + 2x4 = 17

0 + x2 + x3 + x4 = 3
Matlab associé est le suivant :
La première variable a été éliminée de toutes les
function x=diago(A,b) équations sauf une. On procède de la même façon pour les
for i=1 :size(A,1) autres variables jusqu’à obtenir une matrice triangulaire.
x(i)=b(i)/A(i,i) ; Le code Matlab associé à la triangularisation de Gauss est
end le suivant :

Si on suppose que A est triangulaire, le problème function [A,b]=descent(A,b)

devient : for k=1 :size(A,1)-1
pivot=A(k,k) ;
a1,1 0 0 ... 0 x1 b1 if pivot =0
    
 a2,1 a2,2 0 ... 0   x2   b2  for i=k+1 :size(A,1)
 ... =
... ... ... ...   ...   ...  b(i)=b(i)-A(i,k)/pivot*b(k)
an,1 ... an,n−2 an,n−1 an,n xn bn for j=k+1 :size(A,1)
 2
A(i,j)=A(i,j)-A(i,k)/pivot*A(k,j) Les matrices élémentaires M (k) sont inversibles et leurs
end inverses sont les matrices L(k) triangulaires inférieures
end telles que :
end
end 
 li,j = 0 si j > i
Après avoir obtenir une matrice triangulaire supérieure, L(k) = li,i = 1 pour i = 1, ..., n
 li,k = ai,k = −mi,k pour i = k + 1, ..., n
on doit résoudre le système suivant : ak,k

Donc on obtient le code matlab de la décomposition LU

a1,1 a1,2 a1,3 ... a1,n x1 b1
    
suivant :
 0 a2,2 a2,3 ... a2,n   x2   b2 
 ... =
... ... ... ...   ...   ...  function [L,U]=decompose_lu(A)
0 ... 0 0 an,n xn bn n=size(A,1) ;
Mathématiquement la solution est : for k=1 :n-1
( pivot=A(k,k) ;% startégie de pivot
xn = abn,n
n si pivot =0
1
Pn
xi = ai,i (bi − j=i−1 ai,j xj L(k,k)=1 ;
for i=k+1 :n
et le code matlab associé : L(i,k)=A(i,k)/pivot ;
for j=k+1 :n
A(i,j)=A(i,j)-L(i,k)A(k,j) ;
function x=triang(A,b) end
n=size(A,1) ; end
x(n)=b(n)/A(n,n) ; end
for i=n-1 :-1 :1 end
som=b(i) ; 3) Décompostion de Cholesky: Le théorème de Cho-
for j=i+1 :n lesky : Si A est une matrice symétrique définie positive,
som=som-A(i,j)*x(j) ; il existe une unique matrice réelle triangulaire inférieure L
end telle que A = LLT . On commence par calculer la première
√ a1,j
x(i)=som/A(i,i) ; colonne de L : l1,1 = a1,1 et a1,j = l1,1 lj,1 d’où lj,1 = l1,1
eme
end et de même façon on calcule le i colonne après avoir
calculer les (i − 1) premières colonnes :
et la fonction globale :  q
 l = a − Pi−1 l2
i,i i,i k=1 i,k
function x=gauss(A,b) Pi−1
[U,c]=descent(A,b) ;  l = ai,j − k=1 li,k lj,k
j,i li,i
x=triang(U,c) ;
et le code matlab associé :
2) Méthode LU: On a trouvé que le système Ax = b peut
être transformé en U x = c donc on doit chercher L telle function L=cholesky(A)
que A = LU et b = Lc. A chaque étape de l’algorithme on n=size(A,1) ;
a pour i = k + 1, ..., n : L(1,1)=sqrt(A(1,1))
L(2 :n,1)=(1/L(1,1))*A(2 :n,1) ;
 (k)
ai,k
for k=2 :n
(k+1) (k) (k)
 ai,j
 = ai,j − (k) ak,j pour j = k + 1, ..., n L(k :n,k)=A(k :n,k) ;
ak,k
(k) for j=1 :k-1
ai,k
 b(k+1)

i
(k)
= bi − (k)
(k)
(bk L(k :n,k)=L(k :n,k)-L(k,j)*L(k :n,j) ;
ak,k
end
Matriciellement : A(k+1) = M (k) A(k) et b(k+1) = L(k,k)=sqrt(L(k,k)) ;
M (k) b(k) avec L(k+1 :n,k)=(1/L(k,k))*L(k+1 :n,k) ;
  end
1 0 0 ... 0
0 1 0 ... 0 
... ... ... ... ...
 
(k)
M = B. Calcul des valeurs propres
 0 ... mk+1,k ... 0 

... ... ... ... ... 1) Méthode de puissance: La méthode de la puissance
0 0 mn,k 0 1 itérée est utilisée pour calculer la plus grande valeur propre
a et le vecteur propre associé d’une matrice symétrique
et mi,k = − ak,ki,k
. A la dernière itération, A(n) = U = définie positive A de taille n × n. Ainsi A possède n valeurs
M (n−1) A(n−1) = M (n−1) M (n−2) ...M (1) A = M A donc propres : λ1 , ..., λn telles que |λ1 | > |λ2 | ≥ ... ≥ |λn |. Soient
A = M −1 U et on posant L = M −1 on obtient A = LU . u1 , ..., un les vecteurs propres associés.
Comment construire L et U ? On pose x0 un vecteur de IRn de norme égale a 1 (ou
Idée : reprendre l’étape de triangularisation de la méthode quelconque)
Pn que l’on décompose de la façon suivante :
de Gauss. x0 = i=1 xi ui et on calcule la suite xk+1 comme suit :
 3
Soit à résoudre l’équation de Laplace sur l’intervalle
xk = Ak x 0 [a, b] × [c, d] avec les conditions aux limites :
n .
λki ai ui
P
xk = i=1
∆u = 0
(
En mettant λk1 en facteur on obtient : u(x, c) = u(x, d) = u(a, y) = 0
k
Pn λki λk
xk = λ1 ( i=1 ( λk )ai ui ). Or λik pour i > 2 tendent u(b, y) = 100
1 1
vers 0 donc au bout de quelques itérations on obtient la Si on discrétise l’intervalle [a, b] × [c, d] avec un pas h on
plus grande valeur propore : |λ1 | ≈ ||x k+1 ||
||xk || et le vecteur
obtient un système linéaire Ax = b avec A de taille nx ny ×
propre associé u1 ≈ xk . Le code matlab associé est le nx ny et b de taille nx ny :
suivant :

function [lambda,u]=puissance(A,x0,eps)
x=x0 ;
lambda=0 ;lambda_anc=1 ;
while abs(lambda-lambda_anc)>eps
lambda_anc=lambda ;
u=x/abs(x) ;
x=A*u ;
lambda=u’*x ;
end

2) Méthode de puissance inverse: La plus petite valeur Le programme Matlab pour construire A et b est le
propre de A (en valeur absolue) est aussi la plus grande suivant :
de A1 (en valeur absolue) :
function [A,b]=edp(a,b,c,d,h)
1 nx=(b-a)/h ;
Au = λu ssi u = A−1 u (1) ny=(d-c)/h ;
λ
n=nx*ny ;
On peut donc appliquer la méthode de la puissance à A−1 % (remplissage des éléments de la matrice
mais la matrice A−1 doit être calculée. En général, on ne A)
calcule pas l’inverse de la matrice A, mais on réalise sa A=zeros(n) ;
décomposition LU. Donc si on suppose que P A = LU , le for i=1 :n-1
code Matlab sera : A(i,i)=-4 ;
A(i+1,i)=1 ;
A(i,i+1)=1 ;
function [lambda,u]=inverse(P,L,U,x0,eps) if (mod(i,(nx-1))==0)
x=x0 ; A(i+1,i)=0 ;
lambda=0 ;lambda_anc=1 ; A(i,i+1)=0 ;
while abs(lambda-lambda_anc)>eps end
lambda_anc=lambda ; end
u=x/abs(x) ; for i=1 :n-nx+1
c=P*u ; A(nx-1+i,i)=1 ;
x=triang(U,c) ;%utiliser la fonction triang A(i,nx-1+i)=1 ;
lambda=1/(x’*u) ; end
end A(n,n)=-4 ;
% (remplissage des éléments de la matrice
B)
C. Discrétisation de l’EDP
2 2
for i=1 :n
Soit δδxu2 + δδyu2 = 0 avec (x, y) ∈ [a, b] × [c, d]. La B(i)=0 ;
discrétisation de l’intervalle [a, b] est effectué en posant if (mod(i,nx-1)==0)
hx = h = b−a nx et on obtient x(i) = xi = a + ih et
B(i)=-100 ;
hy = h = d−c end
ny et on obtient y(j) = yj = c + jh pour
i = 0, 1, ..., nx et j = 0, 1, ..., ny . end
La méthode de différences finies consiste à approxi-
mer les dérivées partielles d’une équation au moyen des
développements de Taylor et ceci se déduit directement de III. Recherches Opérationnelles
la définition de la dérivée. Posons u(xi , yj ) = ui,j , on a : A. Méthode de simplexe
(
δ2 u ui+1,j −2ui,j +ui−1,j function[A, x, z] = simplex(c, A, b) ;
δx2
≈ h2x c = -c ;
δ2 u ui,j+1 −2ui,j +ui,j−1 [m, n] = size(A) ;
δy 2
≈ h2y
ui+1,j −4ui,j +ui−1,j +ui,j+1 +ui,j−1
A = [A eye(m)] ;
∆u = h2 b = b( :) ;
 4
c = c( :)’ ; if aretes(new(1))==0 && aretes(new(2))==0
A = [A b] ; aretes(new(1))=g ;
d = [c zeros(1,m+1)] ; aretes(new(2))=g ;
A = [A ;d] ; elseif aretes(new(1))==0
mi=min(A(m+1,1 :m+n)) ; aretes(new(1))=aretes(new(2)) ;
col=find(A(m+1, :)==mi) ; elseif aretes(new(2))==0
subs = n+1 :m+n ; aretes(new(2))=aretes(new(1)) ;
while mi < 0 & abs(mi) > eps elseif aretes(new(1))==aretes(new(2))
t = A(1 :m,col) ; test=1 ;
if all(t <= 0)x = zeros(n,1) ; else
z = inf ; m=max(aretes(new(1)),aretes(new(2))) ;
return ; for i=1 :n
end if aretes(i)==m
t1=A(1 :m,m+n+1) aretes(i)=min(aretes(new(1)),aretes(new(2))) ;
t2=A(1 :m,col) ; end
l=find(t2 > 0) ; end
[mi, row] = min(t1(l)./t2(l)) ; end
row = l(row) ; if test == 1
if isempty(row) G(i, :) = [0 0 0] ;
A(row, :)= A(row, :)/A(row,col) ; end
subs(row) = col ; end
for i = 1 :m+1 w = sum(G( :,3)’) ; for i = 1 : ligne
if i = row if G(i,[1 2]) = [0 0]
A(i, :)= A(i, :)-A(i,col)*A(row, :) ; T(G(i,1),G(i,2)) = 1 ;
end T(G(i,2),G(i,1)) = 1 ;
end end
end end
mi=min(A(m+1,1 :m+n)) ; 2) Algorithme de Ford:
col=find(A(m+1, :)==mi) ; %poids :matrice des poids
end %source :sommet de départ
z = A(m+1,m+n+1) ; %dest :sommet d’arrivée
x = zeros(1,m+n) ; function [chemin,cost]=ford(poids, source,
x = x(1 :n)’ ; dest)
clc ;
B. Théorie des graphes n = size(poids, 1) ;
distance(1 :n) = inf ;
1) Algorithme de Kruskal:
somprec(1 :n) = inf ;% sommet précédent
%w :poids de l’arbre et T :matrice
distance(source) = 0 ;
d’adjacence de l’arbre function [w,T] =
for i = 1 :n-1
krus(G)
for j = 1 :n
ligne = size(G) ;
for k = 1 :n
% cration de la matrice d’adjacence
if ((distance(j) + poids(j,k) <
X = [] ;
distance(k)) && (poids(j,k) = 0))
for i = 1 : ligne
distance(k) = distance(j) + poids(j,k) ;
X(G(i,1),G(i,2)) = 1 ;
somprec(k) = j ;
X(G(i,2),G(i,1)) = 1 ;
end
end
end
n = size(X,1) ;
end
for i = 1 : ligne - 1
end
d = ligne + 1 - i ;
chemin = [dest] ;
for j = 1 : d - 1
traverse = dest ;
if G(j,3) > G(j + 1,3)
cost=0 ;
G([j j + 1], :) = G([j + 1 j], :) ;
while (somprec(traverse) = source)
end
chemin = [somprec(traverse) chemin] ;
end
traverse = somprec(traverse) ;
end
cost=cost+poids(chemin(1),chemin(2)) ;
aretes = zeros(1,n) ;
end
T = zeros(n) ;
chemin = [somprec(traverse) chemin] ;
% tester l’existence d’un cycle si on
cost=cost+poids(chemin(1),chemin(2)) ;
insert l’arete ’new’
for i = 1 : ligne
new = G(i,[1 2]) ;
g=max(aretes)+1 ;
test=0 ;
n=length(aretes) ;