UNIVERSITÉ HASSAN II CASABLANCA

ÉCOLE NATIONALE SUPÉRIEURE

TRAVAUX PRATIQUES
Analyse numérique

Filière : IARCI
Niveau : 1ère année GE

Réaliser par : Encadrer par :

ZAKARIA KTIMI Pr. [Link]

Année universitaire 2025-2026

Table des matières

1 Résolution Numérique de Systèmes Linéaires 3

1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Méthodes Directes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 Résolution de Systèmes Triangulaires Inférieurs . . . . . . . . . . . 3
1.2.2 Résolution de Systèmes Triangulaires Supérieurs . . . . . . . . . . . 4
1.2.3 Méthode d’Élimination de Gauss . . . . . . . . . . . . . . . . . . . 4
1.2.4 Factorisation LU . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.2.5 Factorisation de Cholesky . . . . . . . . . . . . . . . . . . . . . . . 6
1.3 Méthodes Itératives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.1 Méthode de Jacobi . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3.2 Méthode de Gauss-Seidel . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3.3 Méthode de Relaxation . . . . . . . . . . . . . . . . . . . . . . . . . 10

2 Résolution d’Équations Non Linéaires 11

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Méthode de Dichotomie . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Méthode de Newton-Raphson . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4 Méthode de la Sécante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.5 Méthode du Point Fixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3 Interpolation Polynômiale 16
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.2 Interpolation de Lagrange . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.3 Interpolation de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.3.1 Différences Divisées . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.3.2 Interpolation de Newton . . . . . . . . . . . . . . . . . . . . . . . . 17

1
Analyse numérique 1ère année GE - IARCI

3.3.3 Algorithme de Horner . . . . . . . . . . . . . . . . . . . . . . . . . 18

4 Dérivation et Intégration Numériques 19

4.1 Dérivation Numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1.1 Formules à Deux Points . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1.2 Dérivée Seconde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 Intégration Numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.2.1 Méthode des Rectangles . . . . . . . . . . . . . . . . . . . . . . . . 20
4.2.2 Méthode des Trapèzes . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.2.3 Méthode de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . 21

5 Exemples d’Application 22
5.1 Résolution de Systèmes Linéaires . . . . . . . . . . . . . . . . . . . . . . . 22
5.1.1 Exemple avec Gauss . . . . . . . . . . . . . . . . . . . . . . . . . . 22
5.1.2 Exemple avec Jacobi et Gauss-Seidel . . . . . . . . . . . . . . . . . 22
5.2 Résolution d’Équations Non Linéaires . . . . . . . . . . . . . . . . . . . . . 23
5.2.1 Comparaison des Méthodes . . . . . . . . . . . . . . . . . . . . . . 23
5.3 Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5.3.1 Comparaison Lagrange vs Newton . . . . . . . . . . . . . . . . . . . 23
5.4 Intégration Numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
5.4.1 Comparaison des Méthodes d’Intégration . . . . . . . . . . . . . . . 24
5.5 Dérivation Numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

A Fonctions Auxiliaires 27
A.1 Fonctions Utilitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

B Tests et Validation 29
B.1 Script de Test Complet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Conclusion 32

2
Chapitre 1

Résolution Numérique de Systèmes

Linéaires

1.1 Introduction
Ce chapitre présente les méthodes de résolution de systèmes linéaires de la forme Ax = b,
où A ∈ Mn (R) est une matrice carrée inversible et b ∈ Rn .

1.2 Méthodes Directes

1.2.1 Résolution de Systèmes Triangulaires Inférieurs

Algorithme de Descente

Pour un système Lx = b où L est triangulaire inférieure :

function x = descente (L , b )
% Resolution d ’ un systeme triangulaire inferieur Lx = b
% Entrees : L - matrice triangulaire inferieure ( n x n )
% b - vecteur second membre ( n x 1)
% Sortie : x - solution du systeme

n = length ( b ) ;
x = zeros (n , 1) ;

x (1) = b (1) / L (1 ,1) ;

for i = 2: n
somme = 0;
for j = 1: i -1
somme = somme + L (i , j ) * x ( j ) ;
end

3
Analyse numérique 1ère année GE - IARCI

x ( i ) = ( b ( i ) - somme ) / L (i , i ) ;
end
end
Listing 1.1 – Algorithme de descente - Système triangulaire inférieur

1.2.2 Résolution de Systèmes Triangulaires Supérieurs

Algorithme de Remontée

Pour un système U x = b où U est triangulaire supérieure :

function x = remontee (U , b )
% Resolution d ’ un systeme triangulaire superieur Ux = b
% Entrees : U - matrice triangulaire superieure ( n x n )
% b - vecteur second membre ( n x 1)
% Sortie : x - solution du systeme

n = length ( b ) ;
x = zeros (n , 1) ;

x ( n ) = b ( n ) / U (n , n ) ;

for i = n -1: -1:1

somme = 0;
for j = i +1: n
somme = somme + U (i , j ) * x ( j ) ;
end
x ( i ) = ( b ( i ) - somme ) / U (i , i ) ;
end
end
Listing 1.2 – Algorithme de remontée - Système triangulaire supérieur

1.2.3 Méthode d’Élimination de Gauss

function x = gauss (A , b )
% Resolution de Ax = b par elimination de Gauss
% Entrees : A - matrice carree ( n x n )
% b - vecteur second membre ( n x 1)
% Sortie : x - solution du systeme

n = length ( b ) ;
A = [ A b ]; % Matrice augmentee

% Phase d ’ elimination
for k = 1: n -1

4
Analyse numérique 1ère année GE - IARCI

% Verification du pivot
if abs ( A (k , k ) ) < eps
error ( ’ Pivot nul ou trop petit ’) ;
end

% Elimination
for i = k +1: n
m = A (i , k ) / A (k , k ) ;
A (i , k ) = 0;
for j = k +1: n +1
A (i , j ) = A (i , j ) - m * A (k , j ) ;
end
end
end

% Extraction de U et b modifie
U = A (: , 1: n ) ;
b_modif = A (: , n +1) ;

% Resolution par remontee

x = remontee (U , b_modif ) ;
end
Listing 1.3 – Méthode d’élimination de Gauss

1.2.4 Factorisation LU
function [L , U ] = factorisation_LU ( A )
% Factorisation LU de la matrice A
% Entree : A - matrice carree ( n x n )
% Sorties : L - matrice triangulaire inferieure
% U - matrice triangulaire superieure
% tel que A = L * U

n = size (A , 1) ;
L = eye ( n ) ;
U = zeros ( n ) ;

% Premiere ligne de U
U (1 ,:) = A (1 ,:) ;

% Premiere colonne de L
for i = 2: n
L (i ,1) = A (i ,1) / U (1 ,1) ;
end

% Calcul des autres elements

for i = 2: n -1

5
Analyse numérique 1ère année GE - IARCI

% Diagonale et partie superieure de U

for j = i : n
somme = 0;
for k = 1: i -1
somme = somme + L (i , k ) * U (k , j ) ;
end
U (i , j ) = A (i , j ) - somme ;
end

% Partie inferieure de L
for j = i +1: n
somme = 0;
for k = 1: i -1
somme = somme + L (j , k ) * U (k , i ) ;
end
L (j , i ) = ( A (j , i ) - somme ) / U (i , i ) ;
end
end

% Dernier element de U
somme = 0;
for k = 1: n -1
somme = somme + L (n , k ) * U (k , n ) ;
end
U (n , n ) = A (n , n ) - somme ;
end

function x = resolution_LU (A , b )
% Resolution de Ax = b en utilisant la factorisation LU
[L , U ] = factorisation_LU ( A ) ;

% Resolution de Ly = b
y = descente (L , b ) ;

% Resolution de Ux = y
x = remontee (U , y ) ;
end
Listing 1.4 – Factorisation LU

1.2.5 Factorisation de Cholesky

function L = cholesky ( A )
% Factorisation de Cholesky pour matrice symetrique definie
positive
% Entree : A - matrice symetrique definie positive ( n x n )
% Sortie : L - matrice triangulaire inferieure
% tel que A = L *L ’

6
Analyse numérique 1ère année GE - IARCI

n = size (A , 1) ;
L = zeros ( n ) ;

% Premier element
L (1 ,1) = sqrt ( A (1 ,1) ) ;

% Premiere colonne
for i = 2: n
L (i ,1) = A (i ,1) / L (1 ,1) ;
end

% Autres elements
for j = 2: n -1
% Element diagonal
somme = 0;
for k = 1: j -1
somme = somme + L (j , k ) ^2;
end
L (j , j ) = sqrt ( A (j , j ) - somme ) ;

% Elements sous la diagonale

for i = j +1: n
somme = 0;
for k = 1: j -1
somme = somme + L (i , k ) * L (j , k ) ;
end
L (i , j ) = ( A (i , j ) - somme ) / L (j , j ) ;
end
end

% Dernier element diagonal

somme = 0;
for k = 1: n -1
somme = somme + L (n , k ) ^2;
end
L (n , n ) = sqrt ( A (n , n ) - somme ) ;
end

function x = resolution_cholesky (A , b )
% Resolution de Ax = b avec Cholesky
L = cholesky ( A ) ;

% Resolution de Ly = b
y = descente (L , b ) ;

% Resolution de L ’ x = y
x = remontee (L ’ , y ) ;
end

7
Analyse numérique 1ère année GE - IARCI

Listing 1.5 – Factorisation de Cholesky

1.3 Méthodes Itératives

1.3.1 Méthode de Jacobi

function [x , iter ] = jacobi (A , b , x0 , tol , maxiter )
% Methode de Jacobi pour resoudre Ax = b
% Entrees : A - matrice carree ( n x n )
% b - vecteur second membre ( n x 1)
% x0 - vecteur initial ( n x 1)
% tol - tolerance
% maxiter - nombre maximal d ’ iterations
% Sorties : x - solution approchee
% iter - nombre d ’ iterations effectuees

n = length ( b ) ;
x = x0 ;
x_new = zeros (n , 1) ;
iter = 0;

while iter < maxiter

iter = iter + 1;

for i = 1: n
somme = 0;
for j = 1: n
if j ~= i
somme = somme + A (i , j ) * x ( j ) ;
end
end
x_new ( i ) = ( b ( i ) - somme ) / A (i , i ) ;
end

% Test de convergence
if norm ( A * x_new - b ) < tol
x = x_new ;
return ;
end

x = x_new ;
end

warning ( ’ Nombre maximal d ’ ’ iterations atteint ’) ;

end

8
Analyse numérique 1ère année GE - IARCI

Listing 1.6 – Méthode de Jacobi

1.3.2 Méthode de Gauss-Seidel

function [x , iter ] = gauss_seidel (A , b , x0 , tol , maxiter )
% Methode de Gauss - Seidel pour resoudre Ax = b
% Entrees : A - matrice carree ( n x n )
% b - vecteur second membre ( n x 1)
% x0 - vecteur initial ( n x 1)
% tol - tolerance
% maxiter - nombre maximal d ’ iterations
% Sorties : x - solution approchee
% iter - nombre d ’ iterations effectuees

n = length ( b ) ;
x = x0 ;
iter = 0;

while iter < maxiter

iter = iter + 1;
x_old = x ;

for i = 1: n
somme = 0;
% Somme des termes deja calcules
for j = 1: i -1
somme = somme + A (i , j ) * x ( j ) ;
end
% Somme des termes anciens
for j = i +1: n
somme = somme + A (i , j ) * x_old ( j ) ;
end
x ( i ) = ( b ( i ) - somme ) / A (i , i ) ;
end

% Test de convergence
if norm ( A * x - b ) < tol
return ;
end
end

warning ( ’ Nombre maximal d ’ ’ iterations atteint ’) ;

end
Listing 1.7 – Méthode de Gauss-Seidel

9
Analyse numérique 1ère année GE - IARCI

1.3.3 Méthode de Relaxation

function [x , iter ] = relaxation (A , b , x0 , omega , tol , maxiter )
% Methode de relaxation ( SOR ) pour resoudre Ax = b
% Entrees : A - matrice carree ( n x n )
% b - vecteur second membre ( n x 1)
% x0 - vecteur initial ( n x 1)
% omega - parametre de relaxation
% tol - tolerance
% maxiter - nombre maximal d ’ iterations
% Sorties : x - solution approchee
% iter - nombre d ’ iterations effectuees

n = length ( b ) ;
x = x0 ;
iter = 0;

while iter < maxiter

iter = iter + 1;
x_old = x ;

for i = 1: n
somme = 0;
% Somme des termes deja calcules
for j = 1: i -1
somme = somme + A (i , j ) * x ( j ) ;
end
% Somme des termes anciens
for j = i +1: n
somme = somme + A (i , j ) * x_old ( j ) ;
end

% Formule de relaxation
x_gs = ( b ( i ) - somme ) / A (i , i ) ;
x ( i ) = omega * x_gs + (1 - omega ) * x_old ( i ) ;
end

% Test de convergence
if norm ( A * x - b ) < tol
return ;
end
end

warning ( ’ Nombre maximal d ’ ’ iterations atteint ’) ;

end
Listing 1.8 – Méthode de relaxation (SOR)

10
Chapitre 2

Résolution d’Équations Non Linéaires

2.1 Introduction
Ce chapitre traite de la résolution numérique d’équations de la forme f (x) = 0 où f :
[a, b] → R.

2.2 Méthode de Dichotomie

function [x , iter ] = dichotomie (f , a , b , tol , maxiter )
% Methode de dichotomie pour trouver une racine de f ( x ) = 0
% Entrees : f - fonction
% a , b - bornes de l ’ intervalle [a , b ]
% tol - tolerance
% maxiter - nombre maximal d ’ iterations
% Sorties : x - approximation de la racine
% iter - nombre d ’ iterations effectuees

% Verification du changement de signe

if f ( a ) * f ( b ) > 0
error ( ’f ( a ) et f ( b ) doivent avoir des signes opposes ’) ;
end

% Verification des bornes

if f ( a ) == 0
x = a;
iter = 0;
return ;
end
if f ( b ) == 0
x = b;
iter = 0;
return ;
end

11
Analyse numérique 1ère année GE - IARCI

iter = 0;

while iter < maxiter

iter = iter + 1;

% Point milieu
x = ( a + b ) / 2;
fx = f ( x ) ;

% Test de convergence
if abs ( fx ) < tol || ( b - a ) /2 < tol
return ;
end

% Choix du sous - intervalle

if f ( a ) * fx < 0
b = x;
else
a = x;
end
end

warning ( ’ Nombre maximal d ’ ’ iterations atteint ’) ;

end
Listing 2.1 – Méthode de dichotomie (bissection)

2.3 Méthode de Newton-Raphson

function [x , iter ] = newton_raphson (f , df , x0 , tol , maxiter )
% Methode de Newton - Raphson pour trouver une racine de f ( x ) = 0
% Entrees : f - fonction
% df - derivee de f
% x0 - approximation initiale
% tol - tolerance
% maxiter - nombre maximal d ’ iterations
% Sorties : x - approximation de la racine
% iter - nombre d ’ iterations effectuees

x = x0 ;
iter = 0;

while iter < maxiter

iter = iter + 1;

fx = f ( x ) ;
dfx = df ( x ) ;

12
Analyse numérique 1ère année GE - IARCI

% Verification de la derivee
if abs ( dfx ) < eps
error ( ’ Derivee trop proche de zero ’) ;
end

% Iteration de Newton
x_new = x - fx / dfx ;

% Test de convergence
if abs ( x_new - x ) < tol
x = x_new ;
return ;
end

x = x_new ;
end

warning ( ’ Nombre maximal d ’ ’ iterations atteint ’) ;

end
Listing 2.2 – Méthode de Newton-Raphson

2.4 Méthode de la Sécante

function [x , iter ] = secante (f , x0 , x1 , tol , maxiter )
% Methode de la secante pour trouver une racine de f ( x ) = 0
% Entrees : f - fonction
% x0 , x1 - deux approximations initiales
% tol - tolerance
% maxiter - nombre maximal d ’ iterations
% Sorties : x - approximation de la racine
% iter - nombre d ’ iterations effectuees

iter = 0;
fx0 = f ( x0 ) ;
fx1 = f ( x1 ) ;

while iter < maxiter

iter = iter + 1;

% Verification du denominateur
if abs ( fx1 - fx0 ) < eps
error ( ’ Division par zero imminente ’) ;
end

% Iteration de la secante
x = x1 - fx1 * ( x1 - x0 ) / ( fx1 - fx0 ) ;

13
Analyse numérique 1ère année GE - IARCI

% Test de convergence
if abs ( x - x1 ) < tol
return ;
end

% Mise a jour
x0 = x1 ;
fx0 = fx1 ;
x1 = x ;
fx1 = f ( x ) ;
end

warning ( ’ Nombre maximal d ’ ’ iterations atteint ’) ;

end
Listing 2.3 – Méthode de la sécante

2.5 Méthode du Point Fixe

function [x , iter ] = point_fixe ( phi , x0 , tol , maxiter )
% Methode du point fixe pour resoudre x = phi ( x )
% Entrees : phi - fonction d ’ iteration
% x0 - approximation initiale
% tol - tolerance
% maxiter - nombre maximal d ’ iterations
% Sorties : x - approximation du point fixe
% iter - nombre d ’ iterations effectuees

x = x0 ;
iter = 0;

while iter < maxiter

iter = iter + 1;

x_new = phi ( x ) ;

% Test de convergence
if abs ( x_new - x ) < tol
x = x_new ;
return ;
end

x = x_new ;
end

warning ( ’ Nombre maximal d ’ ’ iterations atteint ’) ;

end

14
Analyse numérique 1ère année GE - IARCI

Listing 2.4 – Méthode du point fixe

15
Chapitre 3

Interpolation Polynômiale

3.1 Introduction
Ce chapitre présente les méthodes d’interpolation polynômiale permettant de construire
un polynôme passant par un ensemble de points donnés.

3.2 Interpolation de Lagrange

function L = lagrange_base (x , xi , i )
% Calcule le i - eme polynome de base de Lagrange
% Entrees : x - points d ’ evaluation
% xi - noeuds d ’ interpolation
% i - indice du polynome de base
% Sortie : L - valeurs du polynome de base

n = length ( xi ) ;
L = ones ( size ( x ) ) ;

for j = 1: n
if j ~= i
L = L .* ( x - xi ( j ) ) / ( xi ( i ) - xi ( j ) ) ;
end
end
end

function y = interpolation_lagrange (x , xi , yi )
% Interpolation de Lagrange
% Entrees : x - points d ’ evaluation
% xi - noeuds d ’ interpolation
% yi - valeurs aux noeuds
% Sortie : y - valeurs interpolees

n = length ( xi ) ;

16
Analyse numérique 1ère année GE - IARCI

y = zeros ( size ( x ) ) ;

for i = 1: n
L = lagrange_base (x , xi , i ) ;
y = y + yi ( i ) * L ;
end
end
Listing 3.1 – Polynômes de base de Lagrange

3.3 Interpolation de Newton

3.3.1 Différences Divisées

function DD = differences_divisees ( xi , yi )
% Calcule la table des differences divisees
% Entrees : xi - noeuds d ’ interpolation
% yi - valeurs aux noeuds
% Sortie : DD - table des differences divisees

n = length ( xi ) ;
DD = zeros (n , n ) ;
DD (: , 1) = yi (:) ;

for j = 2: n
for i = 1: n - j +1
DD (i , j ) = ( DD ( i +1 ,j -1) - DD (i ,j -1) ) / ( xi ( i +j -1) - xi ( i
));
end
end
end
Listing 3.2 – Table des différences divisées

3.3.2 Interpolation de Newton

function y = interpolation_newton (x , xi , yi )
% Interpolation de Newton avec differences divisees
% Entrees : x - points d ’ evaluation
% xi - noeuds d ’ interpolation
% yi - valeurs aux noeuds
% Sortie : y - valeurs interpolees

n = length ( xi ) ;
DD = differences_divisees ( xi , yi ) ;

17
Analyse numérique 1ère année GE - IARCI

% Evaluation du polynome de Newton

y = DD (1 ,1) * ones ( size ( x ) ) ;
produit = ones ( size ( x ) ) ;

for k = 2: n
produit = produit .* ( x - xi (k -1) ) ;
y = y + DD (1 , k ) * produit ;
end
end
Listing 3.3 – Interpolation de Newton

3.3.3 Algorithme de Horner

function y = horner_newton (x , xi , coeffs )
% Evaluation du polynome de Newton par Horner
% Entrees : x - points d ’ evaluation
% xi - noeuds d ’ interpolation
% coeffs - coefficients ( differences divisees )
% Sortie : y - valeurs du polynome

n = length ( coeffs ) ;
y = coeffs ( n ) * ones ( size ( x ) ) ;

for k = n -1: -1:1

y = y .* ( x - xi ( k ) ) + coeffs ( k ) ;
end
end
Listing 3.4 – Algorithme de Horner pour Newton

18
Chapitre 4

Dérivation et Intégration Numériques

4.1 Dérivation Numérique

4.1.1 Formules à Deux Points

function df = derivee_progressive (f , x , h )
% Approximation de f ’( x ) par difference progressive
df = ( f ( x + h ) - f ( x ) ) / h ;
end

function df = derivee_regressive (f , x , h )
% Approximation de f ’( x ) par difference regressive
df = ( f ( x ) - f ( x - h ) ) / h ;
end

function df = derivee_centree (f , x , h )
% Approximation de f ’( x ) par difference centree
df = ( f ( x + h ) - f ( x - h ) ) / (2* h ) ;
end
Listing 4.1 – Dérivée première - Formules à deux points

4.1.2 Dérivée Seconde

function d2f = derivee_seconde (f , x , h )
% Approximation de f ’ ’( x ) par differences centrees
d2f = ( f ( x + h ) - 2* f ( x ) + f ( x - h ) ) / h ^2;
end
Listing 4.2 – Dérivée seconde

19
Analyse numérique 1ère année GE - IARCI

4.2 Intégration Numérique

4.2.1 Méthode des Rectangles

function I = rectangles_gauche (f , a , b , n )
% Integration par la methode des rectangles a gauche
% Entrees : f - fonction a integrer
% a , b - bornes d ’ integration
% n - nombre de subdivisions
% Sortie : I - approximation de l ’ integrale

h = (b - a) / n;
x = linspace (a , b -h , n ) ;
I = h * sum ( f ( x ) ) ;
end

function I = rectangles_droite (f , a , b , n )
% Integration par la methode des rectangles a droite
h = (b - a) / n;
x = linspace ( a +h , b , n ) ;
I = h * sum ( f ( x ) ) ;
end

function I = point_milieu (f , a , b , n )
% Integration par la methode du point milieu
h = (b - a) / n;
x = linspace ( a + h /2 , b - h /2 , n ) ;
I = h * sum ( f ( x ) ) ;
end
Listing 4.3 – Méthode des rectangles

4.2.2 Méthode des Trapèzes

function I = trapezes (f , a , b , n )
% Integration par la methode des trapezes
% Entrees : f - fonction a integrer
% a , b - bornes d ’ integration
% n - nombre de subdivisions
% Sortie : I - approximation de l ’ integrale

h = (b - a) / n;
x = linspace (a , b , n +1) ;
y = f(x);

I = h * ( y (1) /2 + sum ( y (2: n ) ) + y ( n +1) /2) ;

end

20
Analyse numérique 1ère année GE - IARCI

Listing 4.4 – Méthode des trapèzes

4.2.3 Méthode de Simpson

function I = simpson (f , a , b , n )
% Integration par la methode de Simpson
% Entrees : f - fonction a integrer
% a , b - bornes d ’ integration
% n - nombre de subdivisions ( doit etre pair )
% Sortie : I - approximation de l ’ integrale

if mod (n , 2) ~= 0
error ( ’n doit etre pair pour Simpson ’) ;
end

h = (b - a) / n;
x = linspace (a , b , n +1) ;
y = f(x);

% Somme selon la formule de Simpson

I = y (1) + y ( n +1) ;

for i = 2:2: n
I = I + 4* y ( i ) ;
end

for i = 3:2: n -1
I = I + 2* y ( i ) ;
end

I = ( h /3) * I ;
end
Listing 4.5 – Méthode de Simpson

21
Chapitre 5

Exemples d’Application

5.1 Résolution de Systèmes Linéaires

5.1.1 Exemple avec Gauss

% Exemple : Resolution d ’ un systeme 3 x3
A = [4 -9 2; 2 -4 4; -1 2 2];
b = [4; 2; 9];

% Resolution par Gauss

x = gauss (A , b ) ;

fprintf ( ’ Solution par Gauss :\ n ’) ;

disp ( x ) ;

% Verification
residuel = norm ( A * x - b ) ;
fprintf ( ’ Norme du residu : %.2 e \ n ’ , residuel ) ;
Listing 5.1 – Exemple - Élimination de Gauss

5.1.2 Exemple avec Jacobi et Gauss-Seidel

% Matrice a diagonale dominante
A = [10 -1 2; -1 11 -1; 2 -1 10];
b = [6; 25; -11];
x0 = zeros (3 , 1) ;
tol = 1e -6;
maxiter = 100;

% Jacobi
[ x_j , iter_j ] = jacobi (A , b , x0 , tol , maxiter ) ;
fprintf ( ’ Jacobi : % d iterations \ n ’ , iter_j ) ;

22
Analyse numérique 1ère année GE - IARCI

disp ( x_j ) ;

% Gauss - Seidel
[ x_gs , iter_gs ] = gauss_seidel (A , b , x0 , tol , maxiter ) ;
fprintf ( ’ Gauss - Seidel : % d iterations \ n ’ , iter_gs ) ;
disp ( x_gs ) ;
Listing 5.2 – Comparaison Jacobi vs Gauss-Seidel

5.2 Résolution d’Équations Non Linéaires

5.2.1 Comparaison des Méthodes

% Fonction : f ( x ) = x ^2 - 2 ( racine = sqrt (2) )
f = @ ( x ) x ^2 - 2;
df = @ ( x ) 2* x ;

% Dichotomie
[ x_d , iter_d ] = dichotomie (f , 1 , 2 , 1e -6 , 100) ;
fprintf ( ’ Dichotomie : x = %.10 f (% d iter ) \ n ’ , x_d , iter_d ) ;

% Newton - Raphson
[ x_n , iter_n ] = newton_raphson (f , df , 1.5 , 1e -6 , 100) ;
fprintf ( ’ Newton : x = %.10 f (% d iter ) \ n ’ , x_n , iter_n ) ;

% Secante
[ x_s , iter_s ] = secante (f , 1 , 2 , 1e -6 , 100) ;
fprintf ( ’ Secante : x = %.10 f (% d iter ) \ n ’ , x_s , iter_s ) ;

% Valeur exacte
fprintf ( ’ Valeur exacte : sqrt (2) = %.10 f \ n ’ , sqrt (2) ) ;
Listing 5.3 – Comparaison des méthodes de résolution

5.3 Interpolation

5.3.1 Comparaison Lagrange vs Newton

% Points d ’ interpolation
xi = [0 , 1 , 2 , 3];
yi = [1 , 2 , 9 , 28];

% Points d ’ evaluation
x = linspace (0 , 3 , 100) ;

23
Analyse numérique 1ère année GE - IARCI

% Interpolation de Lagrange
y_lagrange = interpolation_lagrange (x , xi , yi ) ;

% Interpolation de Newton
y_newton = interpolation_newton (x , xi , yi ) ;

% Affichage
figure ;
plot (x , y_lagrange , ’b - ’ , ’ LineWidth ’ , 2) ; hold on ;
plot ( xi , yi , ’ ro ’ , ’ MarkerSize ’ , 10 , ’ LineWidth ’ , 2) ;
xlabel ( ’x ’) ;
ylabel ( ’y ’) ;
title ( ’ Interpolation polynomiale ’) ;
legend ( ’ Polynome d ’ ’ interpolation ’ , ’ Points donnes ’) ;
grid on ;

% Verification : les deux methodes donnent le meme resultat

difference = max ( abs ( y_lagrange - y_newton ) ) ;
fprintf ( ’ Difference max Lagrange - Newton : %.2 e \ n ’ , difference ) ;
Listing 5.4 – Interpolation - Exemple pratique

5.4 Intégration Numérique

5.4.1 Comparaison des Méthodes d’Intégration

% Fonction : f ( x ) = exp ( - x ^2)
% Integrale de 0 a 1
f = @ ( x ) exp ( - x .^2) ;
a = 0;
b = 1;

% Valeur de reference ( avec MATLAB )

I_ref = integral (f , a , b ) ;

% Differents nombres de subdivisions

n_values = [10 , 50 , 100 , 500];

fprintf ( ’ Comparaison des methodes d ’ ’ integration \ n ’) ;

fprintf ( ’ Valeur de reference : %.10 f \ n \ n ’ , I_ref ) ;

for n = n_values
% Rectangles
I_rect = rectangles_gauche (f , a , b , n ) ;
err_rect = abs ( I_rect - I_ref ) ;

% Trapezes

24
Analyse numérique 1ère année GE - IARCI

I_trap = trapezes (f , a , b , n ) ;
err_trap = abs ( I_trap - I_ref ) ;

% Simpson
if mod (n , 2) == 0
I_simp = simpson (f , a , b , n ) ;
err_simp = abs ( I_simp - I_ref ) ;
else
I_simp = NaN ;
err_simp = NaN ;
end

fprintf ( ’n = % d :\ n ’ , n ) ;
fprintf ( ’ Rectangles : %.10 f ( erreur : %.2 e ) \ n ’ , I_rect ,
err_rect ) ;
fprintf ( ’ Trapezes : %.10 f ( erreur : %.2 e ) \ n ’ , I_trap ,
err_trap ) ;
if ~ isnan ( I_simp )
fprintf ( ’ Simpson : %.10 f ( erreur : %.2 e ) \ n ’ , I_simp ,
err_simp ) ;
end
fprintf ( ’\ n ’) ;
end
Listing 5.5 – Comparaison des méthodes d’intégration

5.5 Dérivation Numérique

% Fonction : f ( x ) = sin ( x ) , f ’( x ) = cos ( x )
f = @ ( x ) sin ( x ) ;
df_exacte = @ ( x ) cos ( x ) ;

x = pi /4; % Point d ’ evaluation

df_exact = df_exacte ( x ) ;

% Differentes valeurs de h
h_values = logspace ( -1 , -10 , 50) ;

% Calcul des erreurs

err_prog = zeros ( size ( h_values ) ) ;
err_cent = zeros ( size ( h_values ) ) ;

for i = 1: length ( h_values )

h = h_values ( i ) ;

df_prog = derivee_progressive (f , x , h ) ;
df_cent = derivee_centree (f , x , h ) ;

25
Analyse numérique 1ère année GE - IARCI

err_prog ( i ) = abs ( df_prog - df_exact ) ;

err_cent ( i ) = abs ( df_cent - df_exact ) ;
end

% Affichage
figure ;
loglog ( h_values , err_prog , ’b - ’ , ’ LineWidth ’ , 2) ; hold on ;
loglog ( h_values , err_cent , ’r - ’ , ’ LineWidth ’ , 2) ;
loglog ( h_values , h_values , ’k - - ’ , ’ LineWidth ’ , 1) ;
loglog ( h_values , h_values .^2 , ’k : ’ , ’ LineWidth ’ , 1) ;
xlabel ( ’ Pas h ’) ;
ylabel ( ’ Erreur absolue ’) ;
title ( ’ Erreur de derivation en fonction de h ’) ;
legend ( ’ Diff . progressive O ( h ) ’ , ’ Diff . centree O ( h ^2) ’ , ...
’ Reference O ( h ) ’ , ’ Reference O ( h ^2) ’) ;
grid on ;
Listing 5.6 – Étude de l’erreur de dérivation

26
Annexe A

Fonctions Auxiliaires

A.1 Fonctions Utilitaires

function afficher_matrice (A , nom )
% Affiche une matrice de maniere formatee
fprintf ( ’\ n % s =\ n ’ , nom ) ;
disp ( A ) ;
end

function verifier_convergence ( A )
% Verifie les criteres de convergence pour methodes iteratives
n = size (A , 1) ;

% Matrice a diagonale dominante ?

diag_dom = true ;
for i = 1: n
somme = sum ( abs ( A (i ,:) ) ) - abs ( A (i , i ) ) ;
if abs ( A (i , i ) ) <= somme
diag_dom = false ;
break ;
end
end

if diag_dom
fprintf ( ’ Matrice a diagonale dominante : OUI \ n ’) ;
fprintf ( ’ Convergence garantie pour Jacobi et Gauss - Seidel \ n
’) ;
else
fprintf ( ’ Matrice a diagonale dominante : NON \ n ’) ;
fprintf ( ’ Convergence non garantie \ n ’) ;
end

% Matrice symetrique definie positive ?

if issymmetric ( A )
eigenvalues = eig ( A ) ;

27
Analyse numérique 1ère année GE - IARCI

if all ( eigenvalues > 0)

fprintf ( ’ Matrice symetrique definie positive : OUI \ n ’) ;
fprintf ( ’ Methode de Cholesky applicable \ n ’) ;
end
end
end
Listing A.1 – Fonctions utilitaires

28
Annexe B

Tests et Validation

B.1 Script de Test Complet

% % SCRIPT DE TEST - ANALYSE NUMERIQUE
clear ; clc ; close all ;

fprintf ( ’ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n ’) ;
fprintf ( ’ TESTS DES METHODES D ’ ANALYSE NUMERIQUE \n ’) ;
fprintf ( ’ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n \ n ’) ;

% % TEST 1: Systemes lineaires

fprintf ( ’ TEST 1: Resolution de systemes lineaires \ n ’) ;
fprintf ( ’ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n ’) ;

A = [4 -1 0; -1 4 -1; 0 -1 4];
b = [15; 10; 10];

fprintf ( ’ Matrice du systeme :\ n ’) ;

disp ( A ) ;
fprintf ( ’ Second membre :\ n ’) ;
disp ( b ) ;

% Methodes directes
x_gauss = gauss (A , b ) ;
[L , U ] = factorisation_LU ( A ) ;
x_lu = resolution_LU (A , b ) ;

fprintf ( ’ Solution par Gauss : ’) ;

fprintf ( ’ %.4 f ’ , x_gauss ) ;
fprintf ( ’\ n ’) ;

fprintf ( ’ Solution par LU : ’) ;

fprintf ( ’ %.4 f ’ , x_lu ) ;
fprintf ( ’\ n \ n ’) ;

29
Analyse numérique 1ère année GE - IARCI

% % TEST 2: Equations non lineaires

fprintf ( ’ TEST 2: Equations non lineaires \ n ’) ;
fprintf ( ’ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n ’) ;

f = @ ( x ) x ^3 - 2* x - 5;
df = @ ( x ) 3* x ^2 - 2;

[ x_newton , ~] = newton_raphson (f , df , 2 , 1e -10 , 100) ;

fprintf ( ’ Racine par Newton : %.10 f \ n ’ , x_newton ) ;
fprintf ( ’ Verification f ( x ) = %.2 e \ n \ n ’ , f ( x_newton ) ) ;

% % TEST 3: Interpolation
fprintf ( ’ TEST 3: Interpolation \ n ’) ;
fprintf ( ’ - - - - - - - - - - - - - - - - - - - -\ n ’) ;

xi = [0 , 1 , 2];
yi = [1 , 2 , 5];
x_eval = 1.5;

y_lagrange = interpolation_lagrange ( x_eval , xi , yi ) ;

y_newton = interpolation_newton ( x_eval , xi , yi ) ;

fprintf ( ’ Interpolation en x = %.1 f \ n ’ , x_eval ) ;

fprintf ( ’ Lagrange : %.4 f \ n ’ , y_lagrange ) ;
fprintf ( ’ Newton : %.4 f \ n \ n ’ , y_newton ) ;

% % TEST 4: Integration
fprintf ( ’ TEST 4: Integration numerique \ n ’) ;
fprintf ( ’ - - - - - - - - - - - - - - - - - - - - - - - - - - - -\ n ’) ;

f_int = @ ( x ) x .^2;
a = 0; b = 1;
n = 100;

I_exact = 1/3;
I_trap = trapezes ( f_int , a , b , n ) ;
I_simp = simpson ( f_int , a , b , n ) ;

fprintf ( ’ Integrale de x ^2 de 0 a 1\ n ’) ;
fprintf ( ’ Valeur exacte : %.10 f \ n ’ , I_exact ) ;
fprintf ( ’ Trapezes : %.10 f ( erreur : %.2 e ) \ n ’ , ...
I_trap , abs ( I_trap - I_exact ) ) ;
fprintf ( ’ Simpson : %.10 f ( erreur : %.2 e ) \ n ’ , ...
I_simp , abs ( I_simp - I_exact ) ) ;

fprintf ( ’\ n = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n ’) ;
fprintf ( ’ TESTS TERMINES \ n ’) ;
fprintf ( ’ = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = \ n ’) ;

30
Analyse numérique 1ère année GE - IARCI

Listing B.1 – Script de test complet

31
Conclusion

Ce rapport a présenté l’implémentation en MATLAB des principaux algorithmes d’analyse

numérique étudiés dans le cours. Les méthodes couvertes incluent :

— Résolution de systèmes linéaires : méthodes directes (Gauss, LU, Cholesky) et

itératives (Jacobi, Gauss-Seidel, relaxation)
— Résolution d’équations non linéaires : dichotomie, Newton-Raphson, sécante,
point fixe
— Interpolation polynômiale : méthodes de Lagrange et Newton
— Dérivation et intégration numériques : différences finies, rectangles, trapèzes,
Simpson

Tous les codes présentés sont fonctionnels et peuvent être utilisés directement dans MAT-
LAB. Les exemples d’application démontrent l’utilisation pratique de ces méthodes et
permettent de comparer leurs performances.

Recommandations pour l’utilisation :

— Toujours vérifier les conditions d’applicabilité des méthodes
— Adapter les paramètres (tolérance, nombre d’itérations) selon le problème
— Comparer plusieurs méthodes pour valider les résultats
— Analyser les erreurs et la convergence

32