SUPPORT DE COURS Introduction Au Calcul Scientifique

Introduction au Calcul scientifique
Support de
cours
Résumé
Ce cours est une introduction aux techniques d’implantation du calcul sur ordinateur.
Il suppose que le lecteur aient quelques connaissances de base en architecture des ordina-
teurs et en analyse mathématique. Il traite de l’arithmétique sur ordinateur, le calcul des
racines de fonction, l’interpolation, la résolution des systèmes linéaires et l’intégration. Les
implantations sur ordinateur sont réalisées en utilisant le langage Matlab
1
Table des matières
1 Introduction 4
1.1 Motivations et objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Modèle de calcul . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Positionnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 Organisation du cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Arithmétique en précision finie 6

2.1 Représentation des nombres sur ordinateur . . . . . . . . . . . . . . . . . . 6
2.1.1 Représentation en virgule fixe . . . . . . . . . . . . . . . . . . . . . . 6
2.1.2 Représentation en virgule flottante . . . . . . . . . . . . . . . . . . . 7
2.1.3 La norme IEEE 754 de représentation . . . . . . . . . . . . . . . . . 9
2.1.4 Dépassement de capacité, arrondis et troncatures . . . . . . . . . . . 9
2.1.5 Chiffres corrects et chiffres significatifs . . . . . . . . . . . . . . . . . 11
2.1.6 Source d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Arithmétique flottante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.1 Addition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.2 Multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2.3 Division . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3 Le langage MATLAB 13
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.1 Programmer avec MATLAB . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.2 Les fichiers M . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.2 Les vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.1 Création des vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2.2 Adressage et techniques d’indexation des éléments d’un vecteur . . 20
3.2.3 Opérations avec les vecteurs . . . . . . . . . . . . . . . . . . . . . . . 20
3.3 Les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4 Racine des fonctions 27

4.1 Notions de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1.1 Algorithmes itératifs . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1.2 Convergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2
4.2 Méthode de la bissection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2.1 Convergence de la méthode . . . . . . . . . . . . . . . . . . . . . . . 30
4.2.2 Méthode de la fausse position . . . . . . . . . . . . . . . . . . . . . . 30
4.3 L’approche du point fixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.3.1 La méthode de Newton-Raphson . . . . . . . . . . . . . . . . . . . . 33
4.3.2 La méthode de la sécante . . . . . . . . . . . . . . . . . . . . . . . . 35
4.4 Accélération de la convergence par la méthode d’Aitken . . . . . . . . . . . 36
5 Interpolation numérique 37
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2 Interpolation de Lagrange . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2.1 Forme générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.2.2 Dégré du polynôme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.2.3 Unicité du polynôme . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
5.3 Interpolation de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3.1 Les différences divisées . . . . . . . . . . . . . . . . . . . . . . . . . . 39
5.3.2 Table des différences divisées . . . . . . . . . . . . . . . . . . . . . . 40
5.4 Interpolation inverse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
5.4.1 Ordre des points dans l’interpolation . . . . . . . . . . . . . . . . . 41
5.5 Interpolation par splines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.5.1 Spline cubiques d’interpolation . . . . . . . . . . . . . . . . . . . . . 42
5.5.2 Equations de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
6 Résolution des systèmes linéaires 44

6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.1.1 Existence de la solution . . . . . . . . . . . . . . . . . . . . . . . . . 44
6.2 Résolution d’un système diagonal . . . . . . . . . . . . . . . . . . . . . . . . 45
6.3 Résolution d’un système triangulaire inférieur . . . . . . . . . . . . . . . . . 45
6.4 Résolution d’un système triangulaire supérieur . . . . . . . . . . . . . . . . 47
6.5 Résolution d’un système quelconque . . . . . . . . . . . . . . . . . . . . . . 47
7 Intégration 50
3
Chapitre 1
Introduction
1.1 Motivations et objectifs

L’automatisation des calculs est l’une des motivations essentielles pour la construction
des ordinateurs. Ceci est très utile dans de nombreux domaines de la physique comme
la mécanique, l’astrophysique, la simulation océanique qui requièrent souvent des calculs
énormes potentiellement très coûteux en temps et à réaliser avec la plus grande précision
possible. L’ordinateur physique qui en découle toutefois n’est qu’une mécaniqiue capable de
réaliser à travers des circuits certaines opérations arithmétiques de base comme l’addition
des bits ou la multiplication. Dans l’objectif d’automatiser les calculs, il faut ajouter à cet
outil de base des couches permettant de réaliser des calculs beaucoup de plus haut niveau
comme l’évaluation des fonctions, le calcul des dérivées, des intégrales etc. Ceci est une
des priorités du calcul scientiifique dont les succès sont aujourd’hui visibles à la maitrise
des procedés automatiques de calcul dans la réalisation des grands travaux (lancement des
fusées, construction automobile, météorologie, gestion comptable et financière, etc.).
Dans ce cours, nous nous intéressons à l’automatisation des opérations de base courantes
en analyse fonctionnelle et en algèbre linéaire comme le calcul des racines de fonction,
l’intégration, la résolution des systèmes d’équations etc. Notre objectif est de développer
des algorithmes stables, robustes et précis reposant sur des primitives élémentaires de base
comme l’addition, la multiplication etc dans la réalisation des opérations de haut niveau.
1.2 Modèle de calcul

Le modèle de calcul que nous considérons dans ce cours est d’abord donné par un
ordinateur classique avec régistres, mémoires et caches. En outre, nous employons ici le
langage Matlab pour notamment les primitives de base dans le calcul comme les opérations
arithmétiques de base, de stockage, de comparaison. En outre, le fait que ce langage soient
assez développés dans l’implantation du calcul sur ordinateur nous servira à comparer les
résultats que nous obtiendrons de nos modèles.
4
1.3 Positionnement
L’implantation des calculs sur ordinateur necessitent des connaissances tant dans le
domaine de l’algorithme et la programmation que dans les mathématiques. En particulier,
l’univers manipulé dans le calcul sur ordinateur est entièrement discret (les nombres doivent
tenir dans les régistres et donc sur un ensemble maximal de bits, un algorithme doit réaliser
un nombre fini d’opérations) alors que les primitives que l’on retrouve en analyse fonc-
tionnelle considère un domaine d’application continu. Afin donc d’autmatiser les calculs, il
nous est necessaire de discrétiser l’opération mathématique à implanter. Nous le ferons en
particulier en utilisant les éléments de la théorie de l’approximation et en considérant une
arithmétique discrète sur ordinateur.
1.4 Organisation du cours

Ce cours est organisé en deux parties. La première partie décrit le modèle de calcul de
base que nous donnons et la seconde traite de l’implantation sur ce modèle des primitives
de calcul. Au chapitre 2, nous présentons l’arithmétique sur ordinateur en définissant en
particulier les systèmes de codification des nombres réels que nous allons employer. Le
chapitre 3 traite des primitives basiques de manipulation du langage Matlab. Le chapitre
4 traite des approches d’implantation pour le calcul des racines de fonction. Le chapitre
5 traite des techniques d’approximation de fonction avec la technique de l’interpolation
numérique. Le chapitre 6 est consacré à la résolution des systèmes linéaires et le chapitre 7
à l’intégration numérique.
5
Chapitre 2
Arithmétique en précision finie
Dans ce chapitre nous nous intéressons à la représentation des nombres sur ordinateur
et à l’arithmétique qui en découle. L’objectif pour nous est de comprendre en pratique
comment définir efficacement les opérations des calculs élémentaires sur ordinateurs.
2.1 Représentation des nombres sur ordinateur

2.1.1 Représentation en virgule fixe
Les calculs sur ordinateurs s’effectuent via les régistres de l’unité arithmétique et logique.
Ces régistres ne pouvant contenir qu’une information de taille finie, il en résulte que le calcul
sur ordinateurs ne peut prendre en compte qu’une plage finie de nombres.
Considérons le stockage des nombres réels sur ordinateurs. Un nombre réel est une succession
de chiffres contenant une partie entière et une partie décimale. La partie entière comporte un
nombre fixes de chiffres alors que la partie décimale peut comporter une infinité de chiffres.
Pour stocker un tel nombre dans les régistres de l’UAL, une première approche consiste à
réserver une partie des bits pour le signe, une partie des bits pour la partie entière et une
partie des bits pour la partie décimale. Pour stocker les nombres dans chacune des parties,
on peut utiliser la représentation en complément à deux.
S P. Entière P. Décimale
1 t e
Fig. 2.1 – Structure d’un nombre en virgule fixe. On a un bit pour le signe, t bits pour la
partie entière et e bits pour la partie décimale
L’approche de représentation ainsi proposé est l’approche de représentation avec la vir-

gule fixe. Ici, si e est le nombre de chiffres réservés à la partie décimale, alors, on ne peut
stocker que des chiffres dans R équidistants de 2−e .
6
p
0
Fig. 2.2 – Les nombres en virgule fixe sont équidistants de p = 2−e
Dans la représentation en virgule fixe on a le même nombre de valeurs réelles que l’on
peut stocker en flottant dans les intervalles [0, 1] et [2, 3]. En pratique pourtant la précision
est plus utile lorsque l’on est près de zero que lorsque l’on s’en éloigne. Aussi, il est intéressant
de modifier la représentation de sorte à avoir plus de nombres que l’on peut stocker près de
0. La représentation en nombres flottants permet d’effectuer ce type de stockage.
2.1.2 Représentation en virgule flottante

Definition 2.1.1 Etant donné une base β, un nombre flottant en base β est un nombre
de la forme f.β e . f est appelée ici mantisse du nombre et e son exposant. Un nombre
flottant est dit normalisé si β −1 ≤ f < 1 ; Ceci signifie que f dans ce cas est de la forme
f = 0.d1 d2 d3 . . . , avec 0 ≤ di ≤ β − 1 et d1 6= 0
Etant donné un nombre flottant 0.d1 d2 . . . dt β e , sa valeur entière en base 10 est égale à
d1 β e−1 + · · · + dt β e−t .
Example La valeur de 0.11024 = 23 + 22 = 12.
Pour représenter un nombre flottants, on considère trois composantes principales : le

signe, l’exposant et la mantisse. Aussi la représentation sur un régistre d’un nombre flottants
est obtenue en affectant un certain nombres de bits à chacune de ces composantes. Chacune
de ces composantes est stockée en utilisant la représentation en compléments à deux.
S Exposant Mantisse
1 e t
Fig. 2.3 – Représentation d’un nombre en virgule flottante. On a un bit pour le signe, e
bits pour l’exposant et t bits pour la mantisse.
En résumé, la représentation flottante est caractérisée par :

– La base β (en générale on a β = 2 sur les ordinateurs mais on a récurremment β = 10
sur les calculatrices)
– Le nombre de chiffres t de la mantisse (en base β)
– Deux bornes L et U définissant l’ensemble de valeurs possibles de l’exposant.
7
Noter que dans cette représentation, l’exposant peut être stocké en utilisant la technique
du complément à deux. L’ensemble F des nombres machines est un ensemble fini, dont le
cardinal est |F | = 2(β − 1)β t−1 (U − L + 1) + 1.
Dans une représentation normalisée, on peut supposer que la mantisse comporte 24 bits
dans le cas des nombres en simple précision et 53 bits dans le cas des nombres en double
précision car le premier bit dans ces cas n’est pas stocké.
Exercice 1 : Comment obtient on cette valeur ?
L’intérêt de la représentation flottante est de prendre en compte plus de petits nombre

que la virgule fixe. En effet, dès que l’exposant est négatif les valeurs stockées sont celles de
nombres en valeur absolue plus petits que 1. On peut facilement en déduire que si X et Y
sont deux grands nombres consécutifs que l’on a pu représenter, x, y, deux petits nombres
consécutifs représentés, alors on a en général |X − Y | ≥ |x − y| 1 . Cette observation motive
l’appelation ”virgule flottante”. Nous l’illustrons dans l’exemple suivant :
Example Considérons une représentation flottante avec : t = 3 ; L = −1 ; U = 2 ; |F | = 33.

Nous représentons sur la figure ci dessous les nombres positifs de F . Le plus petit est 1/4
(correspondant à e = −1), le plus grand est 7/2 (pour e = 2).
Fig. 2.4 – Un système simple de nombres flottants
Nous pouvons donner la liste des éléments de F entre 1/2 et 1, soit pour e = 0. Le reste de
F s’en déduit en faisant varier e, ce qui revient juste à multiplier chacun de ces nombres
par une puissance de 2.
1/2 = (0.100)2 ; 3/4 = 1/2 + 1/4 = (0.110)2

5/8 = 1/2 + 1/8 = (0.101)2 ; 7/8 = 1/2 + 1/4 + 1/8 = (0.111)2
On note plusieurs faits généraux sur cet exemple : L’espacement entre les nombres de F
est variable (il augmente d’un facteur 2 à chaque puissance de 2), mais la distance relative
reste constante. Elle est donnée par ǫmach = 1/8 = 1/23 .
1
Noter que l’on a pratiquement autant de nombres plus petit en valeur absolue que 1 que de nombres
plus grands
8
2.1.3 La norme IEEE 754 de représentation
Jusqu’au milieu des années 1980, chaque constructeur d’ordinateur avait sa représentation
flottante. Cette situation entrainait beaucoup de difficultés pour les développeurs de logi-
ciel qui devaient alors à chaque fois maı̂triser la représention flottante de l’ordinateur cible.
C’est dans ce contexte que fût proposée la norme IEEE 754, qui s’est par la suite imposée
comme norme de représentation, pour les nombres flottants. La norme IEEE 754 précise
les représentations pour deux niveaux de précisions, que l’on appelle simple et double
précisions. Dans les deux cas, la norme impose le choix de la base β = 2. Les chiffres di
du développement sont donc des chiffres binaires, ou bits, et on a d1 = 1.
La simple précision Correspond aux types float de Java ou de C. Les nombres sont
représentés sur 32 bits, avec t = 23 ; L = −126 ; U = 127, xmax ≈ 1038 , xmin ≈ 10−38
La double précision correspond aux types double de Java et de C. Les nombres sont
représentés sur 64 bits, avec t = 52 bits pour la mantisse et 11 bits d’exposant. L = −1022 ;
U = 1023, xmax ≈ 10307 , xmin ≈ 10−307 Les figures (2.5) et (2.6) représentent un nombre
respectivement en simple, et double précision.
S Exposant Mantisse
1 8 bits 23 bits
Fig. 2.5 – Nombre en simple précision
S Exposant Mantisse
1 11 bits 52 bits
Fig. 2.6 – Nombre en double précision
Le choix du nombre total de bits (32, 64) dans ces représentations dépend des standards
sur la taille des régistres de l’UAL.
Il existe plusieurs autres stockages étandant la norme IEEE 754. Par exemple les nombres
en quadruple précision qui sont stockés sur 128 bits.
Exercice 2 : Supposons que l’on ne stocke que des nombres positifs en simple précision.
Comment peut on adapter le stockage dans ce cas pour stocker plusieurs nombres ?
2.1.4 Dépassement de capacité, arrondis et troncatures

On peut facilement vérifier que l’ensemble F des nombres flottants est fini. Aussi, il
n’est pas possible de représenter tous les nombres réels en utilisant les nombres flottants.
9
Soit minF le plus petit nombre flottant positif, maxF le plus grand nombre flottant et ǫF
le plus petit écart entre nombres flottants, on peut se poser les interrogations suivantes sur
les nombres flottants :
1. Le résultat d’un calcul entre deux flottants peut donner une valeur plus petite que
minF ou plus grande que maxF . Que se passe t’il dans ce cas ?
2. Etant donné une valeur réelle dont la partie décimale est plus petite que ǫF , comment
doit on stocker cette valeur ?
Lorsque le résultat du calcul est plus petit que minF , on est dans une situation d’underflow.
Dans celle ci en générale, la valeur calculée est arrondie à zero. Lorsque le résultat est plus
grand que maxF , il se produit une erreur dans le calcul liée au dépassement de la capacité
de stockage. Cette erreur est appelée overflow.
Dans la seconde situation (nombre de précision plus petite que ǫF , le nombre à stocker
sera soit arrondi, soit tronqué. On aura donc une erreur d’arrondi ou de troncature.
L’erreur de dépassement de capacité peut être évitée dans certains cas en définissant
√
judicieusement l’opération à effectuer. En particulier, considérons le calcul de c = a2 + b2
tel que a = 1030 et b = 1 sur un ordinateur simple précision. Ce calcul à priori provoquera
un dépassement de capacité immédiat dans l’évalution de a2 . Toutefois, le resultat
q est bien
plus petit ici que maxF = 1038 . On peut noter qu’en reécrivant plutot c = a 1 + ( ab )2 , on
n’aurait pas eu ce problème (malgré la possibilité d’avoir un underflow). En règle générale,
le dépassement de capacité peut être évité en factorisant les grands termes dans l’opération
à effectuer.
La possibilité d’arrondir ou de tronquer un nombre nous impose de considérer en pratique
une erreur implicite dans le stockage de tout nombre réel en virgule flottante. Aussi si a est
un nombre réel, nous considérons que son équivalent flottant est de la forme f l(a) = a(1+ǫa )
où ǫa est l’erreur dans le stockage de a. En particulier, si le nombre a est stockée en flottant
avec la valeur b alors on a ǫa = |b−a||a| . La valeur ǫa sera en pratique appelée erreur relative
sur la valeur a. De façon générale, l’erreur relative se définit comme :
Erreur Relative = Erreur absolue/ Valeur Exacte
avec
Erreur absolue = Valeur Approximative - Valeur Exacte.
On peut aussi noter que l’on a trivialement |ǫa | ≤ ǫF .

L’impact négatif lié à l’existence des erreurs d’arrondis en pratique est toutefois limitée par
le fait que nous opérons des calculs sur des données comportant déjà des erreurs (si par
exemple elles sont mésurées). Toutefois elle introduit la question de la validité des chiffres
que nous avons dans un résultat sur les nombres flottants.
Exercice 3 : Comment obtenir une approximation de ǫF ?
Exercice 4 : On considère une puissance de 2, a ∈ [minF, maxF ]. Quelle est l’erreur ǫa
commise dans son stockage sur un ordinateur ?
10
2.1.5 Chiffres corrects et chiffres significatifs
Considérons une valeur décimale a que l’on doit stocker avec une mantisse de t chiffres.
Supposons que t = 5 et que a soit de la forme a = X.XXXXY . Comme l’on ne peut stocker
que 5 chiffres, ce sera la valeur b = X.XXXZ qui sera stockée à la place de a. Dans ce
stockage on fera soit un arrondi si Y > 5 ou une troncature sinon. L’erreur absolue induite
par ce stockage est de |b − a| = 0.5.10−4 . On peut généraliser ce résultat en notant que de
façon générale, |b − a| = 0.5.10−t+1 . Cette observation nous amène à déduire le nombre de
chiffres corrects et significatifs dans une expression à partir de la valeur de l’erreur absolue
que l’on a.
Definition 2.1.2 Etant donné une valeur a et ã une valeur approchée de a. On dira que ã
possède t chiffres corrects si |ã − a| ≤ 12 .10−t .
Definition 2.1.3 Etant donné une valeur a et ã une valeur approchée de a. Supposons que
ã possède t chiffres corrects. Tous les chiffres de a qui occupent une position telle que l’unité
de l’erreur y est plus grande que 10−t sont appelés chiffres significatifs.
Lorsqu’on connait une valeur approximative avec une estimation du nombre de décimaux
corrects, on en déduit une approximation de l’erreur absolue.
|erreur absolue| ≤ 12 10−t ⇒ t ≈ −log10 |erreur absolue|,
Lorsqu’on connait un resultat avec une estimation du nombre de chiffre significatifs, on
en déduit une approximation de l’erreur relative.
|erreur relative| ≈ 10−m ⇒ −m ≈ −log10 |erreur relative|
Exercice 5 : Comment peut on déduire le nombre de bits significatifs et corrects dans un
nombre flottant en base 2 ?
Jusqu’à présent nous nous sommes intéressés aux erreurs uniquement induites par le
stockage des nombres flottants sur ordinateur. En pratique toutefois d’autres sources d’er-
reurs doivent être considérés. Nous verrons cela dans la suite.
2.1.6 Source d’erreurs

Dans un procedé de calcul, on distingue généralement deux sources d’erreurs :
– Les données : les erreurs de données proviennent des mesures, des calculs intermédiaires
ou de la modélisation.
– Les calculs : les erreurs de calculs proviennent des arrondis(processus finis), des
troncatures(approximation finies de certains processus infinis).
Soit a une valeur que nous voulons utiliser dans un procedé f pour obtenir f (a). Pour
diverses raisons, nous ne manipulerons plutot ã qui est une approximation. La valeur ã − a
donne l’erreur des données. Au mieux en pratique, nous aurons f (ã) au lieu de f (a)
f (ã) − f (a) ≡ erreur de propagation de l’erreur des données.
En général, on n’a pas exactement le procedé f mais une approximation f˜ à cause par
exemple de la necessité de discrétisation du procedé ; On obtient donc f˜(ã) au lieu de f (ã)
f˜(ã) − f (ã) ≡ erreur de calcul
11
f˜(ã) − f (a) ≡ f˜(ã) − f (ã) + f (ã) − f (a) ≡ erreur totale
d’où l’erreur totale dans le processus est la somme des erreurs de propagation et de calcul
2.2 Arithmétique flottante

Dans cette partie nous évaluons les erreurs de propagation sur les opérations arithmétiques
flottantes. arithmétiques sur des nombres flottants. Nous considérerons, l’addition, la mul-
tiplication et la division flottante.
2.2.1 Addition
Considérons l’addition X = ã + b̃. Nous ne tenons pas compte dans un temps de l’erreur
induite par le stockage du résultat. Supposons que l’on a : ã = a(1 + ǫa ) et b̃ = b(1 + ǫb ).
a a
On a alors X = (a + b)(1 + ǫa+b ) avec ǫa+b = a+b ǫa + a+b ǫb . Ce résultat montre que
potentiellement l’addition peut entrainer une grande propagation des erreurs si les valeurs
de a et b sont proches et de signes contraires. L’opération est qualifiée de sensible dans ce
cas. Ceci indique en particulier qu’il faudra formuler le calcul en pratique de sorte à éviter
l’addtion de valeurs de signes contraires proches.
2.2.2 Multiplication
Nous considérons l’opération X = ã.b̃. Avec les hypothèses ci dessus, nous avons :
X = a.b(1 + ǫab ) avec ǫab = ǫa + ǫb + ǫa ǫb ǫa et ǫb sont petites, alors la valeur de ǫa ǫb est
encore plus petite. Dans ce cas, l’erreur induite par la propagation est du même ordre que
les erreurs de données. La multiplication est donc considérée comme étant une opération
stable qui n’est pas sensible à la pertubation des données.
2.2.3 Division
1+ǫa ǫa −ǫb
Soit à calculer X = ãã . On a X = ab ( 1+ǫa
). Soit alors X = ab (1 + ǫa/b ) avec ǫa/b = 1+ǫb .
On en conclut que la division n’est pas sensible à la perbutation des données.
En prenant en compte le fait que dans les calculs flottants sur ordinateur, il faudra
entre autre normaliser les opérandes et arrondir les résultats, on peut remarquer que sur
ordinateur, l’addition ã + b̃ = f l(ã + b̃) = (ã + b̃)(1 + ǫ). On peut donc noter qu’en pratique
certaines propriétés arithmétiques classiques ne seront pas observables sur ordinateur. Par
exemple l’addition flottante sera commutative mais ne sera pas associative.
12
Chapitre 3
Le langage MATLAB
3.1 Introduction
MATLAB est un logiciel de calcul numérique disponible sur plusieurs plateformes (Win-
dows, Linux etc.). Il possède un langage très simple et efficace, optimisé pour le traitement
des matrices et des vecteurs. Il existe plusieurs autres logiciels qui offrent des fonctionnalités
similaires à celles que l’on retrouve dans MATLAB. On peut par exemple citer :
– Scilab (http ://www.scilab.fr)
– Octave(http ://octave.org)1
Scilab et Octave sont des logiciels gratuits.
Dans ce cours, nous nous intéresssons exclusivement au langage de programmation de
MATLAB.
3.1.1 Programmer avec MATLAB

MATLAB est un langage basé sur des commandes. Une commande dans MATLAB a
différentes constituantes. Entre autre, on peut distinguer : les variables, les constantes, les
opérateurs relationnels, les opérateurs arithmétiques, les fonctions MATLAB prédéfinies,
les instructions de contrôle etc. Des commandes dans MATLAB peuvent être utilisées dans
deux modes. Les différentes commandes dans MATLAB peuvent être exécutées dans deux
modes. Ce sont : le mode console direct et le mode fichier script. Dans le mode console
direct, une commande ou plusieurs commandes sont saisies dans dans l’invite de commande
MATLAB et validées avec la touche ”enter” du clavier. Dans le mode fichier script, une
ou plusieurs commandes sont saisies dans un fichier de script et elles sont exécutées en
saisissant le nom du fichier de script sur la console et en validant avec la touche ”enter”. Un
interpréteur avec une console pour les commandes est fourni dans MATLAB pour exécuter
les différentes commandes. Cet interpréteur a un fonctionnement similaire à l’interpréteur
Shell dans Linux ou à l’interpréteur de commandes dans le système MS-DOS. Une des simil-
itudes est le fait qu’il permet l’exécution d’une commande sans la création explicite d’un
1
Octave n’est en général disponible que pour les plateformes Linux. On peut néanmoins utiliser des outils
tels que cygwin pour l’exécuter sur Windows. Scilab est disponible pour les plateformes Windows et Linux
13
fichier script. De même, on peut exécuter un script en saisissant successivement la liste de
ses commandes dans la console.
Dans le mode console direct par exemple, on peut avoir les commandes suivantes :
>> x = 10*3
Cette commande multiplie la valeur 10 par 3 et range le résultat dans une variable x. En
retour à la console, on a le résultat suivant :
>> x = 30
>> x = sin(0); cos(x);
Cette commande affiche demande le calcul du sinus de 0 que l’on conserve dans x puis celui
du cosinus de x en retour on a les résultats suivants
>> x = 0
>> ans = 1
Deux commandes MATLAB peuvent être séparées par un caractère de séparation (es-
pace, tabulation entrée etc.) ou par un point virgule. Si les commandes C1 et C2 se suivent
et sont séparées par un point virgule, alors la commande C1 est sans écho. Dans ce cas le
résultat de la commande C1 n’est pas affichée à moins que cette commande comprennent
une instruction explicite d’affichage. Si par contre elles sont séparées par un caractère de
séparation, alors le résultat de la commande C1 est automatiquement affiché.
>> x = 2; Commande est sans écho

>> y = 4 Commande avec écho
y = 4 Echo de la commande précédente
Les variables
Dans MATLAB on distingue plusieurs types de variables. En particulier, on a les vari-
ables scalaires et les variables vectorielles. Il n y a pas de déclarations de variables dans
MATLAB et seule l’affectation définit le type de la variable.
>> x = 2; x est une variable scalaire contenant 2

>> y = [1 5]; y désigne un vecteur ligne ayant deux composantes.
La variable spéciale ans donne le résultat d’un calcul lorsque celui ci n’est pas affecté
dans une variable 2
2
Matlab comporte un ensemble de constantes spéciales comme la constante pi = 3.14.. Il faudrait éviter
de les choisir comme nom de variables.
14
>> 2+4 Calcul avec écho non affecté dans une variable
ans = 6 ans contient la valeur du calcul précédent
>> x = 2+3 Calcul avec écho affecté dans une variable
>> x = 5 Cette variable prend la valeur du calcul
>> ans affichage de ans
ans = 6 ans n’a pas été modifié par le précédent calcul
Lors de l’exécution des commandes dans MATLAB, une composante particulière nommée
le workspace garde toutes les variables utilisées ainsi que leur contenu. Il est par ailleurs
possible de sauvegarder toutes les valeurs contenues dans le workspace dans un fichier.
L’intérêt ici est qu’il est possible plus tard de recharger ces variables en utilisant le fichier
de sauvegarde.
Les opérateurs relationnels et logiques

– < Inférieur
– <= Inférieur ou égal
– > Supérieur
– >= Supérieur ou égal
– == Egal
– ∼= Différent
– & Et
– | Ou
– ∼ Non
– xor(x, y) Ou exclusif
– any(x) Retourne 1 si un des éléments de x est non nul, 0 sinon.
– isequal(A, B) retourne V si A et B sont égaux, F sinon
Opérateurs arithmétiques
– + Addition
– − Soustraction
– ∗ Multiplication
– / Division à droite
– \ Division à gauche
– ∧ Puissance
– ./ Division à droite éléments par éléments
– .\ Division à gauche éléments par éléments
– .∗ Multiplication éléments par éléments
– .∧ Puissance éléments par éléments
>> x = [1 2];
>> y = [2 3];
>> x+y Addition de deux vecteurs
ans = Résultat de l’addition
15
3 5
>> x .\ y Division éléments par éléments à gauche
ans =
2 1.5
Fonctions MATLAB prédéfinies

MATLAB comporte un ensemble de fonctions prédéfinies 3 pour le calcul, la manipula-
tion des fichiers, l’aide etc. Ci dessous, nous donnons quelques une des ces fonctions :
– help Donne l’aide sur une fonction
– lookfor Pour la recherche d’un mot clé
– what Liste les fichiers MATLAB dans le répertoire courant
– exist Indique si une fonction ou une variable est dans le
– workspace
– who Donne la liste des variables dans le workspace
– whos Version qui donne plus de détails du who
– clear Efface toutes les variables présentes dans le workspace
– save Permet la sauvegarde du workspace dans un fichier
– load Permet de charger le workspace avec un fichier
– disp Pour l’affichage
– Edit Pour lancer un éditeur de texte
Les instructions de contrôle

Les instructions de contrôle dans MATLAB sont similaires à celles de la plupart des
langages de programmation impératifs.
a) Instruction if-then-elseif-else
La structure générale de cette instruction est la suivante :
if (expression1)
(commandes si expression1 est vraie)
elseif (expression2)
(commandes si expression2 est vraie)
else
(commandes si aucune expression n’est vraie)
end
>> y = rand y prend une valeur aléatoire

>> if (y > 0.5)
disp(’Il pleuvra fortement ce soir’)
elseif(y > 0.25)
disp(’Il pleuvra faiblement ce soir’)
3
Ces fonctions ne représentent pas grand chose dans le potentiel de MATLAB. Il est recommandé de
consulter l’aide de MATLAB pour compléter sa connaissance sur les fonctions prédéfinies.
16
else
disp(’Il ne pleuvra pas ce soir’)
end
b) Instruction while
La structure générale est la suivante :
while(expression)
(commandes)
end
c) Instruction for La structure générale est la suivante :

for variable = expression
(commandes)
end
Ici expression peut être un vecteur
>> for x=[1 2 3]
disp(x+3)
end
4
5
6
3.1.2 Les fichiers M

Dans MATLAB, on peut décider de créer des scripts de commandes (un ensemble de
commandes). Ces commandes sont écrites dans des fichiers ayant l’extension ”.m”
% fichier test.m % est utilisé pour le commentaires
disp(’test de fichier .m’)
return % le return est facultatif
Pour exécuter un fichier m, il suffit de taper le nom de ce fichier sur la console MATLAB.
Les fichiers m peuvent aussi être utilisés pour définir des fonctions dans MATLAB.
% fichier test2.m
function y = test2(x)
% test2 est à la fois le nom du fichier et de la fonction
if(x ==0)
y = -1
else
y = 1
end
return
17
Si on essaie alors test(0) on a comme résultat -1. Il faut noter que les variables d’une
fonction sont locales et n’entrent pas dans le workspace.
La syntaxe générale de l’entête d’une fonction Matlab est la suivante :
function [V1, V2, ..., Vn] = nom_fonction(P1,P2,...,Pm);
3.2 Les vecteurs

L’une des qualités essentielle de MATLAB est la facilité qu’il offre dans la manipulation
des vecteurs et des matrices. En outre, MATLAB possède des implémentations efficaces des
opérations usuelles en algèbre matricielle.
3.2.1 Création des vecteurs

Création des vecteurs lignes
a) Création par énumération des composantes
MATLAB permet la manipulation des vecteurs lignes et colonnes. Un vecteur ligne est
crée en listant toutes ses composantes entre les caractères ”[” et ”]” Exemple 2.1 :
>> v = [1 8 5 7]
v =
1 8 5 7
Il est aussi possible de créer un vecteur en indiquant un procédé systématique pour

énumérer ces composantes. Dans ce cas, on peut utiliser l’instruction générique v = [valeur−
initiale : increment : valeur − f inale]. Dans cette instruction, v est le vecteur que l’on
veut créer, valeur-initiale est la première composante de v, La composante v(i) a pour
valeur : valeur − initiale + (i − 1).increment et la dernière composante a pour valeur :
valeur − f inale.
Exemple 2.2 :
>> v = [1:1:4]
v =
1 2 3 4
Exercice 2.1 : Que donne les affectations v = [9 : −2 : 1], v = [0 : 2 ∗ pi : 10] ?

Remarque 2.1 : Si l’incrément n’est pas précisé, sa valeur par défaut est égale à 1. Pour
la création d’un vecteur ligne, on peut aussi utiliser les fonctions linspace(BASE, LIM IT, N )
et logspace(BASE, LIM IT, N ). Pour linspace, BASE est le premier élément du vecteur,
LIM IT est le plus grand élément et N est le nombre d’éléments.
Pour un appel linspace(BASE, LIM IT, N ), BASE et LIM IT seront comprises dans le
vecteur ligne obtenue. linspace va déterminer le bon pas permettant de générer de façon
équidistante les N − 2 composantes intermédiaires. logspace est similaire à linspace à la
18
différence que les composantes sont générées entre 10BASE et 10LIM IT et les composantes
sont logarithmiquement équidistantes (la composante v(i) que l’on aurait eu avec linspace
est ici égale à 10v(i) )
Exercice 2.2
1. Donner l’équivalent de l’instruction v = [valeur − initiale : increment : valeur −
f inale] en utilisant la fonction linspace.
2. Donner l’équivalent de l’instruction v = linspace(BASE, LIM IT, N ) sous la forme
v = [valeur − initiale : increment : valeur − f inale].
3. Dans une commande v = logspace(BASE, LIM IT, N ), N > 4 que vaut log10(x(i)) −
log10(x(i − 1)) pour 1 < i < N.
NB. log10 est la fonction du logarithme en base 10.
b) Création par composition des vecteurs
Dans MATLAB, il est possible dans une création par énumération des composantes
d’indiquer qu’une composante est un vecteur.
Exemple 2.3 :
>> a = [1:1:4];
>> b = [7:10];
>> x = [a b]
x =
1 2 3 4 7 8 9 10
Création des vecteurs colonnes

Un vecteur colonne peut être crée en prenant la transposée d’un vecteur ligne. La trans-
posée d’un vecteur ligne est obtenue en mettant le caractère ”’” à la fin de ce vecteur.
Exemple 2.4 :
>> v = v’
v =
1
2
3
4
Un vecteur colonne peut aussi être crée en listant ses composantes comme dans le cas
d’un vecteur colonne mais en les séparant par le caractère ” ; ”.
Exemple 2.5 :
>> v = [1;2;3;4]
v =
1
19
2
3
4
Remarque 2.2 : Il est aussi possible de composer des vecteurs colonnes. Dans le cas
où on compose un vecteur colonne avec des vecteurs ligne de même taille, on obtient une
matrice. On peut de même composer un vecteur ligne avec des vecteurs colonnes de même
taille.
3.2.2 Adressage et techniques d’indexation des éléments d’un vecteur

L’élément i d’un vecteur v dans MATLAB est donné par v(i). MATLAB permet d’in-
dexer un bloc d’éléments en indiquant leurs coordonnées. L’instruction v(BASE : LIM IT )
donne toutes les composantes du vecteur v, comprises entre BASE et LIM IT . L’instruction
v([i, j, k, ...]) donne les composantes i, j, k... du vecteur v.
Exemple 2.6 :
>> v = [1 2 3 4];
>> v(2:4)
ans =
2 3 4
>> v(1)
ans =
1
>> v([1,3])
ans =
1 3
3.2.3 Opérations avec les vecteurs

Les principales opérations en algèbre linéaire sur les vecteurs sont facilement réalisables
avec MATLAB.
Multiplication scalaire-vecteur et exponentiation

La multiplication d’un vecteur par un scalaire est réalisée par l’opérateur ” * ” entre un
scalaire et un vecteur. L’exponentiation d’un vecteur est réalisée par l’opérateur ”.∧ ” entre
un vecteur et un scalaire. Tous les éléments du vecteur sont élevés à la puissance indiquée
par le scalaire.
Exemple 2.7 :
>> x = [1 2 3 4];
>> x = 3*x
x =
3 6 9 12
>> x.^2
20
ans =
9 36 81 144
Transposée d’un vecteur

La transposée est obtenue avec l’opérateur ”’” .
Exemple 2.8 :
>> x = [1 2 3 4];
>> x = x’
x =
1
2
3
4
>> x = x’
x =
1 2 3 4
Addition et soustraction des vecteurs

Les deux vecteurs doivent avoir la même taille.
Exemple 2.9 :
>> x = [1 2 3 4];
>> y = [ 4 8 5 6];
>> x+y
ans =
5 10 8 10
>> x-y
ans =
-3 -6 -2 -2
Produit scalaire de deux vecteurs

Le produit scalaire est réalisé par l’opérateur ”*” entre un vecteur ligne et un vecteur
colonne. le vecteur à gauche de l’opérateur ”*” doit être le vecteur ligne.
Exemple 2.10 :
>> x = [1 2 3 4];
>> y = [ 4 8 5 6]’;
>> x*y
ans = 59
21
Produit externe entre deux vecteurs
Le produit externe est réalisé par l’opérateur ”*” entre un vecteur ligne et un vecteur
colonne. le vecteur à gauche de l’opérateur ”*” doit être le vecteur colonne.
Exemple 2.11 :
>> x = [1 2 3 4];
>> y = [ 4 8 5 6]’;
>> y*x
ans =
4 8 12 16
8 16 24 32
5 10 15 20
6 12 18 24
Produit éléments par éléments de deux vecteurs

Le produit éléments par éléments est réalisé par l’opérateur ”.*” entre deux vecteurs
lignes ou deux vecteurs colonnes.
Exemple 2.12 :
>> x = [1 2 3 4];
>> y = [ 4 8 5 6];
>> x .* y
ans =
4 16 15 24
Exercice 2.3 Ecrire une fonction Outer( x, y, n) pour calculer le produit externe entre
le vecteur colonne x et le vecteur ligne y de taille n en utilisant uniquement la multiplication
scalaire-vecteur.
Exercice 2.4 La fonction diag(A) dans matlab donne les composantes de la diagonale
de la matrice x. Ecrire une fonction diagonal(A, n, m) qui réalise cette opération. NB. Dans
le cas d’une matrice A, A(i,j) donne la composante située à la ligne i et à la colonne i.
Exercice 2.5 Ecrire une fonction matvec(A, x, n,m) qui calcule le produit matrice
vecteur entre une matrice A et un vecteur x en utilisant le produit scalaire.
Exercice 2.6 Ecrire une fonction vecmat(x, A, n, m) pour calculer le produit entre un
vecteur ligne et une matrice.
Exercice 2.7 Ecrire une fonction prodmat(A, B, n, m) pour calculer le produit de deux
matrices A et B en n’utilisant uniquement :
1. des produits scalaires
2. la fonction matvec
22
3. la fonction vecmat
4. des produits externes
NB. m et n désignent le nombre de lignes et de colonnes des matrices.
3.3 Les matrices

Comme pour les vecteurs, MATLAB offre de nombreuses fonctionnalités pour la manip-
ulation des matrices.
Création des matrices

Création par énumération des composantes
Comme nous l’avons déjà vu, une matrice peut être créee par composition de plusieurs
vecteurs.
Exemple 3.1 :
>> x = [1 2 3 4; 2 3 5 6]
x =
1 2 3 4
2 3 5 6
>> x = [3:-1:1 ; logspace(0, 1, 3)]
x =
3.0000 2.0000 1.0000
1.0000 3.1623 10.0000
Quelques fonctions spéciales de création des matrices
MATLAB comporte un ensemble de fonctions permettant de créer de matrices partic-

ulières
– ones(n) crée une matrice carré de taille n comportant uniquement des ”1”
– zeros(n, m) crée une matrice de n lignes et m colonnes comportant uniquement des
”0”
– eye(n, m) crée une matrice diagonale comportant des ”1” sur la diagonale.
– rand(n, m) crée une matrice de n lignes et m colonnes comportant des nombres
aléatoires entre 0 et 1.
Adressage et techniques d’indexation des éléments d’une matrice

L’élément placé à la ième ligne et la jème colonne d’une matrice A est donné par A(i, j).
Comme dans le cas des vecteurs, il est possible d’indexer une sous matrice d’une matrice
A. L’instruction A(BASE1 : LIM IT 1, BASE2 : LIM IT 2) indexe les composantes de la
matrice A dont les numéros de ligne sont compris en BASE1 et LIM IT 1 et les numéros
23
de colonne entre BASE2 et LIM IT 2. Pour indiquer que l’on sélectionne toute une ligne
ou toute une colonne, on peut juste utiliser le caractère ” :” sans préciser les bornes.
Exemple 3.2 :
>> x = [1 2 3 4; 2 3 5 6; 5 8 9 10];
>> x(2:3,1:3)
ans =
2 3 5
5 8 9
>> x(:, 1:3)
ans =
1 2 3
2 3 5
5 8 9
Opérations sur les matrices

Multiplication scalaire-matrice
La multiplication scalaire-matrice est réalisée par l’opérateur ”*” entre un scalaire * et

une matrice.
Exemple 3.3 :
>> x = [1 2 3 4; 2 3 5 6];
>> 5*x
ans =
5 10 15 20
10 15 25 30
Transposition
Elle est réalisée avec l’opérateur ”’”

Exemple 3.4 :
>> x = [1 2 3 ; 2 5 6]
x =
1 2 3
2 5 6
>> x’
ans =
1 2
2 5
3 6
Produit matrice-vecteur
24
Il est réalisé par l’opérateur ”*” entre une matrice et un vecteur colonne. Le membre de
gauche doit être la matrice.
Exemple 3.5 :
>> A = [1 2 3 ; 2 5 6]
>> z =
[7 8 9]’
>> A*z
ans =
50
108
Produit vecteur-matrice
Il est réalisé par l’opérateur ”*” entre une matrice et un vecteur ligne. Le membre de
gauche doit être le vecteur ligne.
Exemple 3.6 :
>> A = [1 2 3 ; 2 5 6]
>> z =
[7 9]
>> z*A
ans =
25 59 75
Addition et soustraction des matrices
L’addition est réalisée par l’opérateur ”+” et la soustraction par l’ opérateur ”-”. Dans
ces opérations les matrices doivent avoir les mêmes dimensions.
Exemple 3.7 :
>> x = [3:-1:1 ; 2 5 6; 1:1:3];

>> y = ones(3)
>> x + y
ans =
4 3 2
3 6 7
2 3 4
Produit de matrices
Le produit de matrices est réalisé par l’opérateur ”*” entre deux matrices. Il faut noter que
le produit de matrice n’est pas commutatif ! ! !
Exemple 3.8 :
25
>> x = [3:-1:1 ; 2 5 6; 1:1:3];
>> y = ones(3)
>> x*y
ans =
6 6 6
13 13 13
6 6 6
Fonction spéciales sur les matrices

– size(A) retourne dans un vecteur ligne le nombre de lignes et de colonnes de la matrice
A.
– length(A) renvoie la plus grande valeur de size(A)
– rank(A) renvoie le nombre de colonnes linéairement indépendantes de la matrice A
(son rang)
– diag(A) renvoie le nombre d’éléments diagonaux de la matrice A.
– triu(A) renvoie la partie triangulaire supérieure de la matrice A.
– tril(A) renvoie la partie triangulaire inférieure de la matrice A.
Autres fonctions
D’autres fonctions spéciales seront utilisées tout au long de ce cours. En particulier
– La fonction input permet de lire une valeur au clavier (en particulier x = input(’entrer
une valeur’) permet de lire une valeur et x = input(’entrer une valeur’, ’s’) permet
de lire une chaines de caractères. )
– La fonction polyval(P, X) qui évalue le polynôme P en les valeurs X. (Un polynôme
est donné par le vecteur ligne de ses coefficients)
– La fonction interp1(X, Y, method) qui applique la method pour interpoler les valeurs
X et Y
– La fonction lu(A) donne la factorisation de Gauss de la matrice A
– La fonction quad(f un, a, b) calcule l’intégrale de la fonction f un dans l’intervalle [a, b].
– La fonction f zero(f un, x0) qui donne une racine de la fonction f un en prenant x0
comme approximation initiale.
26
Chapitre 4
Racine des fonctions
Nous nous intéressons dans ce chapitre aux calculs des racines pour les fonctions à une
variable. Nous considérons les fonctions de la forme f : R −→ R et les équations de la forme
f (x) = 0 ou de façon plus générale f (x) = h(x). (4.1)
4.1 Notions de base

Il est facile de dériver un algorithme exact pour la résolution de l’équation 4.1 dans
certains cas. Par exemple si f est un polynôme du second dégré, l’on peut employer la
méthode du discriminant (ou de façon plus générale la méthode des radicaux). Toutefois
lorsque le dégré du polynôme atteint 5, il a été prouvé que dans le cas général, on ne
saurait résoudre une telle équation par la méthode des radicaux . Dans ces cas, des solutions
approchées peuvent être employées avec en particulier les algorithmes itératifs.
4.1.1 Algorithmes itératifs

Pour résoudre l’équation 4.1, nous emploierons en général des méthodes itératives. Dans
ces méthodes l’idée de base est de partir d’une approximation initiale de la solution que
l’on améliore au fil des itérations. La structure de base d’un algorithme ou procedé itératif
est la suivante :
x(1) = x0;
k = 1;
while( f(x(k)) ~= 0)
calculer la nouvelle approximation x(k)
k = k+1;
end
Nous présenterons plus loin un exemple d’algorithme itératif. L’intuition dans ces procedés
toutefois est de projeter toujours la solution locale que l’on dans une direction sur laquelle
on pense que se trouve la solution finale. Il est aussi important de noter qu’en général, l’on
27
peut désirer une solution approchée de l’équation f (x) = 0 en s’autorisant une tolérance
tol. Dans ce cas, la boucle while devient : while(abs(f (x(k))) > tol).
4.1.2 Convergence
Dans l’exécution d’un procedé itératif, à chaque étape, une erreur peut être calculée. A
la kième itération, si x∗ est la solution exacte alors l’erreur que l’on a est de ek = x∗ − xk .
L’exécution d’un procedé itératif doit essayer de minimiser la grandeur cette erreur. On a
le résultat suivant sur l’erreur que l’on peut avoir sur un procedé itératif.
Definition 4.1.1 On dira qu’un procedé itératif converge, si lim |ek | = 0
k→+∞
Par exemple si l’on a |ek | ≥ |ek+1 | pour toutes les valeurs de k, alors il est possible qu’à
une itération le procedé itératif converge.
Lorsque quelque soit la valeur de l’approximation initiale, le procedé itératif va converger,
on dit qu’il est alors robuste. Si la différence entre ek et ek+1 est très grande (en parti-
culier |ek | >> |ek+1 |) alors, on dit que la convergence est rapide. Si à une itération, on
a |ek | < |ek+1 | alors on dira qu’à cette itération ou à partir de cette itération (si cela se
répète), le procedé diverge.
En pratique, il est important de pouvoir détecter si un procedé intératif converge ou

pas au risque de l’exécuter indéfiniment. A partir de l’information ci dessus, il est difficile
d’établir un tel résultat dans la mésure ou il faudrait à priori connaı̂tre la solution exacte
pour estimer ek . Une approche qui peut être utilisée dans ce cas consiste à observer les
différences ∆k = xk − xk−1 . En effet, si le procedé converge, alors lorsque l’on sera près de
la solution, l’on aura |∆k | ≃ |∆k+1 |. Ceci est déduit de la relation lim |ek | = 0 qui suggère
k→+∞
qu’en cas de convergence, le procedé va vers une stagnation.
La vitesse de convergence d’un procedé itératif peut être caractérisé. En particulier, on

distinguera :
1. Les convergences linéaires
2. Les convergences quadratiques
Definition 4.1.2 Supposons qu’il existe une constante CL telle que : ∆k+1 ≃ CL ∆k , ∆k ≃
CL ∆k−1 , . . . . Le procedé itératif sera dit linéairement convergent si |CL | < 1 et linéairement
divergent si |CL | > 1.
On pourra aussi établir une convergence ou divergence linéaire à partir du rapport
ek+1
ek ≃ CL .
Definition 4.1.3 Supposons qu’il existe une constante CQ telle que : ∆k+1 ≃ CQ (∆k )2 ,
∆k ≃ CQ (∆k−1 )2 , . . . ; Le procedé itératif sera dit dans ce cas quadratiquement convergent.
On a aussi une convergence quadratique si ek ≃ CQ (ek−1 )2
Dans la suite de ce cours, nous allons présenter plusieurs algorithmes itératifs pour la
résolution de l’équation f (x) = 0.
28
4.2 Méthode de la bissection
La méthode de la bissection est basée sur l’observation suivante : Considérons une fonc-
tion f qui est continue et qui s’annule une seule fois dans l’intervalle [a, b]. Dans ce cas, il
est certain que l’on a f (a).f (b) < 0. Ce résultat est connu sous le nom de théorème des
valeurs intermédiaires.
f(a) < 0
f(b) > 0
a
b
y = f(x)
Fig. 4.1 – Illustration des valeurs intermédiaires
Ce résultat peut être exploitée pour trouver la racine de f dans [a, b] en essayant de
réduire l’intervalle initial. En effet si f (a).f (b) < 0 alors on sait qu’il existe un d tel que la
fonction f s’annule dans l’intervalle [a, d] avec d < b. On peut généraliser cette observation
comme suit pour retrouver une racine de f
a+b
1. On calcule c = 2
2. Si f (c) = 0 alors la solution est trouvée
3. Si f (c) 6= 0 et f (c).f (b) < 0 alors on pose a = c et on revient en 1
4. Si f (c) 6= 0 et f (c).f (a) < 0 alors on pose b = c et on revient en 1
On peut ainsi développer un algorithme itératif pour la recherche des racines d’une fonction.
La condition d’arrêt dans l’algorithme peut être l’obtention d’un intervalle de petite taille
dans lequel la fonction s’annule. On obtient ainsi l’algorithme suivant :
function [a,b] = Bissection(a,b,f,tol)
% Méthode de la bissection
while(abs(a-b) > tol)
c = (a+b)/2;
fc = f(c); fa = f(a); fb = f(b);
if( c == a | c == b)
return;
end
if(fc == 0)
29
a = c;
b = c;
return
else
if(fc*fb < 0)
a = c;
else
b = c;
end
end
end
return;
La solution finale dans la méthode de la bissection est la valeur c = (a + b)/2.
Exercice : Implémenter une procédure pour calculer une racince de f (x) = 1./cosh(x)−
cos(x) avec la méthode de la bissection dans l’intervalle [3, 5]. Prendre tol = 1e − 5.
4.2.1 Convergence de la méthode

Dans la méthode de la bissection à chaque étape, l’intervalle de convergence est divisé
par deux. Après k étapes l’intervalle dans lequel on cherche une solution a une longueur
au plus de b−a
2k
. Soit xk−1 , xk et xk+1 les approximations que l’on a aux étapes k − 1, k et
k + 1. On peut noter que ∆k+1 ≤ |b−a| 2k
car l’intervalle à l’étape k + 1 est contenu dans celui
l’étape k. Aussi on a globalement |ek | ≃ 2−n |e0 |. Or, l’on sait que si on a une convergence
linéarire alors |ek | ≃ CL |ek−1 | soit alors |ek | ≃ CLk |e0 |. On peut facilement en déduire que la
méthode de la bissection converge linéairement.
En pratique, l’une des difficultés dans l’application de la méthode de la bissection est dans
la détermination de l’intervalle initial dans lequel se trouve la solution. Nous ne traiterons
toutefois pas ce problème dans le cadre de ce cours.
4.2.2 Méthode de la fausse position

Une approche similaire à la méthode de la bissection est l’approche de la fausse po-
sition. Comme dans la méthode de la bissection on suppose que l’on a une fonction qui
s’annule dans l’intervalle [a, b]. Toutefois ici, l’on calcule la prochaine approximation en
prenant l’intersection entre la sécante qui passe par les points [a, b] et l’axe des abscisses.
On peut facilement vérifier que cette méthode converge en arithmétique exacte. Toutefois
à la différence de la méthode de la bissection, la convergence ici sera typiquement super
linéaire (donc plus rapide que la méthode de la bissection) mais pas toujours.
Exercice : Donner la forme générale de l’itération de la méthode de la fausse position
et montrer que celle ci a une convergence super linéaire.
Implémenter les méthodes de la bissection et de la fausse position sur f (x) = x2 − 78.8 en
prenant a = 6 et b = 12. A partir de quelle itération a t’on une tolérance atteinte de 1e − 5
dans chacune ds méthodes ?
30
4.3 L’approche du point fixe
Nous nous intéressons dans cette partie à la contruction des procedés itératifs conver-
gents. Supposons que l’on a une fonction g(x) qui est continue. On peut utiliser celle ci pour
chaque fois calculer les nouvelles approximations. On a donc les relations
x1 = g(x0 ), x2 = g(x1 ), . . . , xk+1 = g(xk ).
Si avec cela le procedé itératif converge alors si x∗ est a solution, l’on aura donc g(x∗ ) = x∗ .
La valeur x∗ est dans ce cas le point fixe dans le procedé. En prenant par exemple x = 0.7
et g(x) = 12 ex/2 , on a la table des itérations suivantes :
k xk = g(xk−1 ) ∆k
1 0.7 0.009534
2 0.709534 0.003390
.. .. ..
. . .
6 0.714775 0.00...
Tab. 4.1 – Exemple d’itérations du point fixe
Intéressons nous maintenant à la convergence d’une méthode de point fixe. Nous sup-
posons que la fonction g est continue et dérivable au moins jusqu’à l’ordre 3. Nous avons
alors les résultats suivants :
1. Si g ′ (x∗ ) 6= 0 alors ∆k+1 ≃ g ′ (x∗ )δk pour xk ≃ x∗ . Aussi, On a une convergence
linéaire si 0 < |g ′ (x∗ )| < 1 et une divergence linéaire si |g ′ (x∗ )| > 1.
2. Si g ′ (x∗ ) = 0 alors ∆k+1 ≃ − 21 g ′′ (x∗ )∆k pour x ≃ x∗ . Aussi, on a une convergence
quadratique avec CQ = − 12 g ′′ (x∗ )
Ces résultats peuvent être obtenus à partir de la formule de Taylor pour le calcul des
développements limités. Posons en effet xk = x∗ − ek . En utilisant le développement de
Taylor à l’ordre 2, on a alors g(xk ) = g(x∗ − ek ) = g(x∗ ) − g ′ (x∗ )ek + 21 g ′′ (x∗ )e2k − 61 g ′′′ (µ)e3k
avec µ une valeur entre xk et x∗ . Or, g(x∗ ) = x∗ et g(xk ) = xk+1 . Aussi, on a :
ek+1 = x∗ − xk+1 = g ′ (x∗ )ek − 21 g ′′ (x∗ )e2k + 16 g ′′′ (µ)e3k . Quand xk se rapproche de x∗ , on
a |ek | >> |ek |2 >> |ek |3 . En négligeant les derniers termes du développement limité, on a
e ′ ∗ ′ ∗ ek+1 1 ∗
alors k+1ek ≃ g (x ). De même si g (x ) = 0, on a alors e2k ≃ − 2 g””(x ).
Pour obtenir le résultat final, il faut noter que ∆k = xk+1 − x∗ + x∗ − xk = ek − ek+1 .
∆ e 1−ek+2 /ek+1 1−CL
Aussi ∆k+1 k
= k+1 ek ( 1−ek+1 /ek ) → CL 1−CL . On peut procéder de même pour établir les
convergences quadratiques.
La difficulté principale dans l’approche du point fixe consiste à déterminer la fonction
g telle que sur le point fixe où elle converge, la fonction f s’annule. Nous allons voir dans
certains cas comment déterminer cette fonction.
31
b
c a
Fig. 4.2 – Méthode de la fausse position
P0
y = g(x)
P1
P2
P∗ P3
x2 x1 x0
Fig. 4.3 – Représentation géométrique de la méthode du point fixe
32
4.3.1 La méthode de Newton-Raphson
La méthode de Newton-Raphson est l’une des méthodes de point fixe les plus utilisées.
Elle est encore appelée la méthode de la tangente à cause de sa formulation géométrique.
La formulation géométrique de cette approche est illustrée dans la figure ci dessous :
C B
x3 x2 x1 x0
Fig. 4.4 – Illustration géométrique de la méthode de Newton-Raphson
Dans cette illustration, on part d’une approximation initiale x0 , de la solution. On trace

la tangente au point x0 et son interception avec l’axe des abscisses nous donne un point x1 .
On applique le même procedé pour obtenir le nouveau point x2 . A partir de cette formule,
on peut établir la relation qui permet de passer d’un point xi au point xi+1 . Dans le cas
du passage entre x0 et x1 par exemple, on note que tan ACB \ = BA . Or, BA = f (x0 ),
BC
\ ′ f (x0 )
BC = x0 − x1 et tan ACB = f (x0 ). On a donc x1 = x0 − f ′ (x0 ) . On déduit donc que de
façon générale, le point xk dans l’itération de Newton peut être déduit par la formule :
f (xk )
xk+1 = xk −
f ′ (xk )
La forme générale de l’itération de Newton-Raphson est bien une itération de point fixe
avec g(x) = x − ff′(x)
(x) . On peut donc adopter comme critère d’arrêt dans l’exécution de cet
algorithme la condition |xk − xk−1 | ≤ tol avec une tolérance tol fixée.
La méthode de Newton peut aussi être dérivée de façon analytique à partir du développement
limité de Taylor. Dans ce développement en effet, on peut supposer que si x est proche de
x0 alors on a :
1
f (x) = f (x0 ) + f ′ (x0 )(x − x0 ) + f ′′ (ζ0 )(x − x0 )2
2
33
Aussi si la valeur x0 est dans le voisinage de x∗ alors on peut conclure que la fonction
f¯(x) = f (x0 ) + f ′ (x0 )(x − x0 ) donne une approximation de f (x∗ ). Dans ce cas alors, on
peut prendre f¯(x) = 0 car f (x∗ ) = 0 et on obtient alors la relation précédente.
Pour illustrer la méthode de Newton-Raphson, considérons le calcul de la racine nieme

d’une valeur c. Pour appliquer la méthode de Newton, il nous faut transformer le calcul
de cette valeur en la résolution d’une équation. Cela est obtenu en considérant la fonction
√
f (x) = xn − c. En effet, celle ci s’annule lorsque x = n c. Dans ce cas donc l’itération de
xn −c
Newton que l’on considèrera a la forme générale : xk+1 = xk − nxkn−1 . En prenant c = 78.8
k
et x0 = 14, on obtient la succession des approximations suivantes : En supposant que f et
k xk = g(xk−1 ) ∆k
1 9.814286 −0.892587
2 8.921699 −0.044650
3 8.877049 −0.000113
4 8.876936 −0.0...
Tab. 4.2 – Méthode de Newton
f p sont la fonction et la dérivée de la fonction dont on cherche les racines, la méthode de

Newton-Raphson peut être implémentée comme suit :
function [x,err] = Newton(x0,tol,f, fp)

% Méthode de Newton-Raphson
x1 = x0;
x = x1 - f(x1)/fp(x1);
while(abs(x-x1) > tol)
x = x1 - f(x1)/fp(x1);
end
err = abs(x-x1);
return;
Convergence de la méthode
La méthode de Newton-Raphson est une approche du point fixe dans laquelle l’on a
f ′ (x)2 −f ′′ (x)f (x)
g(x) = x − ff′(x) ′ ′
(x) . En calculant g (x), on obtient : g (x) = 1 − f ′ (x2 )
. g ′ (x∗ ) =
′ 2
1 − f f(x) −0 ′ ∗
′ (x)2 . Aussi, g (x ) = 0. On déduit àn partir de la section 4.3 que la convergence de
la méthode de Newton est quadratique. Toutefois, noter que ce résultat n’est valable qu’en
considérant que les approximations que l’on a initialement se trouvent au voisinage de la
solution que l’on cherche. Aussi même si la convergence de la méthode de Newton-Raphson
est quadratique, elle sera dans plusieurs cas moins robuste que la méthode de la bissection
car plus sensible à la qualité de l’approximation initiale.
34
Exercice : Implémenter la méthode de Newton-Raphson et appliquer la pour le calcul
de la racine cubique de a = 3.333. Prendre x0 = 1.42 comme approximation initiale. Prendre
tol = 1e − 7.
4.3.2 La méthode de la sécante

Dans certaines situations il peut être difficile d’appliquer la méthode de Newton-Raphson
en particulier à cause de la détermination de la fonction f ′ (x). Dans ces cas, on peut
utiliser une approximation de la dérivée. En général, la dérivée en un point xk peut être
approximer par la fonction f ′ (xk ) = f (xk )−fh(xk −h) avec h une petite valeur. En supposant
que xk − h = xk−1 , on peut donc dériver l’itération de la sécante qui a la forme générale
f (xk )(xk − xk−1 )

xk+1 = xk −
f (xk ) − f (xk−1 )
La méthode de la sécante peut aussi être dérivée géométriquement comme celle de

Newton-Raphson. Pour cela il faut prendre la prochaine appproximation à calculée à partir
de l’intersection entre la sécante passant par les points (xk , f (xk )) et (xk−1 , f (xk−1 )). Ceci
est illustrée ci dessous.
x2 x1 x0
Fig. 4.5 – Illustration géométrique de la méthode de la sécante
La méthode de la sécante ne correspond pas exactement à une méthode du point fixe

dans la mésure où elle génére le second point en utilisant deux points au lieu d’un seul.
Aussi, on ne peut pas lui appliquer l’analyse de la convergence pour les méthodes du point
fixe. On√ peut toutefois établir théoriquement que cette méthode converge avec un ordre de
p = 1+2 5 . On peut établir cela en effectuant les développements limités de f (xk ) et f (xk−1
à l’ordre 2 et en calculant avec les développements la valeur de x∗ − xk+1
35
4.4 Accélération de la convergence par la méthode d’Aitken
L’observation d’Aitken est que si un algorithme A converge exactement de façon linéaire,
alors il est possible de déduire les approximations qui seront calculées à partir d’une ob-
servation des solutions approchées sur quelques itérations sans utiliser l’algorithme A. Par
exemple si on a x0 = 2, x1 = 2.1, x2 = 2.11, x3 = 2.111, on peut déduire que l’on aura
x4 = 2.1111, x5 = 2.11111, . . . . Cette observation nous donne l’intuition pour accélérer le
processus de convergence d’un algorithme en calculant l’approximation xk+h à partir de xk .
Supposons maintenant qu’un algorithme itératif converge à partir de l’itération k − 2
vers x∗ . alors on a
x∗ − xk−2 = −(xk−2 − xk−1 + xk−1 − xk + xk − xk+1 + . . . )

= −(−∆k−1 − ∆k − ∆k+1 + . . . )
Or, ∆k−1 ≃ ∆k−2 car on converge à partir de l’itération k − 2. On en déduit :
x∗ − xk−2 = ∆k−2 + CL ∆k−2 + CL2 ∆k−2 + . . .

= ∆k−2 (1 + CL + CL2 + . . . )
1
= ∆k−2 1−C L
∆ ∆2
En posant CL = ∆k−2 k−1
, on obtient x∗ = xk−2 − ∆k−1k−2−∆k−2
La formule d’Aitken peut être utilisée pour accélerer la convergence de n’importe quel
algorithme qui converge linéairement. Pour cela, il suffit de disposer de deux approximations
successives calculées par l’algorithme. A partir de xk−2 , xk−1 , la prochaine approximation
∆2k−2
peut être dérivée suivant la relation xk = xk−2 − ∆k−1 −∆k−2
36
Chapitre 5
Interpolation numérique
5.1 Introduction
Ce chapitre est consacré à l’approximation d’une fonction par la technique de l’interpo-
lation numérique. L’approximation des fonctions a beaucoup d’applications dans les disci-
plines scientifiques. Elle est motivée en général par le contexte suivant : On suppose qu’un
observateur recueille des données à différents points (x1 , y1 ), (x2 , y2 ), . . . , (xk , yk ). A partir
de ces données, il aimerait déterminer la fonction générale f telle que f (xi ) ≃ yi .
L’intérêt de déterminer une telle fonction pour lui est celui de pouvoir a posteriori construire
des points quelconques (xk+i , yk+i ) à partir de son observation intiale. Ce contexte générale
se retrouve dans plusieurs disciplines scientifique comme la dynamique des polulations, l’as-
trophysique, la météorologie, en océanographie etc. Il existe au moins deux approches pour
résoudre ce problème. Dans la première approche, on cherche dans l’ensemble des fonctions
continues la fonction f qui miminise la somme des erreurs que entre les f (xi ) et yi . Dans la
seconde approche, on cherche f parmi l’ensemble des polynômes. Cette dernière approche
est celle de l’interpolation numérique.
Dans ce chapitre, nous allons voir différentes approches de construction d’un polynome d’in-
terpolation donnant en tous les xi la valeur yi . En particulier, nous aborderons les approches
de Lagrange, de Newton et par splines pour la construction d’un tel polynôme.
5.2 Interpolation de Lagrange

5.2.1 Forme générale
Etant donnés k points (x1 , y1 ), (x2 , y2 ), . . . , (xk , yk ), l’approche de Lagrange pour l’in-
terpolation consiste à déterminer un polynôme Pk tel que Pk (xi ) = yi , i ∈ {1, . . . , k}.
Pour construire un tel polynôme, Lagrange décide d’adopter la forme générale suivante :
Pk (x) = y1 L1 (x) + y2 L2 (x) + · · · + yk Lk (x). Les Li ici sont tels que
(
1 si j = i
Li (xj ) =
0 sinon.
37
Dans cette forme on peut bien vérifier que Pk (xi ) = yi . Pour terminer cette forme, il faut
déterminer la valeur des Li . Il est par ailleurs important de noter qu’idéalement chacun des
Li doit être un polynôme. Pour déterminer les Li , considérons le cas où l’on a uniquement
deux points (x1 , y1 ), (x2 , y2 ). La forme de Pk dans ce cas est : Pk (x) = y1 L1 (x) + y2 L2 (x).
L1 doit obéir aux conditions : L1 (x1 ) = 1, L1 (x2 ) = 0. En prenant L1 (x) = xx−x 2
1 −x2
on a bien
x−x1
les conditions sur L1 respectées. De même, on peut déduire que L2 = x2 −x1 .
Le résultat que nous avons sur deux points peut être généralisé sur k points. En effet, il
suggère que pour constuire Li , on prenne une forme Li (x) = A(x) B . Dans cette forme, pour
garantir que Li (xj ) = 0, on introduit le facteur (x − xj ). Lorsque l’on a Li (xi ) on
doitavoir
x−xj
simplement Ai (xi ) = B. On en déduit la forme générale des Li (x) = Π xi −xj .
1≤j≤k,j6=i
Pour illustrer le polynôme de Lagrange, considérons les points (0, 5), (1, 8), (2, 1), (4, 5)
à interpoler. Le polynôme de Lagrange qui en résulte est
P4 (x) = 5 (x−1)(x−2)(x−4) (x−0)(x−2)(x−4)

(−1)(−2)(−4) + 8 (1)(−1)(−3) + 1 (x−0)(x−1)(x−4)
(2)(1)(−2) + 5 (x−0)(x−1)(x−2)
(4)(3)(2) .
On obtient donc P (x) = 2x3 − 11x2 + 12x + 5.
5.2.2 Dégré du polynôme

Intéressons nous maintenant au dégré du polynôme de Lagrange. En k points, le polynôme
de Lagrange
a la forme générale Pk (x) = y1 L1 (x) + y2 L2 (x) + · · · + yk Lk (x) avec Li (x) =
x−xj
Π xi −xj . Dans cette forme, on peut noter que le dégré du polynôme est déterminé
1≤j≤k,j6=i
par celui des Li (x). Chaque Li (x) est de la forme AB i (x)
i
. Dans cette forme, Bi est une con-
stante et Ai (x) est composé de k − 1 facteurs (x − xj ). On en déduit que chaque Li (x) est
de dégré au plus k − 1. Aussi, le polynôme d’interpolation de Lagrange en k points est de
dégré au plus égal à k − 1.
Il est important de noter que le dégré de ce polynôme n’est pas toujours égal à k − 1. Par
exemple sur deux points le polynôme d’interpolation de Lagrange donnera une droite. Si
par contre on a trois points qui tous appartiennent à une droite, le polynôme qu’on aura
après interpolation sera à nouveau une droite. En prenant par exemple les points (1, 1) et
(2, 2), on déduit P2 (x) = x après interpolation de Lagrange. Si on considère maintenant
(1, 1), (2, 2) et (3, 3, on aura à nouveau le polynôme P3 (x) = x.
Le résultat sur le dégré de P indique qu’il est possible donc de retrouver le polynôme de
Lagrange en supposant la forme générale Pk (x) = ak xk−1 + ak−1 xk−1 + · · · + a0 et en recher-
chant les valeurs des ai en posant successivement Pk (xi ) = yi . Nous allons aussi utiliser ce
résultat dans la suite pour établir l’unicité du polynôme de Lagrange.
5.2.3 Unicité du polynôme

Etant donné un polynôme p(x), p(x) possède n racines distinctes r0 , . . . , rn−1 si et seule-
ment si p(x) contient le produit Π x − ri comme un facteur. Aussi, si le dégré de p(x)
0≤j≤n−1
est plus petit que n alors p ne peut être que le polynôme nul (car le dégré de Π x − ri
0≤j≤n−1
38
est n). Supposons maintenant qu’il existe deux polynômes Pk (x) et Pk′ (x) de dégré au plus
k − 1 qui interpolent k points. Considérons alors Ek (x) = Pk (x) − Pk′ (x). Ek (x) est un
polynôme de dégré au plus k − 1. En chacun des xi , on a Ek (xi ) = 0. Aussi, Ek est un
polynôme de dégré au plus k − 1 qui a k racines. On en conclut que Ek est le polynôme
nul et donc Pk (x) = Pk′ (x). L’unicité du polynôme de Lagrange indique que quelque soit
l’approche que l’on utilise dans l’interpolation de k points, si celle ci dérive un polynôme
de dégré au plus k, il serait alors unique. Toutefois, cela ne signifie pas que l’on ne peut
pas trouver de polynômes de dégré plus grand que k − 1 ? Supposons par exemple que nous
construisons un polynôme pour k points. Celui ci peut être de dégré k − 1, mais reste aussi
un polynôme d’interpolation pour les sous ensembles de k − 1, k − 2 points dans l’ensemble
des points considérés.
Dans la suite, nous allons voir une autre approche permettant de construire les polynômes
d’interpolation.
Exercice : Comment peut on simplifier la forme de Lagrange lorsque les xi sont
équidistants (xi = xi−1 + h)
5.3 Interpolation de Newton

5.3.1 Les différences divisées
L’approche d’interpolation de Newton est basée sur l’observation suivante. Supposons
que le polynôme d’interpolation s’écrive sous la forme Pk (x) = a0 + a1 (x − x0 ) + a2 (x −
x0 )(x − x1 ) + · · · + ak (x − x0 )(x − x1 ) . . . (x − xk−1 ). En posant Pk (x0 ) = y0 , on a a0 = y0 . De
même Pk (x1 ) = y1 d’où y0 + a1 (x1 − x0 ) = y1 soit a1 = xy11 −y −x0 . De même, on peut déduire
0

1 y2 −y0 y1 −y0
que a2 = x2 −x 1 x2 −x0 − x1 −x0 . Ces résultats donnent l’intuition de la notion de différence
divisée. Supposons que l’on une fonction f à interpoler.
Definition 5.3.1 On définit les différences divisées de la fonction f par : f [xi ] = f (xi ),
f [x ,...,xi+h ]−f [xi ,...,xi+h−1 ]
f [xi , xi+1 ] = f (xxi+1 )−f (xi )
i+1 −xi
. De façon générale, on a f [xi , xi+1 , . . . , xi+h ] = i+1 xi+h −xi
On peut établir par recurrence que pour la fonction f , les coefficients ai = f [x0 , x1 , . . . , xi ].
Aussi le calcul des différences divisées nous permet d’obtenur un polynôme d’interpolation.
Exercice : Etablir que les différences divisées correspondent effectivement aux coef-
ficients ai . Procéder dans le raisonnement par récurrence ; Supposer à l’ordre k − 1 que
l’on a un polynôme qui interpole (x0 , f (x0 )), (x1 , f (x1 )), . . . , (xk−2 , f (xk−2 )) et un autre qui
interpole les points (x1 , f (x1 )), (x2 , f (x2 )), . . . , (xk−1 , f (xk−1 )).
On peut noter que par l’approche des différences divisées, le polynôme d’interpolation
qu’on a en k points est d’ordre au plus k − 1. Aussi, on en déduit que le polynôme d’in-
terpolation issu des différences divisées (polynôme d’interpolation de Newton) correspond
exactement au polynôme d’interpolation de Lagrange.
39
5.3.2 Table des différences divisées
L’intérêt des différences divisées est qu’elles offrent la possibilité de développer une
approche automatique simple pour calculer le polynôme d’interpolation. Cela est possible
notamment en considérant la table des différences divisées. La table des différences divisées
a la structure générale suivante.
x0 f [x0 ] ...
x1 f [x1 ] f [x0 , x1 ] ...
x2 f [x2 ] f [x1 , x2 ] f [x0 , x1 , x2 ] ...
x3 f [x3 ] f [x2 , x3 ] f [x1 , x2 , x3 ] ...
.. .. .. .. ..
. . . . .
xk−1 f [xk−1 ] f [xk−2 , xk−1 ] f [xk−3 , xk−2 , xk−1 ] ...
Tab. 5.1 – Table des différences divisées
La table des différences divisées comporte k + 1 colonnes et k lignes. Ceci indique que
les différences divisées peuvent être stockées dans une matrice comportant k lignes et k + 1
colonnes. La table des différences divisées peut être calculée en procédant itérativement
colonnes après colonnes. Les deux premières colonnes sont données en entrée. En supposant
que D désigne la matrice des différences divisées, ceci signifie que les colonnes D(:, 1) et
D(:, 2) sont des données initiales. La troisième colonne peut être calculée à partir des deux
D(i,2)−D(i−1,2)
premières colonnes. En particulier, D(i, 3) = D(i,1)−D(i−1,1) . Dans cette relation, i > 1. On
peut généraliser cette relation pour une colonne n quelconque. Dans ce cas, on aura :
D(i,n−1)−D(i−1,n−1)
D(i, n) = D(i,1)−D(i−(n−2),1)
Dans cette relation, on doit avoir i > n − 2

Exercice :
1. Proposer un algorithme pour le calcul des différences divisées et en déduire une fonc-
tion interpNewton(X,Y,x) qui étant donné k points X et Y et une valeur x donné
donne la valeur du polynôme d’interpolation passant pas (X(1), Y (1)), (X(2), Y (2)), . . .
en x. Evaluer sa complexité.
2. Proposer une implémentation de l’interpolation de Lagrange et évaluer sa complexité
dans l’estimation de f (x) pour un x quelconque
5.4 Interpolation inverse

L’interpolation inverse est motivée par la situation suivante : supposons que nous avons
k points (x0 , y0 ), (x1 , y1 ), . . . , (xk−1 , yk−1 ). On peut supposer qu’il existe une fonction f (que
l’on ne connaı̂t pas) telle que f (xi ) = yi . Supposons maintenant que sur une valeur b, nous
voulons déterminer a tel que f (a) = b. Pour aborder ce problème deux approches sont
envisageables :
40
1. On peut calculer le polynôme d’interpolation Pk et résoudre l’équation non linéaire
Pk (x) = b. La résolution d’une telle équation peut être faite en utilisant un procedé
itératif non linéaire.
2. On peut calculer le polynôme d’interpolation inverse Pk−1 qui correspond à la fonction
f −1 et déterminer ensuite a = f −1 (b).
La première approche débouche sur la résolution d’une équation non linéaire qui pourrait
être sujette à des problèmes de convergence. La seconde approche comme la première com-
porte le coût lié à la construction d’un polynôme d’interpolation. Une fois cela fait néanmois,
la détermination de la valeur de a se fait par une simple évaluation de ce polynôme en b.
Si la seconde approche (construction du polynôme d’interpolation inverse semble à pri-
ori plus efficace) que la première, il faut noter que les erreurs induites dans le calcul des
différences divisées peuvent avantager la première. Supposons par exemple que les valeurs
xi sont petites et proches. En réalisant l’interpolation inverse, on aura dans le calcul de cer-
taines différences divisées une division à opérer sur des valeurs petites et qui potentiellement
sont érronées. Si cette erreur est très importante, l’erreur dans le polynôme d’interpolation
inverse peut alors être très importante.
5.4.1 Ordre des points dans l’interpolation

Le constat précédent indique aussi que dans la réalisation du polynôme d’interpola-
tion, il peut être intéressant d’ordonner de façon intelligente les points de sorte à lim-
iter les erreurs induites par le calcul. Supposons par exemple que nous avons k points
(x0 , y0 ), (x1 , y1 ), . . . , (xk−1 , yk−1 ). Si les valeurs x0 et x1 sont très proches et petites, alors, il
est préférable de réaliser l’interpolation en se donnant l’ordre (x0 , y0 ), (x2 , y2 ), . . . , (xk−1 , yk−1 ), (x1 , y1 ).
L’intérêt de cet ordre est que le calcul de la différence x1 − x0 intervient uniquement dans
les dernières différences divisées. Les erreurs qu’il comporte se propagent donc moins.
En règle générale, il est difficile de définir une stratégie efficace pour ordonner les points dans
l’interpolation. Une approche pour ordonner les points peut consister à trier dans un premier
tant l’ensemble des points sur les xi . On obtient alors les points (x′0 , y0′ ), (x′1 , y1′ ), . . . , (x′k−1 , yk−1 ′ ).
On mixe ensuite les points en permuttant avec un pas de 1, les points de la permière
moitié de cette liste avec ceux situés à une distance de k/2. On obtient alors les points
(x′0 , y0′ ), (x′k/2+1 , yk/2+1
′ ), (x′2 , y2′ ), . . . , (x′k−1 , yk−1
′ ). Dans les premières étapes du calcul, cet
ordre limite la propagation des erreurs dans les calculs. Celle ci apparaı̂t néanmois assez
rapidement. On peut envisager une généralisation de l’approche en morcelant la suite triée
non pas en 2 mais en m > 2. Dans ce cas on peut utiliser un pas dans la substitution plus
grand que 2. En la morcelant par exemple en m, on aura par exemple un ordre de la forme
(x′0 , y0′ ), (x′m+1 , ym+1
′ ), (x′2m+1 , ym+1 ′ ), . . . , (x′k−1 , yk−1
′ ).
La notion d’ordre dans les points d’interpolation est aussi liée au problème du choix des
points d’interpolation. Etant donnés un ensemble de points, une question pour la construc-
tion d’un polynôme d’interpolation est celle de savoir comment ceux ci doivent être choisis.
Plusieurs stratégies sont à ce niveau envisageables. On peut par exemple décider de prendre
les points de façon équidistantes. Dans ce cas, on aura xi = xi−1 + h. D’autres stratégies
41
sont aussi recommandées comme celle de prendre les points de Chebyshev.
5.5 Interpolation par splines

Etant donnés un ensemble de points, nous avons jusqu’à présent recherché un polynôme
d’interpolation qui en chaque point xi renvoie yi . Dans cette approche on cherche un
polynôme unique pour l’ensemble des points. Une autre approche pour l’interpolation con-
siste à chercher une fonction d’interpolation par intervalles. En particulier, supposons que
l’on a des points (x1 , y1 ), (x2 , y2 ), . . . , (xk , yk ). Supposons aussi que l’on a x1 < x1 < · · · <
xk . On peut pour chaque intervalle [xi xi+1 ] construire une fonction qi d’interpolation. Dans
cette approche la fonction générale d’interpolation sur l’intervalle [x1 , xk ] est une fonction
S(x) telle que S(x) = qi (x) si x ∈ [xi , xi+1 ]. Ceci est l’approche utilisée dans l’interpolation
par les splines.
5.5.1 Spline cubiques d’interpolation

Pour effectuer l’interpolation par intervalles, on peut procéder en construisant une droite
dans chaque intervalle [xi , xi+1 ]. Cette approche a l’inconvénnient de ne pas s’adapter aux
différentes courbures qui peuvent exister dans la fonction f . Une approche alternative consite
à supposer que dans l’intervalle [xi , xi+1 ], la fonction f est une courbe que l’on peut par
exemple approcher par une courbe cubique. Cette approche est celle des splines cubiques
d’interpolation.
y = q1(x) Pk−2
P0 P3 Pk−1 y = qk−1(x)
P2
P1
Pk
Fig. 5.1 – Illustration des splines d’interpolation
5.5.2 Equations de base

Supposons que l’on veut interpoler les points dans l’intervalle [x0 , xk ], avec les splines
cubiques d’interpolation, on cherche une fonction S telle que :
S(x) = qi (x)si x ∈ [xi , xi+1 ]

′
S (x) = qi′ (x)si x ∈ [xi , xi+1 ]
S”(x) = qi ”(x)si x ∈ [xi , xi+1 ]
42
On peut noter que les dérivées premières et seconde avec les splines ne sont pas neces-
sairement nulles car chaque qi est une fonction cubique. De plus, on a :
qi (xi+1 ) = qi+1 (xi+1 )

qi′ (xi+1 ) = ′ (x
qi+1 i+1 ) qi et qi+1 ont la même tangente en xi+1
qi ”(xi+1 ) = qi+1 ”(xi+1 ) qi et qi+1 ont la même courbure en xi+1
Pour déterminer qi , on note que qi ”(x) est une droite

qui passe
par les points
(xi , s”(x
i ))
x−xi+1 x−xi
et (xi+1 , s”(xi+1 )). Aussi, on a : qi ”(x) = S”(xi ) xi −xi+1 + S”(xi+1 ) xi+1 −xi avec
i = 0, . . . , k − 1. En posant hi = xi+1 − xi et mi = S”(xi ), on a qi ”(x) = m
hi (xi+1 − x) +
i
mi+1 3 3
hi (x−xi ). En intégrant, on déduit que qi (x) = mi (xi+1
6hi
−x)
+mi+1 (x−x i)
6hi +ai (x−xi )+bi )
avec ai et bi des constantes. Les inconnues dans cette expression sont les mi ai et bi .
mi h2i
De qi (xi ) = yi , on déduit que yi = 6 + bi (1). De qi+1 (xi ) = yi+1 , on déduit yi+1 =
mi+1 h2i
6 + ai hi + b (2). q ′ étant continu, on a qi′ (xi ) = −mi h2i + ai = mi hi−1 ′
2 + ai−1 = qi−1 (xi )
(3).
1 hi
En faisant (1) dans (2) on a ai = hi (yi+1 −yi )− 6 (mi+1 −mi ) En remplaçant les ai dans

(3), on obtient hi−1 mi−1 + 2(hi + hi−1 )mi + hi mi+1 = 6 h1i (yi+1 − yi − hi−1
1
(yi − yi−1 )).
Grace à cette équation, on peut dériver les mi en posant cette équation pour toutes les
valeurs possibles de i. On obtiendra ainsi un de k − 1 équations. Or, l’on a k + 1 inconnues.
En pratique donc, on procède en considérant qu’aux frontières, l’on connait la valeur des
mi . En particulier, dans le cas des splines cubiques naturelles, on pose m0 = mk = 0. On
obtient ainsi un système matricielle de la forme T m = f à résoudre. Cette forme matricielle
peut être résolue en utilisant une approche de résolution des systèmes linéaires comme la
méthode de Gauss ou de Crout.
Exercice : Trouver la spline cubique d’interpolation pour les points (−2, −8), (0, 0), (1, 1), (2, 8)
en supposant que S”(−2) = −12 et S”(2) = 12. Quelle est la spline naturelle correspon-
dante ?
43
Chapitre 6
Résolution des systèmes linéaires
6.1 Introduction
Un système d’équations linéaires a la forme générale Ax = b avec A ∈ Rm×n et x ∈ Rn et
b ∈ Rm . Ici, x est l’inconnu et b le second membre. Un cas particulier des systèmes linéaires
est lorsque m = n. Le système est alors dit carré et d’ordre n (on dit aussi que la matrice
A est d’ordre n).
Exemple : On considère le système d’équations
3x1 + 4x2 =5
2x1 − 6x2 = 10
La formulation matricielle de ce système est la suivante :

3 4 x1 5
=
2 −6 x2 10
Dans celle ci,

3 4 x1 5
A= ,x = ,b =
2 −6 x2 10
La résolution des systèmes d’équations linéaires est l’une des opérations de calcul les
plus utilisées. Elle intervient notamment dans la résolution des problèmes non linéaires et
les problèmes d’optimisation.
6.1.1 Existence de la solution

Nous nous intéressons ici à l’existence d’une solution réelle (x ∈ Rn ). On a les équivalences
suivantes dans la résolution de Ax = b (avec A une matrice carrée).
1. Le système Ax = b a une solution unique
2. ∀x, si Ax = 0 alors x = 0 ou A est la matrice nulle.
3. Les colonnes de A sont linéairement indépendantes
44
4. Il existe une matrice A−1 telle que AA−1 = A−1 A = I avec I étant la matrice identité.
5. det(A) 6= 0
On peut facilement établir que lorsque les colonnes d’une matrice sont linéairement
dépendantes, il existe une infinité de solutions. En prenant exemple sur une matrice de
deux colonnes on peut montrer cela ainsi :
Sur une matrice à deux colonnes si le vecteurs sont liées alors on a α1 , α2 non nuls
avec α1 A(:, 1) + α2 A(:, 2) = 0. On en déduit que le vecteur (α1 , α2 )T est une solution de
l’équation Ax = 0. De même tout vecteur γ(α1 , α2 )T est solution de cette équation. Aussi
si on a une solution x telle que Ax = b alors x + γ(α1 , α2 )T est aussi solution de cette
équation.
6.2 Résolution d’un système diagonal

Un système carré Dx = b est dit diagonal si tout élément externe à la diagonale de la
matrice D est nul. Une matrice diagonale a la forme :
d1,1
 

 d2,2 


 × 

D=  × 


 × 

 × 
dn,n
Un système diagonal admet une solution unique ssi les colonnes de D sont aucun élément
diagonal n’est nul. Si un élément diagonal est en effet nul alors ses colonnes sont linéairement
dépendantes. Cette condition vérifiée, on peut dérivée chaque valeur xi du vecteur solution
par la relation xi = bi /di,i . On en déduit le code suivant pour la résolution d’un système
diagonal :
function x = SolDiag(D,b)
% D est une matrice carrée diagonale
for(i = 1:n)
x(i) = b(i)/D(i,i);
end
return;
Complexité : En comptant le nombre de divisions dans le code ci dessus, on peut

conclure que sa complexité en temps est en O(n).
6.3 Résolution d’un système triangulaire inférieur

Un système Lx = b est dit triangulaire inférieur lorsque tous les éléments au dessus
de la diagonale principale sont nuls. Dans ce système, on a la relation ∀i, j si j > i alors
45
L(i, j) = 0. Une matrice triangulaire inférieure a la forme générale :
l1,1
 
 l2,1 l2,2 
 
× × × 
 
L=×
 × × × 

× × × × × 
 
× × × × × × 
ln,1 × × × × ln,n−1 ln,n
Considérons le système triangulaire inférieur
l1,1 x1 b1
    
 l2,1 l2,2   x2   b2 
    
× × ×   ×  ×
    
× × × ×   ×  = ×
    
× × × × ×   ×  ×
    
× × × × × ×   ×  ×
ln,1 × × × × ln,n−1 ln,n xn bn
On peut déduire l1,1 x1 = b1 =⇒ x1 = b1 /l1,1 . De même l2,1 x1 + l2,2 x2 = b2 =⇒
1
x2 = l2,2 (b2 − l2,1 x1 ) Si x1 est déjà calculé, pour le calcul de x2 toutes les opérandes
1
(bi − i−1
P
sont alors disponibles. De façon générale, on aura xi = li,i j=1 li,j xj ). Si les valeurs
x1 , x2 , . . . , xi−1 sont alors calculées alors toutes le opérandes pour le calcul de xi seraient
alors disponibles. Ainsi, la résolution d’un système triangulaire inférieur peut se faire en
calculant successivement les valeurs x1 , xP 2 , . . . , xn . Chacune de ces valeurs peut être obtenue
de la relation de reccurence xi = li,i 1
(bi − i−1j=1 li,j xj ). Ceci constitue la méthode de substition
avant dont l’algorithme est le suivant :
function x = SubstitutionAvant(L,b)
% L est une matrice carrée triangulaire inférieure
for(i = 1:n)
x(i) = b(i);
for(j = 1:i-1)
x(i) = x(i) - L(i,j)*x(j);
end
x(i) = x(i)/L(i,i);
end
return;
Complexité : On considère comme baromètre l’instruction x(i) = x(i) − L(i,P j) ∗ x(j).

Pour un i fixé, cette instruction est exécutée i − 1 fois. Au total, elle est exécutée ni=1 (i −
1) = (n−1)n
2 . L’algorithme de substitution avant est donc en O(n2 ).
46
6.4 Résolution d’un système triangulaire supérieur
Un système U x = b est dit triangulaire supérieur lorsque tous les éléments en deca
de la diagonale principale sont nuls. Dans ce système, on a la relation ∀i, j si j < i alors
U (i, j) = 0. Un système triangulaire supérieur a la forme générale suivante :
u1,1 u1,2 u1,3 × × × u1,n x1 b1
    

 u2,2 u2,3 × × × ×   x2   b2 
   


 × × × × ×    ×  ×
   

 × × × ×    ×  = ×
   

 × × ×  
 ×  ×
  
 × ×   ×  ×
un,n xn bn
Afin de résoudre ce système on peut noter que un,n xn = bn =⇒ xn = bn /un,n . Si xn est
calculé on peut facilement dériver xn−1 à partir de un−1,n−1 xn−1 + un−1,n xn = bn−1 =⇒
1
xn−1 = un−1,n−1 (bn−1 − un−1,n xn ). De façon générale, si on a calculé xn , xn−1 , . . . , xi+1 on
peut déduire xi avec la relation xi = u1i,i (bi − nj=i+1 ui,j xj ). Ceci constitue la méthode de
P
substitution arrière
Exercice : Ecrire l’algorithme de substitution arrière et analyser sa complexité.
6.5 Résolution d’un système quelconque

Considérons maintenant un système quelconque Ax = b. Par opposition avec ce qui
précède, la matrice d’un tel système n’est ni diagonale, triangulaire inférieure ou supérieure.
Dans le cas des matrices quelconques, le système peut être résolu en utilisant la méthode
d’addition de Gauss (appelée aussi élimination de Gauss). Etant donné un système Ax = b,
cette méthode vise à transformer la matrice A en une matrice triangulaire supérieure à
partir d’une sucession d’addition de lignes de la matrices. Dans cette transformation, le
second membre de l’équation (b) est necessairement modifié. Pour illustrer cela, supposons
que la matrice A comporte 3 colonnes. On a donc à résoudre un système de la forme :
    
a1,1 a1,2 a1,3 x1 b1
a2,1 a2,2 a2,3  x2  , = b2 
a3,1 a3,2 a3,3 x3 b3
Nous nommons L1 , L2 , L3 respectivement, la première, la seconde et la troisème ligne de
la matrice A. Dans la première étape de l’élimination de Gauss, on utilise L1 pour introduire
des 0 en deça du premier élément diagonal la première colonne. Pour cela, on effectue les
transformations :
−a2,1
L2 = L2 + ( a1,1 ∗ L1 ),
−a2,1
b2 = b2 + ( a1,1 ∗ b2 )
−a3,1
L3 = L3 + ( a1,1 ∗ L1 ),
−a3,1
b3 = b3 + ( a1,1 ∗ b3 )
47
A l’issue de ces transformations, on a le système A1 x = b1 avec
 
a1,1 a1,2 a1,3
A1 =  0 a12,2 a12,3 
0 a13,2 a13,3
−a −a
et les valeurs b11 = b1 , b12 = b2 + ( a1,1
2,1
∗ b2 ) et b13 = ( a1,1
3,1
∗ b3 ).
Pour continuer l’élimination de Gauss, on introduit maintenant des zeros en deca de la
diagonale de la seconde colonne. Pour ce faire, on applique les tranformations :
−a13,2
L3 = L3 + ( a2,2 ∗ L2 ),
−a13,2
b3 = b3 + ( a2,2 ∗ b3 )
Le système que l’on obtien à l’issue de cette transformation est triangulaire supérieur.
on peut alors le résoudre en utilisant la méthode de substitution arrière.
La transformation d’un système quelconque en un système triangulaire supérieur est la
base de la méthode d’addition. L’intérêt de cette transformation est dans le fait qu’il est
alors aisé de résoudre le système résultant. Afin d’automatiser la résolution d’un système
quelconque, il faut alors développer un algorithme de transformation du système quelconque
en un système triangulaire supérieur. En s’inspirant de l’exemple ci dessus, on peut facile-
ment dériver le code de transformation suivant :
function [A,b] = Gauss(A,b)

% En sortie, la matrice A est triangulaire supérieure
n = size(b)(1);
for(k = 1:n-1)
for(i = k+1:n)
b(i) = b(i) - (A(i,k)/A(k,k))*b(k);
A(i,k:n) = A(i,k:n) - (A(i,k)/A(k,k))*A(k,k:n);
end
end
return;
Dans cet algorithme, nous ne procédons pas exactement en une addition des lignes
ceci pour éviter des additions avec des valeurs nulles. Lorsqu’on a effectué l’ensemble de
transformations qui introduisent un zero en deca de la première colonne, à l’étape qui suit,
nous n’utilisons que la partie non nulle de L2. Nous procédons de même après l’introduction
des zeros en deca de la seconde colonne etc.
Complexité : La complexité de cet algorithme peut être estimée à partir du nombre
de multiplications flottantes. Dans l’opération A(i, k : n) = A(i, k : n) − (A(i, k)/A(k, k)) ∗
A(k, k : n), on effectue n − k − 1 multiplications flottantes. Par ailleurs, on peut déduire une
constantePcn−1telle
Pnque pour le nombre de multiplications flottantes Nm , on ait la relation :
Nm ≤ c k=1 (n − k − 1). On en déduit que l’élimination de Gauss est en O(n 3 ) et
i=k+1
48
donc que la résolution d’un système quelconque est en O(n3 ).
Dans l’élimination de Gauss, on peut à une étape avoir des valeurs diagonales nulles.
Avant d’exécuter par exemple A(i, k : n) = A(i, k : n) − (A(i, k)/A(k, k)) ∗ A(k, k : n),
la valeur A(k, k) peut être nulle. Dans ce cas, on peut procéder par une permutation des
colonnes de sorte à ramener une valeur A(k, k) non nulle. Si deux colonnes i et j sont ainsi
permutées, il faudrait ultérieurement penser à permuter les composantes xi et xj du vecteur
solution. La permutation des colonnes au fil de l’élimination est développée de façon plus
détaillée dans la méthode du pivot partiel. Dans certains cas, la seule permutation des lignes
ne suffit pas. On peut alors employer la méthode du pivot total dans laquelle où lignes et
les colonnes sont permutées.
49
Chapitre 7
Intégration
Simpson, Quadrature de gauss, Euler.
50

SUPPORT DE COURS Introduction Au Calcul Scientifique

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

SUPPORT DE COURS Introduction Au Calcul Scientifique

Transféré par

Droits d'auteur :

Formats disponibles

Introduction au Calcul scientifique

2 Arithmétique en précision finie 6

4 Racine des fonctions 27

6 Résolution des systèmes linéaires 44

1.1 Motivations et objectifs

1.2 Modèle de calcul

1.4 Organisation du cours

Arithmétique en précision finie

2.1 Représentation des nombres sur ordinateur

L’approche de représentation ainsi proposé est l’approche de représentation avec la vir-

Fig. 2.2 – Les nombres en virgule fixe sont équidistants de p = 2−e

2.1.2 Représentation en virgule flottante

Example La valeur de 0.11024 = 23 + 22 = 12.

Pour représenter un nombre flottants, on considère trois composantes principales : le

En résumé, la représentation flottante est caractérisée par :

L’intérêt de la représentation flottante est de prendre en compte plus de petits nombre

Example Considérons une représentation flottante avec : t = 3 ; L = −1 ; U = 2 ; |F | = 33.

Fig. 2.4 – Un système simple de nombres flottants

1/2 = (0.100)2 ; 3/4 = 1/2 + 1/4 = (0.110)2

Fig. 2.5 – Nombre en simple précision

Fig. 2.6 – Nombre en double précision

2.1.4 Dépassement de capacité, arrondis et troncatures

Erreur Relative = Erreur absolue/ Valeur Exacte

Erreur absolue = Valeur Approximative - Valeur Exacte.

On peut aussi noter que l’on a trivialement |ǫa | ≤ ǫF .

2.1.6 Source d’erreurs

2.2 Arithmétique flottante

3.1.1 Programmer avec MATLAB

>> x = sin(0); cos(x);

>> x = 2; Commande est sans écho

>> x = 2; x est une variable scalaire contenant 2

Les opérateurs relationnels et logiques

Fonctions MATLAB prédéfinies

Les instructions de contrôle

>> y = rand y prend une valeur aléatoire

c) Instruction for La structure générale est la suivante :

3.1.2 Les fichiers M

function [V1, V2, ..., Vn] = nom_fonction(P1,P2,...,Pm);

3.2 Les vecteurs

3.2.1 Création des vecteurs

Il est aussi possible de créer un vecteur en indiquant un procédé systématique pour

Exercice 2.1 : Que donne les affectations v = [9 : −2 : 1], v = [0 : 2 ∗ pi : 10] ?

b) Création par composition des vecteurs

Création des vecteurs colonnes

3.2.2 Adressage et techniques d’indexation des éléments d’un vecteur

3.2.3 Opérations avec les vecteurs

Multiplication scalaire-vecteur et exponentiation

Transposée d’un vecteur

Addition et soustraction des vecteurs

Produit scalaire de deux vecteurs

Produit éléments par éléments de deux vecteurs

3.3 Les matrices

Création des matrices

Quelques fonctions spéciales de création des matrices

MATLAB comporte un ensemble de fonctions permettant de créer de matrices partic-

Adressage et techniques d’indexation des éléments d’une matrice

Opérations sur les matrices

La multiplication scalaire-matrice est réalisée par l’opérateur ”*” entre un scalaire * et

Elle est réalisée avec l’opérateur ”’”

Addition et soustraction des matrices

>> x = [3:-1:1 ; 2 5 6; 1:1:3];

Fonction spéciales sur les matrices

Racine des fonctions

La multiplication scalaire-matrice est réalisée par l’opérateur ”” entre un scalaire et

Dans celle ci,