Cours PM

Université Sultan Moulay Slimane
Département de Mathématiques et Informatiques

Filière PM
Année Universitaire : 2021/2022
Cours : Informatique et Analyse Numérique
Prof. Said SAFI
Option : PM (S1)
v.1.1 Octobre 2021
Table des matières
1 Introduction à l'algorithmique 2
1.1 Algorithmique et programmation . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Les variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.1 A quoi servent les variables ? . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.2 Déclaration des variables . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2.3 Les types de variables . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 L'instruction d'aectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3.1 Syntaxe et signication . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3.2 L'Ordre des instructions . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3.3 Expressions et opérateurs . . . . . . . . . . . . . . . . . . . . . . . . 6
1.4 Lecture et Ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.4.2 Les instructions de lecture et d'écriture . . . . . . . . . . . . . . . . . 8
1.5 Les tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5.1 Structure d'un test . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.5.2 Denition d'une condition . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5.3 Les opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . 10
1.5.4 Conditions composées . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5.5 Tests imbriqués . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5.6 Variables Booléennes . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.6 Une première structure de boucle . . . . . . . . . . . . . . . . . . . . . . . . 13
1.7 Boucler en comptant ou compter en bouclant . . . . . . . . . . . . . . . . . . 14
1.7.1 Des boucles dans des boucles . . . . . . . . . . . . . . . . . . . . . . 14
1.8 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2 Initiation à la programmation avec Matlab 17

2.1 Programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.2 Syntaxe du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.1.3 Vecteurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.1.4 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.1 Exemples de fonctions sous Matlab . . . . . . . . . . . . . . . . . . . 21
2.2.2 Les fonctions M-les . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.2.3 Les fonctions Inline . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
i
TABLE DES MATIÈRES ii TABLE DES MATIÈRES
2.2.4 Fonctions outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2.2.5 fonctions préprogrammés sous matlab . . . . . . . . . . . . . . . . . . 24
2.3 Les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.4 Les tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.5 La Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.6 Impressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.7 Lecture et écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.8 Représentation graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
2.9 conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3 Intégration numérique 35
3.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2 Méthode des rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.1 Principe de La méthode . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.2.2 Evaluation de la méthode des rectangles . . . . . . . . . . . . . . . . 36
3.3 Méthode des trapèzes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3.1 Estimation de l'erreur . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.4 Méthode de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.5 Méthode de Monte-Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.5.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.6 conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4 Résolution numérique des équations non linéaires f (x) = 0 43

4.1 introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
4.2 Méthode de bisection ou dichotomie[2, 3] . . . . . . . . . . . . . . . . . . . . 43
4.2.1 Principe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.2.2 Algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
4.2.3 Limite de la méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.3 Méthode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.4 Méthode de Lagrange ou Méthode de la sécante . . . . . . . . . . . . . . . . 46
4.5 conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
5 Résolution des ED 48
5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
5.1.1 Un modèle de dynamique des populations . . . . . . . . . . . . . . . 48
6 Méthodes d'approximation : Interpolation 53

6.1 introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.2 Interpolation polynomiale de Lagrange . . . . . . . . . . . . . . . . . . . . . 53
6.3 Forme polynomiale de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . 55
6.3.1 Présentation de la méthode . . . . . . . . . . . . . . . . . . . . . . . 55
SAFI Said ii Informatique et Analyse Numérique

Table des gures
2.1 Page d'accueil du logiciel Matlab . . . . . . . . . . . . . . . . . . . . . . . . 18

2.2 This table shows conversion characters to format numeric and character data
as text. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.3 représentation graphique d'une fonction . . . . . . . . . . . . . . . . . . . . . 31
2.4 représentation graphique de 3 gure sur une même gure . . . . . . . . . . . 32
3.1 Description de la méthode des rectangles . . . . . . . . . . . . . . . . . . . . 36

3.2 l'erreur est en 1/n de la méthode des rectangles . . . . . . . . . . . . . . . . 36
3.3 Représentation graphique (Exemple 1) . . . . . . . . . . . . . . . . . . . . . 37
3.4 Représentation graphique la fonction f (x) = x2 . . . . . . . . . . . . . . . . 38
3.5 Calcul d'integral par la méthode de Simpson . . . . . . . . . . . . . . . . . . 40
4.1 exemple de fonction non linéaire . . . . . . . . . . . . . . . . . . . . . . . . . 44

4.2 Description de la méthode de Newton-Raphson . . . . . . . . . . . . . . . . 46
4.3 Description de la méthode de Lagrange (ou de la sécante) . . . . . . . . . . . 46
5.1 Evolution des proies et prédateurs au cours du temps . . . . . . . . . . . . . 51

5.2 Evolution des proies en fonction des prédateurs . . . . . . . . . . . . . . . . 52
iii
Introduction générale
Le but de ce module est donné les outils nécessaires pour la résolution des problèmes
des sciences de physique et de l'ingénieries par des méthodes numériques. Pour cela, nous
donnons dans un premier lieu nous donnons dans le chapitre 1 une introduction sur l'algorith-
mique et ces principaux instruction pour concevoir des algorithmes de qualité simpliant la
traduction en langage de programmation, pour nous on s'intéressera à la programmation avec
Matlab qui sera déni dans le chapitre 2. Le choix du langage Matlab réside dans sa richesse
sur plusieurs champs d'applications, il peut être étendu aux systèmes non linéaires et aux
problèmes associés de simulation avec le produit complémentaire SIMULINK. Les capacités
de MATLAB peuvent en outre être enrichies par des fonctions spécialisées regroupées au sein
de dizaines de "toolboxes" (boîtes à outils qui sont des collections de "M-les") couvrant des
domaines très variés tels que :
Analyse numérique
Traitement de signaux et d'image
Statistiques
Logique oue
Finance
Bio-informatique
Économie
Aérospatial
Communications
Optimisation
... etc
Par la suite nous utilisons ce qui précède pour le calcul numérique d'un intégral : Inté-
gration numérique par la méthode des rectangles, la méthode des trapèzes et les méthode de
Simpson. La recherche des zéros des fonctions non linéaires en utilisant la méthode de Dicho-
tomie, la méthode de points xes et la méthode de Newton. Et on termine par la résolution
numériques des équations diérentielles ordinaires(edo).
1
Chapitre 1
Introduction à l'algorithmique
Un algorithme est une suite d'instructions, qui une fois exécutée correctement, conduit à
un résultat donné.
Pour fonctionner, un algorithme doit donc contenir uniquement des instructions compré-
hensibles par celui qui devra l'exécuter.
Les ordinateurs.
Ne sont capables de comprendre que quatre catégories d'ordres (en programmation, on
n'emploiera pas le terme d'ordre, mais plutôt celui d'instructions). Ces quatre familles
d'instructions sont :
• l'aectation de variables
• la lecture / écriture
• les tests
• les boucles
1.1 Algorithmique et programmation

Pourquoi apprendre l'algorithmique pour apprendre à programmer ?
Parce que l'algorithmique exprime les instructions résolvant un problème donné in-
dépendamment des particularités de tel ou tel langage. Il se pose la question primor-
diale : Avec quelles conventions écrit-on un algorithme ?
Historiquement, plusieurs types de notations ont représenté des algorithmes.
La plus ancienne est la représentation graphique, avec des carrés, des losanges, etc. qu'on
appelait des organigrammes. Aujourd'hui, cette représentation est quasiment abandonnée,
pour deux raisons. D'abord, parce que dès que l'algorithme commence à grossir un peu, ce
n'est plus pratique, du tout, l'utilisation de la représentation graphique. C'est pourquoi on
utilise généralement une série de conventions appelée pseudo-code.
2
1.2. LES VARIABLES CHAPITRE 1. 3 INTRODUCTION À L'ALGORITHMIQUE
1.2 Les variables

1.2.1 A quoi servent les variables ?
Dans un programme informatique, on va avoir en permanence besoin de stocker provi-
soirement des valeurs. Il peut s'agir de données issues du disque dur, fournies par l'utilisateur
(frappées au clavier), ... etc. Il peut aussi s'agir de résultats obtenus par un programme,
intermédiaires ou dénitifs. Elles peuvent être des nombres, du texte, etc.
En conclusion : stocker une information au cours d'un programme : utiliser une variable .
1.2.2 Déclaration des variables

La première chose à faire avant de pouvoir utiliser une variable est de créer une boîte
et de lui coller une étiquette. Ceci se fait tout au début de l'algorithme, avant même les
instructions proprement dites. C'est ce qu'on appelle la déclaration des variables.
En pseudo-code algorithmique, Lorsqu'on déclare une variable, il ne sut pas
de créer une boîte (réserver un emplacement mémoire); mais il faut préciser ce
que l'on voudra mettre dedans, car de cela dépendent la taille de la boîte (de
l'emplacement mémoire) et le type de codage utilisé .
1.2.3 Les types de variables
On peut distinguer quatre types de variables :
1. Types numériques classiques : se sont des variables capable de recevoir des nombres.
Par exemple : Si on réserve un octet pour coder un nombre, on ne pourra coder que
28 = 256 valeurs diérentes (soit de 1 à 256 ou de 0 à 255 ...), et si on reserve deux
octets on pourra coder 216 valeurs diérentes.
2. Autres types numériques : certains langages autorisent d'autres types numériques,
notamment : le type monétaire (avec strictement deux chires après la virgule) le
type date (jour / mois / année).
3. Types non numériques ou type alphanumérique : on dispose d'un autre type de variable
dite alphanumérique, également appelé type caractère ou type chaîne ou en anglais :
le type string. Dans une variable de ce type, on stocke des caractères.
4. Le dernier type de variables est le type booléen : on y stocke uniquement les valeurs
logiques VRAI et FAUX ou (TRUE et FALSE) ou des nombres (0 et 1) Peu importe. Ce
qui compte, c'est de comprendre que le type booléen est très économique en termes de
place mémoire occupée, puisque pour stocker une telle information binaire, un seul bit
sut. Le recours aux variables booléennes s'avère très souvent un puissant instrument
de lisibilité des algorithmes : il peut faciliter la vie de celui qui écrit l'algorithme,
comme de celui qui le relit pour le corriger.
Exemple : En pseudo-code, une déclaration de variables aura ainsi cette tête :
Variable g en Numérique
ou encore
Variables PrixHT, TauxTVA, PrixTTC en Numérique
SAFI Said 3 Informatique et Analyse Numérique

1.3. L'INSTRUCTION D'AFFECTATION
CHAPITRE 1.4 INTRODUCTION À L'ALGORITHMIQUE
N.B. En pseudo-code, une chaîne de caractères est toujours notée entre guille-
mets. et ceux pour éviter deux confusions possibles :
1. La confusion entre des nombres et des suites de chires. Par exemple, 423 peut repré-
senter le nombre 423 (quatre cent vingt-trois), ou la suite de caractères 4, 2, et 3. Avec
le premier, on peut faire des calculs, avec le second, on ne peut pas. les guillemets
permettent d'éviter toute ambiguïté.
2. L'autre confusion, plus grave - consiste à se mélanger les pinceaux entre le nom d'une
variable et son contenu. cela consiste à confondre l'étiquette d'une boîte et ce qu'il y
a à l'intérieur.
1.3 L'instruction d'aectation

1.3.1 Syntaxe et signication
La seule chose qu'on puisse faire avec une variable, c'est l'aecter, c'est-à-dire lui attribuer
une valeur. Donc, on peut remplir la boîte.
En pseudo-code, l'instruction d'aectation se note avec le signe ←−
Ainsi :
A ←− 20
Attribue la valeur 20 à la variable A. Ceci, implique que A soit une variable de type numérique.
Si A, a été déni dans un autre type, il faut bien comprendre que cette instruction provoquera
une erreur. On peut en revanche sans aucun problème attribuer à une variable la valeur d'une
autre variable, telle quelle ou modiée. Par exemple :
B ←− A
Signie que la valeur de B est maintenant celle de A.
• Exercice 1
Soit deux variables de type numérique, par exemple, X et Y ayant respectivement comme
valeurs x et y ; quelles sont les aectations qui donneront à X la valeur y et à Y la valeur x ?
Remarque :
N.B. L'instruction d'aectation ne modie que ce qui est situé à gauche de la èche.
B ←A+4
Si A contenait 12, B vaut maintenant 16. De même que précédemment, A vaut toujours 12.
B ←B+1
Si B valait 6, il vaut maintenant 7. La valeur de B est modiée, puisque B est la variable
située à gauche de la èche.
Considérons les deux exemples suivants :
Exemple n◦ 1
Début

tau ← "std"
F ← "tau"
Fin
Exemple n◦ 2
Début
tau ← "std"
F ← tau
Fin
Commentaire
• La seule diérence entre les deux algorithmes (des exemples 1 et 2) consiste dans la
présence ou dans l'absence des guillemets lors de la seconde aectation. Et cela change tout !
=⇒ Dans l'exemple n◦ 1, ce que l'on aecte à la variable F, c'est la suite de caractères t - a -
u. Et à la n de l'algorithme, le contenu de la variable F est donc "tau".
Dans l'exemple n◦ 2, en revanche, tau étant dépourvu de guillemets, n'est pas considéré comme
une suite de caractères, mais comme un nom de variable. Le sens de la ligne devient donc :
" aecte à la variable F le contenu de la variable std.
A la n de l'algorithme n◦ 2, la valeur de la variable F est donc " std ". Ici, l'oubli des
guillemets conduit certes à un résultat, mais à un résultat diérent.
ceci résume l'ensemble des problèmes qui surviennent lorsqu'on oublie les guillemets aux
chaînes de caractères.
1.3.2 L'Ordre des instructions

L'ordre dans lequel les instructions sont écrites va jouer un rôle essentiel dans le résultat
nal. Considérons les deux exemples suivant :
•Exemple 1
Variable A en Numérique
Début
A ← 34
A ← 12
Fin
•Exemple 2
Début
A ← 12
A ← 34
Fin
L'exemple 1 donne comme résultat nal : A = 12, tandis l'exemple 2 donne A = 34, ce
qui implique que l'execution se fait ligne après ligne c-à-d séquentielle.
En eet, on aurait bien atteint le même résultat en écrivant simplement :

•Exemple 1

Début
A ← 12
Fin
•Exemple 2
Début
A ← 34
Fin
c'est-à-dire c'est pas bien de donner à une variable une valeur puis en la change par une
autre ! ! !
1.3.3 Expressions et opérateurs

Nous voyons que dans une instruction d'aectation, on trouve :
1. A gauche de la èche, un nom de variable, et uniquement cela. Donc, si on voit à

gauche d'une èche d'aectation autre chose qu'un nom de variable, on peut être
certain qu'il s'agit d'une erreur.
2. A droite de la èche, ce qu'on appelle une expression. En informatique, le terme
d'expression ne désigne qu'une seule chose très précise :
Une expression est un ensemble de valeurs, reliées par des opérateurs, et
équivalent à une seule valeur.
Dans l'exemple suivant, nous présentons quelques expressions de type numérique :
•7
• 5+4
• 123-45+844
• A-12+5-R
ces expressions sont toutes des expressions valides, avec A et R soient bien des nombres.
Sinon, la quatrième expression n'a pas de sens. Les opérateurs que nous avons employé sont
l'addition (+) et la soustraction (-).
Rque : Une condition supplémentaire (en plus des deux précédentes) de validité d'une
instruction d'aectation est que :
. l'expression située à droite de la èche soit du même type que la variable située à gauche.
C'est très logique ! ! !
Si l'un des trois points énumérés ci-dessus n'est pas respecté, la machine sera incapable
d'exécuter l'aectation.
Conclusion :
Un opérateur est un signe qui relie deux valeurs, pour produire un résultat.
I Les opérateurs possibles dépendent du type des valeurs qui sont en jeu.

Opérateurs numériques
Ce sont les quatre opérations arithmétiques tout ce qu'il y a de classique. + : addition,
- : soustraction, * : multiplication et / : Division. Mentionnons également le ∧ qui signie
puissance. 45 au carré s'écrira donc 452 . Enn, on a le droit d'utiliser les parenthèses, avec
les mêmes règles qu'en mathématiques. La multiplication et la division ont " naturellement "
priorité sur l'addition et la soustraction. Les parenthèses ne sont ainsi utiles que pour modier
cette priorité naturelle. Cela signie qu'en informatique, 12 ∗ 3 + 5 et (12 ∗ 3) + 5 valent même
chose, à savoir 41. En revanche, 12 ∗ (3 + 5) vaut 12 ∗ 8 soit 96.
Opérateur alphanumérique &

Cet opérateur permet de concaténer, autrement dit de chaîner, deux chaînes de caractères.
Prenons l'exemple suivant :
Variables A, B, C en Caractère
Début
A ← "Mohamed"
B ← " Alfatih"
C←A&B
Fin
La valeur de C à la n de l'algorithme est "Mohamed Alfatih"
Opérateurs logiques (ou booléens)
Il s'agit du ET, du OU, du NON et du mystérieux XOR rarement employer.
REMARQUE 1 :
I En mathématiques, une " variable " est généralement une inconnue, qui recouvre un
nombre non précisé de valeurs. Lorsque j'écris :
y = 3x + 2
Les " variables " x et y satisfaisant à l'équation existent en nombre inni (graphiquement,
l'ensemble des solutions à cette équation dessine une droite). Lorsque j'écris :
ax2 + bx + c = 0
La " variable " x désigne les solutions à cette équation, c'est-à-dire zéro, une ou deux valeurs
à la foi...
En informatique, une variable possède à un moment donné une valeur et une
seule.
Opérateurs logiques (ou booléens)
REMARQUE 2 :
I En algorithmique, comme on l'a vu, c'est le signe ←. Mais en pratique, la quasi totalité
des langages emploient le signe égal.
I En maths, A = B et B = A sont deux propositions strictement équivalentes.
I En informatique, absolument pas, puisque cela revient à écrire A ← B et B ← A, deux
choses bien diérentes. De même, A = A + 1, qui en mathématiques, constitue une équation
sans solution, représente en programmation une action extrêmement courante. Donc, pour

1.4. LECTURE ET ECRITURE
ne pas faire cette confusion consiste à bien employer le signe ← en pseudo-code, signe qui a
le mérite de ne pas laisser place à l'ambiguïté. Une fois acquis les bons réexes avec ce signe,
vous n'aurez plus aucune diculté à passer au = des langages de programmation.
1.4 Lecture et Ecriture

1.4.1 Introduction
Imaginons que nous ayons fait un programme pour calculer le carré d'un nombre, 6 par
exemple. Si on a fait au plus simple, nous pouvons écrire :
Début
A ← 6∧2
Fin
D'une part, ce programme nous donne le carré de 6. Mais si l'on veut le carré d'un autre
nombre que 6, il faut réécrire le programme.
D'autre part, le résultat est certainement calculé par la machine. Mais elle le garde soigneu-
sement pour elle, et l'utilisateur qui fait exécuter ce programme, lui, ne saura jamais quel
est le carré de 6. C'est pourquoi, il existe des instructions pour permettre à la machine de
dialoguer avec l'utilisateur.
Dans un sens, ces instructions permettent à l'utilisateur de rentrer des valeurs au clavier pour
qu'elles soient utilisées par le programme. Cette opération est la lecture.
Dans l'autre sens, d'autres instructions permettent au programme de communiquer des va-
leurs à l'utilisateur en les achant à l'écran. Cette opération est l'écriture.
1.4.2 Les instructions de lecture et d'écriture

Tout simplement pour que l'utilisateur entre la (nouvelle) valeur de A, on mettra :
Lire A
Dès que le programme rencontre une instruction Lire, l'exécution s'interrompt, attendant la
frappe d'une valeur au clavier.
Dès que la touche la touche Entrée (Enter) a été frappée, l'exécution reprend. Dans le sens
inverse, pour écrire quelque chose à l'écran, c'est aussi simple que :
Ecrire A
Avant de Lire une variable, il est très fortement conseillé d'écrire des libellés à l'écran, an
de prévenir l'utilisateur de ce qu'il doit frapper (sinon, l'utilisateur passe son temps à se
demander ce que l'ordinateur attend de lui... et c'est très désagréable !) :
Ecrire "Entrez votre nom : "
Lire NomFamille
Lecture et Ecriture sont des instructions algorithmiques qui ne présentent pas de dicultés
particulières, une fois qu'on a bien assimilé ce problème du sens du dialogue (homme ←−
machine, ou machine ←− homme).

1.5. LES TESTS CHAPITRE 1. 9 INTRODUCTION À L'ALGORITHMIQUE
1.5 Les tests

1.5.1 Structure d'un test
Il n'y a que deux formes possibles pour un test ; la première est la plus simple, la seconde
la plus complexe.
Si booléen Alors
Instructions
Finsi
Si booléen Alors
Instructions 1
Sinon
Instructions 2
Finsi
=⇒ Un booléen est une expression dont la valeur est VRAI ou FAUX. Cela peut donc être
(il n'y a que deux possibilités) :
• une variable (ou une expression) de type booléen
• une condition
Dans la forme la plus simple, arrivé à la première ligne (Si... Alors) la machine examine la
valeur du booléen. Si ce booléen a pour valeur VRAI, elle exécute la série d'instructions.
Cette série d'instructions peut être très brève comme très longue, cela n'a aucune impor-
tance. En revanche, dans le cas où le booléen est faux, l'ordinateur saute directement aux
instructions situées après le FinSi.
=⇒ Dans le cas où le booléen est VRAI, et après avoir exécuté la série d'instructions 1, au
moment où elle arrive au mot " Sinon ", la machine saute directement à la première instruc-
tion située après le " Finsi ". De même, au cas où le booléen a comme valeur " Faux ", la
machine saute directement à la première ligne située après le " Sinon " et exécute l'ensemble
des " instructions 2 ". Dans tous les cas, les instructions situées juste après le FinSi seront
exécutées normalement.
=⇒ En fait, la forme simpliée correspond au cas où l'une des deux " branches " du Si
est vide. Exprimé sous forme de pseudo-code, la programmation de notre touriste de tout à
l'heure donnerait donc quelque chose du genre :
Allez tout droit jusqu'au prochain carrefour
Si la rue à droite est autorisée à la circulation Alors
Tournez à droite
Avancez
Prenez la deuxième à gauche
Sinon
Continuez jusqu'à la prochaine rue à droite
Prenez cette rue
Prenez la première à droite
Finsi

1.5.2 Denition d'une condition

La première question qui se pose c'est quoi une condition ?.
Une condition est une comparaison
Cette dénition est essentielle ! Elle signie qu'une condition est composée de trois éléments :
• une valeur
• un opérateur de comparaison
• une autre valeur
Les valeurs peuvent être a priori de n'importe quel type (numériques, caractères...). Mais
si l'on veut que la comparaison ait un sens, il faut que les deux valeurs de la comparaison
soient du même type !
1.5.3 Les opérateurs de comparaison

Les opérateurs de comparaison sont :
• égal à...
• diérent de...
• strictement plus petit que...
• strictement plus grand que...
• plus petit ou égal à...
• plus grand ou égal à...
L'ensemble des trois éléments constituant la condition constitue donc, si l'on veut, une
armation, qui a un moment donné est VRAIE ou FAUSSE.
• A noter que ces opérateurs de comparaison peuvent tout à fait s'employer avec des
caractères. Ceux-ci sont codés par la machine dans l'ordre alphabétique (code ASCII), les
majuscules étant systématiquement placées avant les minuscules. Ainsi on a :
"t"< "w" VRAI
"Maman" > "Papa" FAUX
"maman" > "Papa" VRAI
Remarque très importante
En formulant une condition dans un algorithme, il faut se méer comme dans certaines
notations valides en mathématiques, mais qui mènent à des non-sens informatiques. Prenons
par exemple la phrase " A est compris entre 5 et 8 ". On peut la traduire par :
5 < A < 8.
1.5.4 Conditions composées

Certains problèmes exigent parfois de formuler des conditions qui ne peuvent pas être
exprimées sous la forme simple exposée ci-dessus. Reprenons le cas " A est inclus entre 5 et
8 ". En fait cette phrase cache non une, mais deux conditions. Car elle revient à dire que "
A est supérieur à 5 et A est inférieur à 8 ". Il y a donc bien là deux conditions, reliées par
ce qu'on appelle un opérateur logique, le mot ET.
Comme on l'a évoqué plus haut, l'informatique met à notre disposition quatre opérateurs

logiques : ET, OU, NON, et XOR.

On représente fréquemment tout ceci dans des tables de vérité (C1 et C2 représentent deux
conditions, et on envisage à chaque fois les quatre cas possibles).
C1etC2 C1V rai C2F aux

C1V rai V rai F aux
C1F aux F aux F aux
C1ouC2 C1V rai C2F aux

C1V rai V rai V rai
C1F aux V rai F aux
C1xorC2 C2V rai C2F aux

C1V rai F aux V rai
C1F aux V rai F aux
C1 N onC1
C1V rai F aux
C1F aux V rai
1.5.5 Tests imbriqués

Un SI ouvre donc deux voies, correspondant à deux traitements diérents. Mais il y a des
tas de situations où deux voies ne susent pas. Par exemple, un programme devant donner
l'état de l'eau selon sa température doit pouvoir choisir entre trois réponses possibles (solide,
liquide ou gazeuse).
Une première solution serait la suivante :
Variable Temp en Entier
Début
Ecrire "Entrez la température de l'eau :"
Lire Temp
Si (T emp =< 0) Alors
Ecrire "C'est de la glace"
FinSi
Si (T emp > 0EtT emp < 100) Alors
Ecrire "C'est du liquide"
Finsi
Si (T emp > 100) Alors
Ecrire "C'est de la vapeur"
Finsi
Fin

Dans l'algorithme précédent, on oblige la machine à examiner trois tests successifs alors que
tous portent sur une même chose, la valeur de la variable Temp. Il serait ainsi bien d'imbriquer
les tests de cette manière :
Début
Lire Temp
Si (T emp =< 0) Alors
Sinon
Si (T emp < 100) Alors
Sinon
Finsi
Finsi
Fin
le dernier algorithme s'écrit sous une autre forme :
Début
Lire Temp
Si Temp =< 0 Alors
SinonSi Temp < 100 Alors
Sinon
Finsi
Fin
Dans le cas de tests imbriqués, le Sinon et le Si peuvent être fusionnés en un
SinonSi. On considère alors qu'il s'agit d'un seul bloc de test, conclu par un seul
FinSi
1.5.6 Variables Booléennes

Reprenons l'exemple de l'eau. On pourrait le réécrire ainsi : Variable Temp en Entier
Variables A, B en Booléen
Début
Lire Temp
A ← Temp =< 0
B ← Temp < 100
Si A Alors

1.6. UNE PREMIÈRE STRUCTURE DE BOUCLE
CHAPITRE 13 INTRODUCTION
1. À L'ALGORITHMIQUE
SinonSi B Alors
Sinon
Finsi
Fin.
A priori, cette technique ne présente guère d'intérêt : on a alourdi plutôt qu'allégé l'algorithme
de départ, en ayant recours à deux variables supplémentaires.
• Il est clair que presque dans la plupart des algorithmes on rencontre des tests. Ce qui
nous amène à bien optimisé nos algorithmes si on ait plus d'un test ou bien si on on a des
tests dans des tests (tests imbriqués).
• A noter que pour une bonne lisibilité de l'algorithme on note les tests entre parenthèses.
1.6 Une première structure de boucle

La seule issue est donc cette structure de boucle, qui se présente ainsi :
TantQue booléen
...
Instructions
...
FinTantQue
Le principe est simple : le programme arrive sur la ligne du TantQue. Il examine alors la
valeur du booléen (qui, je le rappelle, peut être une variable booléenne ou, plus fréquemment,
une condition). Si cette valeur est VRAI, le programme exécute les instructions qui suivent,
jusqu'à ce qu'il rencontre la ligne FinTantQue. Il retourne ensuite sur la ligne du TantQue,
procède au même examen, et ainsi de suite. Le manège enchanté ne s'arrête que lorsque le
booléen prend la valeur FAUX. Illustration avec notre problème de contrôle de saisie :
algorithme
Variable Rep en Caractère
Ecrire "Voulez vous un café ? (O/N)"
TantQue Rep <> "O" ET Rep <> "N"
Lire Rep
Si Rep <> "O" ET Rep <> "N" Alors
Ecrire "Saisie erronnée. Recommencez"
FinSi
FinTantQue
On remarquera que la présence du bloc " Si " est uniquement là pour l'achage éventuel du
libellé de saisie erronée. TantQue dans laquelle le booléen ne devient jamais faux ! L'ordina-
teur tourne alors dans la boucle comme un dératé et n'en sort plus.

1.7. BOUCLER EN COMPTANT OU COMPTER
CHAPITRE 14 INTRODUCTION
1. EN BOUCLANT
À L'ALGORITHMIQUE
1.7 Boucler en comptant ou compter en bouclant

Dans le dernier algorithme, vous avez remarqué qu'une boucle était fréquemment utilisée
pour augmenter la valeur d'une variable. Il arrive également très souvent qu'on ait besoin
d'eectuer un nombre déterminé de passages. Or, a priori, notre structure TantQue ne sait
pas à l'avance combien de tours de boucle elle va eectuer (cela dépend d'une condition).
C'est pourquoi une autre structure de boucle est à notre disposition :
Variable Truc en Entier
Truc ← 0
TantQue Truc < 15
T ruc = T ruc + 1
Ecrire "Passage numéro : ", Truc
FinTantQue
Equivaut à :
Variable Truc en Entier
Pour T ruc = 1 à 15
Ecrire "Passage numéro : ", Truc
Truc Suivant
Au sens strict, on pourrait donc s'en dispenser, mais c'est tellement agréable de faire moins
d'eort...
1.7.1 Des boucles dans des boucles

Une structure SI...ALORS peut contenir d'autres structures SI...ALORS, une boucle peut
contenir d'autres boucles.
Variables Tr, Ta en Entier
Pour Tr ← 1 à 15
Ecrire "Il est passé par ici"
Pour Ta ← 1 à 6
Ecrire "Il repassera par là"
Ta Suivant
Tr Suivant
Dans cet exemple, le programme écrira une fois "il est passé par ici " puis six fois de suite "il
repassera par là ", et ceci quinze fois en tout. A la n, il y aura donc eu 15 × 6 = 90 passages
dans la deuxième boucle (celle du milieu).
exemple de structure
Pour Tr ← 1 à 15
Ecrire "Il est passé par ici"
Tr Suivant
Pour Ta ← 1 à 6
Ecrire "Il repassera par là"
Ta Suivant

1.8. CONCLUSION CHAPITRE 1. 15 INTRODUCTION À L'ALGORITHMIQUE
Ici, il y aura quinze écritures consécutives de "il est passé par ici", puis six écritures
consécutives de "il repassera par là" , et ce sera tout. Si des boucles peuvent être imbriquées
(cas n◦ 1) ou successives (cas n◦ 2), elles ne peuvent jamais, au grand jamais, être croisées.
Cela n'aurait aucun sens logique, et de plus, bien peu de langages vous autoriseraient ne
serait-ce qu'à écrire cette structure aberrante.
Pour Tr ...
instructions
Pour Ta ...
instructions
Tr Suivant
instructions
Ta Suivant
Variable Tr en Entier
Pour Tr ← 1 à 15
Tr ← Tr * 2
Ecrire "Passage numéro : ", Tr
Tr Suivant
Vous remarquerez que nous faisons ici gérer " en double " la variable Tr, ces deux gestions
étant contradictoires. D'une part, la ligne " Pour... " augmente la valeur de Tr de 1 à chaque
passage. D'autre part la ligne " Tr ← Tr * 2 " double la valeur de Tr à chaque passage. Il
va sans dire que de telles manipulations perturbent complètement le déroulement normal de
la boucle, et sont sources d'exécutions erratiques.
1.8 Conclusion
Dans ce chapitre nous avons présenté les quatres principaux instructions de l'algorith-
mique à savoir :
1. L'aectation de variables : combien de variables on a besoin pour résoudre notre

problèmes et éventuellement de quelles types.
2. L'écriture et écriture : c'est l'instruction la plus importante qui facilite la conversation
entre l'home et la machine.
3. Les tests : après avoir déclarer les variables et leurs aectés des valeurs, vient l'ins-
truction de comparaisons ou bien test.
4. Les boucles : avec cette quatrième instruction on est à peut près avec plus de 80% de
la plupart des algorithmes.
Il reste à signaler q'on peut dénir des tableaux (sorte d'organisations d'un ensembles de
variables en une seule) et les fonction prédénis (des fonction qui sont déjà dénis sur un tel
ou tel langage de programmation).
Le chapitre suivant sera consacré un des plus célèbre langage de programmation qui est très
utile pour les scientiques en générales et les ingénieurs principalement, vue la richesse qu'il

1.8. CONCLUSION CHAPITRE 1. 16 INTRODUCTION À L'ALGORITHMIQUE
fournit de point de vu fonction prédénis ainsi que la simplicité de traçage des fonctions 2D
et 3D.

Chapitre 2
Initiation à la programmation avec
Matlab
2.1 Programmation
2.1.1 Introduction
Au démarrage du logiciel Matlab nous trouvons Les caractères >> en début de ligne
constituent le prompt de Matlab. C'est après eux que vous pouvez taper des commandes
qui seront exécutées par le logiciel après avoir tapé sur la touche entrée du clavier (gure
4.1).
2.1.2 Syntaxe du langage

Le résultat de l'exécution s'inscrit alors dans la fenêtre ou est représenté graphiquement
dans une nouvelle fenêtre spécique (avec possibilité de zoom, d'impression, etc...). Pour
rentrer une suite complexe d'instructions (on parle aussi d'un script), on les tape au préalable
dans un chier en utilisant l'éditeur intégré. Une fois le script enregistré, on peut l'exécuter
en tapant son nom dans la fenêtre Matlab.
Pour revenir sur l'historique des instructions entrées depuis le début de la session sur la
ligne de commande on utilise, par pressions successives de la touche ↑.
A noter, pour eacer les données en mémoire (par exemple avant d'exécuter un nouveau
calcul), il sut d'utiliser la commande clear.
Exemple 1 :
Tapez dans la fenêtre de commande l'instruction suivante :
>> A=[1 2 3 ; 2 5 7]
le résultat sera la suivante :
A=
1 2 3
2 5 7
Ceci représente une matrice 2 × 3. Matlab est assez friand de lignes blanches. Si on préfère
une format vous préférez des sorties plus compactes, >> format compact
17
2.1. PROGRAMMATION
CHAPITRE 2. 18
INITIATION À LA PROGRAMMATION AVEC MATLAB
Figure 2.1 Page d'accueil du logiciel Matlab

2.1. PROGRAMMATION
CHAPITRE 2. 19
Remarque :
Si vous tapez un ; après la ligne de commande le résultat ne s'achera pas.
Par défaut, Matlab utilise la représentation "short" (4 chires après la virgule).
Si vous tapez >> format long, la représentation devient 15 chires après la virgule.
Pour écrire écrire des commentaires (explication d'une instruction) il sut de précéder
le commentaire par un %, par exemple :
>> A=[1 2 3 ; 2 5 7] % A est une matrice 2 ligne 3 colonnes.
2.1.3 Vecteurs
Pour dénir un vecteur vous pouvez utiliser une syntaxe parmi les suivantes :
>> v = [1 2 3] % v est un vecteur ligne de 3 éléments
>> v 0 % transposé du vecteur v
>> vect = [1; 2; −1; 4] % vect est un vecteur colonne de 4 éléments
>> a = [1; 2 + i; −1; 4] % est un vecteur colonne de complexe de 4 éléments
>> b = a0 % est le transconjugué de du vecteur a
>> w = vect + a % est la somme de deux vecteurs a
>> c = vect0 . ∗ v % est le produit de deux matrices terme à terme
>> m = a.4 % est une mise en puissance 4 de chaque terme
Remarque :
Les composantes, dans un vecteur, sont séparées par des blancs (chose n'est pas conseillé)
ou de préférence par des virgules pour les vecteurs lignes et par des points-virgules pour les
vecteurs colonnes. Des messages erreurs sont achés si une opération impossible est tentée
(par exemple l'addition de vecteurs de longueurs diérentes).
Si vous voulez créer un vecteur à pas xe (incrémenter) vous pouvez utiliser la syntaxe
suivante : >> v = 1 : 3.2 : 23 % vecteur a incrément constant de 3.2
2.1.4 Matrices
La dénition des matrices sous Matlab suit la même syntaxe que les vecteurs, les lignes
de la matrice sont séparés par des points virgule ( ;). Pour dénir une matrice on peut écrire :
>> M = [1 2 3; −1 2 7] % M est une matrice 2 lignes 3 colonne
ou bien sous cette forme :
>> M = [1, 2, 3; −1, 2, 7] % M est une matrice 2 lignes 3 colonne
De même, vous pouvez multiplier deux matrice à condition que le nombre de lignes de la
première matrice soit égal au nombre de colonne de la deuxième matrice.
>> N = [1, −1; −1, 2; 4, 7] % M est une matrice 2 lignes 3 colonne
>> R = M ∗ N % R est le produit des deux matrices M et N
Vous pouvez extraire une ligne à partir d'une matrice comme suit :
>> D = M (1, :) % D est un vecteur constitué avec les éléments de la première ligne de la
matrice M
Comme le logiciel Matlab est logiciel basé sur le calcul matricielle il nous fournis des matrices
prédénis par exemple :

2.1. PROGRAMMATION
CHAPITRE 2. 20
>> A = eye(3, 3) % A est matrice identité d'ordre 3

>> B = toeplitz([2, 1, 0, 0]) % B est une matrice de Toeplitz dont la diagonal principal est
constitué par 2 est la diagonale supérieur est constitué par des 1
Noter que les fonctions scalaires courantes, (sin, exp, etc...) peuvent aussi s'appliquer à des
matrices, composante par composante, comme dans l'exemple suivant :
>> u = [1 : 0.1 : 2] % u est un vecteur contenant 11 valeurs equidistant (0.1) partant de 1 et
ayant comme valeur nal 2
>> t = cos(u) % t est un un vecteur calculant la valeur de chaque élément du vecteur u
A l'aide du logiciel Matlab vous pouvez savoir la position d'une valeur bien dénie, en utilisant
la fonction nd prenons l'exemple suivants :
>> A=rand(1,10) crée un vecteur ligne contenant 10 nombres repartis aléatoirement entre
0 et 1
>> nd(A>0.5) % renvoie les indices des composantes de A >0.5
>> nd(A) % renvoie les indices des composantes de A diérentes de 0
>> nd(A==0.2) % renvoie les indices des composantes de A égales a 0.2
Dans le tableau suivant nous donnons les principales opérations sur les matrices :
Instruction Description
zeros(n,m) crée une matrice de n lignes m colonnes contenant des 0
eye(n,m) crée une matrice de n lignes m colonnes contenant des 1 sur
la diagonale principale et 0 ailleurs
toeplitz(u) crée une matrice de Toeplitz symétrique dont la première
ligne est le vecteur u
diag(u) crée une matrice carrée avec le vecteur u sur la diagonale et 0 ailleurs
diag(A) extrait la diagonale de la matrice A
triu(A) renvoie la partie supérieure de A
tril(A) renvoie la partie inférieure de A
linspace(a,b,n) crée un vecteur de n composantes uniformément réparties de a à b
A\b résolution du système linéaire Ax = b
cond(A) conditionnement d'une matrice (norme euclidienne)
det(A) determinant d'une matrice
rank(A) rang d'une matrice
inv(A) inverse d'une matrice
pinv(A) pseudo inverse d'une matrice
svd(A) norme matricielle ou vectorielle
u' transposé de u
u*v multiplication matricielle
u+v addition matricielle
u-v soustraction matricielle
u.*v multiplication des deux matrice u et v terme à terme
u.v division des deux matrice terme à terme
nd(c(M)) indices des composants du matrice M vériant la condition c(M)

2.2. LES FONCTIONS
CHAPITRE 2. 21
2.2 Les fonctions

Pour dénir une nouvelle fonction sous Matlab, on écrit la dénition de la fonction dans
un chier avec une extension .m (fonction M-File). Le nom du chier doit être le nom de
la première fonction dénie (la seule visible). On l'exécute en tapant le nom de la fonction
avec entre parenthèses la liste des arguments.
La première ligne du chier de la fonction doit suivre la syntaxe suivante :
syntaxe : function arguments de sortie = nom(arguments d'entrée )

On doit donc déclarer les valeurs calculées par la fonction dans les arguments de sortie, et
les paramètres de la fonction dans les arguments d'entrée (qui ne sont pas modiés).
Remarque :
Attention, contrairement au script, les variables d'une fonction sont des variables locales,
qui ne sont pas accessibles en dehors de la fonction. Pour passer des information à une
fonction, il faut donc utiliser les paramètres d'entrée ou de sortie. En fait on peut utiliser des
variables globales (mot clé global) sous Matlab, mais cela est à éviter dans le cadre d'une
bonne programmation.
2.2.1 Exemples de fonctions sous Matlab

1. fonction récursive calculant n ! :
function y = f act(n)
if (n <= 1) y = 1
else y = n ∗ f act(n − 1)
end
On peut écrire cette fonction plus ecacement avec des boucles comme suit :
2. fonction calculant n ! avec des boucles :
function y = f actoriel(n)
% cette fonction vous permet de calculer le factoriel d'un entier
if (n <= 1)y = 1 ;
else
y = 1;
for i = 2 : n
y = y ∗ i;
end
end
2.2.2 Les fonctions M-les

Il faut bien noté qu'il est préférable d'écrire chaque fonction dans un M-le (éditeur de
texte), pour l'appeler, dans un programme, le temps que vous voulez.
la syntaxe générale d'une fonction est la suivante :
function [y1 , ..., ym ] = nom_f onction(x1 , ...., xn )

2.2. LES FONCTIONS
CHAPITRE 2. 22
.
{.. instructions de la fonction
end
où nom_f onction est le nom de la fonction, x1 , ....xn , les n arguments d'entrée et [y1 , ...ym ]
les m arguments de sortie.
Le passage des arguments d'entrée dans les fonctions se fait par valeur. Aussi, même si elles
sont modiées dans la fonction les valeurs des paramètres ne sont pas modiées dans le pro-
gramme appelant.
Si une des variables de la procédure n'est pas dénie à l'intérieur de celle-ci elle doit obliga-
toirement être fournie en argument d'entrée.
La récupération des valeurs calculées par la fonction se fait par les paramètres de sortie
([y1 , ..., yn ] dans la dénition de nom_f onction ci-dessus).
Prenons l'exemple d'une fonction angle, qui doit calculer l'angle formé par le segment
d'extrémités (0, 0) et (x, y) avec l'horizontale et aussi le dessiner. On peut créer le chier
angle.m contenant les lignes :
f unction[s] = angle(x, y)
s = 180 ∗ atan(y/x)/pi;
patch([x, 0, x], [0, 0, y],0 y 0 )
axisequal
On sauvegarde ce chier sous le nom angle.m, puis dans la fenêtre de commandes on tape :
>> angle(4,5)
Il faut bien noté que Le nom du chier contenant la fonction porte obligatoirement le nom de
cette dernière. On peut mettre plusieurs fonctions dans le même M-le mais seule la fonction
du même nom que le chier peut être utilisée, appelée, à partir de la fenêtre de commandes
ou d'une autre fonction ou d'un script. Les autres fonctions éventuellement stockées dans le
chier peuvent s'appeler entre elles mais ne sont pas visibles de l'extérieur.
S'il n'y a qu'un résultat comme dans l'exemple de la fonction angle, on peut se dispenser
de le récupérer dans une variable. En revanche s'il y a plus d'un paramètre de sortie, il faut
récupérer leurs valeurs dans des variables dans le script d'appel. Regardons par exemple
l'utilisation de la fonction polaire dénie ci-dessous et sauvée dans le chier polaire.m
f unction[r, theta] = polaire(x, y)
r = sqrt(x2 + y 2 );
theta = atan(y/x);
Dans la fenêtre, pour appeler la fonction, Matlab on tape une des instructions suivantes :
>> r=polaire(2,3) % Si nous somme intéressé seulement par le rayons ou bien
>> polaire(2,3)
ans =
3.6056
ou bien
>>[r,t]=polaire(2,3) % si on veut récupérer à la fois le rayon et l'angle
r=
3.6056
t=
.9828

2.2. LES FONCTIONS
CHAPITRE 2. 23
2.2.3 Les fonctions Inline

Si vous avez une fonction ne comportant qu'un petit nombre d'instructions, vous pouvez
la dénir directement dans la fenêtre de commandes Matlab de la manière suivante :
>> angle = inline(0 180 ∗ atan(y/x)/pi0 )
angle =
Inlinef unction :
angle(x, y) = 180 ∗ atan(y/x)/pi
>> angle(5, 4)
ans =
0.6747
Les arguments de la fonction angle sont normalement fournis à l'appel dans l'ordre d'ap-
parition dans la dénition de la fonction. On peut aussi spécier les arguments d'appel
explicitement >> f = inline(0 sin(alpha ∗ (x + y))0 ,0 x0 ,0 y 0 ,0 alpha0 )
f=
Inline function :
f(x,y,alpha) = sin(alpha*(x+y))
>> f (0.2, 0.3, pi)
ans =
1
2.2.4 Fonctions outils

Dans cette paragraphe nous présentons certaines commandes spéciales qui ne peuvent
s'utiliser qu'en relation à une fonction :
nargin, donne le nombre d'arguments d'entrée passés à l'appel de la fonction.
function c = testarg1(a,b)
if (nargin == 1)
c = 2 ∗ a;
elseif (nargin == 2) c = a + b; end nargin peut aussi être utilisée pour connaître le nombre
prévu d'arguments d'entrée
>> nargin('testarg1')
ans = 2 La commande nargout fonctionne de manière analogue pour les arguments de sortie.
Dans le tableau suivant nous représentons les principales fonctions qui sont utilisées dans les
fonctions.

2.2. LES FONCTIONS
CHAPITRE 2. 24
nargin nombre d'arguments d'entrée d'une fonction
nargout nombre d'arguments de sortie d'une fonction
error interrompt l'exécution de la fonction, ache le message d'erreur
et retourne dans le programme appelant.
warning imprime le message mais ne retourne pas dans le programme appelant
pause interrompt l'exécution jusqu'à ce que l'utilisateur tape un return
pause(n) interrompt l'exécution pendant n secondes.
pause o indique que les pause rencontrées ultérieurement doivent être ignorées,
ce qui permet de faire tourner tous seuls des scripts requièrent normalement
l'intervention de l'utilisateur.
break sort d'une boucle while ou for.
return retourne dans le programme appelant sans aller jusqu'à la n de la fonction.
2.2.5 fonctions préprogrammés sous matlab

Il existe de nombreux algorithmes préprogrammés dans Matlab pouvant être utilisés dans
des programmes de simulation plus complexes comme boîte noire. Tous sont répertoriés et
présentés dans l'aide en ligne. Leur nom peut se retrouver grâce aux menus search ou index
de help).
f zero(f, a) recherche des zéros d'une fonction f autour de a
quad(f, a, b) calcul de l'intégrale d'une fonction f entre a et b
spline(xx, yy) calcul de la spline cubique passant par les points (xx,yy)
f f t(a) transformation de Fourier rapide du vecteur a
ode23(f, t, y0) résolution de l'équation y'=f(t,x), y(0)=y0
A titre d'exemple nous détaillons ici la syntaxe pour utiliser la fonction f zero, pour
trouver une racine d'une fonction d'une variable. Syntaxes d'appel
x = f zero(f un, x0)
x = f zero(f un, x0, options)
x = f zero(f un, x0, options, P 1, P 2, ...)
[x, f val] = f zero(...)
[x, f val, exitf lag] = f zero(...)
[x, f val, exitf lag, output] = f zero(...)
• Description
• fun est une fonction inline ou 'f un' pour une fonction Matlab ou @f un pour un M _f ile.
• x = f zero(f un, x0) trouve un zéro près de x0, si x0 est un scalaire. La valeur x renvoyée
par f zero est près d'un point où fun change de signe ou bien N aN (Not a Number) si la
recherche a échouée.
• Si x0 est un vecteur à 2 composantes, f zero le comprend comme un intervalle tel que
f un(x0(1)) et f un(x0(2)) sont de signes opposés. Si ce n'est pas le cas il y a une erreur.
• x = f zero(f un, x0, [], P 1, P 2, ...) permet de passer des paramètres supplémentaires
P 1, P 2, etc, ... à la fonction f un.
Exemples
1) Trouver un zéro du polynôme dénit par :

2.3. LES BOUCLES
CHAPITRE 2. 25
p(x) = x2 − x − 2
On peut écrire les instructions suivantes : >> p = inline(0 x2 − x − 20 )
>> x = f zero(p, −2.3)
ou bien : >> x = f zero(p, 2)
2) Trouver un zéro de la fonction paramétrée dénie par :
>> p = inline(0 x2 − a ∗ x − 20 ,0 x0 ,0 a0 ) % df initiondelaf onction >> a = 1
% df initionduparamtre
>> p(2, a) % doitrenvoyer0 >> y = f zero(p, 3, optimset(0 disp0 ,0 of f 0 ), a) Le 3me argument
de f zero indique qu'on ne veut pas acher les messages éventuels. Le 4me (et suivant)
argument passe le paramètre supplémentaire de la fonction (ici a). p(y, a) doit renvoyer 0.
Une description plus détaillée de la fonction f zero, mais en anglais... est bien sûr disponible
dans l'aide en ligne.
2.3 Les boucles

Sous Matlab Il existe deux types de boucles à savoir : les boucles while et les boucles
f or.
La boucle f or (traduction du boucle pour en algorithmique) parcourt un vecteur d'indices
et eectue à chaque pas toutes les instructions délimitées par l'instruction end.
Exemple :
>> x = 1 ; f or k = 1 : 4, x = x ∗ k , end x =
1
x=
2
x=
6
x=
24
la boucle f or peut parcourir un vecteur (ou une matrice) en prenant comme valeur à chaque
pas les éléments (ou les colonnes) successifs comme dans l'exemple suivant :
>> v = [1, 2, 3]
>> x = 1 ; f or k = v, x = x + k , end
x=
2
x=
4
x=
7
La boucle while eectue une suite de commandes jusqu'à ce qu'une condition soit satisfaite.
>> x = 1, while x < 14, x = x + 5, x = x + 5, end
x=
6
x=

2.4. LES TESTS
CHAPITRE 2. 26
11
x=
16
Il faut bien noté que les deux types de boucles peuvent être interrompus par l'instruction
break . Dans les boucles imbriquées break n'interrompt que la boucle la plus interne.
2.4 Les tests

Un test est une alternative entre deux commandes (ou groupe de commandes ) Matlab
sélectionnées suivant le résultat d'une opération logique. Le résultat d'une opération logique
(voir tableau suivant) est une variable logique ou booléenne qui vaut 1 pour V RAI et 0 pour
F AU X .
français test Matlab
et &
ou |
non ∼
égal ==
diérent ∼=
plus petit que <
plus grand que >
plus petit ou égal à <=
plus grand ou égal à >=
Pour faire un test sous Matlab on utilise soit deux fonction if où bien while, avec les
syntaxes suivantes :
• Première variante T antque(Condition)instructions
sous Matlab cette instruction se traduit par :
while (condition)
instruction 1 ;
.......... ;
instruction n ;
end ;
Exemple :
calculer le plus petit entier n tel que 2n soit supérieur à un réel a donné.
sous Matlab on peut écrire le M-le suivant :
max = 2002;
n = 1;
while (2n < max) ;
n = n + 1;
end;
n
on trouvera n = 11 ;

2.4. LES TESTS
CHAPITRE 2. 27
• Deuxième variante
La traduction (d'un test simple) sous Matlab peut être comme suit : if (condition)
instruction1
...
instructionn
end
A noter que la condition peut être simple ou composée.
Exemple :
if ((a < 0&b < 0)k(a > 0&b > 0))
disp(' le produit de a et b est positif ')
end
Avec une autre variante où on a deux possibilités :
if (condition)
instructions1
else
instructions2
end
Si la condition n'est pas vérier alors les instructions 2 sont exécutées.
On peut trouver des tests imbriqué (l'une dans l'autre) comme suit :
if (condition1)
instructions 1
elseif (condition2)
instructions 2
elseif (condition3)
instructions 3
...
else (conditionN )
instructions N
end
Remarque :
On parle parfois de conditions au lieud'instructions la plus utilisé en programmation.
On a aussi la possibilité d'utiliser le switch-case, qui a son équivalent dans le langage C.
switch expression
case case_expr
commande,... ,commande
case case_expr1,case_expr2,case_expr3,...
... otherwise
end Cet élément de syntaxe permet de gérer plus élégamment les tests portant sur un seul
critère pouvant prendre plus de deux valeurs entières, comme dans l'exemple suivant
n=round(10*rand(1,1)) % plus proche valeur entière ex round (3.2)=3 et round (3.6)=4
switch n
case 0
f printf ('cas numero 0')

2.5. LA LECTURE
CHAPITRE 2. 28
case 1
case 2
otherwise
f printf ('autre cas')
end
2.5 La Lecture
La commande input permet de demander à l'utilisateur d'un programme de fournir des
données. La syntaxe est var = input(' tapper la valeur de ...'). La phrase tapper la valeur
de ... est achée et MATLAB attend que l'utilisateur tape une donnée au clavier. Cette
donnée peut être une valeur numérique ou une instruction MATLAB. Une valeur numérique
est directement aectée à la variable var tandis qu'une instruction MATLAB est évaluée et
le résultat est aecté à la variable var. Il est possible de provoquer des sauts de ligne pour
aérer le présentation en utilisant le symbole \n de la manière suivante : var = input('\ n
une phrase :\ n ').
Pensez à mettre un point virgule ( ;) à la n de l'instruction si vous ne souhaitez pas voir
s'acher var =.
Sous cette forme il est impossible d'avoir une donnée de type chaîne de caractères dans la
mesure où MATLAB essaie d'interpréter cette chaîne de caractères comme une instruction.
Si l'on souhaite saisir une réponse de type chaîne de caractères on utilise la syntaxe
var = input(' une phrase ','s').
Exemple
rep = input(' Achage du resultat ? o/n [o] ','s') ;
if isempty(rep), rep = 'o' ;
end
if rep == 'o' | rep == 'y'
disp(['Le resultat vaut ', num2str (rep)])
end
2.6 Impressions
La commande sprintf permet l'impression de variables selon un modèle donné. Un
modèle d'édition se présente sous la forme du symbole pourcent (%) suivi d'indications
permettant de composer le contenu du champ à imprimer, en particulier sa longueur en
nombre de caractères. Le modèle d'édition utilisé par MATLAB est le modèle d'édition du
langage C.
La syntaxe de la commande sprintf est :
sprintf (format, variables )
où

2.6. IMPRESSIONS
CHAPITRE 2. 29
Figure 2.2 This table shows conversion characters to format numeric and character data
as text.
♣ variables : est le nom des variables à imprimer suivant le modèle d'édition spécié dans
format ;
♣ format : est le format d'édition. Il s'agit d'une chaîne de caractères contenant les modèles
d'éditions des variables à imprimer.
Dans le tableau suivant nous donnons quelques exemples d'utilisation du sprintf.

Command Result
sprintf('%0.5g',(1 + sqrt(5))/2) 1.618
sprintf('%0.5g',1/eps) 4.5036e+15
sprintf('%15.5f',1/eps) 4503599627370496.00000
sprintf('%d',round(π )) 3
sprintf('%s','hello') hello
sprintf('The array is %dx%d.',2,3) The array is 2 × 3
sprintf('\n') Line termination character on all platforms

2.7. LECTURECHAPITRE
ET ÉCRITURE
2. INITIATION30
À LA PROGRAMMATION AVEC MATLAB
2.7 Lecture et écriture

On peut avoir à lire des données numériques ou alphanumériques dans un chier, par
exemple les conditions initiales d'un calcul ou un maillage qui a été généré par un autre
programme. Inversement, on peut vouloir sauver le résultat d'un calcul, pour s'en servir
ultérieurement dans Matlab ou dans un autre programme.
M = dlmread ('NomDeFichier','Delimiteur')
Lit des données numériques du chier ASCII NomDeFichier, chaque nombre est séparé du
suivant par le caractère Délimiteur ou par un retour à la ligne. La virgule et l'espace sont des
délimiteurs par défaut.
[A, B, C, ...] = textread ('NomDeFichier ','format ') Lit les variables avec le format spécié
jusqu'à épuisement du chier. (Le nombre de variables à lire et le nombre de données dans
le chier doivent correspondre.) d =fopen ('NomDeFichier ') % ouvre le chier
A = fscanf(d,format)
[A,count] = fscanf(d,format,size)
Lit les données avec le format spécié. Un format est une chaîne de caractères spéciant
en lecture le type de données à lire :
'%d' pour un entier
'%f ' pour un réel
'%c'pour un caractère.
On peut éventuellement spécier le nombre maximal de données à lire avec le paramètre size,
et le paramètre de sortie count renvoie le nombre de données eectivement lues.
Pour écrire des résultats sur l'écran la méthode la plus simple et de taper le nom de la variable
sans la faire suivre d'un point virgule. Si on veut un format plus lisible, en particulier, acher
plusieurs variables sur la même ligne, on peut utiliser la commande fprintf, comme dans
l'exemple ci-dessous :
a=1.5 ;
b=2 ;
fprintf ('a = %f et b= %d',a,b) ;
a =1.5 et b=2
Les commandes d'entrée sortie et les accès chiers.
dlmread ('NomDeFichier','delimiteur') lecture du chier
dlmwrite ('NomDeFichier',M,'delimiteur') écriture de M dans le chier
textread ('NomDeFichier','format') lecture du chier
d=open ('NomDeFichier') ouverture du chier NomDeFichier
[A,count]=fscanf (d,'format') lecture du chier ouvert par open
fprintf (d,'format',données) écriture des données avec un format
close (d) fermeture
fprintf ('format',données) écriture des données avec un format
fprintf ('format',données) écriture des données avec un format
2.8 Représentation graphique

Dans toutes les représentations graphiques, le logiciel se base sur des données discrètes
rangées dans des matrices ou des vecteurs colonnes.

2.8. REPRÉSENTATION
CHAPITREGRAPHIQUE
2. INITIATION31
Figure 2.3 représentation graphique d'une fonction
Par exemple, pour représenter des courbes du type y = f (x) ou des surfaces z = f (x, y), les
données x,y,z doivent être des vecteurs colonnes (x et y) ou des matrices (z) aux dimensions
compatibles. L'instruction de dessin correspondante (par exemple plot(x,y) pour tracer des
courbes planes) est alors utilisée et éventuellement complétée par des arguments optionnels
(couleur, type de trait, échelle sur les axes, etc...).
La visualisation du résultat s'eectue dans une fenêtre graphique (avec possibilité de zoom,
de rotation, d'impression).
Prenons, comme exemple, le script suivant :
x = linspace(0, pi, 30) ; % crée un tableau de 30 composantes uniformément réparties
entre 0 et π
y = sin(x) ;
plot(x, y) % relie les points (xi,yi) par un trait continu noir
plot(x, y,0 p − b0 ) % relie les points (xi,yi) par un trait continu de couleur et matérialise les
points avec un symbole
xlabel(0 l00 axedesx0 ) % le titre de l'axe des x ylabel(0 sin(x)0 ) % le titre de l'axe des y
plot(x, y,0 pb0 ) % matérialise les points (xi,yi) avec un symbole de couleur Les points peuvent
être matérialisés par le symbole p prenant les valeurs suivants : o . ∗ + × Les couleurs sont
repérées par leur initiale en anglais : r(ed), b(lue), blac(k), w(hite), y(ellow), m(agenta),
g(reen) On peut rajouter un titre à la gure avec la commande title comme suit :
title('sin(x) sur l'intervalle [0,pi]'), gure (4.1)
Il faut remarquer qu'on peut tracer plus de courbes dans une même gure (4.2). A noter
que Matlab va donner automatiquement des couleurs (vous pouvez les changer sur l'éditeur
de gure ou bien les dénissez dans le script).
plot(x,cos(x),x,sin(x),x,exp(-x)) % Matlab va automatiquement utiliser des couleurs dié-

CHAPITREGRAPHIQUE
2. INITIATION32
rentes pour chaque courbe

plot (x,cos(x),'o-r',x,sin(x),'x-b',x,exp(-x),'*-g') % pour spécier le type de symbole et la cou-
leur à utiliser pour chaque courbe
legend ('cos(x)','sin(x)','exp(-x)') % pour rajouter une légende
Remarque :
Figure 2.4 représentation graphique de 3 gure sur une même gure
Par défaut la fenêtre graphique est eacée avant chaque commande plot. Pour superposer
(gure 4.2) des courbes par des appels successifs à cette fonction, il faut auparavant avoir
utilisé la commande hold on. Dans le script suivant nous donnons un exemple de fonctionne-
ment de la commande hold on.
hold on
plot(x,x*x,'o-r')
plot(x,sin(x),'x-b')
plot(x,exp(-x),'*-g')
legend('x2 ','sin(x)','exp(-x)')
Dans le tableau suivant nous donnons les principales fonctions utilisé dans la
représentation graphique tracé d'une courbe. Principales instructions graphiques.

CHAPITREGRAPHIQUE
2. INITIATION33
plot(x,y) tracé de la courbe passant par les points (x,y)
loglog(x,y) idem avec échelle logarithmique sur les deux axes
semilogx(x,y) idem avec échelle logarithmique sur l'axe Ox
semilogy(x,y) idem avec échelle logarithmique sur l'axe Oy
plotyy(x,y,x,z) courbe (x,y) avec l'axe (0y) à gauche,
et courbe (x,z) avec l'axe (0z) à droite
xlabel('label') légende pour l'axe (0x)
ylabel('label') légende pour l'axe (0y)
title('label') titre au dessus du graphique
legend('lab1','lab2','lab3',...) légende avec une chaîne de caractères pour chaque courbe
text(x,y,'label') chaîne de caractères à la position x,y
plot3(x,y,z) tracé de la surface passant par les points (x,y,z)
hold on, hold o activedésactive la conservation de la fenêtre graphique
à l'appel de la fonction plot
Remarque :
Outre la représentation cartésienne de courbes ou de surfaces, il existe d'autres possibilités
pour illustrer graphiquement un résultat. On peut citer parmi les plus utiles, les instructions
contour,ezmesh (pour tracer les courbes de niveau d'une surface paramétrique), mesh,ezplot 3
(courbes paramétriques dans l'espace), hist, rose (histogramme d'un échantillon de données
statistiques), etc...
Exemple :
Le script suivant produit la courbe présenté dans la (gure (4.3)).
[X, Y ] = meshgrid (−3 : .125 : 3) ;
Z =peaks (X, Y ) ;

2.9. CONCLUSION
CHAPITRE 2. 34
meshc (X,Y,Z) ;
axis ([−33 − 33 − 105])
2.9 conclusion
Dans ce chapitre nous avons donné une présentation des principaux fonctions utilisés
sous matlab. La richesse du matlab réside dans la présence des toolboxes comme :
Control System Toolbox

Symbolic Math Toolbox
Signal Processing Toolbox
Neural Network Toolbox Optimization Toolbox
Parallel Computing Toolbox
Statistics Toolbox
Fuzzy Logic Toolbox
Image Processing Toolbox
Aerospace Toolbox
Data Acquisition Toolbox
Bioinformatics Toolbox
MATLAB Compiler Vehicle Network
Toolbox Model-Based Calibration Toolbox
Financial Toolbox
RF Toolbox
System Identication Toolbox
...

Chapitre 3
Intégration numérique
3.1 Introduction
Les méthodes numériques d'intégration doivent être utilisées lorsque :
L'intégrale ne peut pas être évaluée analytiquement
L'intégrande n'est pas donné sous forme analytique (mais numériquement pour un
certain nombre de valeurs discrètes)
Dans ce chapitre, nous aborderons les méthodes permettant de traiter les intégrales de fonc-
tions bornées sur un intervalle. Principalement nous décrivons les méthodes suivantes :
1. Méthode rectangles
2. Méthode des Trapèzes
3. Méthode des Trapèzes avec correction aux extrémités
4. Méthode de Simpson
3.2 Méthode des rectangles

3.2.1 Principe de La méthode
Cette méthode, très élémentaire, basée sur les sommes de Cauchy-Riemann (approchant
l'aire sous une courbe) et appliquée à une fonction f continue, permet le calcul approché
d'intégrales en choisissant une subdivision régulière de pas xi+1 − xi = (b − a)/n, donc
indépendant de i avec une valeur de n "susamment grande". On obtient une succession
de rectangles en rose ( gure 3.2), d'où le nom de cette méthode, approchant l'aire sous la
courbe, où ci est choisi ici au "milieu" de [xi ; xi+1 ]. On calcule :
n−1
X
Sn = h f (ci ) (3.1)
i=0
avec : h = (b − a)/n, xi = a + ih, ci = (xi+1 + xi )/2 = a + ih + h/2.

A noté que lorsque n tend vers l'inni (n très grand) nous obtenons l'intégrale cherchée.
Remarque :
35
3.2. MÉTHODE DES RECTANGLES 36
CHAPITRE 3. INTÉGRATION NUMÉRIQUE
Figure 3.1 Description de la méthode des rectangles
Dans la gure 3.2 le coloriage en bleu (resp. en vert) indique des portions d'aires de rectangles
en excès (resp. en manque). Ce qui implique des erreurs ! !
3.2.2 Evaluation de la méthode des rectangles

On montre facilement, que l'erreur est en 1/n, plus précisément inférieure à :
(b − a)2
e≤ × sup |f 0 (x)| (3.2)
2n x∈[a,b]
Le lecteur intéressé par le calcul de cette majoration pourra se reporter au calcul similaire
Figure 3.2 l'erreur est en 1/n de la méthode des rectangles

de l'évaluation de l'erreur commise par la méthode des trapèzes. Cette dernière, en 1/n2 , est

3.3. MÉTHODE DES TRAPÈZES 37
plus ecace : à précision égale, 100 points de subdivision équivalent, grosso modo à 10000
points par la méthode des rectangles. Mais cela est très théorique. Tout dépend de la fonction
et de l'amplitude de l'intervalle d'intégration. Sans oublier les erreurs d'arrondis.
3.3 Méthode des trapèzes

La méthode de trapèzes consiste à remplacer la courbe f (x) par une ligne brisée et
à calculer l'aire de chaque trapèze (g.4.3). donc on aura l'approximation suivante : avec
Figure 3.3 Représentation graphique (Exemple 1)

∆xi = xi − xi−1 Z xi
fi−1 + fi
f (x)dx = ( )∆xi
xi−1 2
On somme les aires de tous les trapèzes. Soit [a, b] l'intervalle d'integration divisé en n
intervalles :
x0 = a, x1 , x2 , ..., xn = b
ce qui nous donne :
Z b n
1X
f (x)dx = (fi−1 + fi )∆xi
a 2 i=1
si les points sont régulièrement espacés : ∆xi = ∆x = b−a

n
Nous obtenons l'expression suivante :
Z b
∆x
f (x)dx ' [(f0 + f1 ) + (f1 + f2 ) + ... + (fn−2 + fn−1 ) + (fn−1 + fn )]
a 2
n−1
∆x X
' [f0 + fn + 2 fi ] (3.3)
2 i=1
3.3.1 Estimation de l'erreur

On utilise un développement en série de Taylor au 1er ordre. (courbe remplacée par une
sécante). On néglige les termes du 2eme ordre en ∆x. Plus ∆x est petit, plus la méthode est

3.3. MÉTHODE DES TRAPÈZES 38
précise.
b n−1
(∆x)2
Z
∆x X
f (x)dx = [f0 + fn + 2 fi ] − (b − a)f ” (x) + θ(∆x4 )
a 2 i=1
12
2 0 0
Avec (∆x)
12
(b − a)f ” (x) + θ(∆x4 ) représente l'erreur commise où f ” (x) = f (b)−f
b−a
(a)
En se basant sur la correction aux extrémités, la formule des trapèzes devient :
b n−1
(∆x)2 0
Z
∆x X 0
f (x)dx = [f0 + fn + 2 f( xi )] − [f (b) − f (a)]
a 2 i=1
12
algorithme de la méthode de trapèse

Principe de la méthode (f étant une fonction continue sur [a, b]) : On découpe l'intervalle
[a, b] en "petits" intervalles de même amplitude (cette amplitude est appelée "pas"). Sur
chacun de ces "petits" intervalles de la forme [a + i ∗ pas; a + (i + 1) ∗ pas], on peut prendre
comme approximation de l'intégrale de f l'aire du trapèze formé par les points de la courbe
d'abscisse a + i ∗ pas et a + (i + 1) ∗ pas et leurs projetés sur l'axe des abscisses. L'aire de
chaque petit trapèze est en fait égal à : pas/2 ∗ (f (a + i ∗ pas) + f (a + (i + 1) ∗ pas)).
Il sut donc d'ajouter toutes les aires des "petits" trapèzes pour avoir une valeur approchée
Figure 3.4 Représentation graphique la fonction f (x) = x2

de l'intégrale sur [a, b].
Dans l'algorithme ci-dessous la fonction f est dénie par f (x) = x2 et le pas est calculé à
partir du nombre de trapèzes utilisés.
Algorithme :
Variables a, b, nbr, pas, ap en numériques
variable i entier
Début
3.4. MÉTHODE DE SIMPSON 39
Ecrire "entrer les deux bornes de l'intégrale"

lire a, b
Ecrire " entrer nombre de trapèse :
lire nbr
Si (nbr>0 et b > a) alors
ap ← 0
pas ← (b − a)/nbr
pour i ← 0 à nbr − 1
ap ← ap + pas/2 ∗ (f (a + i ∗ pas) + f (a + (i + 1) ∗ pas))
i suivant
Ecrire "l'appriximation de l'inegrale est" ap
nsi
n
Exemple 2 : la méthode des trapèzes

Nous
R 4 x proposons de calculer, par la méthode des trapèzes, l'integral suivant :
I = 0 e dx.
On a bien sûr que la valeur exacte de cet integral est : I = e4 − e0 = 53.598150 En utilisant
quatre tranche Méthode des trapèzes avec 4 tranches : ∆x = 1. On a donc :
Itr = 12 [e0 + e4 + 2(e1 + e2 + e3 )] = 57.991950
L'erreur relative est donc : Er = ItrI−I = 8.210−2
En utilisant la méthode de trapèze avec correction aux extrémités :
1
I = 57.991950 − 12 [e4 − e0 ] = 53.525437
L'erreur relative devient maintenant :1.410−3
3.4 Méthode de Simpson

La méthode de Simpson, du nom de Thomas Simpson, est une technique de calcul numé-
rique
R b d'une intégrale, c'est-à-dire, le calcul approché de :
a
f (x)dx
Cette méthode utilise l'approximation d'ordre 2 de f par un polynôme quadratique P
prenant les mêmes valeurs que f aux points d'abscisse a, b et m = (a + b)/2. Pour déterminer
l'expression de cette parabole (polynôme de degré 2), on utilise l'interpolation Lagrangienne.
Elle consiste à remplacer, entre xi−1 et xi+1 , la fonction par l'arc de parabole passant par
fi−1 , fi , fi + 1. R
x
Posons : I(x) = a f (x0 )dx0 , on a donc : I(x)dx
= f (x) Pour ces conditions :
(∆x)2 0 (∆x)3 00 (∆x)4 000

I(xi+1 ) = I(xi + ∆x) = I(xi ) + δf (xi ) + f (xi ) + f (xi ) + f (xi ) + θ(∆x)5
2 3! 4!
(3.4)
2 3 4
(∆x) 0 (∆x) 00 (∆x) 000
I(xi−1 ) = I(xi − ∆x) = I(xi ) − δf (xi ) + f (xi ) − f (xi ) + f (xi ) − θ(∆x)5
2 3! 4!
(3.5)

3.4. MÉTHODE DE SIMPSON 40
Figure 3.5 Calcul d'integral par la méthode de Simpson
On retranche l'équation (3.4) de l'équations (3.5), on obtient l'aire Ai des deux tranches
[xi−1 , xi ] et [xi , xi+1 ] centré sur xi :
Ai = I(xi+1 ) − I(xi−1 )
Ce qui nous donne :
3 00
Ai = 2∆xf (xi ) + (∆x) 3
f (xi ) + θ(∆x)5
00
On remplace f (xi ) par son expression utilisant les diérences centrales :
00 f (xi−1 ) − 2f (xi+1 ) − f (xi+1 )

f (xi ) = + θ(∆x)2 (3.6)
(∆x)2
Nous obtenons, en utilisant la notation f (xi ) = fi : Ai = 2∆xfi + ∆x
3
(fi−1 − 2fi + fi+1 ) +
(∆x)3
θ(∆x)2 +θ(∆x)5
| 3 {z }
negliger
D'où : Ai = ∆x 3
(fi−1 + 4fi + fi+1 ) + θ(∆x)5 L'aire totale est obtenue par :
Rb
a
f (x)dx = A1 + A3 + ... + Ann−1
RbCeci nécessite que le nombre d'intervalle soit pair. Nous obtenons donc, au nal :
a
f (x)dx = ∆x3
(f0 + 4f1 + f2 ) + ∆x
3
(f2 + 4f3 + f4 ) + ... + ∆x
3
(fn−2 + 4fn−1 + fn ) + n2 θ(∆x)5
On regroupe les termes, en remarquant que :
n b−a
2
θ(∆x)5 = 2∆x θ(∆x)5 = θ(∆x)4
Il vient :
Z b n−1 n−2
∆x X X
f (x)dx = [f (a) + f (b) + 4 f (xi ) + 2 f (xi )] + θ(∆x)4 (3.7)
a 3 i=1 i=2
|{z} |{z}
i:impair i:pair
Ou encore
Z b
∆x X X
f (x)dx = [f (a) + f (b) + 4 fimpair + 2 fpair ] + θ(∆x)4 (3.8)
a 3
Exemple de calcul d'integral avec la méthode de Simpson

R4
Considérons l'integral suivant : 0
f (x)dx.
Avec 4 tranches, ∆x = 1

3.5. MÉTHODE DE MONTE-CARLO 41
I = 13 [e0 + e4 + 4(e1 + e3 ) + 2e2 ] = 53.863846 l'erreur relative est de 5.10−3
3.5 Méthode de Monte-Carlo

3.5.1 Principe
On reprend l'exemple de l'intégrale d'une fonction à une variable sur l'intervalle [a, b].
Soient N réels xi tirés aléatoirement sur l'intervalle [a, b] avec une densité de probabilité
uniforme, égale à
1
p(x) = (3.9)
b−a
L'évaluation de l'intégrale par la méthode de Monte-Carlo consiste (dans sa forme élémen-
taire) à calculer la somme suivante :
N −1
b−a X
SN = f (xi ) (3.10)
N i=0
Il s'agit de la même formule que celle de la méthode des rectangles, avec des points répartis
aléatoirement sur l'intervalle.
En introduisant la variable aléatoire X , cette somme est une évaluation de l'espérance de
f (X), multipliée par (b − a). Pour obtenir une expression plus générale, considérons une
variable aléatoire réelle X sur l'intervalle [a, b] avec une densité de probabilité p(x).
Pour une fonction g , l'espérance de g(X) est :
Z b
E(g(x)) = p(x)g(x)dx (3.11)
a
En posant f (x) = p(x)g(x), on peut écrire :

Z b
E(f /p(x)) = f (x)dx (3.12)
a
Une approximation de l'intégrale est donc obtenue en évaluant l'espérance de f /p avec N

échantillons xi tirés dans l'intervalle [a, b] avec une densité de probabilité p, soit :
N −1
1 X f (xi
SN = moy(f /p, N ) = (3.13)
N i=0 p(xi )
Dans le cas d'une densité uniforme, on retrouve l'expression (3.10). Notons que σ 2 la variance
de f (x)/p(x), dénie par :
σ 2 = E((f /p)2 ) − [E(f /p)]2 (3.14)
La variance de la moyenne empirique est :
σ2
var(SN ) = (3.15)
N

3.6. CONCLUSION 42
Il s'en suit que l'écart-type se réduit comme l'inverse de la racine carré de N lorsqu'on
augmente le nombre d'échantillons. Ce résultat reste valable pour une intégrale double, triple,
etc. L'évolution de la variance de la somme avec N est indépendante de la dimension d
de l'espace. Pour une intégrale simple, cette convergence en 1/ (N ) est plus lente que la
p
convergence en 1/N de la méthode des rectangles, qui est la méthode de quadrature la plus
lente. La méthode de Monte-Carlo peut cependant devenir avantageuse pour les intégrales
triples ou en dimension supérieure à 3, lorsque la précision souhaitée est faible. Pour évaluer
la précision du résultat, il faut évaluer la variance σ 2 . Cela peut se faire avec le calcul de la
moyenne, en calculant la variance empirique :
N −1
1 X f (xi ) 2
VN = var(f /p, N ) = ( 2
) − SN (3.16)
N i=0 p(xi )
En divisant par N , on obtient la variance de la somme. L'intervalle de conance à 95% est :

√ √
1.96 VN 1.96 VN
[SN − √ , SN − √ ] (3.17)
N N
L'intégrale considérée a une probabilité 0, 95 de se trouver dans cet intervalle. La dépendance
de la variance de la somme en fonction de N est toujours, quelle que soit la dimension de
l'espace et la fonction intégrée. Pour réduire la variance, il faut réduire la variance σ 2 de
f /p. L'amélioration de la convergence consiste donc à choisir une densité de probabilité p(x)
qui minimise la variance et qui ne soit pas trop dicile à échantillonner. Supposons que et
considérons la densité de probabilité particulière suivante :
f (x)
p0 (x) = R b (3.18)
a
f (x)dx
La variance est dans ce cas : Z b
2
σ = var( f (x)dx) = 0 (3.19)
a
La variance est nulle, mais cette densité de probabilité po (x) n'est pas réalisable car il faudrait
pour cela connaître l'intégrale que l'on cherche. Pour réduire la variance, on cherche à dénir
une densité de probabilité qui s'approche au mieux de la forme de la fonction f , tout en étant
simple et peu coûteuse à échantillonner. C'est ce qu'on appelle l'échantillonnage préférentiel
(importance sampling). La densité de probabilité doit être grande là où la fonction f a une
valeur absolue grande.
3.6 conclusion
Dans ce chapitre nous avons présenté les techniques de calcul d'integral numériquement
en passant de la technique des rectangles qui est très naturelle puisqu'elle sont basée sur
les formules qui permettent de construire l'intégrale (de Riemann) : les sommes de Darboux
ou de Riemann. La méthode méthodes du trapèze utilise l'approximation d'integral par un
polynôme d'ordre 1 passant par les points f (a) et f (b). La méthode de Simpson utilise l'ap-
proximation d'integral par un polynôme d'ordre 2 et nalement la méthode de Monte-carlo
qui se base sur l'utilisation d'une densité de probabilité uniforme sur l'intervalle considéré.

Chapitre 4
Résolution numérique des équations non
linéaires f (x) = 0
4.1 introduction
Lorsque on peut pas chercher analytiquement les zéros (ou les racines) d'une fonction
f nonlinéaire, nous cherchons numériquement les racines approchés de cette fonction. En
général, cette tâche ne peut être accomplie dans un ensemble ni en nombre d'opérations.
Par exemple, lorsque f est un polynôme générique de degré supérieur à quatre, il n'existe
pas de formules explicites pour calculer ses zéros. La situation est encore plus dicile lorsque
f n'est pas un polynôme. On doit faire appel aux méthodes itératives. A partir de l'une
ou plusieurs données initiales, ces méthodes consistent à construire une séquence de valeurs
x(k) qui convergera vers un zéro de la fonction f .
En résumé :
Un algorithme de recherche d'un zéro d'une fonction est une méthode numérique
ou un algorithme de recherche d'une valeur approchée d'un x vériant f (x) = 0,
pour une fonction donnée f . Ici, x est un nombre réel appelé zéro de f ou lorsque
f est polynomiale, racine de f .
Lorsque x est un vecteur, les algorithmes pour trouver x tel que f (x) = 0 sont généralement
appelés : algorithmes de résolution numérique d'un système d'équations. Ces algorithmes
sont une généralisation des algorithmes de recherche d'un zéro d'une fonction et peuvent
s'appliquer à des équations linéaires ou non linéaires. Certains algorithmes de recherche des
zéros (comme la méthode de Newton) peuvent être généralisés à la résolution numérique
des systèmes d'équations non linéaires.
4.2 Méthode de bisection ou dichotomie[2, 3]

La méthode de dichotomie ou méthode de la bissection est, en mathématiques, un
algorithme de recherche d'un zéro d'une fonction qui consiste à répéter des partages d'un
intervalle en deux parties puis à sélectionner le sous-intervalle dans lequel existe un zéro de
la fonction.
43
CHAPITRE 4. RÉSOLUTION NUMÉRIQUE DES ÉQUATIONS NON LINÉAIRES
4.2. MÉTHODE DE BISECTION OU DICHOTOMIE

44 [2, 3] F (X) = 0
Figure 4.1 exemple de fonction non linéaire
4.2.1 Principe
On considère deux nombres réels a et b et une fonction réelle f continue sur l'intervalle
[a, b] telle que f (a) et f (b) soient de signes opposés (4.1). Supposons que nous voulions
résoudre l'équation f (x) = 0. D'après le théorème des valeurs intermédiaires, f a au moins
un zéro dans l'intervalle [a, b]. La méthode de dichotomie consiste à diviser l'intervalle en
deux en calculant c = a+b 2
. Il y a maintenant deux possibilités : ou f (a) et f (c) sont de signes
contraires, ou f (c) et f (b) sont de signes contraires.
L'algorithme de dichotomie est alors appliqué au sousintervalle dans lequel le changement

de signe se produit, ce qui signie que l'algorithme de dichotomie est récursif. L'erreur absolue
de la méthode de dichotomie est au plus égale à :
b−a
erreur = (4.1)
2n+1
après n étapes car l'erreur est diminuée de moitié à chaque étape. Ainsi, la méthode converge
linéairement, ce qui est très lent par comparaison avec la méthode de Newton.
L'avantage par rapport à cette dernière est son domaine d'application plus vaste : il sut
seulement que f (a) et f (b) soient de signes opposés et qu'on puisse déterminer le signe de
f (c) à chaque itération. De plus, si l'on se donne la tolérance relative , on sait majorer le
nombre d'itérations nécessaires pour satisfaire cette tolérance :
1
2n+1 ≤ (4.2)

4.2.2 Algorithme
Suivant le signe de la valeur f (m), avec m = a+b
2
, voilà un pseudo code décrivant la
méthode de dichotomie.
Tant que (b − a) >
m ← (a + b)/2
Calcul f (m)
4.3. MÉTHODE DE NEWTON 45 F (X) = 0
Si ((f (a) ∗ f (m)) > 0) alors

a←m
sinon
b← m
Finsi
Fin
4.2.3 Limite de la méthode

Même si que la méthode de dichotomie présente une grande robustesse, elle nécessite
cependant de connaître à chaque étape le signe de f (m). Dans quelques cas, il peut arriver
que la valeur de f (m) soit si proche de 0 que la précision du logiciel de calcul ne permette
plus de déterminer le signe de f (m) (le logiciel de calcul assimile f (m) à 0). L'application de
l'algorithme risque alors de conduire à l'élimination erronée d'une moitié de l'intervalle et à
la convergence vers une valeur éloignée de la racine.
4.3 Méthode de Newton

La méthode de Newton, appelée aussi méthode de Newton-Raphson, suppose que f est
de classe C 1 . Cette méthode plus ecace que celle de dichotomie, elle peut être construite
en exploitant les valeurs atteintes par f et sa dérivée. La méthode permet de chercher à
construire une bonne approximation d'un zéro de la fonction d'une variable réelle f (x) en
considérant son développement de Taylor au premier ordre. Pour cela, partant d'un point x0
que l'on choisit de préférence proche du zéro à trouver (en faisant des estimations grossières
par exemple), on approche la fonction au premier ordre, autrement dit, on la considère à
peu près égale à sa tangente en ce point :
f (x) ' f (x0 ) + f 0 (x0 )(x − x0 ) Partant de là, pour trouver un zéro de cette fonction
d'approximation, il sut de calculer l'intersection de la droite tangente avec l'axe des
abscisses, c'est-à-dire résoudre l'équation ane :
0 = f (x0 ) + f 0 (x0 )(x − x0 )

On obtient alors un point x1 qui en général a de bonnes chances d'être plus proche du vrai
zéro de f que le point x0 précédent. Par cette opération, on peut donc espérer améliorer
l'approximation par itérations successives (4.2) : on approche à nouveau la fonction par sa
tangente en x1 pour obtenir un nouveau point x2 , etc. Cette méthode requiert que la fonction
possède une tangente en chacun des points de la suite que l'on construit par itération, par
exemple il sut que f soit derivable.
Formellement, on part d'un point x0 appartenant à l'ensemble de dénition de la fonction et
on construit par récurrence la suite :
xk+1 = xk − ff0(x k)
(xk )
où f 0 désigne la dérivée de la fonction f . Le point xk+1 est bien la solution de l'équation

4.4. MÉTHODE DE LAGRANGE OU MÉTHODE

46 DE LA SÉCANTE F (X) = 0
Figure 4.2 Description de la méthode de Newton-Raphson
ane
f (xk ) + f 0 (xk )(x − xk ) = 0.
Bien que la méthode soit très ecace, certains aspects pratiques doivent être pris en compte.
Avant tout, la méthode de Newton nécessite que la dérivée soit eectivement calculée. Dans
les cas où la dérivée est seulement estimée en prenant la pente entre deux points de la fonction,
la méthode prend le nom de méthode de la sécante, moins ecace et inférieure à d'autres
algorithmes. Par ailleurs, si la valeur de départ est trop éloignée du vrai zéro, la méthode
de Newton peut entrer en boucle innie sans produire d'approximation améliorée. À cause
de cela, toute mise en oeuvre de la méthode de Newton doit inclure un code de contrôle du
nombre d'itérations.
4.4 Méthode de Lagrange ou Méthode de la sécante

L'inconvénient de la méthode de la bissection est que l'on divise l'intervalle par deux
sans chercher particulièrement à s'approcher du zéro qui est peut-être très proche d'une des
valeurs initiales.
Hypothèse f (x0 )f (x1 ) < 0 (il existe une solution sur l'intervalle ]x0 , x1 [), On en déduit x2 à
Figure 4.3 Description de la méthode de Lagrange (ou de la sécante)

partir de x1 et x0 par application du théorème de Tales
x2 − x1 x 0 − x1
= (4.3)
0 − f (x1 ) f (x0 ) − f (x1 )
se qui donne
f (x1 )
x2 = x1 − (x1 − x0 ) (4.4)
f (x1 ) − f (x0 )

4.5. CONCLUSION 47 F (X) = 0
On teste le produit f (x2)f (x1). Si f (x2)f (x1) < 0 alors on met x2 dans x0 (f (x2)) dans
f (x0 )) Et on recommence jusqu'à validation de la condition d'arrêt |x2 − x0 | < . En général,
cette méthode converge plus vite que la méthode de la bissection.
4.5 conclusion
Dans ce chapitre nous avons présenté les principaux algorithmes de recherche des zéros
des fonctions non linéaires à savoir la méthode de dichotomie qui est basée sur le théorème
des valeurs intermédiaire et le changement de signe de la fonction. La deuxième méthode que
nous avons présenté dans ce chapitre est la méthode de Newton qui est plus ecace que celle
de dichotomie, elle est basée sur la développement au premier ordre de la fonction (supposé
de classe C 1 ). La troisième méthode est celle de Lagrange qui se base sur le théorème de
Tales est elle converge plus rapidement que celle de bisection.

Chapitre 5
Résolution des ED
5.1 Introduction
L'objet de ce chapitre est la résolution des équations diérentielles issues des phénomènes
physique à l'aide du logiciel MATLAB. Après modélisation et mise au point des équations,
intervient la programmation sous MATLAB. Ceci est eectué à travers un exemple très réel.
5.1.1 Un modèle de dynamique des populations

Un problème pratique de pêche
Vito Volterra, mathématicien et physicien italien du début du XX eme siècle fut confronté
à un problème curieux de dynamique des populations. On lui exposa le phénomène suivant :
entre 1905 et 1923, les eectifs des populations de sardines et de leurs prédateurs en mer
Adriatique semblaient osciller, et qui plus est, en décalage de phase.
Volterra, spécialiste des systèmes dynamiques et des équations diérentielles qui les dé-
crivent, a eu vite fait de construire un modèle d'évolution de ces populations, qu'il publia en
1926.
Un mathématicien américain, Alfred James Lotka, publia indépendamment en 1924 (ou 25
les dates varient selon les sources), un modèle équivalent. On le désigne aujourd'hui sous le
nom de "modèle de Lotka-Volterra" pour ne pas faire de jaloux... Il a été étendu à plusieurs
domaines de la dynamique des populations et est utilisé aujourd'hui très largement en bio-
logie, écologie, ingénierie et même en chimie. Pour ne citer que le cours d'écologie de
Ricklefs et Miller, tout un chapitre (le 9) est consacré à l'étude des écosystèmes et au modèle
de Lotka-Volterra.
Le modèle de Lotka-Volterra est un système dynamique autonome non-lnéaire. Son
analyse mathématique aboutit très rapidement à des détours profonds dans la théorie des
équations diérentielles. Nous proposons d'aborder ce modèle sous sa forme continue et d'en
explorer les grandes lignes à travers une simulation.
48
5.1. INTRODUCTION 49 CHAPITRE 5. RÉSOLUTION DES ED
Mise en équation du problème

La problématique est relativement simple : étudier l'évolution dans le temps de deux
populations, celle des proies qu'on note X(t) et celle des prédateurs qu'on note Y (t). Il faut
noter que ces deux fonctions sont des fonctions de R+ vers N, le nombre d'individus d'une
population étant entier. Il n'est pas évident de travailler sur ce genre de fonctions, pour
lesquelles nous ne disposons pas d'outils simples. Par contre, pour les fonctions de R+ dans
R, supposées continues et dérivables sur le domaine, nous disposons de tout l'arsenal des
équations diérentielles, sous une réserve toutefois...
Pour transformer nos X(t) et Y (t) en fonctions réelles, nous allons les normaliser, c'est
à dire les transformer en rapport, ce qui également pour eet de les adimensionner ! On
écrira donc x(t) = X(t)/X0 et y(t) = Y (t)/Y0 , avec X0 et Y0 respectivement la population à
l'instant t0 des proies et des prédateurs.
Ce qui nous intéresse, c'est d'étudier les variations des populations pour un intervalle
de temps très petit. Pour la population de proies (resp. prédateurs), cette variation s'écrit
4x(t)/x(t) = 4X(t)/X(t). Pour établir la dérivée (matière fondamentale d'une équation
diérentielle !), il faut passer à la limite de ce rapport lorsque 4t tend vers 0. Oui, mais ce
n'est réaliste que si les populations X(t) et Y (t) sont susamment grandes ! C'est une limite
du modèle : c'est à dire on ne peut pas l'appliquer sur un groupe de 10 lapins et 5 renards
(dans les simulations, les unités sont quelconques et les fonctions sont continues et dérivables
par hypothèse) !
On supposera que les conditions mentionnées ci-dessus sont remplies et on va tenter de
mettre en équation notre problème !
Pour ce faire, on va mettre en équation les hypothèses tirées de l'écologie du système :
1. s'il n'existe aucun prédateur, le taux de croissance de la population de proies est
constant, soit x0 (t) = a ∗ x(t), en nommant a ce taux de reproduction. Vous noterez
qu'on ne xe aucune limite à la croissance de la population de proies, ce qui est
irréaliste sur le plan de l'écologie ! Les ressources sont limitées (eau, nourriture) et il
existe une compétition pour le territoire entre les proies.
2. s'il n'existe aucune proie, les prédateurs meurent de faim ! On traduit cela par l'équa-
tion y 0 (t) = −c ∗ y(t), avec c est le taux de mortalité des prédateurs. Notez le signe -
qui traduit la diminution de la population.
3. on supposera que le taux de mortalité des proies du aux prédateurs est proportionnel
au nombre de prédateurs. Ce qui nous donne une version améliorée de l'équation en
x0 (t), soit x0 (t) = (a − b ∗ y(t))x(t). Le coecient b étant le taux de mortalité des proies
en présence de prédateurs
4. Enn, autre supposition, le taux de croissance de la population de prédateurs est
proportionnel à la population des proies (il y a plus à manger ! !), d'où y 0 (t) = (−c +
d ∗ x(t))y(t). Le coecient d est le taux de reproduction des prédateurs en présence
de proies.
5. Enn, autre supposition, le taux de croissance de la population de prédateurs est
proportionnel à la population des proies (il y a plus à manger ! !), d'où y 0 (t) = (−c +
d ∗ x(t))y(t). Le coecient d est le taux de reproduction des prédateurs en présence
de proies.

J'obtiens donc le système diérentiel autonome, c'est à dire dans lequel le temps n'apparait
pas explicitement, ci-dessous (5.1) :
x0 (t) = x(t) ∗ (a − b ∗ y(t)) (5.1)

y 0 (t) = y(t) ∗ (−c + d ∗ x(t))
avec x0 et y0 les populations initiales de proies et de prédateurs. Le système d'équations (5.1)

est nommé système de Lokta-Volterra.
Il n'existe pas de solution analytique à ce système (5.1), mais on peut au moins mentionné
quelques remarques :
Le théorème de Cauchy-Lipschitz nous dit qu'il existe des solutions locales et globales
On en déduit aussi que les solutions sont positives.
Un autre théorème (Lyapunov) nous permet de démontrer que le système a deux états
d'équilibre : (x, y) = (0, 0) et (x, y) = (d/c, a/b).
Les solutions du système de Lotka-Volterra sont périodiques,
Sur une période, on sait calculer la population moyenne de proies < x >= d/c et
< y >= a/b,
Le calcul de la période n'est pas vraiment simple. On se contentera de la mesurer sur
les données simulées.
Programmation du problème
Ce premier programme, LotkaVolterra-1, permet de tracer les courbes d'évolution des
populations de proies et de prédateurs et un portait de phase. Il permettra d'illustrer le carac-
tère périodique des solutions et leur déphasage. Quelque commentaires sur le code, et d'abord
la partie caractéristique de ce genre de programme, c'est à dire la fonction qui dénit le sys-
tème diérentiel :
f unction dy = LotkaV olterra(t, y)
dy = zeros(2, 1);
dy(1) = a ∗ y(1) − b ∗ y(1) ∗ y(2);
dy(2) = c ∗ y(1) ∗ y(2) − d ∗ y(2);
end
avec y1 représente la population des proies et y2 la population des prédateurs. Vous pouvez
bien sur changer les paramètres a, b, c et d de simulation.
La résolution du système se fait en un seul ligne, en faisant appel à la fonction ode45, avec
les paramètre a = 3, b = 1, c = 1 et d = 2 !
[T, Y ] = ode45(@LotkaV olterra, [020], [0.50.5]) ;
Et enn, l'achage des résultats est donné par la courbe de la gure (5.1)
plot(T, Y (:, 1),0 −0 , T, Y (:, 2)) ;
xlabel(0 T emps0 ) ;
legend(0 P roies0 ,0 P rdateurs0 );
title(0 Evolutiondespopulations0 );
Pour tracer l'évolution des prédateurs en fonction des proies en utilise la syntaxe suivante.
plot(Y (:, 1), Y (:, 2));%0 − .0 , T, Y (:, 3),0 .0 )

Figure 5.1 Evolution des proies et prédateurs au cours du temps
xlabel(0 P roies0 );
ylabel(0 P rdateurs0 );
title(0 P ortraitdephase0 );

Figure 5.2 Evolution des proies en fonction des prédateurs

Chapitre 6
Méthodes d'approximation :
Interpolation
6.1 introduction
Il arrive souvent que la fonction que l'on doive traiter (déterminer en certains points sa
valeur, sa dérivée, etc ...) soit dénie par les valeurs qu'elle prend pour un certain nombre de
valeurs discrètes de la variable.
Il est, dans ces cas, nécessaire de remplacer la fonction f (x) à traiter par une fonction
approchée g(x) plus simple ou plus généralement, par un ensemble de fonctions gk (x), puis
de traiter non pas f (x) mais g(x).
Une méthode d'approximation de f (x) par collocation impose à g(x) à coïncider avec f (x)
pour un certain nombre de valeurs de la variable x : g(xj ) = f (xj ) = fj , pour j = 0, 1, ..., n.
Le cas le plus fréquent est celui de fonctions connues en un ensemble discret x0 , x1 , ..., xn
de la variable. C'est le cas que nous traiterons.
On appelle support d'interpolation l'ensemble des points xj , (j = 0, 1, ..., n) où la fonc-
tion est connue, et base d'interpolation l'ensemble des fonctions suivant lesquelles f (x) est
développée.
L'approximation peut être globale, si g(x) est dénie à partir de tous les xj , ou par
morceaux, si g(x) est dénie à partir de sous-ensembles de points xj .
Une fois g(x) déterminée, il est souvent nécessaire de déterminer f (x) en 1 ou plusieurs
points x = t ne coïncidant pas avec les xj . C'est le problème de :
- l'interpolation si t est dans l'intervalle [x0 , xn ].

- l'extrapolation si t est à l'extérieur par rapport à l'intervalle [x0 , xn ]
6.2 Interpolation polynomiale de Lagrange

Pour dépasser les inconvénients de la méthode de résolution, nous utilisons la méthode de
Lagrange. Les données du problème restent inchangées : (xj , fj ). Considérons n+1 polynômes
53
6.2. INTERPOLATION POLYNOMIALE
CHAPITRE DE
6. MÉTHODES54D'APPROXIMATION
LAGRANGE : INTERPOLATION
Lj (x) de degré n :
(x − x0 )(x − xj )...(x − xj−1 )(x − xj+1 )...(x − xn )

Lj (x) = (6.1)
(xj − x0 )(xj − x1 )...(xj − xj−1 )(xj − xj+1 )...(xj − xn )
n
Y x − xi
Lj (x) = ( ) (6.2)
i=0,i6=j
xj − xi
Les Lj (x) de l'equation (6.1) sont appelés les polynômes de Lagrange. Ces polynômes sont
utiliser pour interpoler une fonction.
Objectifs de la méthode
Trouver le polynôme Pn (x) de degré n qui passe par tous les points xj connus
(j = 0, 1, ..., n).
Nous avons n + 1 points, donc un polynôme d'ordre n. On remarque que :
(
1 si i = j
Lj (xi ) =
0 si i 6= j
Lj (xi ) s'identie au symbole de Kroenecker δij , Le polynôme de d'interpolation Pn (x) qui
passe par les n + 1 points x0 , x1 ,..., xn s'écrit :
n
X n
X
Pn (xi ) = f (xj )Lj (xi ) = f (xj )δij = f (xi )
j=0 j=0
Exemples
1. Deux points connus : degré 1
(
x0 = 0 y0 = 0
x1 = 1 y1 = 1.175
alors
x − x1 x − x0
P1 (x) = ( )y0 + ( )y1
x0 − x1 x1 − x0
x−1 x−0
= ( )0 + ( )1.175
0−1 1−0
donc : P1 (x) = 1.175x
2. trois points connus : degré 2


 x0 = 0 y 0 = 0
x1 = 1 y1 = 1.175

 x = 2 y = 3.626
2 2

6.3. FORME POLYNOMIALE DE NEWTON
CHAPITRE 6. MÉTHODES55D'APPROXIMATION : INTERPOLATION
(x − x1 )(x − x2 ) (x − x0 )(x − x2 ) (x − x0 )(x − x1 )

P2 (x) = ( )y0 + ( )y1 + ( )y2
(x0 − x1 )(x0 − x2 ) (x1 − x0 )(x1 − x2 ) (x2 − x0 )(x2 − x1 )
ce qui nous donne : P2 (x) = 0.638x2 + 0.537x
6.3 Forme polynomiale de Newton

6.3.1 Présentation de la méthode
C'est la méthode la plus utilisée, en particulier du fait qu'il n'est pas nécessaire de
décider à priori le degré du polynôme par lequel on approche la fonction.
On peut dénir les diérences divisées d'ordre 0, 1, 2, ..., n par :
δ(xi )f = f (xi ) = fi
(f (x )−f (x ))
δ(xi , xj )f = (xjj −xi ) i
(δ(xj ,xk )f −δ(xi ,xj )f )
δ(xi , xj , xk )f = (xk −xi )
δ(xi , xi+1 , ..., xp−1 , xp )f = (δ(xi+1 ,...,xp(x)fp−δ(x
−xi )
i ,...,xp−1 )f )
alors on aura le polynôme (de Newton) suivant :

Pn (x) = f (x0 )+(x−x0 )f +(x−x0 )(x−x1 )δ(x0 , x1 , x2 )f +...+(x−x0 )...(x−xn−1 )δ(x0 , ..., xn )f
le Polynôme de Newton pour un pas h constant (cas très fréquent) :
Intervalle [x0 , xn ] avec xk+1 = xk+h .
Diérences à droite
∆0 fi = fi , ∆1 fi = fi+1 − fi et ∆2 fi = ∆1 fi+1 − ∆1 fi
maintenant nous construisons le polynôme de Newton :
xi : fi , x0 : f0 , x1 = x0 + h : f1 , x0 + 2h : f2 , ..., x0 + nh : fn . Donc :
Pn (x) = A0 +A1 (x−x0 )+A2 (x−x0 )(x−x1 )+...+An (x−x0 )(x−x0 −h)...(x−x0 )(x−(n−1)h),
avec :
A0 = ∆0 f0



∆1 f0




 1
 A =
h
 .
..


 n
 An = ∆ f0



n!hn
Reprenons l'exemple précédent :

 x0 = 0 y 0 =
 0
x1 = 1 y1 = 1.175

 x = 2 y = 3.626
2 2

6.3. FORME POLYNOMIALE DE NEWTON
CHAPITRE 6. MÉTHODES56D'APPROXIMATION : INTERPOLATION


 A0 = f0 = 0
1


 ∆ f0 f1 − f0
A1 = = = 1.175
 h h
2 1 1
 A2 = ∆ f0 = ∆ f1 − ∆ f0 = f2 − f1 − (f1 − f0 ) = 1.813



2h2 2 2
Donc le polynôme de Newton sera de cette forme : P2 (x) = −1.175(x−0)+1.813(x−0)(x−1)
=⇒ P2 (x) = 0.638x2 + 0.537x
Nous obtenons la même expression qu'avec Lagrange.
Remarque :
Nous pouvons utiliser une autre méthode pour calculer les ∆f0 :
∆f0 ∆1 f0 ∆2 f0
x0 = 0 0
x1 = 1 1.175 1.175 1.276
x1 = 2 3.626 2.451
Diérences à gauche
Le polynôme de degré n s'écrit sous la forme :
Pn (x) = A00 + A01 (x − x00 ) + A02 (x − (x00 + h)) + ...
en utilisant les mêmes formules que précédemment et avec h0 = −1, nous obtenons :
xi x0i fi0
x0 = 0 x00 = 2 f00 = 3.626
x1 = 1 x01 = 1 f10 = 1.175
x2 = 2 x02 = 0 f20 = 0
avec
 0

 A0 = ∆0 f00
∆1 f00


0

 A
 1
 =
h0
..


 .

n 0
 A0 = ∆ f0



n
n!h0n
En reprenons le même exemple on trouve :
∆f00 ∆1 f00 ∆2 f00
0
x0 = 0 3.626
x01 = 1 1.175 −2.451 1.276
x02 = 2 0
alors : P2 (x) = 3.626 + ( −2.451
−1
)(x − x00 ) + ( 1.276
2
)(x − x00 )(x − x01 )

Conclusion Générale
Dans ce module nous avons présenter quelques techniques numériques en se basant sur le
logiciel Matlab. Après avoir présenter une introduction à l'algorithmique nous avons présenter
la programmation à l'aide de Matlab qui sert comme outil de programmation des méthodes
numériques pour le calcul des intégrales, la recherche des zéros des fonctions non linéaires et
la résolution des équations diérentiels.
57
Bibliographie
1. ALLAIRE, G., KABER, S.M. Cours d'Algèbre Linéaire Théorique. Ellipses, Paris (2002).
2. CROUZEIX, M., MIGNOT, A.-L. Analyse Numérique des Equations Diérentielles. Mas-
son, Paris (1983).
3. GANDER, W., HREBICEK, J. Solving Problems in Scientic Computing Using Maple
and Matlab Springer-Verlag (1991).
4. GUERRE-DELABRIERE, S., POSTEL, M. Méthodes d'Approximattion - Equations Dif-
férentielles - Applications Scilab. Ellipses, Paris (2004).
5. LAPRESTÉ, J.-T. Introduction à Matlab Ellipses (2000).
6. A. Quarteroni, F. Saleri et P. Gervasio, Calcul Scientique : Cours, exercices corrigés et
illustrations en Matlab et Octave. Deuxième édition, Spinger-Verlag Italia 2010.
7. J. l. Merrien, Analyse numérique avec Matlab : rappels de cours, méthodes, exercices et
problèmes avec corrigés détaillés, Dunod, 2007.
58

Cours PM

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

Cours PM

Transféré par

Droits d'auteur :

Formats disponibles

Université Sultan Moulay Slimane

Département de Mathématiques et Informatiques

Cours : Informatique et Analyse Numérique

Prof. Said SAFI

2 Initiation à la programmation avec Matlab 17

2.2.4 Fonctions outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

4 Résolution numérique des équations non linéaires f (x) = 0 43

6 Méthodes d'approximation : Interpolation 53

SAFI Said ii Informatique et Analyse Numérique

2.1 Page d'accueil du logiciel Matlab . . . . . . . . . . . . . . . . . . . . . . . . 18

3.1 Description de la méthode des rectangles . . . . . . . . . . . . . . . . . . . . 36

4.1 exemple de fonction non linéaire . . . . . . . . . . . . . . . . . . . . . . . . . 44

5.1 Evolution des proies et prédateurs au cours du temps . . . . . . . . . . . . . 51

1.1 Algorithmique et programmation

1.2 Les variables

1.2.2 Déclaration des variables

SAFI Said 3 Informatique et Analyse Numérique

1.3 L'instruction d'aectation

Considérons les deux exemples suivants :

SAFI Said 4 Informatique et Analyse Numérique

1.3.2 L'Ordre des instructions

En eet, on aurait bien atteint le même résultat en écrivant simplement :

SAFI Said 5 Informatique et Analyse Numérique

1.3.3 Expressions et opérateurs

1. A gauche de la èche, un nom de variable, et uniquement cela. Donc, si on voit à

SAFI Said 6 Informatique et Analyse Numérique

Opérateur alphanumérique &

SAFI Said 7 Informatique et Analyse Numérique

1.4 Lecture et Ecriture

1.4.2 Les instructions de lecture et d'écriture

SAFI Said 8 Informatique et Analyse Numérique

1.5 Les tests

SAFI Said 9 Informatique et Analyse Numérique

1.5.2 Denition d'une condition

1.5.3 Les opérateurs de comparaison

1.5.4 Conditions composées

SAFI Said 10 Informatique et Analyse Numérique

logiques : ET, OU, NON, et XOR.

C1etC2 C1V rai C2F aux

C1ouC2 C1V rai C2F aux

C1xorC2 C2V rai C2F aux

1.5.5 Tests imbriqués

SAFI Said 11 Informatique et Analyse Numérique

1.5.6 Variables Booléennes

SAFI Said 12 Informatique et Analyse Numérique

1.6 Une première structure de boucle

SAFI Said 13 Informatique et Analyse Numérique

1.7 Boucler en comptant ou compter en bouclant

1.7.1 Des boucles dans des boucles

SAFI Said 14 Informatique et Analyse Numérique

1. L'aectation de variables : combien de variables on a besoin pour résoudre notre

SAFI Said 15 Informatique et Analyse Numérique

SAFI Said 16 Informatique et Analyse Numérique

2.1.2 Syntaxe du langage

Figure 2.1  Page d'accueil du logiciel Matlab

SAFI Said 18 Informatique et Analyse Numérique

SAFI Said 19 Informatique et Analyse Numérique

>> A = eye(3, 3) % A est matrice identité d'ordre 3

SAFI Said 20 Informatique et Analyse Numérique

2.2 Les fonctions

syntaxe : function arguments de sortie = nom(arguments d'entrée )

2.2.1 Exemples de fonctions sous Matlab

2.2.2 Les fonctions M-les

1.3 L'instruction d'aectation

En eet, on aurait bien atteint le même résultat en écrivant simplement :

1. A gauche de la èche, un nom de variable, et uniquement cela. Donc, si on voit à

1.5.2 Denition d'une condition

1. L'aectation de variables : combien de variables on a besoin pour résoudre notre

Figure 2.1 Page d'accueil du logiciel Matlab

2.2.2 Les fonctions M-les

Figure 2.3 représentation graphique d'une fonction

Figure 2.4 représentation graphique de 3 gure sur une même gure

Figure 2.5 représentation graphique de 3 gure sur une même gure

Figure 2.6 représentation graphique de 3 gure sur une même gure

Control System Toolbox

Figure 3.1 Description de la méthode des rectangles

Figure 3.2 l'erreur est en 1/n de la méthode des rectangles

Figure 3.3 Représentation graphique (Exemple 1)

Figure 3.4 Représentation graphique la fonction f (x) = x2

Figure 3.5 Calcul d'integral par la méthode de Simpson

En divisant par N , on obtient la variance de la somme. L'intervalle de conance à 95% est :

Figure 4.1 exemple de fonction non linéaire