UE GCI 53
EC GMP 532
ANALYSE NUMERIQUE
NIVEAU 3
Filière : GENIE MECANIQUE ET PRODUCTIQUE
EQUIPE PEDAGOGIQUE
M. MOUNGNUTOU MFETOUM Inoussah, (CC)
Mme DONKING LUCIE, (VAC)
M. JIBIA Brice, (VAC)
M. NDE KENFACK Brice, (VAC)
MATLAB ET ANALYSE NUMERIQUE
Avant-propos
Ce polycopié se trouve être un support pédagogique de cours, destiné aux étudiants de 3ème Année des
Licences LMD assurées à l’IUT. Ce polycopié regroupe un certain nombre de méthodes étudiées dans les
différents chapitres du cours de méthodes numériques. L'objectif de ces chapitres est d'implémenter sous
MATLAB les différentes méthodes pour les comparer et mieux les comprendre.
Références
1- C. Brezinski, Introduction à la pratique du calcul numérique, Dunod, Paris 1988.
2- G. Allaire et S.M. Kaber, Algèbre linéaire numérique, Ellipses, 2002.
3- G. Allaire et S.M. Kaber, Introduction à Scilab. Exercices pratiques corrigés d'algèbre linéaire, Ellipses,
2002.
4- G. Christol, A. Cot et C.-M. Marle, Calcul différentiel, Ellipses, 1996.
5- M. Crouzeix et A.-L. Mignot, Analyse numérique des équations différentielles, Masson, 1983.
6- S. Delabrière et M. Postel, Méthodes d'approximation. Équations différentielles. Applications Scilab,
Ellipses, 2004.
7- J.-P. Demailly, Analyse numérique et équations différentielles. Presses Universitaires de Grenoble, 1996.
8- E. Hairer, S. P. Norsett et G. Wanner, Solving Ordinary Differential Equations, Springer, 1993.
9- P. G. Ciarlet, Introduction à l'analyse numérique matricielle et à l'optimisation, Masson, Paris, 1982.
10- M. Lakrib, Cours d'analyse numérique, OPU Alger 2008.
11- B. Demidovitch, I. Maron, Elément de calcul numérique, Ed. MIR, Moscou, 1979.
TABLE DE MATIERE
CHAPITRE 1: Résolution des équations non linéaires ...................................................................................... 6
CHAPITRE 2 : Interpolation polynômiale...................................................................................................... 10
CHAPITRE 3 : Intégration numérique de fonctions ........................................................................................ 12
CHAPITRE 4 : Résolution des équations différentielles ordinaires ................................................................. 14
CHAPITRE 5 : Résolution des systèmes d'équations linéaires ......................................................................... 16
FICHE DE PROGRESSION
I- PROCESSUS GENERAL DU DEROULEMENT DE CHAQUE COURS
1- Présentation de l’objet du cours :
2- Rappels du cours précédent :
3- Question sur la qualité du cours :
a. Le rythme du Cours Magistral est-il convenable ?
b. Les explications sont-elles assez, ou insuffisantes ?4-
Libellé du nouveau cours
5- Proposer :
a. D’exercices à faire à la maison ;
b. Un exercice durant le CM pour mieux illustrer le cours ?
SEQUENCES THEMES DEVELOPPES DUREE
Rappel sur les différentes méthodes : CM : 3h
CHAPITRE 1 : La bipartition :
TD :1h
Résolution des Regula-Falsi
Newton-Raphson
équations non lineaires
But du CHAPITRE :
CHAPITRE 2 : Interpolation A. La méthode de Lagrange CM : 3h
polynômiale B. La méthode de Newton TD :1h
CHAPITRE 3 : Intégration CM : 3h
But du CHAPITRE :
numérique de fonctions
TD :1h
Rappel des méthodes :
CHAPITRE 4 : Résolution des But du CHAPITRE :
Rappel sur les différentes méthodes : CM : 3h
équations differentielles Méthode d'Euler : TD :1h
ordinaires
But du CHAPITRE : CM : 3h
CHAPITRE 5 : Résolution Rappel de la méthode :
des systèmes d’équations TD :1h
linéaires
5
CHAPITRE 1 : Résolution des équations non linéaires
Durée du CHAPITRE : 2 séances de 1h30
But du CHAPITRE :
Durant ce CHAPITRE, nous allons mettre en œuvre les algorithmes des méthodes de résolution des
équations non linéaires étudiées pendant le cours : la bipartition, Regula-Falsi, les approximations
successives et Newton-Raphson.
Rappel sur les différentes méthodes:
La bipartition :
1- Existence et unicité de la solution :
Si la fonction 𝑓(𝑥) est définie et continue et strictement monotone sur l'intervalle (a, b) et que
𝑓(𝑎) × 𝑓(𝑏) < 0, alors 𝑓(𝑥) = 0 n'a qu'une solution 𝑥 ∗ dans cet intervalle.
2- Approximation de la solution:
On calcule c par l'expression :
𝑎+𝑏
𝑐=
2
On compare ensuite 𝑓(𝑐) avec 𝑓(𝑎) et 𝑓(𝑏) pour déterminer l'intervalle de la solution et on recommence le
calcul de c itérativement jusqu'à ce que : |𝑥𝑛 − 𝑥𝑛−1 | < 𝜀.
𝑏−𝑎
log ( )
𝜀
Le nombre n d'itérations nécessaire pour avoir une approximation de la solution à 𝜀 près est : 𝑛 ≥ log (2)
Regula-Falsi
On calcule c par l'expression :
𝑎 ⋅ 𝑓(𝑏) − 𝑏 ⋅ 𝑓(𝑎)
𝑐=
𝑓(𝑏) − 𝑓(𝑎)
On compare ensuite 𝑓(𝑐) avec 𝑓(𝑎) et 𝑓(𝑏) pour déterminer l'intervalle de la solution et on recommence le
calcul de c itérativement jusqu'à ce que : |𝑥𝑛 − 𝑥𝑛−1 | < 𝜀.
Les approximations successives
Il faut réécrire l'équation 𝑓(𝑥) = 0 sous la forme 𝑥 = 𝑔(𝑥),
La condition de convergence suffisante mais pas nécessaire est :
|𝑔(𝑥)| < 1 pourtout 𝑥 ∈ [𝑎 𝑏] 6
Pour approximer la solution de l'équation
On part de la valeur initiale 𝑥0 = ⋯,
On calcule itérativement les valeurs de 𝑥𝑛 par:
𝑥𝑛 = 𝑔(𝑥𝑛−1 )
Les critères d'arrêts peuvent être
|𝑥𝑛 − 𝑥𝑛−1 | < 𝜀
|𝑥𝑛 − 𝑥𝑛−1 |
<𝜀
|𝑥𝑛 |
|𝑓(𝑥𝑛 )| < 𝜀
Newton-Raphson
L'algorithme de Newton-Raphson est :
𝑓(𝑥 )
𝑥𝑛+1 = 𝑥𝑛 − 𝑓′ (𝑥𝑛 ) Les critères d'arrêts peuvent être
𝑛
|𝑥𝑛 − 𝑥𝑛−1 | < 𝜀
|𝑥𝑛 − 𝑥𝑛−1 |
<𝜀
|𝑥𝑛 |
|𝑓(𝑥𝑛 )| < 𝜀
Méthodologie :
Pour mettre en œuvre les algorithmes, nous allons écrire des programmes (scripts) sous Matlab. Un script
(ou .m) est un fichier ASCII qui contient une succession d'instructions et d'opérations, et exécutable depuis
la fenêtre de commande ou de la fenêtre d'édition.
Pour écrire un script, il suffit de sélectionner l'icône «New Script» dans le menu principal du Matlab. A
l'ouverture d'une fenêtre d'édition (Editor), on saisit le programme puis on le sauvegarde dès qu'on termine.
Pour l'exécuter, on appui sur le triangle vert (Run) depuis la fenêtre d'édition ou bien en tapant le «nom du
programme » depuis la fenêtre de commande (Command Window).
On rappelle, la syntaxe des structures de contrôle et de répétition:
L’instruction de testifs’écrit comme suit :
if condition1 action1
elseif condition2 action2
…
else action3
end
• La boucle for:
7
forcompteur = valeur_initiale : incrément : valeur_finale action
end
• la boucle while :
while condition
action
end
Pour avoir une aide instantanée sur une commande Matlab, l'étudiant peut taper la commande «help» suivie
du nom de la commande, dans la fenêtre de commande de Matlab (Command Window).
Manipulations :
Partie A: Rappel sur le tracé de graphiques 2D à l'aide de la fonction 'plot'
1. Former une liste de valeurs (un vecteur) x allant de 0 à 2 × 𝑝a avec un pas de pi/20 ;
2. Calculer y = cos (x) et z = sin (x);
3. Tracer la courbe de 𝑦 = cos (𝑥);
4. Tracer la courbe de z = sin (x);
5. Tracer les deux courbes dans un même graphe.
La fonction graphique plot ( ) peut contenir plusieurs couples de points : plot (𝑎, 𝑏, 𝑎, 𝑐, 𝑎, 𝑑) trace les
courbes de b, c, et d en fonction de a ;
6. Exécuter les commandes suivantes :
• xlabel ('Abcisses') ;
• ylabel('Ordonnées') ;
• title('Les fonctions Cos et Sin') ;
• grid
• legend('cosinus','sinus') ;
Partie B: Résolution des équations non linéaires
Soit à résoudre l'équation: 𝑓(𝑥) = 𝑥 + 2ln (𝑥) = 0 où 𝑥 ∈]0, +∞[
a) Tracer le graphe 𝑦 = 𝑓(𝑥) sur un intervalle tel qu'il vous permet de localiser la solution de l'équation.
b) Localiser la solution dans le plus petit intervalle ]𝑎, 𝑏[ possible.
1. Ecrire un script, que vous appellerez «bipart.m» qui implémente la méthode de bipartition suivant
les étapes:
8
• Initialiser les limites du domaine de recherche a et b ;
• Initialiser un compteur d'itération k à 0 ;
• Ecrire l'algorithme de bipartition en incrémentant le compteur k à chaque passage de boucle ;
• Arrêter la boucle quand la largeur du domaine devient ≤ 10−5 ;
• Afficher la solution calculée ainsi que le nombre d'itérations.
2. Ecrire un autre script, que vous appellerez «RegFal.m» qui implémente la méthode de Regula-Falsi.
Il faut faire attention ici au critère d'arrêt. En effet, la précision n'est pas comparée à la largeur du
domaine final, comme en (1), mais c'est la différence entre deux valeurs consécutives de la solution.
3. Ecrire un autre script, que vous appellerez «Newton.m» qui implémente la méthode de Newton-
Raphson. L'arrêt des itérations se fera de la même manière que dans la manipulation (2).
4. Ecrire un autre script, que vous appellerez «AppSuc.m» qui implémente la méthode des
approximations successives. Pour cela, on doit réécrire l'équation sous la forme 𝑥 = 𝑔(𝑥), en assurant
la convergence de l'algorithme. L'arrêt des itérations se fera de la même manière que dans la
manipulation (2).
5. Comparer les différentes méthodes implémentées. Module: Méthodes Numériques
9
CHAPITRE 2 : Interpolation polynômiale
Durée du CHAPITRE : 1 ou 2 séances de 1 h30
But du CHAPITRE:
Le but de ce CHAPITRE est l'implémentation des algorithmes d'interpolation étudiés au cours sous Matlab,
il sera ensuite question d'étudier un phénomène qui se produit lorsque l'on augmente le nombre de points de
collocation.
Manipulations :
A. La méthode de Lagrange
Soit une fonction 𝑓(𝑥) = 𝑒(𝑥) définie sur l'intervalle [a, b] avec :
a = 3.50
b = 3.70
Ecrire un programme qui :
• Détermine le pas d'interpolation pour un nombre ' 𝑛 ' donné de sous intervalles ( n = 4) ;
• Remplit un tableau avec les coordonnées des points d'appui ;
• Interpole la fonction 𝑓(𝑥) pour 𝒙 = 𝟑. 𝟔𝟐 en utilisant la méthode de Lagrange.
Pour rappel, l'algorithme de Lagrange est comme suit :
𝑛 𝑛
(𝑥 − 𝑥𝑖 )
𝑃𝑛 (𝑥) = ∑ 𝑦𝑖 ⋅ 𝐿𝑖 (𝑥) où 𝐿𝑖 (𝑥) = ∏
(𝑥𝑖 − 𝑥𝑗 )
𝑖=0 𝑗=0,𝑗≠𝑖
• Refaire l'exécution pour 𝑛 = 10.
B. La méthode de Newton
On considère la même fonction 𝑓(𝑥) = 𝑒(𝑥) définie sur l'intervalle [a, b].
On subdivise cet intervalle en ' 𝑛 ' sous intervalles, ce qui nous donne ' 𝑛 + 1 ' points d'appui.
Pour 𝑛 = 4, écrire un programme qui interpole cette fonction avec la méthode de Newton.
Le programme exécutera les étapes suivantes :
• Construire la matrice des différences finies que nous appelons 'D' comme suit :
10
𝐷(𝑖, 𝑗) = 0 pour 𝑖 = 1. . (𝑛 + 1) et 𝑗 = 1. . (𝑛 + 1)
𝐷(𝑖, 1) = 𝑓(𝑥𝑖 ) pour 𝑖 = 1. . (𝑛 + 1)
𝐷(𝑖, 𝑗 − 1) − 𝐷(𝑖 − 1, 𝑗 − 1)
𝐷(𝑖, 𝑗) = pour 𝑗 = 2. . (𝑛 + 1) et 𝑖
𝑥𝑖 − 𝑥𝑖−𝑗+1
= 𝑗 … (𝑛 + 1)
• Extraire ensuite la diagonale de D dans un vecteur M :
𝑀(𝑖) = 𝐷(𝑖, 𝑖) pour 𝑖 = 1. . (𝑛 + 1)
• Interpoler la fonction 𝑓(𝑥) pour 𝒙 = 𝟑. 𝟔𝟐 en utilisant la méthode de Newton :
𝐼 = 𝑀(1) + 𝑀(2) ⋅ (𝑥 − 𝑥1 ) + 𝑀(3) ⋅ (𝑥 − 𝑥1 ) ⋅ (𝑥 − 𝑥2 ) + ⋯ + 𝑀(𝑛 + 1) ⋅ (𝑥 − 𝑥1 ) … (𝑥 − 𝑥𝑛 )
• Refaire ces étapes pour 𝑛 = 10.
• Calculer la valeur exacte de la fonction et comparer avec les interpolations précédentes, quel est
votre commentaire. Module: Méthodes Numériques
11
CHAPITRE 3 : Intégration numérique de fonctions
Durée du CHAPITRE : 1 ou 2 séances de 1 h30
But du CHAPITRE :
Le but de ce CHAPITRE est le calcul d'une valeur approximative de l'intégrale définie d'une fonction 𝑓(𝑥)
sur un intervalle [𝑥0 , 𝑥𝑛 ].
𝑥𝑛
Pour se faire, il existe plusieurs méthodes d'approximation de l'intégrale ∫𝑥0 𝑓(𝑥)𝑑𝑥, basées sur
l'interpolation polynômiale de 𝑓(𝑥) :
Rappel des méthodes:
La méthode du trapèze: qui n'est autre que l'intégrale du polynôme d'interpolation de 𝑓(𝑥) sur 2 points
d'appui, par extension à l'ensemble des points, on obtient la formule généralisée suivante :
𝑥𝑛 𝑛−1
ℎ
∫ 𝑓(𝑥)𝑑𝑥 ≅ × (𝑦0 + 𝑦𝑛 + 2 × ∑ 𝑦𝑖 )
𝑥0 2
𝑖=1
La méthode de Simpson: qui n'est autre que l'intégrale du polynôme d'interpolation de 𝑓(𝑥) sur 3 points
d'appui équidistants, par extension à l'ensemble des points, on obtient la formule généralisée:
𝑥2𝑛 𝑛−1 𝑛−1
ℎ
∫ 𝑓(𝑥)𝑑𝑥 ≅ × (𝑦0 + 𝑦2𝑛 + 4 × ∑ 𝑦2𝑖+1 + 2 × ∑ 𝑦2𝑖 )
𝑥0 3
𝑖=0 𝑖=0
Travail demandé :
1
On se propose de calculer l'intégrale définie 𝐼 = ∫0 sin (𝑥) ⋅ 𝑒 𝑥 𝑑𝑥, en utilisant les deux méthodes suscitées.
1. Ecrire un programme qui calculerait cette intégrale en utilisant la méthode du trapèze et en divisant
l'intervalle d'intégration en 10 intervalles élémentaires.
2. Refaire l'exécution pour 𝑛 = 100.
3. Matlab possède une fonction équivalente, c'est la fonction TRAPZ, TRAPZ (Y) donne la valeur
calculée par la méthode du trapèze sur un vecteur Y avec un pas d'intégration unitaire. Adapter cette
fonction pour le calcul de notre intégrale 𝐼.
4. Ecrire un deuxième programme qui calculerait cette intégrale en utilisant la méthode de Simpson
avec les mêmes conditions que dans (1).
5. Refaire l'exécution pour 𝑛 = 100.
6. Il existe une fonction dans Matlab qui ressemble à la méthode de Simpson, la fonction QUAD qui
implémente l'algorithme de Simpson adaptatif.
12
La syntaxe de cette fonction est: 𝐼 = 𝑄𝑈𝐴𝐷( nom_fonction, 𝑎, 𝑏 ) où nom_fonction est le nom de la
fonction à intégrer, et a et b sont les bornes d'intégration. La fonction doit impérativement accepter des
variables de type vecteur. Utiliser cette fonction et comparer avec le résultat obtenu en (3).
7. Comparer les résultats obtenus sachant que la valeur exacte est 0,909330673631479. Module:
Méthodes Numériques
13
CHAPITRE 4 : Résolution des équations différentielles ordinaires
Durée du CHAPITRE : 2 séances de 1h30
But du CHAPITRE:
Durant ce CHAPITRE, nous allons mettre en œuvre les algorithmes des méthodes de résolution des
équations différentielles ordinaires étudiées pendant le cours : la méthode d'Euler et la méthode de Range
Kutta. Il sera ensuite question de comparer les deux méthodes avec la solution exacte.
Rappel sur les différentes méthodes:
Méthode d'Euler :
ℎ = 𝑥𝑖 − 𝑥𝑖−1
𝑦1 = 𝑦0 + ℎ𝑓(𝑥0 , 𝑦0 )
𝑦2 = 𝑦1 + ℎ𝑓(𝑥1 , 𝑦1 )
𝑦𝑖+1 = 𝑦𝑖 + ℎ𝑓(𝑥𝑖 , 𝑦𝑖 )
Méthode de Range Kutta d'ordre 4 :
𝑘1 = 𝑓(𝑥0 , 𝑦0 )
ℎ ℎ
𝑘2 = 𝑓 (𝑥0 + , 𝑦0 + ∗ 𝑘1 ) =
2 2
ℎ ℎ
𝑘3 = 𝑓 (𝑥0 + , 𝑦0 + ∗ 𝑘2 ) =
2 2
𝑘4 = 𝑓(𝑥0 + ℎ, 𝑦0 + ℎ𝑘3 ) =
ℎ
𝑦1 = 𝑦0 + ∗ (𝑘1 + 2𝑘2 + 2𝑘3 + 𝑘4 ) =
6
𝑥1 = 𝑥1 + ℎ =
𝑘1 = 𝑓(𝑥1 , 𝑦1 ) =
ℎ ℎ
𝑘2 = 𝑓 (𝑥1 + , 𝑦1 + ∗ 𝑘1 ) =
2 2
ℎ ℎ
𝑘3 = 𝑓 (𝑥1 + , 𝑦1 + ∗ 𝑘2 ) =
2 2
𝑘4 = 𝑓(𝑥1 + ℎ, 𝑦1 + ℎ𝑘3 ) =
ℎ
𝑦2 = 𝑦1 + ∗ (𝑘1 + 2𝑘2 + 2𝑘3 + 𝑘4 ) =
6
Travail demandé :
Soit l'équation différentielle
𝑦
𝑦=
1 + 𝑥2
avec 𝑦(0) = 1 et 𝑥 ∈ [0 0,4]
14
Résoudre cette équation avec un pas d'intégration ℎ = 0,2 en utilisant :
• La méthode d'Euler
• La méthode de Range Kutta d'ordre 4 (RK4)
Calculer la solution exacte de l'équation et comparer avec les approximations précédentes, quel est votre
commentaire. Module: Méthodes Numériques
15
CHAPITRE 5 : Résolution des systèmes d'équations linéaires
Durée du CHAPITRE : 2 séances de 1h30
But du CHAPITRE :
Le but de ce CHAPITRE est l'implémentation de la méthode de triangularisation de Gauss pour la
résolution d'un système d'équations linéaires.
Rappel de la méthode:
• On commence par le remplissage de la matrice augmentée A du système qui n'est autre que
l'augmentation de la matrice du système d'une colonne contenant le vecteur des données: 𝐴 = (𝐴 ⋮
𝑏)
La dimension de la matrice A sera de ' 𝑛 ' lignes et ' 𝑛 + 1 ' colonnes.
• Ensuite, on programme l'algorithme de Gauss qui va triangulariser la matrice A. Il procède de la
manière suivante :
Pour 𝑘 allant de 1𝑎` 𝑛 − 1
𝑎𝑖𝑘
ligne 𝑖 = ligne 𝑖 − × ligne 𝑘; avec 𝑖 allant de 𝑘 + 1𝑎` 𝑛
𝑎𝑘𝑘
• Et enfin, on extrait la solution du système suivant l'algorithme:
𝑎𝑖,𝑛+1 − ∑𝑛𝑖+1 𝑎𝑖𝑗 × 𝑥𝑗
𝑥𝑖 = ; i allant de 𝑛𝑎`1
𝑎𝑖𝑖
Travail demandé:
a. Ecrire un script Matlab qui utilise la méthode de Gauss pour trouver la solution du système 𝐴 ⋅ 𝑥 = 𝑏
suivant :
10 7 8 7 𝑥1 4
7 5 6 5 𝑥2 3
[ ] × [𝑥 ] = [ ]
8 6 10 9 3 3
7 5 9 10 𝑥4 1
b. Vérifier ensuite votre résultat en le calculant directement avec : 𝑥 = inv (𝐴) × 𝑏
16
