Documents Pédagogiques : Manuel des Travaux Pratiques d'Analyse

Numérique
Année Universitaire 2023 - 2024

Pr Hamid El Ouardi
Email : [email protected]

- TP1 : Méthodes numériques de résolution de f (x) = 0

- TP2 : Interpolation linéaire de type Lagrange et Newton
- TP3 : Approximation d’une intégrale
- TP4 : Résolution numérique d’une équation différentielle
- TP5 : Résolution Numérique des systèmes linéaires
 2

Le manuel de Travaux Pratiques est composé de 20 pages et de cinq sujets indépendants.

Les élèves ingénieurs sont invités à réaliser les principaux résultats du cours d’Analyse nu-
mérique, à mettre en oeuvre les différentes méthodes, et à analyser les principaux résultats
obtenus.

Objectifs des travaux pratiques d’Analyse Numérique

☞ Se familiariser avec le Logiciel Matlab ;

☞ Implementer et résoudre des algorithmes ;

☞ Apprendre à tracer des courbes et visualiser les résultats ;

☞ Programmation de la méthode de Newton-Raphson et de la sécante ;

☞ Visualiser les résultats ;

☞ Programmation des approximations des intégrales ;

☞ Programmation de l’interpolation de Lagrange et de Newton ;

☞ Approximation d’une équation différentielle (Euler, RK2, RK4) ;

☞ Résolution numérique des systèmes linéaires (Gauss, Cholesky).

Informations pour les élèves ingénieurs

— Chaque binôme effectue 4 séances de TP (4h par séance).
— Chaque séance est notée sur 4 points, afin d’avoir une note de TP à la fin des travaux
pratiques d’Analyse Numérique.
— Chaque binôme devra rédiger un compte-rendu de TP dans lequel, il doit expliciter les
méthodes employées, présenter et commenter les résultats obtenus.
— La qualité de la rédaction, de synthèse, de l’analyse des résultats obtenus sont des critères
importants pour la note.
— Vous devez rendre un compte rendu par binôme (par mail, format PDF). L’objet du
mail sera [AN TPi Nom1 Nom2] (i=1,2,3,4,5) avec Nom1 et Nom2 les noms du binôme.
Le nom du fichier sera AN_tpi_nom1_nom2.pdf. Mon adresse mail est la suivante :
[email protected]
— Ce compte rendu résumera votre travail, et inclura notamment : les parties de code que
vous avez modifiées ou écrites ; le lien entre vos résultats et les démonstrations du cours
du Pr Hamid El Ouardi.
 TP1 : Approximations des équations non linéaires

1 Introduction
Dans ce TP on appliquera les notions vues dans le cours d’Analyse Numérique sur la ré-
solution numérique des équations non linéaires. En particulier, vous implémenterez différents
algorithmes pour des équations non linéaires. Les calculs seront effectués à l’aide de scripts exé-
cutés dans l’environnement Matlab. Pour chaque partie du TP, des squelettes de programmes
vous sont fournis, à vous de les compléter pour répondre aux questions.

1.1 Résultat 1 : Méthode de Newton - Raphson

Le problème est de trouver x tel que F ( x) = 0 et l’algorithme s’écrit :

Choisir x0 et déterminer la suite ( xn ) par la relation

F(x )
xn+1 = xn − F′ ( xn ) , n = 0, 1.....
n

1.2 Résultat 2 : Méthode de la sécante :

Choisir x1 et x2 tels que F ( x1 ) F ( x2 ) < 0
déterminer la suite ( xn ) par la relation
x −x
xn+1 = xn − F ( xn ) F( x n)− Fn(−x 1 ) , n ≥ 2
n n−1

1.3 Résultat 3 : Méthode itérative

Le problème est de trouver x tel que g( x) = x et l’algorithme s’écrit :

Choisir x0 et déterminer la suite ( xn ) par la relation

xn+1 = g( xn ) , n = 0, 1.....

2 Travail à faire :
1) Représenter graphiquement les fonctions suivantes :
a) f ( x) = exp( x) − 2 cos( x), dans l’intervalle [−1, 1] .
h i
b) g( x) = x4 − 10x3 + 35x2 − 50x + 24, dans l’intervalle 25 , 72 .
√
c) h( x) = 2x − sin( x) + π6 − 23 , dans les intervalles − π2 , π3 et π3 , π .
   

3 Pr Hamid El Ouardi
3. PROGRAMMES 4

d) m( x) = exp(−2x) − cos( x) − 3, dans l’intervalle [−1, 0] .

2) a) Résoudre numériquement en utilisant la méthode de la sécante les équations f ( x) =
0, g( x) = 0 et h( x) = 0.
b) Résoudre numériquement en utilisant la méthode de Newton - Raphson les équations
f ( x) = 0, g( x) = 0 et h( x) = 0.
c) Résoudre numériquement en utilisant la méthode itérative l’équations m( x) = 0 en
choisissant g( x) = − 21 ln(3 + cos( x)).

3 Programmes

Voici un programme écrit en Matlab pour représenter graphiquement la courbe de f .

Exemple 3.1 (Exemple de code de Courbe en 1D).

clf ;
x=-1 :0.1 :1 ;
f=exp(x)-2*cos(x) ;
figure(1) ;
plot(x,f) ; grid on ;
title(’Fonction : f(x)=exp(x)-2.cos(x)’) ;

Voici un programme Matlab qui détermine la solution de l’équation f ( x) = 0 par l’algorithme

de Newton - Raphson.

Exemple 3.2 (Exemple de code de la méthode de Newton - Raphson).

clf ;
x=-1 :0.1 :1 ;
f=exp(x)-2*cos(x) ;
title(’Fonction : f(x)=exp(x)-2.cos(x)’) ;
clear all ;
clc ;
x(1)= input(’Donner la valeur initiale x(1) : \n′ );
iter=1 ;
e=1e-10 ;
n=5000 ;
for i=2 :n
f=exp(x(i-1))-2*cos(x(i-1)) ;
diff=exp(x(i-1))+2*sin(x(i-1)) ;
x(i)=x(i-1)-f/diff ;
if abs(x(i)-x(i-1))<=e
break
xp = x(i) ;
3. PROGRAMMES 5

fprintf(’xp =%f\n′ , x(i ));

end
end
disp(’Les valeurs successives de x(i) sont :’) ;
x’

Voici un programme Matlab qui détermine la solution de l’équation f ( x) = 0 par l’algorithme

de la sécante.

Exemple 3.3 (Exemple de code de la méthode de la sécante).

f = @(x) exp(-x)-sin(x) ;
x(1) = 2 ; x(2) = 10 ;
error = 0.001 ;
k=2 ;
maxIt = 100 ;
while (abs(x(k)-x(k-1)) > error) (k-1 <= maxIt)
x(k+1) = x(k) - f(x(k))*(x(k) - x(k-1))/(f(x(k)) - f(x(k-1))) ;
k = k + 1;
end
disp([’x(end) = ’ num2str(x(end)) , ’ f(x(end)) = ’ num2str(f(x(end))) , ’ iterations : ’ num2str(k-
2)]) ;
 TP2 : Interpolation linéaire de type Lagrange et
Newton

4 Introduction
Dans ce TP on appliquera les notions vues dans le cours du chapitre 2 sur l’interpolation
linéaires. En particulier, vous implementers l’approximation par les polynômes de Lagrange et
les polynômes de Newton. Les calculs seront effectués à l’aide de scripts exécutés avec Matlab.

4.1 Résultat 1 : Polynôme de Lagrange

Le polynôme d’interpolation de Lagrange de f aux points xi , i = 0, n distincts de [ a, b]
n
s’écrit Pn ( x) = ∑ f ( xi )Li ( x) où (Li )i=0,n est la base de Lagrange dans Pn .
i =0

∏ (x − x j )
j ̸ =i
Li ( x ) = .
∏ ( xi − x j )
j ̸ =i

4.2 Résultat 2 : Polynôme de Newton

Posons pour y0 , y1 , ..., yk ∈ R, n ∈ N∗ ,

 f ( yi )
 si k = i,
f [ yi , . . . , y k ] = f [ yi +1 , . . . , y ] − f [ yi , . . . , y ]
k k−1
 si k ≥ i.
y k − yi


Le polynôme d’interpolation  de f s’écrit, dans la base de Newton, 



Pn ( x ) = f [ x 0 ] + ( x − x 0 ) f [ x 0 , x 1 ] + ( x − x 1 ) . . . f [ x 0 , . . . , x n − 1 ] + ( x − x n − 1 ) f [ x 0 , . . . , x n ] .

5 Questions :
Les masses volumiques du matériau pour différentes températures sont données par le ta-
bleau ci-dessous :

6 Pr Hamid El Ouardi
6. SCRIPTS ET RÉSULTATS 7

T : Temprature (en ◦ C ) 94 205 371

R( T ) : Masse volumique (en kg/m3) 929 902 860

1) Trouver les masses volumiques du sodium pour T = 251 ◦ C,

T = 305◦ C et T = 800◦ C en utilisant l’interpolation de Lagrange.
2) Trouver les masses volumiques du sodium pour T = 251◦ C,
T = 305◦ C et T = 800◦ C en utilisant l’interpolation de Newton.

6 Scripts et résultats
[Exemple de code du polynôme de Lagrange]
Programme : polylag.m
clc ;
clear ;
T=[94 205 371] ;
R=[929 902 860] ;
Ti=[251 305 800] ;
Ri=lag(T,R,Ti)
La fonction ‘lag.m’ est un sous programme permettant de donner l’interpolation de La-
grange. La liste de ce sous programme est :
Fonction : lag.m
function Ri = lag(T,R,Ti)
Ri=zeros(size(Ti)) ;
n=length(R) ;
for i=1 :n
y=ones(size(Ti)) ;
for j=1 :n
if i ∼= j
y=y.*(Ti-T(j))/(T(i)-T(j)) ;
end
end
Ri=Ri+y*R(i) ;
end
return

[Exemple de code du polynôme de Newton]

Programme : polyNewt.m
clc ;
clear ;
T=[94 205 371] ;
R=[929 902 860] ;
Ti=[251 305 800] ;
n=length(T) ;
for i=1 :n
6. SCRIPTS ET RÉSULTATS 8

Ri=newtoninterpolation(T,R,Ti(i))
end
Fonction : newtoninterpolation.m
function fp = newtoninterpolation(T,R,Ti)
n = length(T) ;
a(1) = R(1) ;
for k = 1 : n - 1
d(k, 1) = (R(k+1) - R(k))/(T(k+1) - T(k)) ;
end
for j = 2 : n - 1
for k = 1 : n - j
d(k, j) = (d(k+1, j - 1) - d(k, j - 1))/(T(k+j) - T(k)) ;
end
end
for j = 2 : n
a(j) = d(1, j-1) ;
end
Df(1) = 1 ;
c(1) = a(1) ;
for j = 2 : n
Df(j)=(Ti - T(j-1)) .* Df(j-1) ;
c(j) = a(j) .* Df(j) ;
end
fp=sum(c) ;
end
 TP3 : Approximation Numérique d’une
intégrale

7 Introduction
Dans ce TP on appliquera les notions vues dans le cours d’Analyse Numérique sur l’approxi-
mation numérique des intégrales. En particulier, vous implémenterez différents algorithmes
pour calculer une valeur approchée d’une intégrale. Les calculs seront effectués à l’aide de
scripts exécutés dans l’environnement Matlab. Pour chaque partie du TP, des squelettes de pro-
grammes vous sont fournis, à vous de les compléter pour répondre aux questions.

7.1 Résultat 1 : Méthode des Rectangles

b − a n−1
Z b
f ( x)dx ≈ f ( xi ) .
a n i∑ =0

7.2 Résultat 2 : Méthode des Trapèzes

Zb
" ! #
n−1
b−a
f ( x)dx ≈ f ( x0 ) + 2 ∑ f ( xk ) + f ( xn )
2n k=1
a

7.3 Résultat 3 : Méthode de Simpson

Zb
b−a
f ( x)dx ≈ [ f ( x0 ) + 4 f ( x1 ) + 2 f ( x2 ) + 4 f ( x2 ) + ...... + f ( xn )]
3n
a

8 Travail à faire :
Soit I l’intégrale définie par :

R2 1 2 √
I= x
0 ( 2 x + 4 + 1 + e )dx.

9 Pr Hamid El Ouardi
8. TRAVAIL À FAIRE : 10

1) Montrer que la fonction F définie sur R par

√
t3 p
t
1 + et − 1
F (t) = + 4t + 2 1 + e + ln √
6 1 + et + 1

est une primitive de la fonction f définie sur R par

2 √
f (t) = t2 + 4 + 1 + et .
R2
En déduire une valeur exacte de I = 0 f (t)dt.
2) Utiliser la méthode des rectangles pour donner une valeur approchée de I, notée IRec .
3) Utiliser la méthode des trapèzes pour donner une valeur approchée de I, notée ITrap .
4) Utiliser la méthode de Simpson pour donner une valeur approchée de I, notée ISimp .
5) Déterminer les erreurs de ces méthodes.
6) Faire un seul programme sous forme d’un tableau récapitulatif (Méthode des trapèzes,
Méthode de Simpson)

Voici un programme Matlab, qui calcule la valeur approchée de I par l’algorithme des rec-
tangles en fonction de n.

Exemple 8.1 (Programme des rectangles).

clc ; clear ;
Iexact=13.34032756 ; a=0 ; b=2 ;
fprintf(’\n Méthode des Rectangles \ n′ );
fprintf(’\n n\t \t I \t Pourc. erreur relat.\n′ );
fprintf(’——————————————–\n′ );
n=1 ;
for k=1 :10
n=2*n ;
h=(b-a)/n ;
i=1 :n ;
x=a+(i-1)*h ;
f=(0.5*x2 + 4) + sqrt(1 + exp( x));
I=h*sum(f) ;
erreur=abs(Iexact-I)/Iexact ;
fprintf(’%d\t %10.5 f \t %10.8 f \n′ , n, I, erreur);
end

Voici un programme Matlab, qui calcule la valeur approchée de I par l’algorithme des trapèzes
en fonction de n.

Exemple 8.2 (Programme des trapèzes).

clc ; clear ;
Iexact=13.34032756 ; a=0 ; b=2 ;
8. TRAVAIL À FAIRE : 11

fprintf(’\n Méthode des Trapèzes \ n′ );

fprintf(’\n n\t \t I \t Pourc. erreur relat.\n′ );
fprintf(’——————————————–\n′ );
n=1 ;
for k=1 :10
n=2*n ;
h=(b-a)/n ;
i=1 :n+1 ;
x=a+(i-1)*h ;
f=(0.5*x2 + 4) + sqrt(1 + exp( x));
I=(2*sum(f)-f(1)-f(length(f)))/2*h ;
erreur=abs(Iexact-I)/Iexact ;
fprintf(’%d\t %10.5 f \t %10.8 f \n′ , n, I, erreur);
end

Voici un programme Matlab, qui calcule la valeur approchée de I par l’algorithme de Simpson
en fonction de n.

Exemple 8.3 (Programme de Simpson).

clc ; clear ;
Iexact=13.34032756 ; a=0 ;b=2 ;
fprintf(’\n Méthode de Simpson \n′ );
fprintf(’\nn\t \t I \t Pourc.erreurrelat.\ n′ );
fprintf(’———————————————’) ;
n=1 ;
for k=1 :10
n=2*n ;
h=(b-a)/n ;
i=1 :n+1 ;
x=a+(i-1)*h ;
f=(0.5*x2 + 4) + sqrt(1 + exp( x));
I=h/3*(f(1)+4*sum(f(2 :2 :n))+f(n+1)) ;
if n>2
I=I+h/3*2*sum(f(3 :2 :n)) ;
end
erreur=abs(Iexact-I)/Iexact ;
fprintf(’%d\t %10.5 f \t %10.8 f \n′ , n, I, erreur);
end
 TP3 : Résolution Numérique d’une équation
différentielle

9 Introduction
Dans ce TP on appliquera les notions vues dans le cours d’Analyse Numérique sur la ré-
solution numérique des équations différentielles. En particulier, vous implémenterez différents
algorithmes (Euler, RK2 et RK4). Les calculs seront effectués à l’aide de scripts exécutés dans
l’environnement Matlab. Pour chaque partie du TP, des squelettes de programmes vous sont
fournis, à vous de les compléter pour répondre aux questions.

9.1 Résultat 1 : Méthode d’Euler

y0 donnée
yk+1 = yk + h f ( tk , yk ) , k≥ 0

9.2 Résultat 2 : Méthode de Runge - Kutta d’ordre 2

y0 donnée
yk = yk−1 + 2h (k1 + k2 )
k1 = f ( tk−1 , yk−1 )
k2 = f (tk−1 + h, yk−1 + hk1 )

10 Résultat 3 : Méthode de Runge - Kutta d’ordre 4

y0 donnée
yk = yk−1 + 6h (k1 + 2k2 + 2k3 + k4 )
k1 = f ( tk−1 , yk−1 )
k2 = f (tk−1 + 12 h, yk−1 + 2h k1 )
k3 = f (tk−1 + 12 h, yk−1 + 2h k2 )
k4 = f (tk−1 + h, yk−1 + hk1 )

12 Pr Hamid El Ouardi
11. TRAVAIL À FAIRE : 13

11 Travail à faire :
On considère l’équation différentielle suivante :
 ′
 y (t) + 2y(t) = 4t − 5 + 3 exp(−4t), et 0 ≤ t ≤ 4
y(0) = 1
h = 0, 1


3
1) Vérifier que la solution exacte est y(t) = 6 exp(−2t) − 2 exp(−4t) + 2t − 72 .
2) Écrire et programmer la méthode d’Euler pour déterminer la solution approchée de cette
équation différentielle.
3) Écrire et programmer la méthode de Runge - Kutta d’ordre 2 pour déterminer la solution
approchée de cette équation différentielle.
4) Écrire et programmer la méthode de Runge - Kutta d’ordre 4 pour déterminer la solution
approchée de cette équation différentielle.
5) Tester les différents programmes avec h = 0, 1 ; h = 0, 5 et h = 0, 01.
6) Pour comparer l’erreur commise, tracer les trois courbes des trois solutions approchées
et la courbe de la solution exacte.

Voici un programme Matlab, qui calcule la valeur approchée de l’équation différentielle par
l’algorithme d’Euler avec h = 0, 1.

Exemple 11.1 (Exemple du code de la Méthode d’Euler).

h=0.1 ;
t=0 :h :4 ;
clear ystar ;
ystar(1)=1.0 ;
for i=1 :length(t)-1,
k1=3*exp(-4*(t(i)))-2*ystar(i)+4*t(i)-5 ;
ystar(i+1)=ystar(i)+h*k1 ;
end
y(t)=6*exp(-2*t)-1.5*exp(-4*t)+2*t-3.5) ;
plot(t,ystar,’b–’,t,y,’r-’) ;
legend(’Approximation’,’Exacte’) ;
title(’Euler Approximation, h=0.1’) ;
xlabel(’Temps’) ;
ylabel(’y*(t), y(t)’) ;
for i=1 :length(t)
disp(sprintf(’t=%5.3f, y(t)=%6.4f, y*(t)=%6.4f’,t(i),y(i),ystar(i))) ;
end

Voici un programme Matlab, qui calcule la valeur approchée de l’équation différentielle par
l’algorithme de Runge - Kutta d’ordre 2 avec h = 0, 1.
11. TRAVAIL À FAIRE : 14

Exemple 11.2 (Exemple du code de la Méthode de Runge - Kutta d’ordre 2).

h=0.1 ;
t=0 :h :4 ;
clear ystar ;
ystar(1)=1.0 ;
for i=1 :length(t)-1,
k1=3*exp(-4*(t(i)))-2*ystar(i)+4*t(i)-5 ;
k2=3*exp(-4*(t(i)+h))-2*(ystar(i)+h*k1)+4*t(i)-5 ;
ystar(i+1)=ystar(i)+h*0.5*(k1+k2) ;
end
y=6*exp(-2*t)-1.5*exp(-4*t)+2*t(i)-3.5 ;
plot(t,ystar,’b–’,t,y,’r-’) ;
legend(’Approximation’,’Exacte’) ;
title(’rk2 Approximation, h=0.1’) ;
xlabel(’Temps’) ;
ylabel(’y*(t), y(t)’) ;
for i=1 :length(t)
disp(sprintf(’t=%5.3f, y(t)=%6.4f, y*(t)=%6.4f’,t(i),y(i),ystar(i))) ;
end

Voici un programme Matlab, qui calcule la valeur approchée de l’équation différentielle par
l’algorithme de Runge - Kutta d’ordre 4 avec h = 0, 1.

Exemple 11.3 (Exemple du code de la Méthode de Runge -Kutta d’ordre 4).

h=0.1 ;
t=0 :h :4 ;
clear ystar ;
ystar(1)=1.0 ;
for i=1 :length(t)-1,
k1=3*exp(-4*(t(i)))-2*ystar(i)+4*t(i)-5 ;
k2=3*exp(-4*(t(i)+(h/2)))-2*(ystar(i)+(h/2)*k1)+4*(t(i)+(h/2))-5 ;
k3=3*exp(-4*(t(i)+(h/2)))-2*(ystar(i)+(h/2)*k2+)+4*(t(i)+(h/2))-5 ;
k4=3*exp(-4*(t(i)+h))-2*(ystar(i)+h*k3)+4*(t(i)+h)-5 ;
ystar(i+1)=ystar(i)+h*(1/6)*(k1+2*k2+2*k3+k4) ;
end
y=6*exp(-2*t)-1.5*exp(-4*t)+2*t-3.5 ;
plot(t,ystar,’b–’,t,y,’r-’) ;
legend(’Approximation’,’Exacte’) ;
title(’rk4 Approximation, h=0.1’) ;
xlabel(’Temps’) ;
ylabel(’y*(t), y(t)’) ;
for i=1 :length(t)
disp(sprintf(’t=%5.3f, y(t)=%6.4f, y*(t)=%6.4f’,t(i),y(i),ystar(i))) ;
end
 TP5 : Résolution numérique des systèmes
linéaires

12 Introduction
Dans ce TP on appliquera les notions vues dans le cours du chapitre 5 sur la résolution nu-
mérique des systèmes linéaires. En particulier, vous implémenterez les principales méthodes
(Méthode de Gauss, méthode de Choleski). Les calculs seront effectués à l’aide de scripts exé-
cutés avec Matlab.

13 Questions :
1) Résoudre le système Ax = b, avec
   
1 4 0 0 9
 1 7 2 0   21 
A=  et b =  .
 0 −3 3 7   31 
0 0 5 15 75

a) En utilisant d’abord l’opérateur \ de Matlab.

b) Résoudre ce système avec la méthode de Gauss.
c) Afficher toutes les matrices de calcul.
2) Résoudre le système Ax = b, avec
   
0.9 0.06 −0.39 −0.24 0.063
 0.06 1.604 0.134 0.464   −0.6358 
A=
 −0.39
 et b =  .
0.134 2.685 0.802   0.5937 
−0.24 0.464 0.802 1.977 −0.1907

a ) En utilisant d’abord l’opérateur \ de Matlab.

b ) Résoudre ce système avec la méthode de Choleski. Afficher la matrice L.

15 Pr Hamid El Ouardi
14. SCRIPTS ET RÉSULTATS 16

3 ) Résoudre le système Ax = b, avec

   
4 −1 0 0 0 100
 −1 4 −1 0 0   50 
   
A=  0 −1 4 −1 0 50
 et b =  .
  
 0 0 −1 4 −1   1150 
0 0 0 −1 4 2300

a) En utilisant d’abord l’opérateur \ de Matlab.

14 Scripts et résultats
1) a) Directement avec Matlab :
A=[1 4 0 0 ; 1 7 2 0 ; 0 -3 3 7 ; 0 0 5 15]
1 4 0 0
1 7 2 0
A=
0 −3 3 7
0 0 5 15
>> b = [9 21 31 75]
b=
9 21 31 75

La solution est donnée directement par :

>> x = A\b′
1
2
x=
3
4
b) [Exemple de code du programme de l’algorithme de Gauss]

Programme : gauss.m
clear
a = [1 4 0 0 9 ; 1 7 2 0 21 ; 0 -3 3 7 31 ; 0 0 5 15 75] ;
x = [0 0 0 0]’ ;
b(1, :) = a(1, :) ;
b(2, :) = a(2, :)-a(1, :) ;
b(3, :) = a(3, :) ;
b(4, :) = a(4, :)
c(1, :) = b(1, :) ;
c(2, :) = b(2, :) ;
c(3, :) = b(2, :)+b(3, :) ;
c(4, :) = b(4, :)
d(1, :) = c(1, :) ;
d(2, :) = c(2, :) ;
14. SCRIPTS ET RÉSULTATS 17

d(3, :) = c(3, :) ;
d(4, :) = c(4, :) - c(3, :)
x(4) = d(4,5)./d(4,4) ;
x(3) = (d(3,5) - d(3,4).*x(4))./d(3,3) ;
x(2) = (d(2,5) - d(2,3).*x(3))./d(2,2) ;
x(1) = (d(1,5) - d(1,2).*x(2))./d(1,1)
c) Après execution du programme, on obtient :
1 4 0 0 9
1 7 2 0 21
a=
0 −3 3 7 31
0 0 5 15 75
b=
1 4 0 0 9
0 3 2 0 12
0 −3 3 7 31
0 0 5 15 75
1 4 0 0 9
0 3 2 0 12
c=
0 0 5 7 43
0 0 5 15 75
1 4 0 0 9
0 3 2 0 12
d=
0 0 5 7 43
0 0 0 8 32
1
2
x=
3
4
2) description
a) Directement avec Matlab
A=[0.9 0.06 -0.39 -0.24 ; 0.06 1.604 0.134 0.464 ; -0.39 0.134 2.685 0.802 ; -0.24
0.464 0.802 1.977]
0.9000 0.0600 −0.3900 −0.2400
0.0600 1.6040 0.1340 0.4640
A=
−0.3900 0.1340 2.6850 0.8020
−0.2400 0.4640 0.8020 1.9770

>> b=[0.063 -0.6358 0.5937 -0.1907]

b=
0.0630 -0.6358 0.5937 -0.1907

La solution est déterminée directement par :

>> x = A\b′
14. SCRIPTS ET RÉSULTATS 18

0.2000
−0.4000
x=
0.3000
−0.1000
b) A=[0.9 0.06 -0.39 -0.24 ; 0.06 1.604 0.134 0.464 ; -0.39 0.134 2.685 0.802 ; -0.24 0.464
0.802 1.977]

0.9000 0.0600 −0.3900 −0.2400

0.0600 1.6040 0.1340 0.4640
A=
−0.3900 0.1340 2.6850 0.8020
−0.2400 0.4640 0.8020 1.9770

La décomposition de Choleski est directement déterminée par :

>> R = chol ( A)
0.9487 0.0632 −0.4111 −0.25300
1.2649 0.1265 0.37950 0
R=
1.5811 0.41110 0 0
1.2649
>> L = R′
0.9487 0 0 0
0.0632 1.2649 0 0
L=
−0.4111 0.1265 1.5811 0
−0.2530 0.3795 0.4111 1.2649

On vérifie directement que :

>> b = L ∗ R
0.9000 0.0600 −0.3900 −0.2400
0.0600 1.6040 0.1340 0.4640
b=
−0.3900 0.1340 2.6850 0.8020
−0.2400 0.4640 0.8020 1.9770
b) [Exemple de code de l’algorithme de Choleski]

Programme : choleski.m
M = [0.9 0.06 − 0.39 − 0.24;
0.06 1.604 0.134 0.464;
− 0.39 0.134 2.685 0.802;
− 0.24 0.464 0.802 1.977] ;

L = chol( M )’
n = length( M ) ;
L = zeros( n, n ) ;
for i = 1 :n
L(i, i) = sqrt(M(i, i) - L(i, :)*L(i, :)’)
for j=(i + 1) :n
L(j, i) = (M(j, i) - L(i, :)*L(j , :)’)/L(i, i)
end
14. SCRIPTS ET RÉSULTATS 19

end
b = [0.063, -0.6358, 0.5937, -0.1907]’
y = L \b
x = L’ \ y
Après exécution du programme, on obtient :
0.9487 0 0 0
0.0632 1.2649 0 0
L=
−0.4111 0.1265 1.5811 0
−0.2530 0.3795 0.4111 1.2649
0.9000 0.0600 −0.3900 −0.2400
0.0600 1.6040 0.1340 0.4640
M=
−0.3900 0.1340 2.6850 0.8020
−0.2400 0.4640 0.8020 1.9770
0.9487 0 0 0
0 0 0 0
L=
0 0 0 0
0 0 0 0
0.9487 0 0 0
0.0632 0 0 0
L= .
−0.4111 0 0 0
0 0 0 0
.
.
0.9487 0 0 0
0.0632 1.2649 0 0
L=
−0.4111 0.1265 1.5811 0
−0.2530 0.3795 0.4111 1.2649
0.0630 0.0664 0.2000
−0.6358 −0.5060 −0.4000
b= y= et x =
0.5937 0.4332 0.3000
−0.1907 −0.1265 −0.1000
a) Directement avec Matlab,
A=[4 -1 0 0 0 ; -1 4 -1 0 0 ; 0 -1 4 -1 0 ; 0 0 -1 4 -1 ; 0 0 0 -1 4]

4 −1 0 0 0
−1 4 −1 0 0
A = 0 −1 4 −1 0
0 0 −1 4 −1
0 0 0 −1 4
>> b = [100 50 50 1150 2300]

b=
100 50 50 1150 2300

La solution est déterminée directement par :

>> x = A\b′
14. SCRIPTS ET RÉSULTATS 20

40.1923
60.7692
x = 152.8846
500.7692
700.1923