Université ABBES LAGHROUR Khenchela

Faculté des Sciences et de la Technologie

Département de Génie Industriel

‫ﺟﺎﻣــــــﻌﺔ ﻋﺑـــــﺎس ﻟـــــــﻐرور ﺧــﻧــﺷـــﻠﺔ‬

‫ﻛﻠﯾــــﺔ اﻟﻌﻠـــــوم واﻟﺗﻛﻧـــوﻟـــوﺟﯾــﺎ ﻗﺳـم اﻟﮭﻧـدﺳﺔ اﻟﺻﻧــﺎﻋﯾﺔ‬

Département : Génie Industriel

Spécialité : Commande des machines électriques
Module : Méthodes numérique
Tp :01
Rappel sur MATLAB

Réalisé par :
 Belfounes Ayoub Eddine
 Aggoun Nadjib
 Belaghmas Ahmed
 Chitour Yazid

Promotion 2024/2025
But de Tp
L'objectif de ce TP est connaissant nos les étudiants avec les concepts
fondamentaux de MATLAB nécessaires pour résoudre des problèmes en
méthodes numériques appliquées. Il permet de maîtriser les bases de la
manipulation des vecteurs et matrices, l’utilisation des structures
conditionnelles, les boucles, ainsi que la visualisation graphique pour
l’analyse et la présentation des données.
Dans ce TP on a approndent spécialement la création des fonctions Ce que
nous allons aborder beaucoup dans les prochains TP inchaallah.

Compte rendu
Premièrement On a commencer par les bases commandes chaque un :
•Les commandes essentiells de MATLAB
Clc : Efface la fenêtre de commande (Command Window).
Clear: Supprime toutes les variables du workspace.
Close all: Ferme toutes les fenêtres de figures ouvertes.
Who: Affiche une liste des variables actuellement dans le workspace.
Whos: Affiche une liste détaillée des variables du workspace et leurs
tailles, et types.
Exist: Vérifie si une variable, un fichier ou une fonction existe.
Deuxièmement manipulation des Vecteurs et Matrices
1-déclaration des vecteurs:
Pour une ligne a = [1 2 3];
Pour une colonne b = [4; 5; 6];
2-Déclaration de matrices :
A = [1 2; 3 4];
B = [5 6; 7 8];
; est la fin de chaque ligne de la matrice
3-Matrices spéciales par une commande :
Rand(a,b): Génère une matrice de taille a×b contenant des nombres
aléatoires.
Eye(a) : Génère une matrice identité de taille a×a identité a des 1 sur la
diagonale principale et des 0 ailleurs.

Zeros(a) : Crée une matrice de taille a×a remplie de zéros.

Inv(A) : Calcule l’inverse de la matrice A si elle est carrée et inversible.

Det(A) : Calcule le déterminant de la matrice carrée A.

• Deuxièmement :Méthodes pour définir une fonction

Dans ce TP on a connaissant quatres types de définir une fonction chaque un :

• Premier méthode : @ (fonction anonyme)

f= @(x) x – 4;

f(2)=

• Deuxième méthode : Inline

f = inline(‘2*x + 4’, ‘x’);

Solve(f) Trouve les racines

Fplot(f,[2,5])

• Troisième méthode : Syms (symbolique)

Pour définir une fonction symbolique en MATLAB .

Syms x z;
G = 2*x + 4;

Solve(g); % Trouve les racines

Subs(g,x,z) % changement de variable par order.

• Quatrième méthode : function (dans un fichier ou script) :

Ce type de définir une fonction basé sur créé une programme d’un fonction dans
une fichier et appeler dans un autre le fichier doit porter le même nom que la
fonction et avoir l’extension .m ( fichier MATLAB).

function s = surface(r)

S = pi * r^2;

End

S=surface(5)

S=

Commandes associées au fonction

Solve : Permet de résoudre des équations algébriques ou systèmes d’équations

symboliques.

Subs: Substitue une valeur numérique ou une expression dans une variable
symbolique ou une expression.

Diff:Calcule la dérivée symbolique d’une fonction.

Int: Calcule l’intégrale symbolique d’une fonction.

Pretty :Affiche une expression symbolique dans une forme lisible et agréable.
Comment Tracé un graphique

Pour tracer un graphique en MATLAB, on utilise principalement la commande

plot. Voici l’exemple suivant :

X = 0:0.1:10;

Y = sin(x);

Plot(x, y);

Grid;

Xlabel(‘x-axis’);

Ylabel(‘y-axis’);

Title(‘Courbe de sin(x)’);

Les Structures Conditionnelles et les Boucles

1-condition if

La structure conditionnelle if permet d’exécuter du code en fonction de la

satisfaction d’une condition logique. Elle est utilisée pour prendre des décisions
dans un programme.

Exemple :

If x > 0

Disp(‘Le nombre est positif’);

Elseif x < 0

Disp(‘Le nombre est négatif’);

Else

Disp(‘Le nombre est nul’);

End

2- les boucles

Les boucles en MATLAB sont utilisées pour répéter l’exécution d’un bloc de code
plusieurs fois, en fonction d’une condition. MATLAB offre principalement deux
types de boucles : for et while.

Exemple de programme avec des boucles :

• Boucle for :

Clear; clc

X=1;

For k = 1:10

X=x*k

End

Disp(k);

• Boucle while :

Clear; clc

X = 1;

While x < 10

X = x + 3;

End

Conclusion
Finalement, Nous avons abordé la création de fonctions, un concept clé qui sera approfondi dans
les prochains TP. Cette première approche de MATLAB constitue une étape importante pour
acquérir les compétences nécessaires pour créer des programmes avec les instructions président
de TP.
TP n°2 : Résolution de systèmes linéaires avec les
méthodes numériques Jacobi et Gauss Seidel sous
MATLAB
Objectifs :
1. Comprendre et implémenter en MATLAB la méthode de Jacobi
pour résoudre un système linéaire A⋅X=B
2. Appliquer la méthode de Gauss Seidel pour résoudre le même
système.
3. Visualiser les résultats en utilisant MATLAB.
Méthode de Jacobi :
Théorie :
La méthode de Jacobi repose sur la décomposition de la matrice A
en trois parties :
𝐴= 𝐷 – 𝐸 – 𝐹
Où :
D : matrice diagonale de A,
E : matrice triangulaire supérieure,
F : matrice triangulaire inférieure.
La formule itérative est donnée par :
Comprendre et implémenter en MATLAB la méthode de Jacobi pour
résoudre un système linéaire A⋅X=B :
La méthode de Jacobi est une méthode itérative utilisée pour
résoudre un système d'équations linéaires de la forme A⋅X=B où A
est une matrice carrée, X est le vecteur des inconnues, et B est le
vecteur des termes constants. L'algorithme repose sur l'idée de
résoudre chaque équation du système pour une inconnue à chaque
itération, en utilisant les valeurs des inconnues calculées lors de
l'itération précédente.
La méthode de Gauss-Seidel est une autre méthode itérative pour
résoudre des systèmes linéaires de la forme A⋅X=B où A est une
matrice carrée, X est le vecteur des inconnues et BBB est le vecteur
des constantes. Elle est souvent considérée comme une
amélioration de la méthode de Jacobi.
 Différence
1.Méthode de Jacobi
function [X] = mjacobi(A, B, n, X0, maxIter, tol)
D = diag(diag(A)); % Matrice diagonale D
L = tril(A, -1); % Matrice triangulaire inférieure L
U = triu(A, 1); % Matrice triangulaire supérieure U

% Initialisation
X = X0; % Le vecteur X initial
for iter = 1:maxIter
X_old = X; % Sauvegarder la solution précédente

% Mise à jour de X selon la méthode de Jacobi

X = inv(D) * (B - (L + U) * X);

% Vérification de la convergence
if norm(X - X_old, inf) < tol
fprintf('Convergence atteinte après %d itérations\n', iter);
break;
 end
end

if iter == maxIter
fprintf('Max itérations atteintes sans convergence.\n');
end
end

Explication de la fonction mjacobi :

 Paramètres d'entrée :
o A : La matrice des coefficients.

o B : Le vecteur des termes constants.

o n : Le nombre de variables (dimensions du système).

o X0 : Le vecteur initial X0 (généralement un vecteur de

zéros).
o maxIter : Le nombre maximal d'itérations.

o tol : La tolérance pour vérifier la convergence (par

exemple, 10−6.
 Décomposition de la matriceA :
o D : Diagonale deAA.

o L : Partie inférieure de A (sans la diagonale).

o U : Partie supérieure de A (sans la diagonale).

 Itération : À chaque itération, nous calculons une nouvelle

estimation X(k+1) en utilisant la formule de Jacobi. La condition
de convergence est vérifiée en comparant la norme de la
différence entre l'itération courante et l'itération précédente.
A=

5 1 02

2 7 −1

132,

B=2−9−1

En matlab
% Déclaration des coefficients du système A*X = B
A = [5 2 1; 1 7 3; 0 -1 2];
B = [2; -9; -1];
n = length(B); % Nombre de variables
X0 = zeros(n, 1); % Initialisation de X
maxIter = 1000; % Nombre maximal d'itérations
tol = 1e-6; % Tolérance pour la convergence

% Appel de la méthode de Jacobi

[X] = mjacobi(A, B, n, X0, maxIter, tol);

% Affichage du résultat
disp('Solution du système A*X = B :');
disp(X);
Méthode de Gauss-Seidel :
function [X] = mgauss_seidel(A, B, n, X0, maxIter, tol)
% Initialisation
X = X0; % Le vecteur X initial
for iter = 1:maxIter
X_old = X; % Sauvegarder la solution précédente

% Mise à jour de X selon la méthode de Gauss-Seidel

for i = 1:n
sum_L = A(i, 1:i-1) * X(1:i-1); % Somme pour L
sum_U = A(i, i+1:n) * X_old(i+1:n); % Somme pour U
X(i) = (B(i) - sum_L - sum_U) / A(i,i);
end

% Vérification de la convergence
if norm(X - X_old, inf) < tol
fprintf('Convergence atteinte après %d itérations\n', iter);
break;
end
 end

if iter == maxIter
fprintf('Max itérations atteintes sans convergence.\n');
end
end

Application de Gauss Seidel à l'exemple :

% Appel de la méthode de Gauss-Seidel

[X_gs] = mgauss_seidel(A, B, n, X0, maxIter, tol);

% Affichage du résultat

disp('Solution du système A*X = B avec Gauss-Seidel :');

disp(X_gs);
Visualisation des résultats :
% Initialisation des vecteurs de solutions pour
visualisation
X_jacobi = X0;
X_gs_visu = X0;

% Tableau pour stocker les valeurs de X à chaque

itération
X_jacobi_iter = zeros(n, maxIter);
X_gs_iter = zeros(n, maxIter);

% Itération de Jacobi
for iter = 1:maxIter
X_jacobi_iter(:, iter) = X_jacobi;
X_jacobi = mjacobi(A, B, n, X_jacobi, iter, tol);
end

% Itération de Gauss-Seidel
for iter = 1:maxIter
X_gs_iter(:, iter) = X_gs_visu;
X_gs_visu = mgauss_seidel(A, B, n, X_gs_visu, iter,
tol);
end

% Tracer les résultats

figure;
subplot(1, 2, 1);
plot(1:maxIter, X_jacobi_iter(1, :), 'r', 1:maxIter,
X_jacobi_iter(2, :), 'g', 1:maxIter, X_jacobi_iter(3, :),
'b');
title('Convergence de Jacobi');
xlabel('Itérations');
ylabel('Valeurs de X');
legend('x_1', 'x_2', 'x_3');

subplot(1, 2, 2);
plot(1:maxIter, X_gs_iter(1, :), 'r', 1:maxIter,
X_gs_iter(2, :), 'g', 1:maxIter, X_gs_iter(3, :), 'b');
title('Convergence de Gauss-Seidel');
xlabel('Itérations');
ylabel('Valeurs de X');
legend('x_1', 'x_2', 'x_3');

Conclusion :
Ce TP La méthode de Jacobi et la méthode de Gauss-Seidel sont
des méthodes itératives efficaces pour résoudre des systèmes
linéaires, avec Gauss-Seidel généralement plus rapide en termes
de convergence.

Vous pouvez visualiser les solutions obtenues à chaque itération

pour voir l'évolution de la convergence.
 MINISTERE DE L’ENSEIGNEMENT SUPERIEUR ET DE LA RECHERCHE
SCIENTIFIQUE

UNIVERSITE ABBES LAGHROUR- KHENCHELA

‫جامعة عباس لغرور خنشلة‬

Faculté des Sciences et de la Technologie Année 2024/2025

Département de Génie industriel
1ère année Master (Commande électrique)

Module : Tp. Méthode numérique

TP03 : Intégration numérique. de fonctions

Réalisé par:
- Chitour yazid
- Aggoun nadjib
- Ayoub belfounes
- Ahmed belghmass
 INTRODUCTION:

En pratique, on est souvent amener à calculer l’intégrale définie d’une

fonction Continue sur [a , b] dans R, définie par I(f)= alpha∫ F(x) dx
peut se révéler très laborieux, Ou tout simplement impossible à
atteindre. Par conséquent, on fait appel à des méthodes Numériques,
afin de calculer une approximation de . Dans ces méthodes
numériques, La fonction , est remplacée par une somme finie. Dans ce
chapitre, nous allons étudier et Implémenter, sous Matlab, quelques
méthodes usuelles (point milieu, trapèze et Simpson) Dédiées à
l’intégration numérique. Supposons qu’on veuille intégrer une
fonction f(x) sur un intervalle [a,b]. Puisque L’intégrale est la limite
de sommes de Riemann, l’idée la plus évidente pour approximer
Numériquement le résultat qu’on cherche est de calculer des sommes
de Riemann en Espérant qu’elles s’approcheront de manière désirée
de la réponse exacte à condition de Prendre les sous-intervalles
suffisamment petits.

Objectif d’activité:

Le but de ce TP est le calcul numérique d’une intégrale

définie en utilisant les méthodes Du point milieu, des
trapèzes et de Simpson.
  TRAVAIL DEMANDE :

 ECRIRE UN PROGRAMME QUI CALCULE CETTE INTéGRALE EN

UTILISANT LES MéTHODES DU TRAPèzE AVEC N=100 :

La méthode du trapèze est une méthode numérique d’intégration qui

approximates l’intégrale d’une fonction en la divisant en petits
intervalles. Chaque intervalle est représenté par un trapèze dont l’aire
est calculée et additionnée. Plus le nombre de subdivisions augmente,
plus l’approximation devient précise.
Programme MATLAB
 • Dans la commande Windows on a :

B_Ecrireun programme qui calcule cette intégrale en utilisant

la méthode de simpson avec n=18 :
La méthode de Simpson est une technique d’intégration
numérique qui utilise des paraboles pour approximer
l’intégrale d’une fonction. Elle divise l’intervalle
d’intégration en un nombre pair de sous-intervalles, puis
ajuste des paraboles aux points de chaque sous-
intervalle. Cette méthode est plus précise que celle du
trapèze, surtout pour des fonctions lisses.

I(f) = ∫ X× sin(x)dx
Programme MATLAB
• Dans la commande Windows on a :
Analyse et déference des résultats de ce deux
méthodes

La méthode du trapèze est simple et rapide, mais moins

précise, surtout pour des fonctions avec une courbure
 marquée. Elle approxime l’intégrale en utilisant des segments
de droite, ce qui peut sous-estimer ou surestimer l’aire sous
la courbe. La méthode de Simpson, en utilisant des
paraboles, offre une précision supérieure, surtout pour des
fonctions lisses, avec une meilleure approximation même
pour un nombre réduit de subdivisions. Cependant, elle
nécessite plus de calculs que la méthode du trapèze. En
général, la méthode de Simpson est plus efficace pour obtenir
une approximation précise sans augmenter excessivement le
nombre de subdivisions.

 Conclusion Générale

Les méthodes d’intégration numérique jouent un rôle crucial

dans les calculs scientifiques et d’ingénierie où les intégrales
analytiques sont impraticables. Le choix de la méthode dépend
fortement de la nature de la fonction intégrée et des exigences
de précision. Pour des applications pratiques, il est souvent
nécessaire de comparer plusieurs méthodes et de choisir celle
qui offre le meilleur compromis entre précision et efficacité.
 Université ABBES LAGHROUR Khenchela
Faculté des Sciences et de la Technologie
Département de Génie Industriel

‫ﺟﺎﻣــــــﻌﺔ ﻋﺑـــــﺎس ﻟـــــــﻐرور ﺧــﻧــﺷـــﻠﺔ‬

‫ﻛﻠﯾــــﺔ اﻟﻌﻠـــــوم واﻟﺗﻛﻧـــوﻟـــوﺟﯾــﺎ ﻗﺳـم اﻟﮭﻧـدﺳﺔ اﻟﺻﻧــﺎﻋﯾﺔ‬

Département : Génie Industriel

Spécialité : Commande des machines électriques
Module : Méthodes numérique
Tp 04 :
La résoLution numérique des systèmes d’équation non
linéaire

Réalisé par :
 Belfounes Ayoub Eddine
 Aggoun Nadjib
 Belaghmas Ahmed
 Chitour Yazid
Objectif de tp

Ce TP permet aux étudiants d’apprendre à résoudre des systèmes

d’équations non linéaires avec la méthode de Newton-Raphson et des
équations différentielles ordinaires (EDO) avec les méthodes d’Euler et de
Runge-Kutta (ordre 4). L’objectif est de maîtriser l’application pratique de ces
méthodes numériques pour résoudre des problèmes complexes.

Introduction

1. Résolution des systèmes d'équations non linéaires:

Utilisation de la méthode itérative Newton-Raphson pour résoudre des équations sous forme non
linéaire.

2. Résolution des équations différentielles ordinaires (EDO):

Application des méthodes numériques d'Euler et de Runge-Kutta (ordre 4).

Partie 1: Méthode de Newton-Raphson

Principe: Résoudre un système non linéaire en mettant à jour les solutions à l'aide de:

x_{n+1}=x_n-J^{-1}(x_n) f(x_n)

Exemple MATLAB 1:

Résolution de Utilisation d'une tolérance.

Code MATLAB fourni pour calculer les racines.

Exemple MATLAB 2: Résolution d'un système non linéaire:

begin{cases}

x^2+y^2-4=0

x^2 - y - 1 = 0

end (cases)

Partic 2: Résolution des EDO

Méthode d'Euler.

Principe: Approximation par pas constants:

y _ (n + 1) =y _ n+h cdot f(x_n, y_n)

Exemple MATLAB:

Résolution de, avec pour Méthode de Runge-Kutta (RK4

1. Méthode de Newton-Raphson pour une équation non linéaire
La méthode de Newton-Raphson est une méthode itérative pour trouver une solution
approchée d’une équation non linéaire \( f(x) = 0 \). Elle utilise une formule basée sur la
tangente en un point pour converger vers une racine, donnée par :
Xn+1=Xn-[f(xn)/f’(xn)]
Cette méthode est rapide mais nécessite une bonne estimation initiale et f’(xn)≠ 0
comme l’exercice de brochure de Tp.

Programme MATLAB De TP

Dans la commande window On a :

2. Méthode de Newton- Raphson pour un système d'équations
non linéaires

La méthode de Newton-Raphson pour un système d’équations non

linéaires est une méthode itérative utilisant la matrice jacobienne
pour approcher la solution d’un système ( F(x) = 0 .

Programme MATLAB
Dans la commande window On a :
3. Méthode d'Euler pour une ED
La méthode d’Euler est une méthode numérique itérative pour résoudre
une ED de la forme y′(t)=f(t,y)y'(t) = f(t, y). Elle approxime la solution par
yn+1=yn+h⋅f(tn,yn)y_{n+1} = y_n + h \cdot f(t_n, y_n), où hh est le pas.

Programme MATLAB
Dans la commande window On a :

4. Méthode de Runge-Kutta d'ordre 4 (RK4)

La méthode de Runge-Kutta d’ordre 4 est une méthode
numérique utilisée pour résoudre des équations différentielles.
Elle améliore la précision en calculant des valeurs intermédiaires
pour estimer plus précisément la solution à chaque étape.
Programme MATLAB
Dans la commande window On a :

Comparaison entre Euler et Runge-Kutta

% Résolution par Euler
% Résolution par RK4
[x_euler, y_euler] = Euler(f, 0, 2, 20, 1);
[x_rk4, y_rk4] = RungeKutta4(f, 0, 2, 20, 1);
% Comparaison
plot(x_euler, y_euler, 'r--', x_rk4, y_rk4, 'b-')
legend('Euler', 'Runge-Kutta 4')
xlabel('x'), ylabel('y'), title('Comparaison des méthodes')
Graphique MATLAB:
Euler : courbe légèrement décalée.
RK4: courbe plus proche de la solution exacte.
Analyse :
RK4 est plus précis mais demande plus de calculs.

Observations générales :

1. Méthode de Newton-Raphson :
• Convient bien pour résoudre des équations non linéaires.
• Sensible aux valeurs initiales: un mauvais choix peut entraîner la
non-convergence.
2. Méthodes pour EDO :
• La méthode d'Euler est simple à implémenter mais peu précise.
• La méthode RK4 est plus complexe mais offre une précision bien
meilleure pour un effort supplémentaire.
 Conclusion:
Ce TP a permis de se familiariser avec des méthodes numériques
fondamentales pour résoudre des problèmes mathématiques
complexes. Il est structuré en deux parties principales:
1. Résolution des systèmes d'équations non linéaires :
La méthode de Newton-Raphson s'est révélée être une approche
puissante et rapide pour trouver les solutions d'équations non
linéaires. Elle converge efficacement lorsqu'une bonne estimation
initiale est choisie et que le