Partie II Méthodes Numériques

TABLE DES MATIÈRES 1
Table des matières
1 Introduction générale 5
1.1 Utilité des langages informatiques . . . . . . . . . . . . . . . . . . . . . . . 5
1.2 Utilité et limitations des méthodes numériques . . . . . . . . . . . . . . . . 6
1.2.1 Nécessité des méthodes numériques . . . . . . . . . . . . . . . . . . 6
1.2.2 Limitations des méthodes numériques . . . . . . . . . . . . . . . . . 7
1.3 Outils de base des méthodes numériques . . . . . . . . . . . . . . . . . . . 7
2 Éléments de base du langage Turbo Pascal 9

2.1 Les données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.1 L’alphabet Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.2 Mot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.1.3 Mots réservés ou mots-clés . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.4 Les types de données . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.5 Les déclarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.6 Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2 Structure d’un programme Pascal . . . . . . . . . . . . . . . . . . . . . . . 11
2.2.1 Les composantes d’un programme . . . . . . . . . . . . . . . . . . . 11
2.2.2 structure globale d’un programme . . . . . . . . . . . . . . . . . . . 11
2.3 Les actions de base dans un programme : lire, écrire et calculer . . . . . . . 12
2.3.1 Instruction d’affectation . . . . . . . . . . . . . . . . . . . . . . . . 12
2.3.2 Instructions Write et Writeln . . . . . . . . . . . . . . . . . . . . . 12
2.3.3 Instructions Read et Readln . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Les opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.1 Opérateurs arithmétiques . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.2 Opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . 14
2.4.3 Opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4.4 Priorité des opérateurs et évaluation des expressions . . . . . . . . . 14
2.5 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.6 Texts et Choix : instructions conditionnelles . . . . . . . . . . . . . . . . . 15
2.6.1 Position du problème . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.6.2 L’alternative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.6.3 Choix fondé sur une cascade de questions . . . . . . . . . . . . . . . 17
2.6.4 Questionnaire de classification . . . . . . . . . . . . . . . . . . . . . 20
2.7 Les BOUCLES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.7.2 Parcours d’un intervalle en sens croissant : la boucle For ordinaire. . 21
2.7.3 Parcours séquentiel rétrograde . . . . . . . . . . . . . . . . . . . . . 22
2.7.4 Boucle de recherche sur un intervalle non borné . . . . . . . . . . . 23
2 TABLE DES MATIÈRES
2.8 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.8.1 Utilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.8.2 Dimension des tableaux . . . . . . . . . . . . . . . . . . . . . . . . 25
2.8.3 déclaration des tableaux . . . . . . . . . . . . . . . . . . . . . . . . 25
2.8.4 Manipulation des tableaux . . . . . . . . . . . . . . . . . . . . . . . 25
2.9 Les sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.9.2 Arguments et paramètres . . . . . . . . . . . . . . . . . . . . . . . . 26
2.9.3 Les Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.9.4 Les procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.10 Exercices et problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.10.1 exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2.10.2 Problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3 Dérivation de fonctions : méthode de différences finies 31

3.1 position du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2 Différences à droite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2.1 Opérateur différence à droite . . . . . . . . . . . . . . . . . . . . . . 31
3.2.2 Dérivées successives de f(x) à l’ordre 1 en h . . . . . . . . . . . . . 32
3.3 Différences à gauche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.1 Opérateur différence à gauche . . . . . . . . . . . . . . . . . . . . . 34
3.4 Différences centrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4 Résolution numériques d’équations 39

4.1 Position du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.2 Méthodes de recherche des racines d’une équation . . . . . . . . . . . . . . 39
4.2.1 Principe de la méthode des approximations successives . . . . . . . 39
4.2.2 Méthode de Lagrange par des partitions proportionnelles . . . . . . 40
4.3 Méthode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
4.3.1 Principe de la méthode : détermination de la fonction g(x) . . . . . 41
4.3.2 Cas de racines multiples . . . . . . . . . . . . . . . . . . . . . . . . 42
4.4 Théorème du point fixe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.5 Condition de convergence de la méthode du point fixe . . . . . . . . . . . . 46
4.6 Méthode de dichotomie ou par bissection . . . . . . . . . . . . . . . . . . . 47
4.7 Méthode da la sécante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
4.8 Recherche des extrêma d’une fonction . . . . . . . . . . . . . . . . . . . . . 54
4.9 Racines d’un polynôme : Méthode de Bairstow . . . . . . . . . . . . . . . . 54
4.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
5 Introduction à la résolution numérique des systèmes linéaires 61

5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
5.2 Méthode du pivot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.2.1 Exposé de la méthode. . . . . . . . . . . . . . . . . . . . . . . . . . 63
5.2.2 Méthode de Gauss-Jordan . . . . . . . . . . . . . . . . . . . . . . . 64
5.2.3 Méthode de Gauss. . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
5.2.4 Matrices tri-diagonnale : Méthode de double balayage de Choleski. . 67
TABLE DES MATIÈRES 3
5.3 Méthodes itératives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

5.3.1 Méthode de Jacobi . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
5.3.2 Méthode de Gauss-Seidel . . . . . . . . . . . . . . . . . . . . . . . . 69
5.4 Programmation informatique des méthodes étudiées . . . . . . . . . . . . . 71
5.4.1 Méthode de Gauss-Jordan . . . . . . . . . . . . . . . . . . . . . . . 71
5.4.2 Méthode de Gauss . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.4.3 Méthode de Gauss . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
6 Approximation des fonctions numériques... 83

6.1 Interpolation de Lagrange . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2 Interpolation de Lagrange . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2.1 Estimation de l’erreur . . . . . . . . . . . . . . . . . . . . . . . . . 86
6.2.2 Choix au mieux des xi . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.3 Interpolation de Hermite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
6.4 Interpolation par les splines . . . . . . . . . . . . . . . . . . . . . . . . . . 89
6.4.1 Etude d’un exemple élémentaire d’approximation par les fonctions
splines : les splines cubiques. . . . . . . . . . . . . . . . . . . . . . . 89
7 Intégration numérique des fonctions. 93

7.1 Position du problème . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
7.2 Formule de quadrature de type interpolation . . . . . . . . . . . . . . . . . 93
7.2.1 Formule de quadrature de type interpolation de Lagrange . . . . . . 93
7.2.2 Formule de quadrature généralisée . . . . . . . . . . . . . . . . . . . 96
7.3 Les quadratures classiques: Formules de Newton-COTES . . . . . . . . . . 97
7.3.1 Formule des trapèzes . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.3.2 Formule de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.4 Méthode de Gauss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.4.1 Principe de la Méthode . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.4.2 Formule composite : cas n=3 . . . . . . . . . . . . . . . . . . . . . . 101
7.5 Méthode d’extrapolation : Méthode de Romberg . . . . . . . . . . . . . . . 102
7.6 Programmation informatique des formules classiques . . . . . . . . . . . . 103
7.6.1 Formule des Trapèzes . . . . . . . . . . . . . . . . . . . . . . . . . . 103
7.6.2 Formule de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . 105
7.6.3 Formule de Gauss-Legendre . . . . . . . . . . . . . . . . . . . . . . 107
8 Résolution numérique des équations différentielles 109

8.1 Problème de Cauchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
8.1.1 Rappel des résultats fondamentaux sur les équations différentielles
du premier ordre . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
8.1.2 Systèmes différentiels du premier ordre . . . . . . . . . . . . . . . . 110
8.1.3 Equations différentielles d’ordre supérieur à 1 . . . . . . . . . . . . 110
8.2 Discrétisation des équations du premier ordre . . . . . . . . . . . . . . . . 111
8.2.1 Principe d’analyse numérique . . . . . . . . . . . . . . . . . . . . . 111
8.2.2 Méthode d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
8.2.3 Schéma général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
8.2.4 Construction de ∆(x,y,h) consistant d’ordre p par Taylor . . . . . . 115
8.2.5 Méthode de Runge-Kutta . . . . . . . . . . . . . . . . . . . . . . . 115
8.3 Formules à pas multiples:Méthodes d’Adams . . . . . . . . . . . . . . . . 118
4 TABLE DES MATIÈRES
8.3.1 Formules d’Adams ouvertes ou Méthode d’Adams-Bashforth . . . . 118

8.3.2 Formules d’Adams fermés ou Méthode d’Adams-Moulton . . . . . . 119
8.3.3 Méthode de prédicteur-correcteur: Méthode d’Adams-Bashforth-Moulton119
8.4 Programmation informatique des méthodes présentées . . . . . . . . . . . . 121
8.4.1 Résolution des équations de premier ordre . . . . . . . . . . . . . . 121
8.4.2 Résolution des systèmes déquations de premier ordre . . . . . . . . 126
5
Chapitre 1
Introduction générale
1.1 Utilité des langages informatiques

En ce début du 21ème siècle, on a assiste à une pénétration véritablement explosive de
l’informatique et de la télématique dans notre travail comme dans notre vie quotidienne.
L’ordinateur est omniprésent, il fait partie de notre paysage familier. Le scientifique ne
doit pas se sentir étranger à cette révolution industrielle, puisque l’ordinateur a été conçu
à l’origine (peu après la fin de la seconde guerre mondiale) par des scientifiques pour des
calculs scientifiques. Ce n’est qu’en suite qu’on s’est avisé que l’ordinateur pouvait aussi :
– Faire des fiches de paie,
– Contrôler un processus en temps réel,
– Gérer une banque de données,
– Donner des consultations à la manière d’un expert, ...etc.
Pourtant, l’emploi rationnel, par les scientifiques, des moyens de calcul modernes n’est pas
aussi naturel qu’il y eut paru.
En effet, un physicien, un ingénieur,...etc., c’est d’abord un spécialiste d’une discipline

dont il connaı̂t les lois et les méthodes. Mais il n’est pas toujours facile de passer direc-
tement d’un modèle physique à l’écriture d’un programme, pour rentrer les données puis,
les traiter; il s’agit de donner à l’ordinateur des instructions. Il ne peut les comprendre
que si elles sont dans un langage bien particulier : le langage machine. Chaque instruction
y est représentée par un groupe de chiffres binaires. Mais l’apprentissage et la manipula-
tion de tels langages sont longs et fastidieux. De plus, les erreurs sont nombreuses car les
vérifications sont difficiles à effectuer. C’est pourquoi on a créé des langages dits évolués
plus proches de notre langage et de notre mode de raisonnement courant(Basic, Algol,
Turbo pascal, Fortran, C, C++,Java, ...etc). Pour les rendre compréhensible par l’ordina-
teur, on leur associe un traducteur appelé compilateur.
On peut alors, dans un langage évolué, écrire des suites d’instructions ou programme.
Le rôle du compilateur (qui est lui-même un programme en langage machine) est alors
au préalable de contrôler la syntaxe du programme, ( càd de voir s’il respecte les règles
d’orthographe du langage évolué), puis de traduire en langage machine. Pour passer déjà
des modèles physiques à l’écriture d’un programme, il y a tout un art à maı̂triser: les
méthodes numériques
6 CHAPITRE 1. INTRODUCTION GÉNÉRALE
1.2 Utilité et limitations des méthodes numériques
1.2.1 Nécessité des méthodes numériques
La plupart des phénomènes physiques, biologiques, économiques et même sociaux sont

modélisés à l’aide d’équations différentielles, d’équations aux dérivées partielles linéaires
ou non linéaires, d’équations intégrales ou intégro-différentielles, et le développement de
ces sciences passe par une meilleure compréhension des propriétés des solutions de ces
équations.
Bien plus, dans de nombreux domaines de pointes (industrie aéronautique, industrie

pétrolière, industrie nucléaire, problème de fusion contrôlée, prévisions météorologiques,
...etc.) le progrès technique nécessite de résoudre numériquement des systèmes d’équations
parfois très compliqués afin d’obtenir des solutions quantitatives. Avec le progrès des per-
formances des ordinateurs, la simulation numérique des phénomènes devient simple, facile
à réaliser, et surtout plus économique que la simulation expérimentale et tend de plus en
plus , à tord ou à raison, à s’y substituer.
Par ailleurs un phénomène différentielle, par exemple, est par nature continu : sa
résolution signifie l’obtention des valeurs d’une ou de plusieurs inconnues en fonction d’une
variable comme le temps t qui prend une infinité de valeurs possibles. Si l’on est capable
de résoudre analytiquement ce problème différentiel, càd d’exprimer sa solution à l’aide
d’une formule incluant éventuellement des quadratures, ou le calcul de fonctions spéciales
par série, formule approchée ou développement asymptotique alors tout va bien : il suffira,
à posteriori, d’appliquer cette formule à telle ou telle valeur de t que choisira l’utilisateur.
En revanche, les résolutions analytiques ou exactes quoique fort intéressantes, car

étant très manipulables, et pouvant également servir de référence pour tester la méthode
numérique utilisée, ne sont pas nombreuses. Hormis le cas des problèmes simples ou de
géométrie très particulière, il ne faut pas trop espérer les résoudre ” à la main ”.
L’ordinateur, tout comme l’homme qui l’a créé est ” fini ” dans toutes les direc-
tions : il est limité en place mémoire, en précision, en durée de fonctionnement. Résoudre
numériquement le problème continu est une utopie. Il faut donc discrétiser le problème,
càd le remplacer par un problème discret sensé lui être proche en certains sens. On peut
réaliser une approximation d’un problème aux dérivées partielles par :
– les différences finies,

– les éléments finis,
– une méthode particulière,
– la méthode spectrale.
On peut de même approcher une équation intégrale singulière selon une méthode de sin-
gularité. Les méthodes sont nombreuses mais leur choix ou leur emploi représente tout un
art : c’est l’analyse numérique ou méthodes numériques.
1.3. OUTILS DE BASE DES MÉTHODES NUMÉRIQUES 7
1.2.2 Limitations des méthodes numériques

Il y a cependant aussi des limitations à l’utilisation des méthodes numériques bien que
le problème soit discrétisé :
– certains programmes sont si importants qu’ils dépassent la capacité des ordinateurs
actuels, soit que la résolution dure trop longtemps : dans ce cas, la possibilité d’utiliser
les méthodes numériques dépend de la réponse à la question suivante : ” quelle somme
est-on disposée à payer pour résoudre le problème?
– D’autres n’ont pas encore trouvé de modèle mathématique complet et précis.
1.3 Outils de base des méthodes numériques

Le développement en série de Taylor est le fondement des méthodes numériques. Une
fonction f (x) est analytique dans le domaine de convergence de rayon R autour de a si
pour a − R < x < a + R, on peut écrire :
(x − a)2 ” (x − a)n (n)

f (x) = f (a) + (x − a)f 0 (a) + f (a) + ... + f (a) + ... (1.1)
2! n!
Ceci est le développement de f (x) en série de Taylor autour du point a. Pour que ce
développement soit valable, il faut que toutes les dérivées f (n) (a) existent et soient finies.
On peut écrire f sous la forme condensée suivante :
X∞ · ¸
(x − a)n dn f (x)
f (x) = (1.2)
n=0
n! dxn x=a
En fait, pour approximer la fonction f (x), on ne tient compte dans (1.1) que d’un
nombre fini de termes : on effectue une troncature de la série. On a donc l’expression
approchée :
(x − a)2 ” (x − a)n (n)

f (x) ≈ f (a) + (x − a)f 0 (a) + f (a) + ... + f (a). (1.3)
2! n!
En négligeant les termes d’ordre n + 1 et au dela, on commet une erreur qui sera d’autant
plus petite que n est grand. La valeur maximale de cette erreur est :
(x − a)n+1 £ (n+1) ¤
E(x) = f (x) max (1.4)
(n + 1)!
£ ¤
où f (n+1) (x) max est la valeur maximale de la dérivée d’ordre n+1 de f (x) dans l’intervalle
[a,x]. On voit que cette erreur est de l’ordre de (x − a)n+1 , ce qu’on écrit couramment :
(x − a)2 ” (x − a)n (n)

f (x) = f (a) + (x − a)f 0 (a) + f (a) + ... + f (a) + °(x − a)n+1 (1.5)
2! n!
A partir de ce développement, on peut effectuer des opérations comme les dérivations et
les intégrations sur les fonctions.
8 CHAPITRE 1. INTRODUCTION GÉNÉRALE
9
Chapitre 2
Éléments de base du langage Turbo

Pascal
2.1 Les données
2.1.1 L’alphabet Pascal

L’alphabet pascal est formé des caractères alphabétiques et numériques : les 10 chiffres
de 0 à 9, les 26 lettres de l’alphabet française, et des caractères spéciaux. Les caractères
spéciaux sont des caractères de ponctuations: le point ” . ”, la virgule ” , ”, deux points
” : ”, le point-virgule ” ; ” et l’astérisque ” * ”.
2.1.2 Mot
On appelle ” mot” une suite de caractères délimitée par des caractères spéciaux ou
blancs, il peut représenter un nombre, un mot réservée ou un ” identificateur ”. Le compi-
lateur Pascal reconnaı̂t les caractères spéciaux et les mots et ne distingue pas les majuscules
des minuscules. Il ne connaı̂t pas non plus les indices ; ainsi la variable x1 peut être écrite
comme x1. Le caractère retour chariot ” CR ” ou ” ENTREE ” ou encore ” ENTER ”
selon les claviers est interprété comme un caractère blanc.
La partie effective d’un identificateur est limitée aux n premières lettres, le nombre
n dépend des implantations. Bien que cela ne soit pas standard, la plupart des implan-
tations admettent aussi le caractère souligné, on l’utilise pour séparer les mots indicatifs
d’un identificateur. Cependant, dans le même but, on préférera utiliser les majuscules (ex.
TemperatureMax) pour assurer la transportabilité du programme. Pour améliorer la lisi-
bilité du programme, il est conseillé de choisir le nom des variables judicieusement. Par
exemple, si nous écrivons un programme calculant la température maximale atteinte par
un système pendant une certaine période, il sera préférable d’appeler TemperatureMax la
variable destinée à contenir la valeur de la température maximale calculée.
Les noms des variables doivent satisfaire à certaines règles. Ils sont composés des ca-
ractères alphabétiques et numériques et du blanc souligné.
10 CHAPITRE 2. ÉLÉMENTS DE BASE DU LANGAGE TURBO PASCAL
2.1.3 Mots réservés ou mots-clés

Un mot réservé est un mot prédéfini par le compilateur et qui a un rôle précis. Il
ne peut servir d’identificateur. Dans le texte, ces mots seront écrits en gras ou brillance
(c’est le cas du compilateur Turbo7). Le tableau ci-dessous donne à titre indicatif quelques
mots réservés disponibles dans Turbo Pascal : and, array, begin, case, const, div, do,
downto, else, end, file, for, function, goto, if, in, label, mod, not, of, or, packed,
procedure, program, record, repeat, set, then, to, type, until, var, while, with....
2.1.4 Les types de données

Turbo Pascal peut gérer deux types de données : les types standards et les scalaires
définis par l’utilisateur.
Les types standards sont les suivants : INTEGER, REAL, CHAR, BOOLEAN,
TEXT. Les trois derniers appartiennent à la classe des scalaires et les deux premiers
sont des données numériques. En mode étendu, on utilisera EXTENDED pour les réels,
LONGINT pour les entiers et STRING pour les chaı̂nes de caractères.
2.1.5 Les déclarations

Quand Turbo Pascal doit utiliser une variable, il lui faut réserver une adresse dans la
mémoire où stocker cette variable. Cette déclaration doit se faire au début du programme.
La synthaxe à respecter pour déclarer une variable est :
Le mot-clé var suivi du nom de la variable et de sa nature. Exple.

Var integrale : real ;
Var x1 : integer;
Var test : Boolean ;
Si nous avons plusieurs variables de même nature à déclarer, nous pouvons le faire de
la manière suivante, en les séparant par des virgules.
Var Integrale, TamperatureMax, Intensite : Real ;
Var nbreLigne, IterMax, nbreColonne, degrePoly : Integer;
On peut aussi éviter la réptition du mot var, et les déclarations précédentes auraient pû
être écrites :
Var Integrale, TemperatureMax, Intensite : real ;
nbreLigne, IterMax, nbreColonne, degrePpoly : Integer;
Certaines valeurs resteront constantes tout au long d’un programme. Au lieu d’écrire ex-
plicitement leurs valeurs numériques, on peut préférer leur donner un nom en précisant au
début du programme quelle valeur est représentée par ce nom. La syntaxe est la suivante :
const Dimension = 10;
DegrePoly=20;
ConstEuler=0.577;
Epsi=3.50e-09;
2.2. STRUCTURE D’UN PROGRAMME PASCAL 11
2.1.6 Les commentaires

Les commentaires permettent de faciliter la lisibilité du programme. Ils commencent par
les caractères ”(* ” et finissent par ”*)”. Ceci évite toute confusion entre les commentaires
et les éléments du programme. Exple:
Var y : Real; (* valeur de la fonction *)
H :Real; (* pas d’iterations *)
yprime : Real ; (* valeur de la derivee de la fonction y *).
On peut si on préfère, parenthéser les commentaires par des accolades. Exple
Var xpivot, ypivot : Integer ; {numeros de la ligne et de la colonne
pivot}.
Le commentaire {§U +} placé au début du programme, juste après l’instruction Program,
permet d’interrompre l’éxécution du programme à tout moment par la touche ” CRTL +
C”.
2.2 Structure d’un programme Pascal

2.2.1 Les composantes d’un programme
Un programme est constitué d’une série d’instructions de déclaration, précisant les
caractéristiques de données manipulées ; d’instructions exécutables, ordonnant un certain
travail à l’ordinateur ; et de commentaires à volonté.
2.2.2 structure globale d’un programme

Un programme Pascal commence par une entête suivie d’une suite de déclarations
définissant les objets utilisés et se termine par le corps du programme. Dans le cas général,
il a l’allure suivante :
– Program Nomduprogramme ; cette instruction permet de donner un nom à notre
programme. Par exple:
Program Newton ; Conviendrait tout à fait pour un programme de calcul de la
racine d’une équation f (x) = 0 par la méthode de Newton.
– La déclaration des constantes qui doivent être conformes aux règles données ci-
dessous. Exple:
Const dimension = 10 ;
DegrePoly=20 ;
– La déclaration des types nouveaux de données par le mot- clé Type. Exple:
Type nom= String[30];
Vecteur = array[0..1000] of Real ;
– La déclaration des variables ou identificateurs à utiliser dans le programme. Exple:
Var varf1, varf2 :Text;
Ce : Char;
x0, y0, Temperature : real;
NbreLigne, NbreColonne : Integer ;
– La déclaration des sous-programmes qui sont les procédures et les fonctions,
– Le mot-clé Begin qui commence le corps du programme, suivi d’une suite d’instruc-
tions séparées par des points-virgules et le mot-clé end suivi d’un point qui annonce
la fin du programme. Cette structuration est schématisée par le tableau suivant:
(a) Program nomduprogramme
(b) Label
(c) Const
(d) Type
(e) Var
Procedure Nomdelaprocedure (déclaration des paramètres)
Begin
(f) instructions
end;
FunctionNomdelafonction(déclaration des paramètres): déclaration de la fonction
Begin
(f’) instructions
end;
(g)
corps Begin
instructions
end.
2.3 Les actions de base dans un programme : lire,

écrire et calculer
2.3.1 Instruction d’affectation
Le symbole d’affection est le caractère ” := ”. Elle est utilisée dans une instruction
sans mot-clé. Sa syntaxe est la suivante :
Variable réceptrice := Expression source
L’expression est d’abord évaluée, et le résultat rangé dans la variable réceptrice. Autre-
ment dit, l’ancienne valeur de la variable est effacée et remplacée par celle de l’expression.
Exple:
X := 2 ∗ Y + Z
signifie : prendre la valeur de Y , la multiplier par 2, y ajouter Z et remplacer le contenu
de la variable X par la valeur de cette opération. A la fin de l’opération,le contenu des
variables Y et Z ne sont pas modifiées.
2.3.2 Instructions Write et Writeln

Pour afficher des messages et des valeurs des variables, Turbo Pascal met à notre dispo-
sition les procédures write et writeln. Nous pouvons afficher des messages et des résultats
au cours de l’exécution du programme comme sur l’exemple suivant :
Write(’ Nombre de lignes :’, var1, ’et Nombre de colonnes :’, var2) ;
2.3. LES ACTIONS DE BASE DANS UN PROGRAMME : LIRE, ÉCRIRE ET CALCULER13
Si au moment où cette instruction est effectuée, les variables var1 et var2 ont pour valeurs
respectives 15 et 8, l’effet de l’instruction sera d’afficher à l’écran la ligne
Nombre de lignes : 15 et Nombre de colonnes : 8
La procédure writeln fonctionne de la même manière que la procédure write, à la seule

différence qu’après affichage, elle repositionne le curseur au début de la ligne suivante de
l’écran en vue des affichages suivants.
Pour afficher des nombres réels, nous pouvons préciser quel doit être l’encombrement
du résultat affiché. Par exemple, soit à afficher la valeur de x=123.09876543, l’instruction
Writeln(’ valeur de x :’, x );
affichera le résultat suivant
Valeur de x :**1.2309876543E+02
(noter qu’il y a 2 blancs qui sépare deux points du premier chiffre 1 du nombre à écrire).
Writeln(’ valeur de x :’, x :5 )
affichera le résultat suivant
Valeur de x :**1.2E+02
Writeln(’ valeur de x :’, x :7 :2 ) affichera le résultat suivant
Valeur de x :**123.10
Writeln(’ valeur de x :’, x :18 :10 ) affichera le résultat
Valeur de x :*****123.0987654300.
2.3.3 Instructions Read et Readln

Les procédures Read et Readln permettent de communiquer avec la machine comme
les procédures write et writeln. Cependant, la communication se fait dans le sens inverse.
Ces procédures permettent de communiquer de l’utilisateur vers la machine. La syntaxe
est la suivante :
Read (var1,var2,...,varn) ou Readln (var1,var2,...,varn)

La procédure Read attend l’entrée au clavier de n valeurs correspondant à la nature
des variables à lire. L’utilisateur doit entrer les n valeurs en une seule ligne et séparées par
des espaces avant la validation par la touche ” Entrée ”. Si on lui propose trop de données
sur la ligne avant de valider, elle conservera l’excédent pour la prochaine exécution d’un
ordre Read ou Readln. Si on ne lui donne pas assez avant de valider, elles considérera
comme nuls les nombres manquants.
La procédure Readln ne diffère de la précédente que dans le fait que les éventuelles
valeurs excédentaires seront ignorées.
2.4 Les opérateurs

2.4.1 Opérateurs arithmétiques
Il s’agit de l’addition (+), de la soustraction (-), de la multiplication (*), de la division
euclidienne (/). L’opérateur div est utilisé pour la division des nombres entiers et le résultat
est aussi un nombre entier.
N.B. Remarquer que l’opérateur puissance n’existe pas en Pascal.
2.4.2 Opérateurs de comparaison

Les opérateurs de comparaison donnent un résultat logique, vrai ou faux. Ils permettent
de travailler sur des expressions booléennes. Il s’agit de:
Opérateur Description Opérateur Description

= égal à <> différent de
> plus grand que >= plus grand ou égal à
< plus petit que <= plus petit ou égal à
Exemple : x=1.00, y=2.00, le résultat de l’opération x > y est faux.
2.4.3 Opérateurs logiques

Not : négation logique ;
and : et logique ;
or : ou logique;
xor : ou logique exclusif.
Exemple : x=1.00, y=2.00, a=-10.00 et b=35.23.

Le résultat de l’opération (x > a) and (x <= b) est vrai.
Le résultat de l’opération (x > b) and (y < a) est faux.
2.4.4 Priorité des opérateurs et évaluation des expressions

Une expression est une suite structurée d’opérations élémentaires destinées à l’évaluation.
Cette évaluation repose sur les règles suivantes :
– L’évaluation d’une constante donne la valeur représentée par la constante.
– L’évaluation d’une variable donne la valeur que possède cette variable au moment
de l’évaluation.
– L’évaluation d’une opération résulte de l’action de l’opérateur sur l’évaluation de ses
facteurs.
– L’évaluation d’un appel de fonction résulte de l’application de cette fonction à
l’évaluation de son (ou ses) argument(s).
L’évaluation d’une expression plus complexe est fondée sur une stratégie du compilateur
et qui s’appuie sur un système de priorités relatives entre les opérateurs. Ces règles de
priorité s’énoncent essentiellement selon l’ordre décroissant suivant :
opérateur arithmétique (priorité la plus élevée); opérateurs de comparaison; opérateurs
logiques (priorité la plus basse).
2.5. LES FONCTIONS 15
Pour déterminer l’ordre d’évaluation d’une expression quelconque, le compilateur procède

ainsi :
– Les appels de fonctions sont évalués en premier lieu;
– Puis les expressions entre parenthèses (dans le cas des parenthèses imbriquées, on
commence par les plus internes).
– Quand il ne reste plus ni appel de fonction, ni parenthèses, le reliquat de l’expression
est évaluée en respectant les priorités relatives des opérateurs, de gauche à droite pour
les opérateurs d’égale priorité comme le + et le −, la division et la multiplication.
Exemples:
I=0 or J>I+3 sera evalue comme (I =0) ou (J > (I+3))
a+b/c+d sera evalue comme a+(b/c)+d.
2.5 Les fonctions

Turbo pascal fournit des fonctions mathématiques de base telles que le carré, la racine
carrée, le sinus, etc. Ces fonctions disponibles sont :
Fonction Type de l’argument Type du résultat Description

ABS(X), Integer, Real Integer, Real Valeur absolue
SQR(X) Integer, Real Integer, Real carré
Sin(X),Cos(X),Arctan(X) Integer, Real Integer, Real Fonctions trigo
Exp(X) Integer, Real Integer, Real Exponentielle
Ln(X), Réel positif Real Logarithme népérien
SQRT(X) Réel positif Real Racine carrée
ODD(X) Integer Boolean impair
EOLN(X) File Boolean Fin de ligne
EOF(X) File Boolean Fin de fichier
Trunc(X) Real Integer Troncature
Round(X) Real Integer Partie entière
ORD(X) Real Integer rang
CHR(X) Integer Char Conversion ASCII
SUCC(X) Real idem Successeur
PRED(X) Real idem Prédécesseur
LENGTH(X) Char ou string Integer Longueur chaı̂ne
Int(X) Real Real Partie entière réelle
Frac(X) Real Real partie fractionnaire
2.6 Texts et Choix : instructions conditionnelles

2.6.1 Position du problème
Les instructions exécutables introduites jusqu’à présent (affectation, lire et écrire) ne
permettent d’écrire que des séquences d’instructions, exécutées les unes à la suite des
autres. Or cela ne suffit pas pour résoudre même des problèmes élémentaires comme, par
exemple, le calcul des racines d’une équation du second degré : de nombreux traitements
ne peuvent ainsi être effectués que si certaines conditions sont remplies. Dans cette section,
nous exposons comment se réalise, en Pascal, cette décision d’exécution conditionnelle.
2.6.2 L’alternative
2.6.2.1 Action simple : le If logique simple
Supposons que nous voulions faire à ce que la plus grande valeur de deux nombres réels
A et B soit mise dans B. L’algorithme correspondant est :
Si A > B alors B = A sinon B reste inchangé.
L’instruction Pascal permettant de traduire un tel schéma se note:
IF (expression à valeur logique) THEN instruction exécutable
dont l’action peut se représenter par l’organigramme de la figure (2.1):

L’instruction n’est exécutée que si et seulement si l’évaluation de l’expression logique
Fig. 2.1 –
donne la valeur vrai. Voici donc la séquence de ce programme pascal:

IF (A > B) then B :=A ;
2.6.2.2 Séquence conditionnée : IF .. Then Begin..end

Le plus souvent, ce n’est pas une instruction simple qui doit être conditionnée, mais une
suite d’instructions, ou séquence. L’organigramme précédent reste valide mais la syntaxe
du ”IF” devient:
IF (expression) Then
Begin
Instructions
End;
Par exemple, supposons que nous voulions classer les deux nombres réels A et B utilisés
précédemment et que la plus grande valeur des deux sera mise dans B et la plus petite
dans A . L’algorithme correspondant est le suivant :
Si A>B
alors Temp=B
B=A
A= Temp
Sinon A et B restent inchangees.
2.6. TEXTS ET CHOIX : INSTRUCTIONS CONDITIONNELLES 17
Fig. 2.2 –
On peut constater qu’ entre ” alors ” et ” sinon ” il y a plus d’une expression. Cette
séquence en Pascal se traduit par :
IF (A>B) Then
Begin
Temp:=B;
B:=A ;
A:=Temp;
End;
Writeln(’le plus grand nombre est B=’,B ,’ et le plus petit A= ’,A)
2.6.2.3 Sequence d’instructions conditionnées sous forme alternative (IFThen.Else.)

Dans le cas le plus général, la formulation d’un problème peut conduire vers plusieurs
définitions conditionnelles dont l’algorithme est du genre:
Si expression alors faire
Sequence1
Sinon faire
Sequence2
Fin si.
L’organigramme correspondant est celui da la figure (2.2).
La syntaxe de cette instruction est
IF (expression) Then
Begin
Seq.1
End else
Begin
Seq. 2
End ;
2.6.3 Choix fondé sur une cascade de questions

Il s’agit d’une variante de choix dans laquelle chacune des séquences en parallèle dépend
d’une proposition. Les propositions ou critère de choix sont évaluées à tour de rôle ; dès
qu’une proposition est vraie, la séquence associée est exécutée, et le programme reprend
à la suite. L’organigramme est celui de la figure (2.3). Ce schéma peut aussi être visualisé
Fig. 2.3 –
sous forme d’une arborescence dont chaque nœud représente une question à deux issues :
Cette arborescence se traduit En Pascal par :
Fig. 2.4 –
IF(Prop1) Then
Seq.1
Else if (Prop2) then
Seq.2
Else if (Prop.3) then
Seq.3
2.6. TEXTS ET CHOIX : INSTRUCTIONS CONDITIONNELLES 19
:
Else if(prop. N) Then
Seq. n
Else
Seq. n+1.
NB Dans le cas où la sequence n+1 est vide, càd ne contient aucune instruction , le
”else ” final disparaı̂t.
Exemple: Résolution d’une équation de premier degré.

Il s’agit d’écrire un programme permettant de résoudre en x l’équation ax = b quelque
soit les coefficients réels a et b. Les données a et b sont introduites par lecture dans le
programme.
• Solution : Etude mathématique.
Si a = 0 et b = 0 alors la solution est R,

si a = 0 et b 6= 0, la solution est l’ensemble vide,
dans le cas contraire x = b/a ;
d’où l’arborescence de la figure (2.5)
Fig. 2.5 – Arborescence de résolution de l’équation de premier degré.
• Propgramme.
Program Equa1degre;
Var a, b, x :Real;
Begin {debut du programme principal}
Witeln(’donner dans l"ordre les valeurs des coefficients de
l’equation du premier degre, a et b’);
Readln(a,b);
{****Fin enregistrement des donnees ****}
If (a<>0.0) Then
Begin
x=b/a;
writeln(’la solution de l"equation’, a,’X=’,b,’ est ’, x :7 :5);
end
else if (b<>0.0) Then
writeln(’ l"equation’, a,’X=’,b,’n"a pas de solution dans R’)

else
writeln(’la solution de l"equation’, a,’X=’,b,’ est l’ensemble R’);
(**** Fin du programme****)
Readln;
End.
2.6.4 Questionnaire de classification

Certains algorithmes s’apparentent à un mécanisme de reconnaissance de forme en ce
sens qu’ils ne peuvent déterminer le traitement que doit subir un certain élément qu’après
une série de questions concernant ses caractéristiques. Ce qu’on peut schématiser par une
arborescence du genre (Fig. 2.6).
Cette arborescence se traduit en Pascal par
Fig. 2.6 –
IF (cond1) Then
If (cond2) then
Trait1
else
Trait2
Elseif (Cond3) then
Trait3
Elseif (cond4) Then
Trait4
Elseif (Cond5) then
Trait5
Else
Trait6;
2.7. LES BOUCLES 21
Exemple2 (devoir): Résolution d’une équation de second degré.

Il s’agit d’écrire un programme permettant de résoudre en x l’équation ax2 + bx + c = 0,
quelque soit la valeur des coefficients réels a, b et c. Les données a, b et c sont introduites
par lecture dans le programme.
2.7 Les BOUCLES

Dans une séquence, chaque instruction était à tour de rôle exécutée 1 fois (et une seule
fois). L’exécution conditionnelle, combinant test et séquence, permet d’exécuter chaque
instruction 0 ou 1 fois exactement. Il faut donc enrichir ces schémas de base de telle sorte
que chaque instruction puisse être exécutée un nombre quelconque de fois, aussi grand
qu’on le souhaite. Par exemple, soit à traiter les notes des étudiants de Physique 3. Le
traitement associé à chaque étudiant s’exprime à l’aide d’une même section de programme
quel que soit l’étudiant ; il est hors de question cependant d’écrire autant de fois cette
section qu’il y a d’étudiants en PH3, ou de relancer l’exécution du programme en lui four-
nissant, à chaque fois les données relatives à un nouvel étudiant ! Le schéma de boucle
permet donc de décrire la répétition d’un même traitement que doit subir tout élément
d’un ensemble . Cette section passe en revue quelques formes de boucles que l’on peut
souhaiter et donne leur transcription en Pascal.
2.7.2 Parcours d’un intervalle en sens croissant : la boucle For

ordinaire.
Les éléments d’un ensemble fini E peuvent être numérotés :
E = ea ,ea+1 ,...,eb (2.1)

Lorsqu’on connaı̂t à l’avance le nombre des éléments de E(càd la borne a et b) on décrit
la répétition d’un traitement identique à faire en séquence à tout élément ei de E grâce à
l’algorithme suivant :
Faire varier i de a b, (a<b); pour chaque valeur de i :
...
Traitement de ei
...
Fin i
i est appelée, par extension, indice de la boucle
L’organigramme correspondant est donné sur la figure (2.7):

L’algorithme précédent se traduit en Pascal par :
For i:=a to b do
Begin
...
Traitement
...
Fig. 2.7 –
End;
Exemple1. Soit à calculer la somme des n premiers entiers naturels non nuls; la séquence
du programme est la suivante:
somme:=0 ; For i :=1 to n do somme:=somme+i ;
Exemple 2. Ecrire une portion de programme qui calcule factoriel 10;
Toutes les instructions comprises dans la boucle sont exécutées b − a + 1 fois au total,
successivement pour i = a,a + 1,a + 2,...,b.
Lorsque la valeur initiale de l’indice a est supérieure à la valeur finale b, alors la boucle
est sautée. Le seul effet sera de donner à l’indice de la boucle la valeur initiale a.
2.7.3 Parcours séquentiel rétrograde
Le compilateur a prévue que la boucle peut aussi être parcouru de la plus grande valeur
de l’indice à sa plus petite. Càd a > b. dans ce cas on utilise la syntaxe
For i=a downto b

Begin
...
Traitement
...
End;
NB Il est strictement interdit de modifier l’indice d’une boucle ”for” à l’intérieur de son
corps .
2.7. LES BOUCLES 23
Fig. 2.8 – Organigramme de la boucle for en parcours séquentiel rétrograde
2.7.4 Boucle de recherche sur un intervalle non borné

2.7.4.1 Boucle faire tant que...
Lorsque le programme n’utilise pas l’indice de la boucle et que l’on est sûr que la
condition de recherche sera réalisée, alors on a l’algorithme suivant:
Faire tant que (condition)
...
Traitement
...
Fin faire.
L’organigramme correspondant est donné par la figure (2.9) En Pascal cela se réalise par
Fig. 2.9 – Organigramme de la boucle faire tant que
la boucle While dont la syntaxe est la suivante:

While (condition) do
Begin
...
Traitement
...
End;
”Traitement ” sera répété jusqu’à ce que la valeur booléenne de ”condition” soit fausse.
Le mécanisme de cette boucle est le suivant :
La valeur booléenne de ”condition” est évaluée, si elle est vraie alors le corps de la boucle
est exécutée, puis ”condition” est à nouveau évaluée, etc.... L’éxécution de la boucle
s’arrêtera dès que la valeur booléenne de ”condition” sera ” faux ”. Si nous voulons que
l’éxécution de la boucle cesse, il faut bien sûr que le corps de la boucle rende fausse
”condition”.
La boucle ne peut pas être exécutée, si ”condition” possède la valeur ”faux” à l’entrée de
la boucle. De même la boucle peut être exécutée perpétuellement si la valeur de ”condition”
est toujours ” vrai ”.
2.7.4.2 Boucle Jusqu’à ce que ...
L’organigramme d’une telle boucle est donné par la figure(2.10). En pascal cette boucle
Fig. 2.10 – Organigramme de la boucle Repeat
se réalise par l’instruction Repeat dont la syntaxe est :

Repeat
...
Traitement
...
Until (condition)
Remarques. Il y a deux différences essentielles entre la boucle while et la boucle
repeat.
– La condition qui décide de la continuation ou de l’arrêt des itérations est testée en
début de boucle pour la boucle while et en fin de boucle dans le second cas.
– La valeur booléenne de condition doit être ”faux” pour que le corps de la boucle
soit exécutée dans le premier cas et ”faux” pour qu’il soit à nouveau exécutée dans
le second.
On choisira le type de boucle préférable pour chaque situation. La différence essentielle
étant que le corps de la boucle Repeat est toujours exécutée au moins une fois, alors que
celui de la boucle while peut ne jamais être exécutée.
2.8. LES TABLEAUX 25
2.8 Les tableaux

2.8.1 Utilité
On utilise un tableau à chaque fois que l’on veut, par nécessité ou commodité, conser-
ver en mémoire un ensemble d’informations scalaires homogènes (entiers, réels, logiques,
caractères ou chaı̂nes de caractères), de façon à pouvoir accéder à tout moment à n’im-
porte laquelle grâce à la position (ou l’indice) de l’information voulue dans le tableau : le
tableau permet l’accès direct à ses éléments.
2.8.2 Dimension des tableaux

Un tableau à un indice (ou de dimension 1) est un ” vecteur ” (on utilise parfois le
mot ” liste ”, mais ce terme désigne, en programmation, une autre structure bien précise).
Un tableau de dimension 2 (à deux indices) est une matrice. Ces deux cas particuliers
sont les plus utilisés dans la pratique. Cependant, rien n’empêche de définir des tableaux
de dimension supérieure, bien que leur emploi s’avère assez rare. Sauf erreur de ma part
la dimension des tableaux est limitée à trois dans le compilateur Pascal.
2.8.3 déclaration des tableaux

Comme tout identificateur, tout tableau doit être obligatoirement déclaré, et l’attribut
de dimension qui indique le nombre de dimension du tableau et, pour chacune, les bornes
inférieure et supérieure de l’indice de repère dans cette dimension ; ceci se fait grâce à
l’instruction de déclaration spécifique, l’ordre ” array ” :
Var nom : array[i1 ...s1 ,,in ...sn ] of Real;
où nom est un identificateur désignant le tableau; n : son nombre de dimensions ; ij borne
inférieure de la jième dimension et sj sa borne supérieure. Les bornes ij et sj sont des
constantes positives. Exemple
Var V :array[1..10] of integer.
Cette instruction définit un vecteur à 10 éléments entiers numérotés de 1 à 10.
2.8.4 Manipulation des tableaux

L’élément d’indice i du vecteur V se note V [i]. Pour donner la valeur a à cet élément
d’indice i, on écrit
V[i]:=a
Ainsi, une variable indicée s’utilise comme une variable simple du même type. Càd que a
doit être du même type que tous les éléments du tableau V. Un tableau peut être manipulé
globalement dans un ordre d’entrée sortie, ou être transmis en argument à une procédure.
Mais il est interdit d’affecter directement quelque chose à un tableau( tel que V = a), ou
d’écrire une opération sur un tableau (comme par exemple A = V 1 + V 2, où A, V 1 et V 2
sont des tableaux).
2.9 Les sous-programmes

Souvent, dans un programme, un même traitement doit être réalisé en un ou plusieurs
endroits, éventuellement sur des données différentes. Parfois encore, il arrive qu’un traite-
ment, bien qu’il ne soit le cas échéant utilisé qu’une seule fois par le programme, s’avère
d’intérêt général, et donc susceptible d’être incorporé à d’autres programmes ; comme par
exemple le problème de la résolution d’une équation du second degré.
– Dans le premier cas, pour s’épargner la peine de recopier une même suite d’instruc-
tion, et aussi pour diminuer la ” taille ” du programme ;
– dans le second cas , par ce qu’il est commode et agréable de disposer une fois pour
toutes d’un outil réalisant un traitement spécifique donné,
on écrira qu’une seule fois ce traitement, sous la forme d’un morceau de programme compilé
séparément, qu’on appelle module ou procédure, et qui est utilisable (on dit appelable) par
toute autre procédure chaque fois qu’il sera nécessaire, exactement comme si le texte de la
partie de programme correspondante était physiquement présent à chaque point d’appel.
2.9.2 Arguments et paramètres

Une procédure manipule les données et renvoie certains résultats ; ces données et
résultats sont désignés par des variables qu’on appelle les paramètres de la procédure.
Ce sont eux qui permettront de communiquer avec les programmes qui l’utiliseront : les
paramètres réalisent l’interface entre la procédure et son environnement.
Il s’ensuit qu’une procédure a trois types de paramètres :
– Les paramètres d’entrée qui servent à transmettre lors de l’appel des données à
la procédure.
– Les paramètres de sortie qui transmettent au retour les résultats calculés par la
procédure.
– Les paramètres mixtes dont la valeur est utilisée par la procédure et modifiée
ensuite. Ces paramètres sont à la fois données et résultats. Mais on ne les utilise que
dans des cas très spécifiques.
Notons
– qu’une procédure peut disposer de ses propres identificateurs (variables et constantes)
pour ses besoins propres : ils sont strictement locaux à cette procédure,
– et qu’ils existent deux types de sous-programmes : les procédures et les fonctions.
2.9.3 Les Fonctions

La création d’un sous-programme de type fonction permet d’enrichir le répertoire ou
la bibliothèque de fonctions intrinsèques de Turbo Pascal.
La syntaxe ou structure formelle d’un sous-programme de type fonction est :

Le mot clé Function, suivi du nom de la fonction, de ses arguments écrits entre les pa-
renthèses et déclarés là dedans, et enfin du type de résultat renvoyés par la fonction.
Function nom (liste des paramètres : type) :type ;

2.9. LES SOUS-PROGRAMMES 27
Exemple1: fonction sinus hyperbolique de nom SIN H.
Function SINH(X :Real): Real;

Var x1,x2 : Real;
Begin
x1:=exp(-x);
x2:=exp(x);
SINH:=(x2-x1)/2.0;
end;
Exemple2: définir la function sinc.
Function SINC(X :Real): Real;

Const epsi=1.0e-14;
Begin
If (abs(x)<=epsi) then sinc:=1.0 else sinc:=sin(x)/x;
end;
Pour appeler une fonction dans le programme principal, il suffit d’écrire le nom de la
fonction suivie de ses paramètres.
Par exemple, l’instruction
A := SIN C(x) ;
calcule et retourne la valeur de sin(x)/x et l’affecte à la variable A.
NB. Lorsqu’on utilise le mot-clé var pour déclarer les paramètres de la fonction, il ne
sera plus possible d’effectuer des opérations dans l’argument de la fonction au moment de
l’appel. Exemple : je peux écrire A := sinc(x + y) car var n’a pas été utilisé pour déclarer
l’argument x de la fonction sinc(x) alors que je ne peux plus pas le faire dans le cas où
l’argument de sinc était déclaré à l’aide du mot-clé var.
2.9.4 Les procédures

La création d’un sous-programme de type procédure permet d’enrichir le répertoire de
Turbo Pascal par une sorte de super-instructions. Ainsi, on a souvent besoin par exemple,
d’échanger les valeurs de deux variables.
Une procédure est un sous-programme dont le texte commence par une instruction spécifique :
Procedure nom (liste des paramètres)

Par exemple si Permut est le nom de la procédure permettant d’échanger la valeur de
deux variables réelles, cette procédure s’écrira :
Procedure Permut(x,y :real);
Var temp:real;
Begin
temp:=x;
x:=y;
y:=temp;
end ;
NB. Les paramètres de notre procédure permut sont mixtes.
Remarquer qu’une procédure est un programme complet, à la différence qu’elle ne com-
mence pas par le mot-clé Program et ne finit pas par un point à la suite de End.
L’utilisation des services rendus par une procédure se fait par une instruction dont la
syntaxe est :
Nom de la procédure (liste des paramètres) ;
Exemple. La procédure permut s’appelle par l’instruction P ermut(a,b); où a et b sont des
réels.
Gestion des fichiers. Dans un programme on a souvent besoin de sauvegarder les

résultats que nous donne notre programme ou encore de lire certaines données à partir
d’un fichier. Turbo Pascal met à notre disposition des mots-clé permettant de gérer cette
situation. Par exemple nous pouvons définir dans notre programme une procédure per-
mettant de créer un fichier. soit ouverture le nom que nous donnons à cette procédure.
sa syntaxe sera:
Procedure Ouverture(varf :text ; nomf :string);
Begin
Assign(varf, nomf);
Rewrite(varf);
End;
Il suffira d’appeler cette procédure dans votre programme principal par exemple par
l’instruction
Ouverture(varf1, ’c:fichier1.dat’);
Pour y écrire, on peut utiliser l’instruction
W riteln(varf 1,x,0 ,0 ,y);
où varf1 est une variable de type ”text” préalablement déclarée qui permet de repérer le
fichier créé dans la racine du disque C dénomé: f ichier1.dat.
Si nous voulons par contre ouvrir un fichier déjà existant, nous pouvons adopter la
syntaxe suivante: le nom de la procédure est lecture,
Procedure lecture(varf :text ; nomf :string);
Begin
Assign(varf, nomf);
Reset(varf);
End;
Comme précédemment, Il suffira d’appeler cette procédure dans votre programme principal
par exemple par l’instruction
Lecture(varf2, ’c:fichier2.dat’);
Pour y lire, on peut utiliser l’instruction
Readln(varf 2,x,0 ,0 ,y);
où varf2 est une variable de type ”text” préalablement déclarée qui permet de repérer le
fichier C : f ichier2.dat ouvert.
2.10. EXERCICES ET PROBLÈME 29
2.10 Exercices et problème

2.10.1 exercices
Construire les organigrammes des exercices suivants:
1. Recherche du maximum d’une liste de n nombres x1 ,x2 ,x3 ,...,xn .

2. Recherche du maximun et du minimum de n nombres x1 ,x2 ,x3 ,...,xn .
3. Classement par ordre décroissant de la liste des nombres x1 ,x2 ,x3 ,...,xn .
En déduire, dans chaque cas, l’écriture d’un programme Pascal.
2.10.2 Problème
On désire écrire un programme Pascal permettant de traiter les notes des étudiants de
Physique 3. La liste des matières est constituée de 04 UV dénommés UV1, UV2, UV3, et
UV4. Ces UV ont toutes les mêmes coefficients. L’effectif de la classe est N.
Construire un organigramme et écrire un programme, pour ce problème, qui calculent

la moyenne de chaque étudiant, classent les étudiants par odre de mérite, et impriment le
résultat selon le modèle:
Noms et Prenoms UV1 UV2 UV3 UV4 Moyenne

31
Chapitre 3
Dérivation de fonctions : méthode de

différences finies
3.1 position du problème

En calcul numérique, on effectue certaines opérations sur des fonctions, mais on ne
connaı̂t pas toujours la forme analytique de la fonction f (x) en tout point x, mais souvent
seulement les valeurs fj = f (xj ) que prend f en un certain nombre fini de valeurs discrètes
x1 ,x2 ,...,xj . Sauf exceptions, nous considérons que les valeurs xj sont régulièrement espacées
de pas h = xj+1 − xj . Nous nous proposons ici de déterminer les dérivées successives de
f (x) au point xj . Pour cela, nous exposerons dans cette section les méthodes utilisant les
différences à droite, à gauche, et centrées.
3.2 Différences à droite

Cette méthode est aussi appelée ”différences avant” qui est la traduction du mot anglais
(n)
”forward differences”. La méthode permet de calculer fj à partir des valeurs à droite:
fj ,fj+1 ,fj+2 ,...,fj+n ,....
3.2.1 Opérateur différence à droite

On définit l’opérateur différence à droite ∆+ (notée par certains auteurs ∆) comme
l’opérateur linéaire défini par:
∆+ fj = fj+1 − fj . (3.1)
On peut alors aisément définir les puissances entières de cet opérateur:
∆2+ fj = ∆+ (∆+ fj ) = ∆+ (fj+1 − fj ) = ∆+ fj+1 − ∆+ fj = fj+2 − 2fj+1 + fj . (3.2)
De la même façon, on aura
∆3+ fj = −(fj − 3fj+1 + 3fj+2 − fj+3 ) (3.3)
et plus généralement
∆n+ fj = ∆+ (∆n−1
+ fj ). (3.4)
32CHAPITRE 3. DÉRIVATION DE FONCTIONS : MÉTHODE DE DIFFÉRENCES FINIES
On peut facilement montrer par recurrence que :

n
X n!
∆n+ fj = (−1)n (−1)k Cnk fj+k , Cnk = . (3.5)
k=0
k!(n − k)!
L’équation (3.5) montre que les coefficients de fj+k sont ceux du développement du binôme
(1 − x)n , multipliés par (−1)n . On vérifiera aisément (3.5) à partir des équations (3.1) à
(3.4), en faisant tendre n = 1,2,3.
3.2.2 Dérivées successives de f(x) à l’ordre 1 en h

calcul de f ’ Pour calculer la dérivée de f (x) , on développe f (x + h) en série de taylor
à l’ordre 1:
h2
f (x + h) = f (x) + hf 0 (x) + f ”(x) + ..., (3.6)
2
d’où,
f (x + h) − f (x) h f (x + h) − f (x)
f 0 (x) = − f ”(x) + ... ≡ + °(h). (3.7)
h 2 h
Ainsi, au point x = xj , et en remarquant que xj + h = xj+1 , on a:
fj+1 − fj ∆+ fj
fj0 = + °(h) ≡ + °(h). (3.8)
h h
Une interprétation géométrique nous montre que la relation (3.8) revient à remplacer la
tangente en un point Mj par la sécante Mj Mj+1 (Fig.3.1).
Fig. 3.1 –
3.2. DIFFÉRENCES À DROITE 33
calcul de f” Pour calculer la dérivée seconde, on développe f (x + h) et f (x + 2h)

h2 h3 (3)
f (x + h) = f (x) + hf 0 (x) + 2
f ”(x) +6
f (x) + ... ,
0 2 8h3 (3)
f (x + 2h) = f (x) + 2hf (x) + 2h f ”(x) + 6 f (x) + ... , (3.9)
en multipliant la première équation par -2 et la seconde par 1 et en additionnant membre
à membre les équations obtenues, on obtient:
f (x) − 2f (x + h) + f (x + 2h) h (3)
f ”(x) = − f (x) + ... (3.10)
h2 2
En se plaçant au point xj , on obtient:
fj − 2fj+1 + fj+2 ∆2+ fj

f ”j = + °(h) ≡ + °(h). (3.11)
h2 h2
calcul de f (n) On peut poursuivre les calculs des différentes dérivées de f(x) à l’ordre 1
en h et montrer qu’en général on a:
(n) ∆n+ fj
fj = + °(h). (3.12)
hn
En utilisant la relation (3.5), on obtient:
n
(n) (−1)n X k k k n!
fj = (−1) Cn f j+k , C n = (3.13)
hn k=0 k!(n − k)!
Cette relation permet de déterminer les dérivées de f(x) à l’ordre 1 en h à condition de

connaı̂tre f en un nombre suffisamment grand de points. Le tableau ci-dessous donne les
coefficients jusqu’à l’ordre 4.
fj fj+1 fj+2 fj+3 fj+4

hfj0 -1 1 .. .. ..
2
h f ”j 1 -2 1 .. ..
(3)
h3 fj -1 3 -3 1 ..
(4)
h4 fj 1 -4 6 -4 1
par exemple, à l’ordre 4, on a :

(4) 1
fj = (fj − 4fj+1 + 6fj+2 − 4fj+3 + fj+4 ) + °(h). (3.14)
h4

Pour obtenir une dérivée de f à l’ordre 2 en h, on prend plus de termes dans son
développement en série.
h2 h3
f (x + h) = f (x) + hf 0 (x) + f ”(x) + f (3) (x) + ..., (3.15)
2 3!
on en déduit:
0 f (x + h) − f (x) h h2 (3)
f (x) = − f ”(x) − f (x)... (3.16)
h 2 6
D’après (3.10), on a :
f (x) − 2f (x + h) + f (x + 2h) h (3)
f ”(x) = − f (x) + ... (3.17)
h2 2
Cette valeur portée dans (3.16), donne :
· ¸ 2
0 f (x + h) − f (x) h f (x) − 2f (x + h) + f (x + 2h) h (3) h (3)
f (x) = − − f (x) + ... − f (x)...
h 2 h2 2 6
(3.18)
après simplification, nous avons:
−3f (x) + 4f (x + h) − f (x + 2h) h2 (3)
f 0 (x) = − f (x)... (3.19)
2h 3
Au point x = xj , nous avons:
−3fj + 4fj+1 − fj+2
fj0 = + °(h2 ). (3.20)
2h
Le tableau ci-dessous donne les dérivées ainsi calculées jusqu’à l’ordre 4:
fj fj+1 fj+2 fj+3 fj+4 fj+5

2hfj0 -3 4 -1 .. .. ..
h2 f ”j 2 -5 4 -1 .. ..
(3)
2h3 fj -5 18 -24 14 -3 ..
(4)
h4 fj 3 -14 26 -24 11 -2
Par exemple la dérivée quatrième à droite de f(x), d’ordre 2 en h, au point xj est:

2fj − 5fj+1 + 4fj+2 − fj+3
f ”j = + °(h2 ). (3.21)
h2
3.3 Différences à gauche

Cette méthode est aussi appelée différence arrière du fait de son appelation anglaise
(n)
”backward differences”. Elle permet de calculer les dérivées de fj à partir des valeurs à
gauche: fj ,fj−1 ,fj−2 ,...,fj−n ,....
3.3.1 Opérateur différence à gauche

On appelle opérateur différence à gauche l’opérateur ∆− défini par :
∆− fj = fj − fj−1 . (3.22)
On peut comme précédemment montrer que
∆n− fj = ∆− (∆−
n−1
fj ), (3.23)
et que
n
X n!
∆n− fj = (−1)k Cnk fj−k , Cnk = (3.24)
k=0
k!(n − k)!
3.3. DIFFÉRENCES À GAUCHE 35

Comme précédemment, on fait un développement de f (x − h) en série de taylor à
l’ordre 1:
h2
f (x − h) = f (x) − hf 0 (x) + f ”(x) + ..., (3.25)
2
d’où,
f (x) − f (x − h) h
f 0 (x) = + f ”(x) + ... (3.26)
h 2
Ainsi, au point x = xj , on a:
fj − fj−1 ∆− fj
fj0 = + °(h) ≡ + °(h). (3.27)
h h
L’interprétation géométrique montre que la relation (3.26) revient à remplacer la tangente

en un point Mj par la sécante Mj Mj−1 (Fig.3.1). On a comme précédemment :
(n) ∆n− fj
fj = + °(h). (3.28)
hn
En d’autres termes,
n
(n) 1 X
fj = n (−1)k Cnk fj−k , (3.29)
h k=0
Le tableau ci-dessous donne les coefficients des dérivées jusqu’à l’ordre 4.
fj fj−1 fj−2 fj−3 fj−4

hfj0 1 -1 .. .. ..
2
h f ”j 1 -2 1 .. ..
(3)
h3 fj 1 -3 3 -1 ..
(4)
h4 fj 1 -4 6 -4 1

On procède comme au paragraph précédent, à partir du développement de f (x − h)
au lieu de f (x + h). Les dérivées de f jusqu’à l’ordre 4 sont consignées dans ce tableau:
fj fj−1 fj−2 fj−3 fj−4 fj−5

2hfj0 3 -4 1 .. .. ..
h2 f ”j 2 -5 4 -1 .. ..
(3)
2h3 fj 5 -18 24 -14 3 ..
(4)
h4 fj 3 -14 26 -24 11 -2
3.4 Différences centrées

(n)
Pour calculer fj , on utilise les points situés de part et d’autre de xj . Considérons les
deux développements:
h2 h3 (3) h4 (4)
f (x + h) = f (x) + hf 0 (x) + f ”(x) + f (x) + f (x) + ... (3.30)
2! 3! 4!
h2 h3 (3) h4 (4)
f (x − h) = f (x) − hf 0 (x) + f ”(x) − f (x) + f (x) + ... (3.31)
2 3! 4!
En retranchant (3.31) de (3.31), il vient:
f (x + h) − f (x − h) h2 (3)
f 0 (x) = − f (x) + ... (3.32)
2h 3
et au point xj , on obtient:
fj+1 − fj−1
fj0 = + °(h2 ). (3.33)
2h
Interprétation géométrique:
La tangente en Mj (Fig.3.1) est remplaçée par la sécante Mj−1 Mj+1 . On voit sur cette
figure que cette approximation est nettement meilleure que celle obtenue à partir des
différences à droite ou à gauche, ce qui traduit le fait que (3.32) donne une approximation
en h2 alors que (3.7) et (3.27) ne sont approchées qu’en h.
Pour obtenir la dérivée seconde, on additionne (3.31) et (3.31) et on déduit:

f (x − h) − 2f (x) + f (x + h) h2 (4)
f ”(x) = − f (x).... (3.34)
h2 12
Au point xj , on a alors:
fj−1 − 2fj + fj+1
f ”j = + °(h2 ). (3.35)
h2
D’une manière générale, on montre que:
– Pour n pair (n=2p), on a:
(2p) ∆2p 2p
− fj+p + ∆+ fj−p
fj = + °(h2 ). (3.36)
2h2p
– Pour n impair (n=2p+1), on a:
2p+1 2p+1
(2p+1) ∆− fj+p + ∆+ fj−p
fj = 2p+1
+ °(h2 ). (3.37)
2h
Il est très aisé de calculer toutes les dérivées à l’ordre 2 en h. On peut aussi obtenir des
approximations à l’ordre 4 en h. Les tableaux ci-dessous donnent les quatre premières
dérivées, à l’ordre 2 et à l’ordre 4.
A l’ordre 2 on a:
fj−2 fj−1 fj fj+1 fj+2

2hfj0 .. -1 0 1 ..
h2 f ”j .. 1 -2 1 ..
(3)
2h3 fj -1 2 0 -2 1
(4)
h4 fj 1 -4 6 -4 1
3.4. DIFFÉRENCES CENTRÉES 37
A l’ordre 4 on a le tableau:
fj−3 fj−2 fj−1 fj fj+1 fj+2 fj+3

12hfj0 .. 1 -8 0 8 -1 ..
2
12h f ”j .. -1 16 -30 16 -1 ..
(3)
8h3 fj 1 -8 13 0 -13 8 -1
(4)
6h4 fj -1 12 -39 56 -39 12 -1
Il apparait de ces résultats que les différences centrées donnent des résultats bien plus
précis que les différences à droite ou à gauche. Par conséquent, chaque fois qu’il sera
posssible, on utilisera les différences centrées. Toutefois, le nombre de valeurs x étant
limité, en bord de domaine on devra aussi utiliser (Fig.3.2) les différences à droite (au
voisinage de x0 ) ou à gauche (au voisinage de xn ).
Fig. 3.2 – Graphe d’une courbe limitée entre x0 et xn . Au point x0 , il n’est pas pos-
sible d’utiliser les différences à gauche, tandis qu’au point xn , on ne peut pas utiliser les
différences à droite.
39
Chapitre 4
Résolution numériques d’équations
4.1 Position du problème

Soit f une fonction donnée. On désire trouver une ou plusieurs solutions de l’équation
f (x) = 0. Dans ce chapitre nous considérons deux cas de figure : le cas où la fonction f
est une fonction numérique à variables réelles quelconque et le cas où f est un polynôme.
Dans le premier cas, la première étape consiste à localiser la racine dans un domaine
suffisamment ” étroit ” pour être certain qu’il n’ y a pas plusieurs racines dans ce domaine.
Ceci, peut se faire par une première étude sommaire, soit graphique, soit par calculs à la
main ou par ordinateur avec un pas suffisamment petit.
4.2 Méthodes de recherche des racines d’une équation

4.2.1 Principe de la méthode des approximations successives
A l’exception de quelques cas simples, où il existe des méthodes analytiques de recherche
de la racine de f (x), comme les équations algébriques de 1er et 2nd degré, il n’existe pas
de méthode exacte pour déterminer les zéros d’une fonction. Pour le faire, on construit
une suite (xn ) dans l’espoir qu’elle tende vers la solution ` du problème qui vérifie f (`) = 0.
Pour engendrer une suite, on remplace l’équation f (x) = 0 par une équation équivalente
dans l’intervalle considéré, x = g(x), où g(x) est encore une fonction continue. Par exemple
on peut avoir x − f (x) = g(x), càd qu’on pose g(x) = x − f (x). On peut aussi poser
g(x) = x − f (x)/α, avec α 6= 0. Ensuite, on choisit x0 ∈ [a,b] et on construit x1 = g(x0 ),
x2 = g(x1 ),...,xn+1 = g(xn ).
Pour cela, il y a plusieurs façons d’obtenir une méthode d’approximations successives,

i.e. de générer la fonction g(x) à partir de f (x). Le choix est conditionné par les réponses
aux questions suivantes :
1. la suite (xn ) est-elle convergente?
2. si (xn ) converge, sa limite est-elle `? d’une autre manière limn→∞ xn = `?
Si à l’une de ces questions, la réponse est non, alors il faut éliminer la méthode
d’approximations successives.
Ces deux premières conditions relèvent purement des considérations mathématiques.

Elles sont nécessaires mais pas suffisantes car, numériquement on effectue qu’un
40 CHAPITRE 4. RÉSOLUTION NUMÉRIQUES D’ÉQUATIONS
nombre fini d’itérations. Il faut donc se préoccuper des problèmes suivants :

3. si on veut obtenir la solution à ² près, comment arrêter les itérations une fois cette
condition remplie?
4. comme dans tout calcul numérique, on désire obtenir rapidement le résultat ap-
proché, il faudra donc estimer la manière dont évolue l’erreur en = xn − ` au cours
des itérations.
Remarque. Si limn→∞ xn = s alors limn→∞ g(xn ) = g(s)
4.2.2 Méthode de Lagrange par des partitions proportionnelles

La méthode consiste à remplacer le graphe de f (x), restreinte dans l’intervalle [a,b],
par la droite (AB) où A(a,f (a)) et B(b,f (b)), càd qu’on interpole la fonction f (x) par un
polynôme de degré 1 et on résout localement p(x) = 0.
Soit x1 l’intersection de (AB) avec l’axe des abscisses. Nous avons :
bf (a) − af (b)
x1 = − (4.1)
f (b) − f (a)
car, la droite (AB) a pour équation
f (b) − f (a) bf (a) − af (b)

y=x + . (4.2)
b−a b−a
Si f (x1 ) ∗ f (b) < 0, on considère maintenant l’intervalle [x1 ,b] et on reprend le même pro-
cessus pour calculer x2 .
On remarque qu’en prenant x0 = b, on a :
af (x0 ) − x0 f (a)
x1 = − . (4.3)
f (a) − f (x0 )
Ainsi, on peut donc prendre l’expression de g(x) comme suit:
af (x) − xf (a) af (x) − xf (a)

g(x) = − = , (4.4)
f (a) − f (x) f (x) − f (a)
et la suite xn est définie par :

½
x0 ∈ [a,b], x0 = b
(4.5)
xn+1 = g(xn )
où g est la fonction définie par la relation (4.4).
4.3 Méthode de Newton

Cette méthode est valable lorsqu’on peut calculer les dérivées de f (x).
4.3. MÉTHODE DE NEWTON 41
Fig. 4.1 –
4.3.1 Principe de la méthode : détermination de la fonction g(x)

Il consiste à approcher la racine ` par une interpolation linéaire. Géométriquement la
méthode consiste à remplacer la courbe (AB) par la tangente à la courbe au point A ou
B (Fig.4.1).
Au point (xi ,yi ), l’équation de la tangente est donnée par :
y = f 0 (x)(x − xi ) + yi . (4.6)
L’intersection de cette droite avec l’axe ox donne le point suivant xi+1 , d’où
f (xi )
f 0 (xi )(xi+1 − xi ) + yi = 0 → xi+1 = xi − (4.7)
f 0 (xi )
car, yi = f (xi ). On en déduit:
f (xi )
xi+1 = xi + h ≡ g(xi ) avec h = − . (4.8)
f 0 (xi )
Remarque.
– Le choix de x0 est très important. Sur la figure ci-dessous (Fig.4.3), on s’aperçoit
que la tangente en A coupe l’axe ox en dehors du segment [a,b]. Pour éviter cette
éventualité et assurer rapidement la convergence, x0 doit être suffisamment proche de
la racine `. C’est le choix de la valeur initiale qui rend cette méthode peu avantageuse
en général.
– Toutefois si f (a)f (b) < 0, f (x) et f 0 (x) strictement monotones sur [a,b], la racine
simple peut être calculée avec la précision voulue partant de x0 ∈ [a,b] tel que
f (x0 )f 00 (x0 ) > 0.
– Si la courbe Cf de f (x) est presque horizontale au voisinage de la racine, la méthode
de Newton n’est pas recommandée.
La figure (4.2) montre l’organigramme de la procédure de Newton: Le test d’arrêt | h |< ²
ne garantit pas que la précision sur la racine soit ². En effet, il existe des cas pathologiques
pour lesquels la courbe est presque verticale (voir figure). De même, pour que la précision
sur ` soit de ², on choisit d’arrêter l’algorithme lorsque | xn+1 − xn |<= ²/10.
Fig. 4.2 – Organigramme de la méthode de Newton
4.3.2 Cas de racines multiples
Dans le cas des racines multiples, la convergence est lente. On sait qu’une racine mul-
tiple d’ordre r de f (x) est aussi racine d’ordre r − 1 de f 0 (x). On a, au voisinage de cette
racine ` :
f (x) = A(x − `)r , f 0 (x) = B(x − `)r−1 . (4.9)

4.3. MÉTHODE DE NEWTON 43
Fig. 4.3 –
On considère alors la fonction
u(x) = f (x)/f 0 (x), (4.10)
Les relations (4.9) montrent que ` est racine simple pour u(x). On peut alors appliquer la
méthode de Newton à u(x) et écrire :
u(x)
xn+1 = xn − , (4.11)
u0 (x)
avec d’après (4.10),
f (x)f 00 (x)
u0 (x) = 1 − . (4.12)
[f 0 (x)]2
Remarque. Si on ne sait pas que ` est racine simple ou multiple de f (x), on peut appli-
quer systématiquement cette méthode, valable pour les racines simples ou multiples.
Le programme Pascal concrétisant la méthode de Newton est le suivant:
Program Newton;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* Ce programme calcule la racine de l’equation f(x)=0 ****
******* par la methode de Newton. la precision est de epsi *****
******* *****
*****************************************************************
*****************************************************************)
const epsi=1.0E-10;
zero=1.0E-34;
Var
j,count,Maxiter:integer;
x,x0,l,h:real;
Function f(x:real):real;
begin
f:=(x-5)*exp(x)+5;
end;
Function fp(x:real):real;
begin
fp:=(x-4)*exp(x);
end;
(* Debut du programme principal*)
Begin
Maxiter:=50;
j:=0;
repeat
if (j=0) then
begin
writeln(’donner la valeur de x0’);
readln(x0);
end
else
begin
writeln(’fprime(x0)=0.0, entrer de nouveau la valeur de x0’);
readln(x0);
end;
j:=j+1;
until (fp(x0) <> 0.0);
(* fin enregistrement des donnees*)

x:=x0;
if (f(x)=0.0) then
l:=x
else
begin
count:=0;
repeat
count:= count+1;
h:=-f(x)/fp(x);
x:=x+h;
until ((abs(h)<epsi/10) or (count>=Maxiter));
(******* fin procedure Newton, ***************)

(******* impression du resultat ***************)
4.4. THÉORÈME DU POINT FIXE 45
if (abs(h)<epsi/10) then
l:=x
else
begin
writeln(’il n" y a pas eu de convergence’);
writeln(’apres ’, count,’ iterations’);
writeln(’Revoir la valeur de x0 ou de Maxiter’);
Readln;
Halt;
end;
end;
writeln;
writeln(’la solution de l"equation est l=’, l:10:8);
writeln(’ obtenue apres ’,count,’ iterations’);
writeln;
writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Fin du programme $$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
4.4 Théorème du point fixe

Les méthodes précédentes sont souvent appelées méthode du point fixe. La question
que l’on se pose ici est de savoir si la suite (xn ) générée par la fonction g converge vers `. Il
faut bien évidemment que la solution de x = g(x) dans [a,b] soit la même que la solution
de f (x) = 0 dans [a,b].
Si dans l’intervalle [a,b], g vérifie les conditions suivantes :
1. ∀x ∈ [a,b] =⇒ g(x) ⊂ [a,b]

2. G est strictement contractant i.e. ∀x,y ∈ [a,b] | g(x)−g(y) |< L | x−y |, où L ∈ [0,1[,
alors ∀x0 ∈ [a,b] la suite récurrente définie par xn+1 = g(xn ) converge vers l’unique solu-
tion ` de l’équation x = g(x) avec ` ∈ [a,b]. Si g est dérivable, il est souvent commode
d’exprimer une condition suffisante sur g 0 que de vérifier que g est une fonction strictement
contractante. D’où les propositions suivantes:
Proposition1
Soit g dérivable sur [a,b]. si g 0 vérifie M ax | g 0 (x) |= L < 1, alors g est une application
strictement contractante dans [a,b].
Si dans [a,b] on a g([a,b]) ⊂ [a,b], M ax | g 0 (x) |= L < 1, alors en posant en = xn − `

pour x ∈ [a,b], on a : | en |≤ Ln | e0 |. Le nombre d’itérations qui assure la convergence
| en |≤ ² est n ≥ N , avec
log ² − log e0
N= (4.13)
log L
Il est souvent délicat de déterminer un intervalle [a,b] dans lequel les hypothèses du
théorème du point fixe sont vérifiées. Si on peut calculer ou estimer g 0 (`) on a le résultat
suivant:
Proposition2
Soit ` une solution de l’équation g(x) = x avec g 0 continue. Si | g 0 (`) |< 1 alors il existe un
intervalle [a,b] contenant ` pour lequel la suite définie par:
½
x0 ∈ [a,b],
(4.14)
xn+1 = g(xn )
converge vers `.
Proposition 3
Soit ` une solution de l’équation x = g(x). Si g 0 est continue au voisinage de ` et si
| g 0 (`) |> 1 alors ∀x0 6= ` la suite définie par (4.14) ne converge pas vers `.
En résumé:
On estime g 0 (`).
– Si | g 0 (`) |> 1 on élimine la méthode (on la change)
– Si | g 0 (`) |< 1, la méthode est bonne. Il faut trouver l’intervalle dans lequel M ax |
g 0 (x) |= L < 1 et g([a,b]) ⊂ [a,b].
Remarque. Le cas | g 0 (`) |= 1 est plus délicat à traiter car on peut avoir convergence ou
non. En plus la méthode ne sera pas bonne à cause des erreurs d’arrondi qui perturbent
les données.
4.5 Condition de convergence de la méthode du point

fixe
On utilise en général l’extrémité fixe qui vérifie
f 00 (x)/f (a) > 0, (4.15)
pour tester la convergence dans le cas de la méthode de Lagrange.
Quant à la méthode de Newton on a:

Si f ∈ C 2 ([a,b]) vérifie
– f (a) × f (b) < 0, ∀x ∈ [a,b], f 0 (x) 6= 0 ( f strictement monotone)
– ∀x ∈ [a,b], f 00 (x) 6= 0 (concavité dans le même sens)
alors, en choisissant x0 ∈ [a,b] tel que f 00 (x0 ) × f (x0 ) > 0, la suite (xn ) définie par (4.14)
converge vers l’unique solution ` de l’équation f (x) = 0 dans [a,b].
4.6. MÉTHODE DE DICHOTOMIE OU PAR BISSECTION 47
4.6 Méthode de dichotomie ou par bissection

Soit à résoudre f (x) = 0 avec f continue. S’il existe un intervalle [a,b] tel que f (a)f (b) <
0 alors il existe au moins une racine dans [a,b]. Si de plus f est strictement monotone sur
[a,b], alors cette racine est unique. L’algorithme est le suivant:
– On considère le milieu de cette intervalle [a,b] : c = (a + b)/2
– Si f (c) = 0 alors c = ` (on arrête le processus)
– Si f (c) 6= 0 alors on reprend le procédé avec l’intervalle [a,c[ ou[c,b] suivant que
f (c)f (a) < 0 ou f (c)f (b) < 0, respectivement.
Fig. 4.4 –
Cette méthode, illustrée par la figure (4.4), a l’avantage de convenir dans tous les cas où
on a déterminé a et b tel que f (a)f (b) < 0.
La figure (4.5) montre l’organigramme correspondant à cette procédure
Fig. 4.5 – Organigramme de la méthode de Bissection
Program Bissection;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* par la methode de la Bissection, *****
******* la precision est de epsi *****
******* *****
*****************************************************************
*****************************************************************)
const epsi=1.0E-010;
Var
4.6. MÉTHODE DE DICHOTOMIE OU PAR BISSECTION 49
count, j,Maxiter:integer;
x,a,b,c,l,diff,ll:real;
begin
f:=(x-5)*exp(x)+5;
end;
Begin
Maxiter:=100;
j:=0;
repeat
if (j=0) then
begin
writeln(’entrer les valeurs de a et b’);
readln(a,b);
end
else
begin
writeln(’f(a)*f(b)>0, entrer de nouveau les valeurs de a et b’);
readln(a,b);
end;
j:=j+1;
until (f(a)*f(b)<=0.0);
count:=0;
repeat
count:=count+1;
c:=(a+b)/2.0;
if (f(c)=0.0) then begin
l:=c;
diff:=epsi;
end
else
begin
if(f(a)*f(c)<0) then
b:=c
else
a:=c;
diff:=abs(b-a);
end;
until (diff<=epsi) or (count>=Maxiter);
(**** Fin procedure de la Bissection *****)

(***** impression du resultat *********)
if (diff<=epsi) then
begin
l:=c;
ll:=f(l);
writeln(’la solution est l=’,l:10:8,’ f(l)=’,ll:10:8);
writeln(’obtenue apres ’, count,’ iterations’);
end
else
begin
writeln(’apres’,count,’iterations il n"y a pas eu convergence’);
writeln(’Revoir peut-etre le nombre d"iterations maximale Maxiter’);
end;
writeln; writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$ Fin du programme $$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
4.7 Méthode da la sécante

Cette méthode s’apparente à la fois à la bissection et à la méthode de Newton.
Elle est illustrée par la Fig.4.6, d’où on déduit xn+1 à partir de xn−1 et xn par application
du théorème de Thalès
xn+1 − xn xn − xn−1
= (4.16)
0 − f (xn ) f (xn ) − f (xn−1 )
Soit :
f (xn ) [xn−1 f (xn ) − xn f (xn−1 )]
xn+1 = xn − (xn − xn−1 ) = . (4.17)
f (xn ) − f (xn−1 ) [f (xn ) − f (xn−1 )]
Si xn−1 et xn sont de part et d’autre de `, on voit que xn+1 est en général plus proche
de ` que 21 (xn−1 + xn ) (méthode de la bissection). Mais xn−1 et xn peuvent être aussi du
même côté de `. On voit alors que cette méthode dérive directement de celle de Newton
en remplaçant, dans l’équation (4.8), f 0 (xn ) par la différence finie :
f (xn ) − f (xn−1 )
f 0 (xn ) = . (4.18)
xn − xn−1
Avec (4.18), l’équation (4.8) redonne directement (4.17).
En général, cette méthode converge moins vite que celle de Newton. Cependant, elle
évite le calcul de f 0 (x) : si ce calcul est long, la méthode peut être intéressante. Elle nécessite
4.7. MÉTHODE DA LA SÉCANTE 51
Fig. 4.6 –
de plus, de calculer initialement f (x) en deux points x0 et x1 , qui peuvent être les réels a
et b, d’où on déduit par l’équation (4.17), x2 , x3 ,....
L’organigramme ci-dessus (Fig.4.7) concrétise cette procédure.

Le programme Pascal correspondant est:
Program Secante;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* par la methode de la Secante. *****
******* la precision est de epsi *****
******* *****
*****************************************************************
*****************************************************************)
const epsi=1.0E-010; Var

count, j,Maxiter:integer;
x,a,b,c,l,diff,h,ll:real;
begin
f:=(x-5)*exp(x)+5;
end;
(* D\’ebut du programme principal*)

Begin
Maxiter:=100;
j:=0;
repeat
if (j=0) then
begin
writeln(’entrer les valeurs de a et b’);
readln(a,b);
end
else
begin
writeln(’f(a)*f(b)>0, entrer de nouveau les valeurs de a et b’);
readln(a,b);
end;
j:=j+1;
until (f(a)*f(b)<=0.0);
count:=0;
repeat
count:=count+1;
h:=-(b-a)*f(b)/(f(b)-f(a));
c:=b+h;
{ c:=(a+b)/2.0;}
if (f(c)=0.0) then begin
l:=c;
h:=epsi/10;
end
else
begin
if(f(a)*f(c)<0) then
b:=c
else
a:=c;
end;
until (abs(h)<=epsi) or (count>=Maxiter);
(*** Fin methode de la secante ******)

(**** impression du resultat ********)
if (abs(h)<=epsi) then
begin
l:=c;
writeln(’la solution est l=’,l:10:8);
writeln(’obtenue apres ’, count,’ iterations’);
end
4.7. MÉTHODE DA LA SÉCANTE 53
else
begin
writeln(’apres’,count,’iterations il n"y a pas eu con vergence’);
writeln(’Revoir peut etre le nombre d"iterations maximale Maxiter’);
end;
writeln; writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’Fin du programme’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
Fig. 4.7 – Organigramme correspondant à la méthode de la sécante. Notons que a = x0 ,

b = x1 , et c = x2 , à la première itération.
4.8 Recherche des extrêma d’une fonction

Nous ne considérons pas le cas des fonctions d’une variable réelle, puisque la recherche
des extrêma de f (x) se ramène à celle des racines de g(x) = df (x)/dx.
On envisage donc le problème de la recherche des extrêma d’une fonction f (x,y) de deux
variables (la méthode est identique si le nombre de variables est plus grand) : on utilise
généralement une méthode dérivée de celle de Newton. On doit résoudre le système :

 ∂f (x,y)
 p(x,y) = = 0,
∂x (4.19)
 ∂f (x,y)
 q(x,y) = = 0.
∂y
Etant donné un couple (x0 ,y0 ), on pose x = x0 + ∆x et y = y0 + ∆y où ∆x et ∆y sont
solutions du système:
½
p(x0 + ∆x,y0 + ∆y) = p(x0 ,y0 ) + ∆xp0x (x0 ,y0 ) + ∆yp0y (x0 ,y0 ) = 0,
(4.20)
q(x0 + ∆x,y0 + ∆y) = q(x0 ,y0 ) + ∆xqx0 (x0 ,y0 ) + ∆yqy0 (x0 ,y0 ) = 0.
en résolvant ce système, nous obtenons:
 £ ¤
 ∆x = −p(x0 ,y0 )qy0 (x0 ,y0 ) + q(x0 ,y0 )p0y (x0 ,y0 ) /D,
∆y = [p(x0 ,y0 )qx0 (x0 ,y0 ) − q(x0 ,y0 )p0x (x0 ,y0 )] /D, (4.21)

D = p0x (x0 ,y0 )qy0 (x0 ,y0 ) − p0y (x0 ,y0 )qx0 (x0 ,y0 )
Cette équation (4.21) permet d’obtenir un nouveau couple (x1 = x0 +∆x, y1 = y0 +∆y) qui
remplace (x0 ,y0 ). On continue ainsi jusqu’à ce que ∆x et ∆y soient suffisamment petits.
4.9 Racines d’un polynôme : Méthode de Bairstow

Il existe plusieurs méthodes de détermination systématique de toutes les racines (réelles
ou complexes) de l’équation Pn (x) = 0, parmi lesquelles la méthode de Bairstow, où Pn (x)
est un polynôme d’une variable réelle x à coefficients réels et de degré n supérieur à 2 :
Pn (x) = a0 xn + a1 xn−1 + ... + an−1 x + an (4.22)
Le principe de l’algorithme de Bairstow consiste à diviser Pn (x) par un polynôme de degré

2 : x2 + px + q où p et q sont des constantes quelconques, et on obtient un reste de degré
inférieur ou égale à 1, dont les coefficients sont des fonctions de p et q. Soit :
Pn (x) = (x2 +px+q)(b0 xn−2 +b1 xn−3 +b2 xn−4 +...+bn−4 x2 +bn−3 x+bn−2 )+Rx+S (4.23)
On calcule ensuite p et q de manière à annuler R et S ; on aura ainsi factorisé Pn (x) en le

mettant sous forme du produit d’un polynôme de degré n − 2 et d’un polynôme de second
ordre dont on connaı̂t la solution.
On recommence ce processus avec le polynôme de degré n − 2
b0 xn−2 + b1 xn−3 + b2 xn−4 + ... + bn−4 x2 + bn−3 x + bn−2 . (4.24)
Au bout de n/2 étapes, il restera à trouver les racines d’un polynôme de degré 1 ou 2.
L’algorithme est simple : le problème est de trouver seulement p et q ou ∆p et ∆q comme
4.9. RACINES D’UN POLYNÔME : MÉTHODE DE BAIRSTOW 55
on le verra ci-dessous. Nous procéderons comme suit :
En développant (4.23) nous avons :
Pn (x) = b0 xn + (b1 + pb0 )xn−1 + (b2 + pb1 + qb0 )xn−2 + ...+

(4.25)
(bk + pbk−1 + qbk−2 )xn−k + ... + (pbn−2 + qbn−3 + R)x + S + qbn−2
L’identification de (4.25)) et (4.22) donne :


 a0 = b0 ,



 a1 = b1 + pb0

a2 = b2 + pb1 + qb0
(4.26)

 .....



 a = pbn−2 + qbn−3 + R
 n−1
an = S + qbn−2 .
Remarquons qu’en posant
R = bn−1 et S = bn + pbn−1 , (4.27)
La relation (4.26) se met sous la forme compacte

½
bk = ak − pbk−1 − qbk−2 ,
(4.28)
b−2 = b−1 = 0,
avec k = 0,1,2,...,n.
Les relations (4.26) permettent de trouver bk fonction de p et q, donc R et S. Pour

trouver p et q tels que R = 0 et S = 0, on donne initialement à p et q deux valeurs
arbitraires notées p0 et q0 , et on utilise la méthode de Newton adaptée aux cas de fonctions
à deux variables : à p0 et q0 correspondent R(p0 ,q0 ) = R0 et S(p0 ,q0 ) = S0 . On cherche
alors ∆p et ∆q tels que R(p0 + ∆p,q0 + ∆q) = 0 et S(p0 + ∆p,q0 + ∆q) = 0. En utilisant
le développement de Taylor à l’ordre 1 on a:
½
R0 + ∆p(∂R/∂p)0 + ∆q(∂R/∂q)0 = 0
(4.29)
S0 + ∆p(∂S/∂p)0 + ∆q(∂S/∂q)0 = 0
En utilisant les relations (4.27), on a donc:
½
R0 + ∆p(∂bn−1 /∂p)0 + ∆q(∂bn−1 /∂q)0 = 0,
(4.30)
S0 + ∆p[bn−1 + p0 (∂bn−1 /∂p)0 + (∂bn /∂p)0 ] + ∆q[p0 (∂bn−1 /∂q)0 + +(∂bn /∂q)0 ] = 0
Il faut donc calculer les différentes dérivations de bn et bn−1 par rapport à p et q. En
utilisant les relations de récurrence (4.28) de bk , on a :
dérivation par rapport à p
∂bk /∂p = −bk−1 − p(∂bk−1 /∂p) − q(∂bk−2 /∂p). (4.31)
En posant:
ck−1 = −∂bk /∂p, (k = 0,1,...,n − 1). (4.32)

La relation (4.31) devient

½
ck = bk − pck−1 − qck−2 , (k = 0,1,...,n − 1)
(4.33)
c−1 = c−2 = 0
car les dérivées de b0 et b1 sont nulles. On remarque que si f est une fonction telle que
ck = f (bk ), alors on aura aussi bk = f (ak ). Ainsi, ck et bk sont symétriques. Autrement
dit, la connaissance de bk (k = 0,1,...,n) entraı̂ne celle de ck (k = 0,1,...,n − 1).
Dérivation par rapport à q
En dérivant (4.28) par rapport à q, on a :

∂bk ∂bk−1 ∂bk−2
= −p − bk−2 − q( ), (k = 0,1,2,3,...,n). (4.34)
∂q ∂q ∂q
En posant:
∂bk
dk−2 = − , (k = 2,3,...,n), (4.35)
∂q
cette équation devient :
½
dk = bk − pdk−1 − qdk−2 , (k = 0,1,...,n − 1)
(4.36)
d−1 = d−2 = 0.
La comparaison des équations (4.36) et (4.33) montre que dk = ck . La connaissance de ck
et dk entraine celle de cn et dn . Ainsi le système d’équations (4.30) devient :
½
R0 − ∆pcn−2 − ∆qcn−3 = 0,
(4.37)
S0 + ∆p[bn−1 − cn−1 − p0 cn−2 ] − ∆q[p0 cn−3 + cn−2 ] = 0
Comme R = bn−1 et S = pbn−1 + bn , on a le système
½
∆pcn−2 + ∆qcn−3 = bn−1 ,
(4.38)
∆p[bn−1 − p0 cn−2 − cn−1 ] − ∆q[p0 cn−3 + cn−2 ] = −p0 bn−1 − bn
dont la solution est :
∆p = P/D et ∆q = Q/D (4.39)
où D est le déterminant du système (4.38):


 D = c2n−2 − cn−3 (cn−1 − bn−1 ),
P = −bn cn−3 + bn−1 cn−2 , (4.40)

Q = bn cn−2 + bn−1 (bn−1 − cn−1 )
Nous venons de calculer ∆p et ∆q, donc p = p0 + ∆p et q = q0 + ∆q.
En resumé , la procédure de recherche des racines de Pn est la suivante :

1. On se donne initialement un couple arbitraire (p0 ,q0 ), on calcule b0 ,b1 ,...,bn et c0 ,c1 ,...,cn−1
par les formules de récurrence (4.28) et (4.33).
2. On calcule ∆p et ∆q par les formules (4.39) et (4.40) précédentes et on en déduit
p1 = p0 + ∆p et q1 = q0 + ∆q.
3. On recommence cette opération jusqu’à obtenir un couple (pj ,qj ) sensiblement égal
à (pj−1 ,qj−1 ), càd jusqu’à ce que ∆p et ∆q soient inférieurs à la précision voulue ².
4. On calcule ensuite les racine de x2 +pj x+qj , où j est le nombre d’itérations effectuées
pour avoir le couple (pj ,qj ) cherché. On donne ainsi les 2 premières racines de Pn (x).
5. On recommence le processus ci-dessus (étapes 1 à 4) avec le polynôme Pn−2 (x) dont
les coefficients sont b0 ,b1 ,...,bn−2 jusqu’à réduire finalement le degré du polynôme à
2, 1 ou 0.
Le programme Pascal permettant de concrétiser cette procédure est:
Program Bairstow ;
Uses crt, printer, dos, graph ;
Const degremax = 15 ;
Epsi=1.0e-07 ;
Epsi2=1.0e-14 ;
a00=1.0 ;
itmax=50 ; {nbre d "iterations pour obtenir deltap et deltaq cherches}
Type Vecteur = array[0..degremax] of Real ;
Var a, b, c:Vecteur;
N,i,j,k1,k2,itmax,k,degre :Integer ;
x1r, x1i, x2r, x2i, x, p, q, deltap, deltaq: Real;
Ce:char;
{ declaration des procedures}
Procedure deltapq (Var b,c:Vecteur; var n:intger; var deltap,

deltaq:Real);
{cette procedure calcule les parameters deltap et deltaq}
Var n1, n2, n3:integer;

Detp, detq, det:Real;
Begin
n1:=n-1; n2:=n-2; n3:=n-3;
Detq:=b[n1]*(c[n1]-b[n1])-b[n]*c[n2];
Detp:=c[n3]*b[n]- c[n2]*b[n1];
Det:= (c[n1]-b[n1])*c[n3]-c[n2]*c[n2];
If (abs(det)<epsi2) then
Begin
Writeln(’attention le determinant de deltapq est nul, division par zero!’) ;
Ce :=upcase(readkey) ;
Halt !
End ;
Deltap :=detp/det ;
Deltaq :=detq/det ;
End ; { Fin de la procedure deltapq}
Procedure Equa2(var a1, b1, c1, x1r, x2r, x1i, x2i :real) ;
Var delta:real;
Begin
Delta:=b1*b1-4*a1*c1;
if (abs(delta)<epsi2) then delta:=0.0;
if (delta>0.0) then
begin
x1r:=(-b1-sqrt(delta))/(2*a1);
x2r:=(-b1+sqrt(delta))/(2*a1);
x1i:=0.0; x2i:=0.0;
writeln(’deux racines reelles’);
writeln(’x1:=’, x1r:9:5);
writeln(’x2:=’, x2r:9:5);
end else
if (delta<0.0) then
begin
x1r:=-b1/(2*a1); x2r:=x1r;
x1i:=-sqrt(-delta))/(2*a1); x1i=abs(x1i); x2i:=-x1i;
writeln(’deux solutions complexes conjuguees’);
writeln(’x1 =’, x1r :9 :5,’+i(’,x1i :9 :5,’)’) ;
writeln(’x2 =’, x2r :9 :5,’-i(’,x1i :9 :5,’)’) ;
end else
begin
x1r:=-b1/(2*a1); x2r:=x1r; x1i:=0.0; x2i:=0.0;
writeln(’Une racine double’);
writeln(’x1=x2=’,x1r:9:5);
end;
end; {Fin de la procedure}
Procedure Equa1(var a1, b1,x:real);

Begin
x:=-b1/a1;
Writeln(’ la derni\‘ere solution est x=’,x:9:5);
End;
(*\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S\S*)
Begin {debut du programme principal}

Clrscr ;
(************** Enregistrement des donnees***********************)
Writeln(’saisissez le degre du polynome. Il doit etre < a’,degremax);
Readln(degre);
While (degre>degremax) do
Begin
Writeln(’ degre doit etre <=’,degremax);
Writeln(’saisissez de nouveau la valeur de degre’);
Readln(degre);
End;
N :=degre;
Writeln(’entrer les coefficients du polynome ’) ;
For i :=0 to n do
Begin
Writeln(’entrer a[’, i,’]’);
Readln(a[i]);
End;
(**************** Fin enregistrement des donnees*****************)
{Debut de la procedure de Bairstow}.
If (n<=2) then
Begin
If (n=1) then Equa1(a[0],a[1],x)
Else Equa2(a[0],a[1],a[2],x1r,x2r,x1i,x2i)
End else
Begin
Repeat
p:=2.0;
q:=1.0;
b[0]:=a[0]; c[0]:=b[0];
j:=0; {j est le compteur des iterations}
Repeat{factorisation du polynome; calcul de p et q}
j:=j+1; b[1]:=a[1]-p*b[0];
c[1]:=b[1]-p*c[0];
for k:=2 to n do {calcul des termes des suites bn et cn}
begin
k1:=k+1; k2:=k-2;
b[k]:=a[k]-p*b[k1]-q*b[k2];
c[k]:=b[k]-p*c[k1]-q*c[k2];
end; { fin calcul des termes de la suite bn et cn}
deltapq(b,c,n,deltap,deltaq);
p:=p+deltap;
q:=q+deltaq;
until ((abs(deltap)<= epsi) or (abs(deltaq)<= epsi)or (j>= itmax);
(**************** Fin factorisation de Pn et calcul de p et q*****************)
if (j<= itmax) then {il y a eu convergence}
begin
writeln(’solutions obtenues apres’,j,’iterations :’);
equa2(a00, p, q, x1r, x2r, x1i, x2i);
end else
begin
writeln(’pas de convergence’);
writeln(’ l"execution du programme est suspendue’);
ce:=upcase(readkey);
halt;
end;
(**** reinitialisation en vue d"une nouvelle factorisation ******)
n:=n-2;
for k:=1 to n do a[k]:=b[k];
until (n<=2);
if (n=2) then equa2(a[0], a[1], a[2], x1r, x2r, x1i, x2i)

else equa1(a[0], a[1],x);
end;
(**************** Fin procedure Bairstow *****************)
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$ FIN DU PROGRAMME BAIRSTOW $$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
ce:= upcase(readkey);
end. fin du programme
4.10 Conclusion
La méthode de Newton est celle qui est plus avantageuse car elle est d’ordre 2. Mais
elle suppose généralement que l’on a localisé la racine cherchée. On emploie souvent la
méthode de Dichotomie au début des itérations puis dès que l’intervalle contenant ` est
petit, on utilise la méthode de Newton. Lorsqu’on ne peut pas calculer aisément la dérivée
de f , alors on peut utiliser la méthode de la sécante.
61
Chapitre 5
Introduction à la résolution
numérique des systèmes linéaires
5.1 Introduction
La résolution d’un système de n équations à n inconnus intervient dans de nombreux
problèmes :
– Résolution numérique des équations différentielles ordinaires et aux dérivées par-
tielles
– Analyse structurelle (voir calcul dynamique),
– Analyse des réseaux (réseaux atomiques),
– Analyse des données, ...
Soit à résoudre le système :


 a11 x1 + a12 x2 + ... + a1n xn = y1

a21 x1 + a22 x2 + ... + a2n xn = y2
. (5.1)

 ...

an1 x1 + an2 x2 + ... + ann xn = yn
Ce système peut se mettre sous la forme d’une équation matricielle
AX = B, (5.2)
où les n inconnues x1 ,x2 ,...,xn et y1 ,y2 ,,yn sont rangés dans les matrices uni-colonnes sui-
vantes :
   
x1 y1
 x2   y2 
   
 .   
  = X et  .  = Y, (5.3)
 .   . 
   
 .   . 
xn yn
et A est une matrice carrée n × n réelle donnée par :
 
a11 a12 ... a1n
 a21 a22 ... a2n 
 
 . . . . 
  = A ≡ [aij ] (5.4)
 . . . . 
 
 . . . . 
an1 an2 ... ann
62CHAPITRE 5. INTRODUCTION À LA RÉSOLUTION NUMÉRIQUE DES SYSTÈMES LINÉAIR
Dans aij , l’indice ”i” représente le numéro de la ligne et l’indice ”j” celui de la colonne. A
ce stade, il est utile de remarquer que la résolution du système linéaire, s’il est possible,
est équivalente à l’inversion d’une matrice car, si le déterminant de A est différent de zéro,
on a :
X = A−1 Y. (5.5)
Le choix d’une bonne méthode de résolution du système (5.1) doit se faire en fonction du
critère de précision et de coût :
– la précision est liée à la stabilité de la méthode employée.

– le coût s’évalue en nombre de multiplications et de divisions qui sont les opérations
les plus longues sur un ordinateur (une opération élémentaire équivaut à l’inverse de
la fréquence du microprocesseur de la machine utilisée).
Un mauvais exemple serait celui qui consisterait à résoudre le système (5.1) par la méthode
de Cramer car, par cette méthode, xj = detAj /detA, où Aj est la matrice obtenue par
remplacement de la jième colonne de A par Y.
En effet, le calcul d’un déterminant n × n demande n ∗ n = n2 opérations élémentaires.

Ceci implique que la résolution du système (5.1) nécessiterait par la méthode de Cramer
n∗n2 = n3 opérations. La résolution d’un système de 18 équations prendrait alors plusieurs
jours. Il va donc falloir chercher une méthode plus rapide si on veut résoudre les systèmes
engendrés par les problèmes de physique ou de techniques industrielles qui vont jusqu’à
100.000 équations et même parfois plus.
Nous étudions dans ce chapitre :

Les méthodes de résolution directe (dites aussi méthode du pivot) :
– Méthode de Gauss-Jordan,
– Méthode de Gauss,
– Méthode de Choleski
Les méthodes itératives :
– Méthodes de Gauss-Seidel
– Méthode de Jacobi.
La méthode du pivot est commode pour les systèmes denses, peu élevés ainsi que pour les
matrices bandes même d’ordre élevé. La méthode itérative est mieux adaptée aux autres
matrices d’ordre élevé comportant de nombreux éléments nuls.
Pratiquement, tous les calculateurs ont des programmes optimisés de résolution des
systèmes d’équation. Lorsque cela est possible, il est préférable d’utiliser ces programmes
plutôt que d’en écrire un soi-même car ils sont optimisés et adaptés aux calculateurs
utilisés. Cependant, de nombreuses situations spécifiques peuvent se présenter où il est
plus avantageux d’écrire un programme adapté.
5.2. MÉTHODE DU PIVOT 63
5.2 Méthode du pivot

5.2.1 Exposé de la méthode.
C’est la méthode directe la plus utilisée, nous allons l’exposer à partir d’un système de
4 équations à 4 inconnues:
    
a11 a12 a13 a14 x1 y1
 a21 a22 a23 a24  x2   y2 
    
 a31 a32 a33 a34  x3 = y3 . (5.6)
a41 a42 a43 a44 x4 y4
La méthode du pivot se présente comme suit :
On choisit successivement chaque ligne comme ligne pivot. Le pivot étant le premier
élément non nul de la ligne. (le but principal de la méthode étant de diagonaliser la ma-
trice).
Première étape
On divise la première ligne de (5.6) par a11 . Ce qui donne:
    0 
1 a012 a013 a014 x1 y1
 a21 a22 a23 a24    
x2   y2 
  = . (5.7)
 a31 a32 a33 a34  x3   y3 
a41 a42 a43 a44 x4 y4
Ensuite, on annule le premier terme de chacune des autres lignes en procédant comme
suit :
– A la 2ième ligne, on retranche la première multipliée par a21
– A la 3ième ligne, on retranche la première multipliée par a31
– A la 4ième ligne, on retranche la première multipliée par a41 ,
ce qui donne :
    0 
1 a012 a013 a014 x1 y1
 0 a022 a023 a024  x2   y20 
    
 0 a032 a033 a034  x3 = y30 . (5.8)
0 a042 a043 a044 x4 y40
Deuxième étape
On prend maintenant la 2ième ligne comme ligne pivot, et a022 comme élément pivot. On
répète sur la deuxième ligne les opérations précédentes faites sur la première ligne, càd :
    0 
1 a012 a013 a014 x1 y1
 0 1 a”23 a”24  x2   y”2 
    
 0 a032 a033 a034  x3 = y30 . (5.9)
0 a042 a043 a044 x4 y40
On annule les autres termes de la 2ième colonne. Pour cela :

– à la première ligne, on retranche la 2ième ligne multipliée par a012 ,
– à la 3ième ligne, on retranche la 2ième ligne multipliée par a032 ,
– à la 4ième ligne, on retranche la 2ième ligne multipliée par a042 ,

ce qui donne :
    
1 0 a”13 a”14 x1 y”1
 0 1 a”23 a”24  x2   y”2 
    .
 0 0 a”33 a”34  x3 = y”3 
(5.10)
0 0 a”43 a”44 x4 y”4
Troisième étape
On prend ensuite la 3ième ligne comme ligne pivot et a0033 comme élément pivot, puis la
4ième ligne comme ligne pivot et a0044 comme élément pivot, ce qui donne finalement:
    (4) 
1 0 0 0 x1 y1
 0 1 0 0   x2   (4) 
y2 
  = . (5.11)
 0 0 1 0  x3   y (4) 


3
0 0 0 1 x4 (4)
y4
Et on obtient donc:
(4) (4) (4) (4)
x1 = y1 , x2 = y2 , x3 = y3 , x4 = y4 , (5.12)
qui est le résultat du système (5.6).
5.2.2 Méthode de Gauss-Jordan

D’une manière générale, nous nous proposons de résoudre le système
AX = Y (5.13)
en appliquant la méthode du pivot. On voit qu’à l’issue de la première étape, on obtient

la matrice A(1) donnée par l’équation (5.6) comportant de zéros et 1 dans sa première
colonne. A l’issue de la seconde étape, on a une matrice A(2) donnée par l’équation (5.7)
comportant des zéros et des 1 dans ces deux premières colonnes. A l’issue de la k ieme étape,
obtiendra donc un système qui s’écrit
A(k) = Y (k) (5.14)

(k) (k)
Avec A(k) donnée par [aij ] et Y (k) qui est la matrice colonne d’éléments yi .
(
(k)
aij = 1 si i = j ≤ k
(k) (5.15)
aij = 0 si i 6= j et j ≤ k
(k)
Y (k) est le vecteur dont la iieme composante est yi . L’étape suivante consiste à prendre
(k)
ak+1,k+1 comme élément pivot. On divise la (k + 1)ieme ligne par cet élément, ce qui donne
pour j = k + 1,
première étape
(
(k) (k)
a0ij = aij et yi0 = yi , si i 6= k + 1
(k) (k) (k) (k) (5.16)
a0k+1,j = ak+1,j /ak+1,k+1 et yk+1
0
= yk+1 /ak+1,k+1 , si i = k + 1.
(k)
Puis à chaque ligne i 6= k + 1, on retranche la ligne (k + 1) multipliée par ai,k+1 , ce qui
donne pour i 6= k + 1:
Deuxième étape
(
(k+1) (k) (k)
aij = aij − ai,k+1 × a0k+1,j
(k+1) (k) (k) 0
(5.17)
yi = yi − ai,k+1 × yk+1 si i = k + 1.
On remarque à partir des équations (5.16) et (5.17) que les formules désignant y identiques
à celles définissant a. On obtient donc les relations sur les composantes du vecteur Y en
(k) (k)
posant yi = ai,n+1 (matrice d’ordre n). On n’a plus qu’à considérer les équations sur les
éléments aij . Il suffit de faire varier j de k + 1 à n + 1 au lieu de k + 1 à n.
En portant dans (5.17) les valeurs de [aij ] tirées des équations (5.16), on obtient fina-
lement la procédure suivante :
• Initialisation
(0) (0)
A(0) = A et ai,n+1 = yi (5.18)
pour i allant de 1 à n
• Traitement
Pour k allant de 0 à n − 1
– i = k + 1 (ligne pivot) et j = k + 1 à n + 1
(k+1) (k) (k)
ak+1,j = ak+1,j /ak+1,k+1 (5.19)
– i allant de 1 à n, i 6= k + 1, et j = k + 1 à n + 1
(k+1) (k) (k) (k+1)
ai,j = ai,j − ai,k+1 × ak+1,j (5.20)
Le nombre d’opérations nécessaires pour résoudre le système est environ n3 /2, (n ≥ 10).
La difficulté de la méthode de Gauss-Jordan provient du fait que dans chaque étape,

on divise la ligne par l’élément pivot. Ceci n’est pas possible si cet élément est nul. Plus
généralement, des difficultés surviennent lorsque l’élément pivot est petit, car les erreurs
d’arrondi sont alors relativement importantes et affectent toute la suite des opérations. Il
est difficile de prévoir le comportement des pivots car ils changent de valeurs à chaque
traitement.
Les programmes optimisés intervertissent les colonnes de façon à placer en pivot le

terme de coefficient le plus élevé de la ligne. On peut aussi intervertir à la fois les lignes et
les colonnes pour placer en pivot le terme de coefficient le plus élevé de la matrice entière.
5.2.3 Méthode de Gauss.

5.2.3.1 Présentation de la méthode
Elle consiste à triangulariser la matrice A au lieu de la diagonaliser. A chaque étape,
au lieu de faire apparaı̂tre qu’en dessous de la diagonale (Matrice triangulaire supérieure),
ce qui supprime tous les calculs relatifs aux termes situés au dessus de la diagonale. Il en
résulte deux modifications par rapport aux équations (5.19) et (5.20) :
i variant de k + 2 à n et non de 1 à n et le fait que A(n) soit triangulaire nécessite une

étape supplémentaire afin d’obtenir les xi .
5.2.3.2 Calcul
Première phase : Triangularisation de la matrice A
• Initialisation
(0) (0)
A(0) = A et ai,n+1 = yi , i = 1,2,..,n (5.21)
• Traitement
Pour k allant de 0 à n − 1 on a :
– i = k + 1 (ligne pivot) et j = k + 1 à n + 1
(k+1) (k) (k)
ak+1,j = ak+1,j /ak+1,k+1 (5.22)
– i allant de k + 2 à n et j = k + 1 à n + 1
(k+1) (k) (k) (k+1)
ai,j = ai,j − ai,k+1 × ak+1,j (5.23)
Deuxième phase : Résolution du système triangulaire

A la fin de la première étape, on obtient une matrice triangulaire que nous écrivons pour
simplifier les notations A(n) = R = ri,j . Il suffit donc de résoudre le système suivant :


 x1 + r12 x2 + r13 x3 ... + r1n xn = z1


 x2 + ... + r2n xn = z2
... (5.24)

 x = z
 n
 n
 (n)
ou zi = ai,n+1
On obtient de proche en proche xn , xn−1 ,...,x1 :

½
xn = z n P
(5.25)
xj = zj − nk=j+1 (rjk xk ) pour j = n − 1 a 1.
Le nombre total d’opérations nécessitées par la méthode de Gauss y compris la résolution

du système triangulaire est environ n3 /3 (si n ≥ 10). Par suite, pour les grands systèmes,
elle est 1.5 fois plus rapide que la méthode de Gauss-Jordan : il vaut mieux l’utiliser dans
ce cas. Par contre la méthode de Gauss est moins simple à programmer à cause de la
résolution du système triangulaire. On pourra donc utiliser la méthode de Gauss-Jordan
pour des systèmes pas trop grands.
La méthode de Gauss est en butte aux mêmes difficultés que celle de Gauss-Jordan
pour les pivots nuls et pivots petits. Les précision des résultats dépend de la grandeur du
(k)
module de ak+1,k+1 par rapport aux autres coefficients. Deux techniques de choix du pivot
(k)
ak+1,k+1 permettent de limiter les erreurs :
? Pivot partiel
(k) (k)
On permute les lignes A(k) de façon à avoir | aii | supérieur à | aji | pour j allant de i + 1
à n. cette méthode est sans influence sur l’ordre des inconnues x1 , x2 ,..., xn .
? Pivot Glogal
(k) (k)
On permute les lignes et colonnes de A(k) de façon à avoir | aii | supérieur à | ajk | pour
j et k allant de i + 1 à n. Cette méthode induit une perturbation des variables dont il faut
garder la trace pour le résultat.
5.2.4 Matrices tri-diagonnale : Méthode de double balayage de

Choleski.
Dans le cas des matrices tridiagonales, le système d’équation (5.1) peut se mettre sous
la forme :
    
b1 c1 . . . . . x1 y1
 a2 b2 c2 . . . .  x2   y2 
    
 . a 3 b3 c3 . . .  x3   y3 
  = . (5.26)
 . . .. .. .. . .  .   . 
    
 . . .. .. an−1 bn−1 cn−1  xn−1   yn−1 
. . .. .. .. an bn xn yn
Le passage d’une notation à double indice à une notation à simple indice montre que la
matrice peut être décrite par 3n données : càd a1 ,a2 ,...,an , b1 ,b2 ,...,bn et c1 ,c2 ,...,cn , avec
a1 = cn = 0. L’avantage principale des matrices bandes est d’occuper une place mémoire
bien plus réduite qu’une matrice normale (ici nous avons un tableau à 3 n dimensions au
lieu de n2 ), ce qui est un gain considérable pour les systèmes de grande taille.
On résout ces systèmes en utilisant la méthode de Gauss et non celle de Gauss Jordan
car cette dernière fait apparaı̂tre des éléments non nuls, dans les étapes intermédiaires, à
des places où il y avait des zéros dans la matrice initiale. Dans le cas de systèmes tridia-
gonnaux, cette méthode du pivot est parfois appelée méthode du double balayage ou de
Choleski.
La première équation de (5.26) permet d’exprimer x1 en fonction de l’inconnue x2 :

c1 y1
x1 = − x2 + . (5.27)
b1 b1
Portons cette valeur de x1 dans la 2nde équation de (5.26), on obtient:
c1 y1
a2 [− x2 + ] + b2 x2 + c2 x3 = y2 , (5.28)
b1 b1
ou encore
c1 y1
[− a2 + b2 ]x2 = −c2 x3 + y2 − a2 . (5.29)
b1 b1
On a ainsi exprimé x2 en fonction de x3 , et ainsi de suite, on exprimera chaque inconnue
en fonction de la suivante. Supposons qu’on ait obtenu
xi−1 = Ai−1 xi + Bi−1 , (5.30)

en portant cette valeur dans la iieme equation (5.26), il vient :
ai [Ai−1 xi + Bi−1 ] + bi xi + ci xi+1 = yi , (5.31)
ou encore,
ci yi − ai Bi−1
xi = − xi+1 + (5.32)
ai Ai−1 + bi ai Ai−1 + bi
On peut donc écrire
Xi = Ai xi+1 + Bi , (5.33)
avec
ci yi − ai Bi−1
Ai = − , Bi = . (5.34)
ai Ai−1 + bi ai Ai−1 + bi
Les coefficients Ai et Bi de (5.33) sont obtenus en comparant l’ expression de xi de la

relation (5.33) à celle de la relation (5.32). En prenant i = 1 dans les équations (5.33) et
(5.34), et en comparant avec (5.27), on voit que
A0 = B0 = 0. (5.35)
Les équations (5.33), (5.34) et (5.35) nous permettent de calculer aisément de proche en
proche, étant donné que A0 = 0 = B0 , les couples (A1 ,B1 ), (A2 ,B2 ),..., (Ai ,Bi ), etc. Le
calcul des coefficients Ai a donc été rendu possible en utilisant un premier balayage de
i = 1an.
Nous allons maintenant effectuer un 2nd balayage de i = n à 1 qui va nous permettre

de calculer les inconnus. A cet effet, la dernière équation de (5.26) s’écrit :
an xn−1 + bn xn = yn . (5.36)
Ce qui s’écrit en remplaçant xn−1 par sa valeur tirée de (5.33) et (5.34), où on a fait :
i = n − 1:
an [An−1 xn + Bn−1 ] + bn xn = yn . (5.37)
D’où,
yn − an Bn−1
xn = . (5.38)
an An−1 + bn
D’après (5.33) et (5.34) si on fait i = n dans l’expression de Bi on obtient:
x n = Bn . (5.39)
On a ainsi obtenue la valeur cherchée de xn . on en déduit :
xn−1 = An−1 xn + Bn−1 , (5.40)
Puis xn−2 ,xn−3 ,..., etc. jusqu’à x1 .

5.3. MÉTHODES ITÉRATIVES 69
5.3 Méthodes itératives

5.3.1 Méthode de Jacobi
Considérons l’exemple d’un ensemble de 3 équations à 3 inconnues :

 a11 x1 + a12 x2 + a13 x3 = y1
a21 x1 + a22 x2 + a23 x3 = y2 (5.41)

a31 x1 + a32 x2 + a33 x3 = y3
On résout la première équation par rapport à x1 , la 2nde par rapport à x2 , etc., ce qui
donne :

 x1 = (y1 − a12 x2 − a13 x3 )/a11
x2 = (y2 − a21 x1 − a23 x3 )/a22 (5.42)

x3 = (y3 − a31 x1 − a32 x2 )/a33 .
Donnons aux inconnues les valeurs arbitraires x01 , x02 , et x03 , portés dans le 2nd membre de
(28), on obtient 3 nouvelles valeurs :

(1)
 0 0
 x1 = (y1 − a12 x2 − a13 x3 )/a11 ,
(1)
x2 = (y2 − a21 x01 − a23 x03 )/a22 , (5.43)

 x(1) = (y − a x0 − a x0 )/a .
3 3 31 1 32 2 33
Ce nouvel ensemble porté dans le 2nd membre de (28) donne un autre ensemble:

(2)
 0 0
 x1 = (y1 − a12 x2 − a13 x3 )/a11 ,
(2)
x2 = (y2 − a21 x01 − a23 x03 )/a22 , (5.44)

 x(2) = (y − a x0 − a x0 )/a ,
3 3 31 1 32 2 33
et ainsi de suite.
5.3.2 Méthode de Gauss-Seidel

Partant comme précédemment du système (28), on choisit un ensemble de valeurs x01 ,
x02 , et x03 ; x02 , et x03 sont portés dans la 1ere équation de (28) :
(1) (0) (0)
x1 = (y1 − a12 x2 − a13 x3 )/a11 , (5.45)
C’est cette nouvelle valeur de x1 et non x01 , qui est portée dans la deuxième équation de
(28), ce qui donne :
(1) (1)
x2 = (y2 − a21 x1 − a23 x03 )/a22 , (5.46)
De même, dans la 3ieme équation de (28), on porte x11 et x12 au lieu de x01 et x02 :
(1) (1) (1)
x3 = (y3 − a31 x1 − a32 x2 )/a33 . (5.47)
Lorsqu’une inconnue est utilisée, c’est automatiquement la plus proche de la solution, ceci
assure une convergence bien plus rapide que la méthode de Jacobi.
On arrête les itérations lorsque 2 valeurs successives de xj sont suffisamment voisines.

On peut utiliser 2 critères :
(k+1) (k)
– Convergence absolue : c’est-à-dire que xj − xj ≤ ²
(k+1) (k) (k+1)

– Convergence relative : [xj − xj ]/xj ≤²
Pour les ensembles de grande taille, il est mal commode de faire le test sur chaque
inconnue xj , soit on le fait seulement sur certaines d’entre elles, soit on teste des quantités
du type
P (k+1) (k)
? nj=1 |xj − xj | ≤ ²
P (k+1) (k)
? nj=1 |xj − xj | ≤ ²
P n (k+1) (k)
o1/2
? nj=1 [xj − xj ]2 ≤² (5.48)
Pn (k+1) (k) (k+1)
? j=1 |[xj − xj ]/xj |≤²
Pn n o1/2
(k+1) (k) (k+1) 2
? j=1 [(xj − xj )/xj ] ≤²
(0)
La convergence du procédé ne dépend pas du choix des valeurs initiales xj , mais seule-
ment des valeurs du coefficient.
La convergence est assurée si on a, pour chaque valeur de i (càd pour chaque ligne) :
n
X
|aii | ≥ aij , (5.49)
j=1,i<>j
En d’autres termes, il y a convergence si chaque élément diagonal est supérieur

ou égal à la somme des modules des autres éléments de sa ligne.
En pratique, on peut aussi observer une convergence dans les conditions moins restric-
tives.
Facteur de Relaxation
(0)
Si le choix initial, xj n’influe pas sur la convergence, ou la divergence de la méthode, il
influe par contre considérablement sur la rapidité de la convergence, si convergence il y a.
Plus, les valeurs initiales sont proches des valeurs réelles, et plus la convergence est rapide.
La figure suivante montre l’évolution possible de l’une des quantités xj :
(k)
Fig.2 Evolution possible des xj . ici, xj est la valeur recherchée.
(0) (1) (1)
Partant de xj on obtient xj . Au lieu de réutiliser xj pour l’itération suivante, on
(1)
voit que la convergence serait plus rapide si on prenait à la place de xj
∗(1) (0) (1) (0)
xj = xj + λ(xj − xj ), λ > 1. (5.50)
Une autre évolution possible de xj est :

Fig.3 Autre évolution possible de xj .
(0) (1)
Dans ce cas, on voit qu’à partir de xj et xj , la convergence serait plus rapide si au
(1)
lieu de partir de xj , on partait de
∗(1) (0) (1) (0)
xj = xj + λ(xj − xj ), λ < 1. (5.51)
(k) (k+1) (k+1)
Ainsi, partant de xj , on obtient xj à l’itération suivante. Au lieu de xj on part de
∗(k+1) (k) (k+1) (k)
xj = xj + λ(xj − xj ), (5.52)
5.4. PROGRAMMATION INFORMATIQUE DES MÉTHODES ÉTUDIÉES 71
où λ est le facteur de relaxation.
En pratique, λ est défini de façon arbitraire tel que
0 < λ < 2. (5.53)
Si λ > 2, le processus diverge souvent. En général, 1 < λ < 2 est utilisé pour accélérer la
convergence d’un processus itératif déjà convergent et 0 < λ < 1 permet souvent de faire
converger un processus divergent.
On peut soit utiliser la même valeur de λ pour tout l’ensemble soit utiliser des λ
différents pour différents blocs.
En pratique, λ n’est pas connu à l’avance, il faut faire des essais. On peut suivre
(k) (k)
l’évolution de xj puis injecter une valeur de λ et voir comment évolue les xj suivants.
La méthode itérative est plus utilisée pour la résolution des systèmes de grande taille
et des systèmes non linéaires.
5.4 Programmation informatique des méthodes étudiées

5.4.1 Méthode de Gauss-Jordan
Program GaussJordan;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* Ce programme resoud un systeme lineaire de la forme ****
******* AX=Y par la methode de Gauss-Jordan *****
******* *****
*****************************************************************
*****************************************************************)
const
rangmax=5;
rangmax1=6;
epsi1=1.0E-14;
Type
Matrice=array[1..rangmax,1..rangmax1] of real;
Vecteur=array[1..rangmax] of real;
Var
a,a0:Matrice;
X,Y,Y0,m:Vecteur;
ii,i,j,k,kp1,Lpivot, n,nm1,np1, test:integer;
Pivotmax, somme:real;
ce:char;
{Definition des fonctions et Procedures}

Procedure ecriture(var a:matrice;var y:vecteur;var n:integer);

var i,j:integer;
begin
for i:=1 to n do
begin
write(’ ’, a[i,1]:5:4,’x1’, ’ ’);
for j:=2 to n do
begin
if (a[i,j]>=0.0) then write(’+’);
write(a[i,j]:5:4,’x’,j:1,’ ’);
end;
writeln(’= ’, y[i]:5:4);
end;
end;
Procedure Permutligne(var a:matrice;var n,k,lp:integer);

var Temp1:real;
j:integer;
begin
for j:=k to n+1 do
begin
Temp1:=a[lp,j];
a[lp,j]:=a[k,j];
a[k,j]:=Temp1;
end;
end;
(* $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*)
(************ Dbut du programme principal*************)
Begin
(* donnees du systeme lineaire de n equations a n inconnues*)
writeln(’entrer la valeur de n, n etant le nombre d"equations’);
readln(n);
while (n>rangmax) do
begin
writeln(’n doit etre >= a ’, rangmax);
writeln(’entrer de nouveau n’);
readln(n);
end;
(* elements de la matrice*)
np1:=n+1;
nm1:=n-1;
writeln;
writeln(’entrer les elements de la matrice A’);
for i:=1 to n do
for j:=1 to n do
begin
writeln(’entrer a[’,i,’,’,j,’]’);
readln(a0[i,j]);
end;
(* elements du second membre Y*)
writeln;
writeln(’entrer les elements du second membre Y’);
for i:=1 to n do
begin
writeln(’entrer y[’,i,’]’);
readln(y0[i]);
end;
(* Fin enregistrement des donnees*)
writeln;
writeln(’Premiere Phase, INITIALISATION’);
for i:=1 to n do
for j:=1 to n do a[i,j]:=a0[i,j];
for i:=1 to n do a[i,np1]:=y0[i];
(* Deuxieme etape : Diagonalisation de la matrice*)
test:=5;
{ecriture du systeme d"equations}
writeln(’voulez-vous suivre les diffrentes etapes de la diagonalisation?’);
writeln(’Tapez " 1" si vous le desirez et " 0 " sinon’);
readln(test);
if (test=1) then
begin
writeln(’systeme d"equations AX=Y’); writeln;
ecriture(a0,y0,n);
end;
(*********** Diagonalisation ****)
for k:=0 to nm1 do

begin
{recherche du pivot maximal}
Lpivot:=k+1; kp1:=k+1;
Pivotmax:=abs(a[Lpivot,k+1]);
for ii:=k+2 to n do
begin
if (abs(a[ii,k+1])> pivotmax) then Lpivot:=ii;
end;
if (Lpivot<>k+1) then
begin
permutligne(a,n,kp1,Lpivot);
if ( test=1) then writeln(’permutons les lignes’, k+1,’ et ’, Lpivot);
end;
{fin de la recherche de pivot maximal}
{ Traitement ligne pivot}

for j:=k+1 to n+1 do m[j]:= a[k+1,j]/a[k+1,k+1];
{ Autres lignes}
For i:= 1 to n do
begin
if (i=k+1) then
begin
for j:=k+1 to n+1 do a[k+1,j]:=m[j];
end
else
begin
for j:=k+2 to n+1 do a[i,j]:=a[i,j]-(a[i,k+1])*m[j];
a[i,k+1]:=0.0; (* cle du pb*)
end;
y[i]:=a[i,np1]; (* necessaire si on veut suivre les differentes etapes *)
end; {boucle i}
(* ecriture du systeme d"equations etape par etape *)

if (test=1) then
begin
writeln(’systeme d"equations AX=Y a l"etape’, k+1); writeln;
ecriture(a,y,n); readln;
end;
end;{fin boucle sur k}
(* fin traitement de la matrice *)
(* ecriture du systeme apres diagonalisation*)
for i:=1 to n do y[i]:=a[i,np1];

writeln;
writeln(’systeme d"equations apres diagonalisation’);
ecriture(a,y,n);
(* Solution et impression du resulat du systeme AX=Y*)
writeln;
writeln(’ solution du systeme precedent’);
writeln;
for i:=1 to n do
begin
x[i]:=a[i,np1];
writeln(’x[’,i,’]=’, x[i]:10:5);
end;
writeln;
writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Le Programme $$$$’);
writeln(’$$$$$$ Gauss-Jordan $$$$’);
writeln(’$$$$$$ Vous dit Aurevoir $$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
5.4.2 Méthode de Gauss

Program Gauss;
uses Dos,printer;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* AX=Y ****
******* par la methode de Gauss *****
******* *****
*****************************************************************
*****************************************************************)
const
rangmax=50;
rangmax1=51;
epsi=1.0E-7;
Type
Matrice=array[1..rangmax,1..rangmax1] of real;
Vecteur=array[1..rangmax] of real;
Var
a,a0:Matrice;
X,Y,Y0,m:Vecteur;
ii,i,j,k,Lpivot, n,nm1,np1, test:integer;
Pivotmax, somme:real;
ce:char;
{Dfinition des fonctions et Procdures}
Procedure ecriture(a:matrice; y:vecteur; n:integer);
var i,j:integer;
begin
for i:=1 to n do
begin
write(’ ’, a[i,1]:5:4,’x1’, ’ ’);
for j:=2 to n do
begin
write(a[i,j]:5:4,’x’,j:1,’ ’);
end;
writeln(’= ’, y[i]:5:4);
end;
end;
Procedure Permutligne(a:matrice; n,lp,k:integer);

var Temp1:real;
j:integer;
begin
for j:=k+1 to n+1 do
begin
Temp1:=a[lp,j];
a[lp,j]:=a[k,j];
a[k,j]:=Temp1;
end;
end;
(*$$$$$$$ Debut du programme principal $$$$$$ *)
Begin
{ clrscr; }
(* donnes du systeme lineaire de n equations a n inconnues*)
readln(n);
begin
readln(n);
end;
(* elements de la matrice*)
np1:=n+1;
nm1:=n-1;
writeln;
writeln(’entrer les elements de la matrice A’);

for i:=1 to n do
for j:=1 to n do
begin
writeln(’entrer a[’,i,’,’,j,’]’);
readln(a0[i,j]);
end;
(* elements du second membre Y*)
writeln;
writeln(’entrer les elements du second membre Y’);
for i:=1 to n do
begin
writeln(’entrer y[’,i,’]’);
readln(y0[i]);
end;
(* Fin enregistrement des donnees*)
(******* Premiere Phase, INITIALISATION *******)
writeln(’Premiere Etape: INITIALISATION’);

for i:=1 to n do
begin
for j:=1 to n do a[i,j]:=a0[i,j];
end;
for i:=1 to n do a[i,n+1]:=y0[i];
(* Deuxieme etape: Diagonalisation de la matrice*)

test:=5;
{ecriture du systeme d"equations}
writeln(’voulez-vous suivre les diffrentes etapes de la diagonalisation?’);
writeln(’Tapez 1 si vous le desirez et 0 sinon’);
readln(test);
if (test=1) then
begin
writeln(’systeme d"equations AX=Y’); writeln;
ecriture(a0,y0,n);
end;
(*********** Triangularisation ****)
for k:=0 to nm1 do

begin
{recherche du pivot maximal}
Lpivot:=k+1;
Pivotmax:=abs(a[Lpivot,k+1]);
for ii:=k+2 to n do
begin
if (abs(a[ii,k+1])> pivotmax) then Lpivot:=ii;
end;
if (Lpivot<>k+1) then permutligne(a,n,k+1,Lpivot);
{fin de la recherche de pivot maximal}
{ Traitement ligne apres ligne pour la triangularisation}
For i:= k+1 to n do

begin
if (i=k+1) then
begin
for j:=k+2 to n+1 do a[k+1,j]:=a[k+1,j]/a[k+1,k+1];
a[k+1,k+1]:=1.0;
end
else
begin
for j:=k+2 to n+1 do a[i,j]:=a[i,j]-(a[i,k+1])*a[k+1,j];
a[i,k+1]:=0.0; (* cl du pb *)
end;
end; {boucle i}
end;{fin boucle sur k}
(************ Fin premiere phase ***************)
(* ecriture du systeme apres triangularisation *)
for i:=1 to n do y[i]:=a[i,n+1];

writeln;
writeln(’systeme d"equations apres triangularisation’);
ecriture(a,y,n);
(* Debut de la seconde Phase *)

x[n]:=a[n,n+1];
for j:=n-1 downto 1 do
begin
somme:=0.0;
for k:=j+1 to n do somme:= somme+a[j,k]*x[k];
x[j]:=a[j,n+1]-somme;
end;
(************* Fin de la seconde Phase **********)
(* Impression de la solution du systeme AX=Y*)

writeln;
writeln(’ solution du systeme precedent’);
for i:=1 to n do writeln(’x[’,i,’]=’, x[i]:10:5);
writeln;
writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Gauss $$$$’);
writeln(’$$$$$$ Vous dit Aurevoir $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
5.4.3 Méthode de Gauss

Program Choleski;
uses Dos,printer;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* *****
******* AX=Y ****
******* *****
******* par la methode dou double balyage de Cholesky *****
******* A est une matrice tridiagonnale *****
******* *****
*****************************************************************
*****************************************************************)
const
rangmax=50;
rangmax1=51;
epsi=1.0E-14;
Type
Matrice=array[1..rangmax,1..rangmax] of real;
Vecteur1=array[1..rangmax] of real;
Vecteur2=array[0..rangmax] of real;
Var am:matrice;
a, b,c, X,Y:Vecteur1;
Ga, Gb : Vecteur2;
i,j,n:integer;
Deno:real;
ce:char;
singu:boolean;

Procedure ecriture(a:matrice; y:vecteur1; n:integer);
var i,j:integer;
begin
for i:=1 to n do
begin
write(’ ’, a[i,1]:5:4,’x1’, ’ ’);
for j:=2 to n do
begin
write(a[i,j]:5:4,’x’,j:1,’ ’);
end;
writeln(’= ’, y[i]:5:4);
end;
end;
(*$$$$$$$$$$ Debut du programme principal $$$$$$$$*)
Begin
{ clrscr; }
singu:=false;
(* donnees du systeme lineaire de n equations a n inconnues*)

readln(n);
begin
readln(n);
end;
(* elements de la matrice A *)
writeln;
for i:=1 to n do for j:=1 to n do am[i,j]:=0.0; {initialisation de A}
for i:=1 to n do
begin
if (i=1) then
begin
writeln(’donner dans l"ordre les valeurs de A[’,i,’,’,i,’]’,
’ A[’,i,’,’,i+1,’]’, ’ et y[’,i,’]’);
readln(am[i,i],am[i,i+1],y[i]);
end
else if (i=n) then
begin
writeln(’donner dans l"ordre les valeurs de A[’,i,’,’,i-1,’]’,
’ A[’,i,’,’,i,’]’, ’ et y[’,i,’]’);
readln(am[i,i-1], am[i,i], y[i]);
end
else
begin
writeln(’donner dans l"ordre les valeurs de A[’,i,’,’,i-1,’]’,
’ A[’,i,’,’,i,’]’, ’ et A[’,i,’,’,i+1,’]’, ’y[’,i,’]’);
readln(am[i,i-1], am[i,i], am[i,i+1], y[i]);
end;
end;
(**** ecritue du systeme d"equations a resoudre****)
writeln;
ecriture(am,y,n);
(**** Initialisation de la Methode de Choleski ****)

For i:=1 to n do
begin
b[i]:=am[i,i];
if (i=1) then a[i]:=0.0 else a[i]:=am[i,i-1];
if (i=n) then c[i]:=0 else c[i]:=am[i,i+1];
end;
(* for i:=1 to n do
begin
writeln(’entrer dans l"ordre a[’,i,’]’,
’ b[’,i,’]’, ’ c[’,i,’]’,’ et y[’,i,’]’);
readln(a[i], b[i], c[i], y[i]);
end;
a[1]:=0.0;
c[n]:=0.0; *)
(*********** Premier balayage ****)
Ga[0]:=0.0; Gb[0]:=0.0;
i:=1;
while (i<=n) and not singu do
begin
if (i=1) then
begin
Gb[i]:=y[i]/b[i];
Ga[i]:=-c[i]/b[i];
end
else
begin
Deno:=a[i]*Ga[i-1]+b[i];
if abs(Deno)<=epsi then singu:=true
else
begin
Gb[i]:=(Y[i]-a[i]*Gb[i-1])/Deno;
Ga[i]:=-c[i]/Deno;
end;
end;
i:=i+1;
end;
{**** Fin du Premier balayage ******}
{**** Debut du Second balayage ******}
if not singu then

begin
x[n]:=Gb[n];
for i:=n-1 downto 1 do x[i]:=Ga[i]*x[i+1]+Gb[i];
end;
{**** Fin du Second balayage ******}
(* Impression de la solution du systeme AX=Y *)

writeln;
if not singu then
begin
writeln(’ solution du systeme Ax=Y’);
for i:=1 to n do writeln(’x[’,i,’]=’, x[i]:10:5);
end
else writeln(’Pas de solution; changer de methode’);
writeln;
writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Choleski $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
83
Chapitre 6
Approximation des fonctions

numériques de variables réelles par
des polynômes : Méthodes
d’interpolations.
6.1 Interpolation de Lagrange

Considérons une fonction numérique f (de variable réelle) représentée par une gran-
deur physique dans un domaine qu’on identifie à un intervalle de R. On suppose que par
une approche expérimentale, on peut accéder à des valeurs de f en certains points for-
mant une famille notée {xi }i∈I . Pour fixer les idées on suppose qu’on a n + 1 points :
a < x0 < x1 < ... < xn < b ([a,b] étant l’intervalle mentionnée ci-dessus). On notera fi la
valeur de f , mesurée au point xi pour i = 0,1,...,n. Le problème est de pouvoir définir fi
de façon approximative, sur le segment [a,b].
En d’autres termes, cette technique est utilisée lorsqu’une fonction f (x) d’une variable
réelle est connue par une table de valeurs. Elle peut également être exploitée quand on
dispose aussi de l’expression d’une fonction. En effet, si la fonction est utilisée plusieurs au
cours du programme et que son calcul requiert beaucoup trop de temps machine, on pourra
alors construire une table de valeurs {xi ,f (xi )}i=0,...,n (les abscisses étant judicieusement
choisies) à partir de laquelle on estimera la fonction par une interpolation. L’interpolation
a lieu entre les points {xi ,fi } équidistants de h , où h est le pas de la table.
6.2 Interpolation de Lagrange

L’idée de Lagrange, pour résoudre le problème posé ci-dessus, est de chercher un po-
lynôme Pn de degré inférieur ou égale à n tel que
Pn (xi ) = fi , ∀i = 0,1,...,n. (6.1)
La question qu’on peut se poser est de savoir s’il existe un tel polynôme. Pour répondre à
cette question, considérons la base naturelle de l’espace des polynômes de degré inférieur
84 CHAPITRE 6. APPROXIMATION DES FONCTIONS NUMÉRIQUES...
ou égale à n : {ϕ0 ,ϕ1 ,...,ϕn } où on a posé pour i = 0,...,n,
ϕi (x) = xi , ∀x ∈ <. (6.2)
Ensuite, on cherche Pn sous la forme

n
X
Pn (x) = λj ϕj (x), ∀x ∈ <, (6.3)
j=0
où les λj sont des scalaires à déterminer à l’aide des contraintes (6.1). En écrivant que
(6.1) doit être satisfaite par l’expression (6.3) de Pn , on obtient :


 λ0 ϕ0 (x0 ) + λ1 ϕ1 (x0 ) + ... + λn ϕn (x0 ) = f0 ,



 λ 0 ϕ0 (x1 ) + λ1 ϕ1 (x1 ) + ... + λn ϕn (x1 ) = f1 ,

...
(6.4)

 ...



 ...

λ0 ϕ0 (xn ) + λ1 ϕ1 (xn ) + ... + λn ϕn (xn ) = fn ,
Ce système équivaut à :


 λ0 x00 + λ1 x10 + ... + λn xn0 = f0 ,



 λ0 x01 + λ1 x11 + ... + λn xn1 = f1 ,

...
(6.5)

 ...



 ...

λ0 x0n + λ1 ϕ1 x1n + ... + λn ϕn xnn = fn ,
Soit :
    
1 x10 x20 xn0 λ1 f0
 1 x11 x21 xn1  λ2   f1 
  = 
 . . . .  ...   . . (6.6)
1 x1n x2n xnn λn fn
Soit A la matrice carrée d’ordre n + 1 du système (6.6), il est clair que AT (transposée de
A) est de Van Dermonde. D’autre part, on a (résultat de l’algèbre linéaire):
detA = detAT . (6.7)
Or,
Y
detAT = (xi − xj ). (6.8)
0≤j<i≤n
Comme x0 < x1 < ... < xn , on déduit que det(A) 6= 0, donc Pn existe et de façon unique.
Maintenant, on sait que Pn existe, mais on ne dispose pas encore de son expression
explicite. On peut y accéder par la résolution du système linéaire (6.6). Mais on peut
procéder autrement.
6.2. INTERPOLATION DE LAGRANGE 85
On va chercher une base dans laquelle les (fi )ni=0 sont les composantes de Pn . Pour cela,
on introduit les polynômes de degré inférieur ou égale à n, Φi vérifiant :
Φi (xj ) = δij , ∀0 ≤ j ≤ n (6.9)
où δij est le symbole de Kronecker. On rappelle que δij = 1sii = j et δij = 0 si i 6= j. En
prenant :
n
Y
Φ0 (x) = γ0 (x − xk ), ∀x ∈ <, (6.10)
k=1
on a :
n
Y n
Y
−1
Φ0 (x0 ) = 1 ⇒ γ0 = [ (x0 − xk )] = (x0 − xk )−1 . (6.11)
k=1 k=1
D’une manière générale, on a:

Yn Yn
x − xk x − xk
Φ0 (x) = ( ), Φi (x) = ( ). (6.12)
k=1
x 0 − xk
k=0,k6=i
x i − xk
Supposons, pour l’instant, que les (Φi )i=0,...,n) forment une base de l’espace des polynômes
de degré inférieur ou égale à n et montrons que les (fi )i=(0,...,n) sont les composantes de Pn
dans cette base.
X
Pn = µi Φ i , (6.13)
où les µi sont des scalaires. Il s’agit de montrer que µi = fi , ∀i = 0,...,n.

X
Pn (x) = µi Φi (x), ∀x. (6.14)
Pour x = xj , on a :
n
X n
X
fj = Pn (xj ) = µi Φi (xj ) = µi δij = µj ,∀j = 0,1,...,n. (6.15)
i=0 i=0
D’où la démonstration.
Il reste maintenant à démontrer que {Φi }i=0,...,n est une base. Il suffit de montrer que
cette famille est libre.
X X
γi Φi = 0 == γi Φi (x) = 0,∀x. (6.16)
En particulier, pour x = xj , on a :
X
γi Φi (xj ) = 0 ⇒ γi = 0 ∀i. (6.17)
L’essentiel de ce qui précède est résumé dans le théorème suivant :
Théorème I.1 (de Lagrange)

Soit f une fonction numérique définie sur [a,b], avec −∞ < a < b < +∞ données.
Soit a ≤ x0 < x1 < ... < xn ≤ b, n + 1 points réels donnés. On note fi la valeur de f
au points xi pour i = 0,...,n alors il existe un unique polynôme de degré n noté Pn , qui
coı̈ncide avec f aux points xi (i = 0,1,...,n). Ce polynôme est donné par :
n
X Yn µ ¶
x − xk
Pn (x) = fi Φi (x) avec Φi (x) = . (6.18)
i=0 k=0,k6=i
xi − xk
Pn s’appelle polynôme d’interpolation de Lagrange de f aux points xi . on l’appelle aussi

l’interpolé de Lagrange de f aux points xi .
Proposition I.1
En posant
n
Y
ωn (x) = (x − xk ) (6.19)
k=0
Le polynôme d’interpolation de Lagrange Pn s’écrit encore :

n
X fk ωn (x)
Pn (x) = (6.20)
k=0
x − xk ωn0 (xk )
0 Q
NB on démontre que ωn (xk ) = j=0,j6=k (xk − xj ).
Proposition I.2
Cette proposition donne une expression qui offre l’avantage de réduire sensiblement le
temps de calcul sur ordinateur de Pn (x) pour un réel x donné.
Pn fk
0
k=0 (x−xk )ωn (xk )
Pn (x) = Pn 1 . (6.21)
0
k=0 (x−xk )ωn (xk )
P
Pour démontrer cette proposition, on part de la remarque nk=0 Φk (x) = 1 (on a pris le cas
particulier d’une fonction définie f (x) = 1, ceci implique que fi = 1 et considérer (6.18),
ceci implique que
n
X 1
ωn (x) = 1/ . (6.22)
k=0
(x − xk )ωn0 (xk )
6.2.1 Estimation de l’erreur

On appelle erreur dans l’interpolation de Lagrange d’une fonction f (définie sur [a,b])
aux points a ≤ x0 < ... < xn ≤ b la quantité
en (x) = f (x) − Pn (x), ∀x ∈ [a,b] (6.23)
Le théorème ci-dessous donne cette erreur :
Théorème III.2
6.3. INTERPOLATION DE HERMITE 87
Soit f une fonction numérique de variable réelle définie sur [a,b], avec a < b des réels
donnés.
Soient Pn l’interpolé de Lagrange aux points a ≤ x0 < ... < xn ≤ b. Si f est de classe
C n+1 sur [a,b], alors on a :
ωn (x)f (n+1) (θx )

en (x) = f (x) − Pn (x) = , ∀x ∈ [a,b], (6.24)
(n + 1)!
où, minx,x0 <= θx <= maxx,xn . Une estimation de cette erreur montre que
max|ωn (y)|y∈[a,b] (n+1)
|en (x)| ≤ f (θx ), y ∈ [a,b] (6.25)
(n + 1)!
6.2.2 Choix au mieux des xi

On montre que la méthode de Lagrange ne converge pas sur E = C ∞ ([a,b]) munie de la
norme de la convergence uniforme. Compte tenu de cela, l’idée de Tchebychev est d’opérer
un choix des points {xi } qui minimise l’erreur. Ces points sont donnés par:
a+b b−a 2k + 1
xk = + cos[ π], k = 0,1,...,n. (6.26)
2 2 2(n + 1)
6.3 Interpolation de Hermite

Théorème III
Soit a ≤ x0 < x1 < xn , n+1 réels, avec a,b donnés dans <, f une fonction assez régulière
définie sur [a,b] et α = (αi )i=0,1,...,n un multi indice (i.e. chaque αi ∈ N tel que f (γ) existe
et est continue P sur [a,b], avec γ = maxαi |i=0,...,n . Alors, il existe un polynôme unique de
degré m = n + ni=0 αi vérifiant
∀i ∈ {0,1,..,n} , ∀0 ≤ βi ≤ αi , βi ∈ N, P (βi ) (xi ) = f (βi ) (xi ). (6.27)
Démonstration admise.
Ce résultat que nous admettons est une version généralisée du résultat de Lagrange
énoncé à la section précédente. En effet, lorsque αi = 0, ∀i = 0,1,...,n , le problème revient
à chercher un polynôme de P tel que : P (xi ) = f (xi ),∀i = 0,1,...,n.
On a alors d’après Hermite P qui existe de façon unique et qui est de degré m = n.
Ceci est un résultat déjà énoncé sous le nom de Théorème de Lagrange.
Définition Le polynôme P mis en évidence dans le théorème précédent se nomme

polynôme d’interpolation de Hermite de f ou encore l’interpolé de Hermite de f .
Corollaire
Soit les n+1 triplets {xi ,f (xi ),f 0 (xi )}i=0,1,...,n où les xi sont des points donnés distincts.
Alors il existe un polynôme P unique de degré inférieur ou égal à 2n tel que
½
P (xi ) = f (xi ),
(6.28)
P 0 (xi ) = f 0 (xi ), pour i = 0,1,...,n.
De plus, le polynôme P est donné par :

n
X n
X
P (x) = f (xi )hi (x) + f 0 (xi )ki (x) (6.29)
i=0 i=0
où on a posé
0
hi (x) = [1 − 2(x − xi )Φi (xi )]Φ2i (x) (6.30)
et
n
Y x − xk
ki (x) = (x − xi )Φ2i (x), Φi (x) = ( ) (6.31)
k=0,k6=i
xi − xk
On pourra démontrer que

n
X
0 1
Φi (xi ) = ( ) (6.32)
k=0,k6=i
xi − xk
Preuve.
Il est clair que hi et ki sont des polynômes de degré 2n + 1 puisque Φi est de degré n,
∀i ∈ 0,1,...,n.
On a déjà montré dans ce qui précède que Φ vérifie Φi (xj ) = δij où δij est le symbole
de Kronecker. Donc pour
j 6= i on a :
0
hi (xj ) = [1 − 2(xj − xi )Φi (xi )]Φ2i (xj ) = 0, car Φi (xj ) = δij = 0. (6.33)
i = j, on a :
0
hi (xi ) = [1 − 2(xi − xi )Φi (xi )]Φ2i (xi ) = 1 car Φi (xi ) = δii = 1. (6.34)
D’autre part, on a pour i 6= j,
ki (xj ) = (xj − xi )Φ2i (xj ) = 0, (6.35)
et pour i = j,
ki (xi ) = (xi − xi )Φ2i (xi ) = 0, (6.36)
Donc on voit sans peine que
P (xk ) = f (xk ) ∀k ∈ 0,1,...,n. (6.37)

Pour achever la preuve du corollaire, on doit montrer que P 0 (xk ) = f 0 (xk ) ∀k ∈ o,1,...,n.
Pour cela, on doit calculer h0i et ki0 .
h0i (x) = −2Φ0i (xi )Φ2i (x) + 2[1 − 2(x − xi )Φ0i (xi )]Φ0i (x)Φi (x)
(6.38)
ki0 (x) = Φ2i (x) + 2(x − xi )Φ0 − i(x)Φ − i(x)
6.4. INTERPOLATION PAR LES SPLINES 89
Pour i = j, h0i (xi ) = 0 et ki0 (xi ) = 1. Ce qui achève la preuve du corollaire.
Le théorème suivant donne une expression de l’erreur associée à la méthode de Hermite.
Théorème 4
Soit f une fonction de classe C (2n+2) sur [a,b], a ≤ x0 < x1 < ... < xn ≤ b (n+1) points
d’interpolations de f pour la méthode de Hermite. Alors, on a pour tout x ∈ [a,b]
(x − x0 )2 (x − x1 )2 ...(x − xn )2 (2n+2)
en (x) = f (x) − p(x) = f (θx ), (6.39)
(2n + 2)!
avec min {x,x0 } ≤ θx ≤ max {x,xn }.
Remarque
On peut obtenir des formulas d’interpolation dites mixtes où
P (xi ) = f (xi ),∀i ∈ 0,1,,n p0 (xk ) = f 0 (xk ) ∀k ∈ K ⊂ {0,1,...,n} (6.40)
Exercice1 Trouver l’expression de l’intyerpolé de P de f (x) tel que
P (xi ) = f (xi ),∀i ∈ 0,1,3 p0 (x0 ) = f 0 (x0 ); p0 (x3 ) = f 0 (x3 ). (6.41)
Indications : commencer par exemple par x0 ,x1 ,x2 puis x0 ,x1 ,x2 ,x3 et généraliser.
Exercice 2
On considère le carré Ω = [0,1] × [0,1]. Les Mi sont les points expérimentaux:
1) définir les Φi (x1 ,x2 ) tel que Φi (Mj ) = δij
2) Monter que la famille {Φi }3i=0 est une base de l’espace des polynômes de degré inférieur
ou égal à 1 par rapport à chacune des variables.
6.4 Interpolation par les splines

Motivés par le soucis d’économiser l’espace mémoire à l’intérieur des ordinateurs et le
temps de calcul, sur ordinateur, les ingénieurs utilisent couramment la méthode d’inter-
polation par les fonctions splines. Cette méthode consiste à approcher localement (i.e. sur
[xi ,xi+1 ] une fonction f définie sur [a,b] par un polynôme de degré faible (≤ 3) de sorte
que certaines conditions de raccord aux points de la fonction soient remplies. L’avantage
de l’approximation par les fonctions splines c’est qu’on peut assurer un degré de régularité
aux nuds xi aussi grand qu’on le désire.
6.4.1 Etude d’un exemple élémentaire d’approximation par les

fonctions splines : les splines cubiques.
Soit a < b deux réels et f une fonction suffisamment régulière définie sur [a,b]. Soit
a = x0 < x1 < ... < xn = b, n+1 points réels donnés (ici les deux extrémités appartiennent
à la famille {xi }ni=0 ). On suppose donné la valeur de f en chaque xi , i = 0,1,...,n et on
souhaite interpoler f par une fonction s dont la restriction en chaque [xi ,xi+1 ] notée si ,
est un polynôme vérifiant :
Si (xi ) = f (xi ) = fi
Si (xi+1 ) = f (xi+1 ) = fi+1
(6.42)
s0i−1 (xi ) = s0i (xi )
s”i−1 (xi ) = s”i (xi )
Les deux première équations assurent que s coı̈ncide avec f aux nuds {xi }ni=1 , alors que
les deux dernières assurent la régularité C 2 de s sur [a,b]. Le problème revient à chercher
des polynômes si définis sur [a,b] satisfaisant aux relations () et de plus bas degré.
premier cas : Polynôme de degré 0

Cela revient à considérer si sous la forme d’une constante : si (x) = cste = γi . Cette forme
n’est pas bonne car en appliquant les premières relations de (), il vient que fi = fi+1 ,
∀i ∈ 0,1,...,n − 1. Ce qui n’est pas vrai.
Deuxième cas : Polynôme de degré 1

Cela revient à considérer si sous la forme d’une constante : si (x) = ai x + bi . Les deux
premières relations de () permettent de trouver ai et bi . Mais cependant la fonction s(x)
ne sera pas dérivable car les deux autres relations de () nous conduisent à une relation
triviale ai−1 = ai , ce qui n’est pas vrai dans tous les cas.
Deuxième cas : Polynôme de degré 2

Cela revient à considérer si sous la forme d’une constante : si (x) = ai x2 + bi x + ci . Les trois
premières relations de () permettent de trouver ai , bi et ci . Mais cependant la dernière
relation portant sur la dérivée seconde de la fonction s(x) ne sera pas satisfaite car elle
conduit à ai−1 = ai , ce qui n’est pas vrai dans tous les cas.
On vérifie ainsi aisément que le degré le plus bas de de si (x) vaut 3. Ce qui conduit
naturellement à poser :
x − xi+1 x − xi
s”i (x) = αi + αi+1 , (6.43)
xi − xi+1 xi+1 − xi
où αi et αi+1 sont des inconnues réelles. De la relation (6.43), on peut écrire :
x − xi+2 x − xi+1
s”i+1 (x) = αi+1 + αi+2 , (6.44)
xi+1 − xi+2 xi+2 − xi+1
On voit que cette expression de la dérivée seconde de s(x) vérifie déjà la dernière relation
de (6.42) car s”i (xi+1 ) = s”i+1 (xi+1 ) = αi+1 .
En intégrant (6.43) deux fois, on obtient :

(x − xi+1 )3 (x − xi )3
si (x) = −αi + αi+1 + ai [xi+1 − x] + bi [x − xi ], (6.45)
6hi 6hi
pour i = 0,1,...,n − 1, où on a posé hi = xi+1 − xi et où les ai , bi sont les constantes
d’intégration. On peut déterminer ai et bi à l’aide des deux premières conditions de (6.42).
On obtient alors :
fi hi fi+1 hi
ai = − αi ai = − αi+1 , i = 0,1,...,n. (6.46)
hi 6 hi 6
6.4. INTERPOLATION PAR LES SPLINES 91
En reportant les expressions precedents dans (6.45), on obtient

h i
−x)3
si (x) = αi (xi+1 6hi
− hi
6
(x i+1 − x) +
h 3
i (6.47)
fi+1
αi+1 (x−x6hi
i)
− hi
6
(x − x i ) + fi
hi
(x i+1 − x) + hi
(x − x i ) , i = 0,1,...,n − 1.
Jusqu’à présent, on a utilisé que les deux premières conditions et la dernière condition de
(6.42), il reste donc à exploiter l’avant-dernière condition dans l’espoir de trouver les αi .
En dérivant (6.47), on obtient :
· ¸ · ¸
0 hi (xi+1 − x)2 hi (x − xi )2 fi fi+1
si (x) = αi − + αi+1 − + − + , i = 0,1,...,n − 1.
6 2hi 6 2hi hi hi
(6.48)
Cette condition est satisfaite si s0i (xi ) = s0i−1 (xi ), soit :
hi hi fi fi+1 hi−1 hi−1 fi−1 fi
−2αi − αi+1 − + = αi−1 + 2αi − + i = 1,...,n − 1. (6.49)
6 6 hi hi 6 6 hi−1 hi−1
En écrivant cette equation sous une forme convenable, on obtient :
µ ¶
fi+1 − fi fi − fi−1
hi−1 αi−1 + 2(hi + hi−1 )αi + hi αi+1 = 6 − i = 1,...,n − 1. (6.50)
hi hi−1
On a donc, (n-1) équations à (n+1) inconnues. On suppose connu α0 et αn . Ce qui conduit
au système suivant :


 2(h0 + h1 )α1 + h1 α2 = γ1



 h1 α1 + 2(h1 + h2 )α2 + h2 α3 = γ2 ,

h2 α2 + 2(h2 + h3 )α3 + h3 α4 = γ3 ,
(6.51)

 ...



 h α + 2(hn−3 + hn−2 )αn−2 + hn−2 αn−1 = γn−2 ,
 n−3 n−3
hn−2 αn−2 + 2(hn−2 + hn−1 )αn−1 = γn−1 .
La matrice de ce système est alors :
 
2(h0 + h1 ) h1 0 0 0 0
 h1 2(h1 + h2 ) h2 0 0 0 
 
 0 h (2h + h ) h 0 0 
A= 
2 2 3 3 

 . . . . . . 
 0 0 0 hn−3 2(hn−3 + hn−2 ) hn−2 
0 0 0 0 hn−2 2(hn−2 + hn−1 )
(6.52)
Cette matrice est une matrice tridiagonale par points.
Définition On appelle matrice tridiagonale par points une matrice A carré d’ordre N
ayant la structure suivante :
 
a11 a12 0 0 0 0
 a21 a22 a23 0 0 0 
 
 0 a32 a33 a 0 0 
 34  (6.53)
 . . . . . . 
 
 0 0 0 an−1,n−2 an−1,n−1 an−1,n 
0 0 0 0 an,n−1 an,n
Dans le cas où hi = h = cste,∀i on a alors

 
4h h 0 0 0 0
 h 4h h 0 0 0 
 
 0 h 4h h 0 0 
A=  .
.
 (6.54)
 . . . . . 
 0 0 0 h 4h h 
0 0 0 h h 4h
Cette matrice est symétrique.
Rappels Soit A une matrice carrée d’ordre n telle que:

Pn
i) i=1,i6=j |Aij | ≤ |Aii | ∀i ∈ 1,2,...,n
Pn
ii) ∃i0 ∈ 1,...,n tel que j=1,j6=i0 |Ai0 j | ≤ |Ai0 i0 |
Alors A est inversible.
Définition Une matrice carrée A vérifiant les conditions (i) et (ii) du rappel précédent
s’appelle une matrice à dominance diagonale ou encore une matrice à diagonale dominante.
Lorsque l’inégalité (i) est stricte ∀i = 1,2,...,n, la matrice A est dite à diagonale stric-
tement dominante.
Dans les deux cas, on a affaire à des matrices inversibles.
Ceci montre que les αi peuvent bien être obtenus. Ils sont calculés numériquement soit
par une méthode directe, soit par une méthode itérative.
93
Chapitre 7
Intégration numérique des fonctions.
7.1 Position du problème

Soit a et b des réels et f une fonction définie sur [a,b] et suffisament régulière (en
Rb
particulier, a |f (x)|dx < ∞). Le problème posé consiste à approximer l’intégrale suivante:
Z b
I(f ) = f (x)dx, (7.1)
a
par une expression de la forme

n
X
Anj f (xj ), (7.2)
j=0
où les Anj sont des scalaires indépendants de f .
Définition 1 La relation (7.2) se nomme formule de quadrature (ou tout simplement

quadrature) à n + 1 points.
7.2 Formule de quadrature de type interpolation

7.2.1 Formule de quadrature de type interpolation de Lagrange
Etant donné l’intégrale (7.1) avec a,b et f , choisis comme il est dit Rdans la section I.
Est-il possible d’approcher I(f ) en remplaçant la fonction f sous le signe par le polynôme
d’interpolation de Lagrange?
Z b Z b Z b
f = Pn + en ⇒ f (x)dx = Pn (x)dx + en (x)dx. (7.3)
a a a
Rb
En négligeant a en (x)dx, on obtient:
Z b Z b
f (x)dx ' Pn (x)dx. (7.4)
a a
Pn étant l’interpolé de Lagrange de f en x0 ,x1 ,...,xn , c’est-à-dire:

n
X
Pn (x) = fi Φi (x), (7.5)
i=0
94 CHAPITRE 7. INTÉGRATION NUMÉRIQUE DES FONCTIONS.
de sorte que
Z b Z b Z bX
n
f (x)dx ' Pn (x)dx = fi Φi (x)dx. (7.6)
a a a i=0
soit
Z b n Z
X b n µZ
X b ¶ n
X
f (x)dx ' fi Φi (x)dx = Φi (x)dx fi = Ani fi (xi ), (7.7)
a i=0 a i=0 a i=0
avec
Z b
Ani = Φi (x)dx. (7.8)
a
Remarque
Lorsqu’il n’y a aucun risque de confusion, on note Ai au lieu de Ani . Dans le cas général,
l’intégrale
Z b n
X
µ(x)f (x)dx = Ani fi (xi ), (7.9)
a i=0
avec
Z b
Ani = Φi (x)µ(x)dx, (7.10)
a
où µ(x) est une fonction régulière aussi.
Définition 2
Une quadrature à (n + 1) points est de type interpolation si la condition suivante est
satisfaite:
Z b
n
Ai = Φi (x)µ(x)dx, ∀i = 0,1,...,n. (7.11)
a
Définition 3
L’erreur associée à une quadrature de type interpolation est
Z b n
X
Rn (f ) = f (x)µ(x)dx − Ani fi (xi ), (7.12)
a i=0
d’où le théorème suivant:
Théorème 1 L’erreur associée à une quadrature de type interpolation est:

Z b
ωn (x)f (n+1) (θx )µ(x)
Rn (f ) = dx. (7.13)
a (n + 1)!
Définition 4
Soit E un espace fonctionnel et
n
X
In (f ) = Ani fi (xi ), (7.14)
i=0
7.2. FORMULE DE QUADRATURE DE TYPE INTERPOLATION 95
une quadrature. On dit que la quadrature In (f ) est exacte si:
Rn (f ) = I(f ) − In (f ) = 0, ∀f ∈ E. (7.15)
Théorème 1 Soit (7.14) une quadrature à (n + 1) points. Cette quadrature est de type
interpolation si elle est exacte sur E ≡ Pn espace des polynômes de dedré inférieur ou égal
à n.
Définition 5
Une quadrature définie par (7.14) a un degré de précision égal à p si elle est exacte sur
℘p (espace des polynômes de degré ≤ p) et Rn (x(p+1) ) 6= 0, Rn (xk ) = 0, ∀0 ≤ k ≤ p.
Proposition 1
Si la quadrature définie par 7.14) est de type interpolation, alors son degré de précision
est supérieur ou égal à n.
Application du théorème 3
Le théorème 3 fournit un moyen de calcul des Ai .
Exemple. calculer les coefficients A0 et A1 dans la quadrature suivante:
Z 1
f (x)dx ' A0 f (−1) + A1 f (1), (7.16)
1
de telle sorte qu’elle soit de type interpolation et expliciter l’erreur qui y est associée.
Solution.
• Elle est de type interpolation ssi elle est exacte sur P1 6=< 1,x > (n=1 car on a n+1
points qui est 2).
R1
– La formule est donc exacte pour f (x) = 1, soit 1 1dx = A0 + A1 ⇒ A0 + A1 = 2.
R1
– Elle est aussi exacte pour f (x) = x ⇒ 1 xdx = A0 f (−1)+A1 f (1) ⇒ −A0 +A1 = 0.
On obtient finalement un système de 2 équations à deux inconnues qui s’écrit:
½
A0 + A1 = 2,
(7.17)
A0 − A1 = 0
dont la solution est A0 = A1 = 1.

Ainsi la quadrature s’écrit, dans le cas général,
Z 1
f (x)dx = f (−1) + f (1) + R1 (f ) (7.18)
−1
où
Z 1
(x + 1)(x − 1) (2)
R1 (f ) = f (θx )dx, (7.19)
−1 2!
où θx est une application continue de [−1,1] dans lui-même. On a par le théorème de la
moyenne
Z
f ”(α) 1
R1 (f ) = (x + 1)(x − 1)dx, − 1 ≤ α ≤ 1, (7.20)
2 −1
c’est à dire R1 (f ) = −(2/3)f ”(α).
• On peut aussi calculer le degré de précision de celle-ci. En effet,

Z 1
2
R(x ) = x2 dx − [A0 f (−1) + A1 f (1)] = −4/3 6= 0. (7.21)
−1
Donc la formule est exacte sur P1 mais ne l’est pas sur P2 . Le degré de précision est donc
1.
7.2.2 Formule de quadrature généralisée

Il exixte une version généralisée de la formule de quadrature. En effet, soit a < b
des reéls donnés, x0 < x1 < ... < xn des points de l’intervalle [−1,1], α = (αj )nj=0 un
multiindice et f une fonction numérique de variable réelle supposée assez régulière. On
pose:
|α| = α0 + α1 + ... + αn (7.22)
l’intégrale (7.1) peut être approchée par:
αj
n X
X
In (f ) = Anjk f (k) (xj ), (7.23)
j=0 k=0
où, f (k) désigne la dérivée d’ordre k de f . La relation (7.23) s’appelle formule de qua-
drature généralisée. Comme on le verra dans l’exemple ci-dessous, on peut déterminer les
coefficients Ajk de telle sorte que la quadrature généralisée (7.23) soit exacte sur Pn+|α| . Au-
trement dit, de telle sorte que la quadrature généralisée ait un degré de précision ≥ n+|α|.
Exemple. Déterminer les coefficients A00 ,A01 ,A10 ,A20 ,A21 dans la quadrature suivante:
Z 1
f (x)dx = A00 f (−1) + f 0 (−1)A01 + f (0)A10 + f (1)A20 + f 0 (1)A21 + R(f ) (7.24)
−1
de telle sorte que cette quadrature ait un degré de précision au moins égal à 4.
Solution. Cette quadrature a un degré de précision ≥ 4 entraine qu’elle est exacte sur
P4 =< 1,x,x2 ,x3 ,x4 >. On écrit donc successivement que la quadrature est exacte pour
f (x) = 1,x,x2 ,x3 , et x4 et on trouve: A00 = A20 = 7/15, A01 = −A21 = 1/15, A10 = 16/15.
La quadrature s’écrit donc:
Z 1
7 1 16 7 1
f (x)dx = f (−1) + f 0 (−1) + f (0) + f (1) − f 0 (1) + R(f ). (7.25)
−1 15 15 15 15 15
On peut maintenant vérifier qu’en calculant l’intégrale de x5 de −1 à 1, on trouve une

quantité non nulle, preuve que la quadrature est exacte seulement sur P4 .
7.3. LES QUADRATURES CLASSIQUES: FORMULES DE NEWTON-COTES 97
7.3 Les quadratures classiques: Formules de Newton-

COTES
7.3.1 Formule des trapèzes
7.3.1.1 Définition
Rb
L’idée consiste à approcher I(f ) = a
f (x)dx par :
Z b
˜ )=
I(f P1 (x)dx, (7.26)
a
où P1 est l’interpolé de Lagrange de f aux points a et b.

Exo expliciter P1 .
On obtient alors:
˜ ) = b − a [f (a) + f (b)] .
I(f (7.27)
2
Par rapport aux notations de la section précédente, on obtient A00 = A01 = (b − a)/2.
Définition La formule (7.27) s’appelle formule des trapèzes.
7.3.1.2 Méthode composite des trapèzes

On considère une subdivision de [a,b] à l’aide de xi tels que xi = a + ih, i = 0,1,...,n,
avec h = (b − a)/n. La longueur de chaque intervalle [xi ,xi+1 ] est égale à h:
Z b Z xn n−1 Z
X xi+1
f (x)(x)dx = f (x)dx = f (x)dx. (7.28)
a x0 i=0 xi
On va utiliser la formule des trapèzes pour calculer les intégrales sur [xi ,xi+1 ], ce qui donne:
Z xi+1
h h3
f (x)dx = [f (xi ) + f (xi+1 )] − f ”(θi ), xi < θi < xi+1 . (7.29)
xi 2 12
En additionnant memebre à memmbre, on obtient:

Z b · ¸
1 1
f (x)(x)dx = h f (a) + f (a + h) + f (a + 2h) + ... + f (a + (n − 1)h) + f (b) .
a 2 2
(7.30)
soit encore,
Z " n−1
#
b
h X
f (x)(x)dx = f (a) + f (b) + 2 f (a + ih) . (7.31)
a 2 i=1
Cette formule est connue sous le nom de la formule Composite des trapèzes.
7.3.1.3 Estimation de l’erreur

L’erreur associée à cette formule compsite des trapèzes est:
n−1
h3 X
R(f ) = − f ”(θi ). (7.32)
12 i=0
Elle est inférieure ou égale à:

n−1 n−1
h3 X h3 X h3
R(f ) ≤ |f ”(θi )| ≤ max|f ”(θi )| ≤ n max|f ”(θi )|i=0,...,n−1 . (7.33)
12 i=0 12 i=0 12
on en déduit que
(b − a)3
R(f ) ≤ max|f ”(x)|x∈[a,b] . (7.34)
12n2
NB Ainsi, pour f de classe C 2 sur [a,b], l’erreur est de l’ordre 1/n2 .
7.3.2 Formule de Simpson

7.3.2.1 cas simple
Commençons par effectuer le changement de variable:
b−a
x=a+ y (7.35)
n
où n est un entier positif non nul. L’intégral I(f ) devient:
Z b Z
b−a n
f (x)dx = F (y)dy (7.36)
a n 0
où F (y) = f (a + b−a

n
y). Suuposons maintenant qu’on peut approcher f sur [a,b] par un
polynçome qui coı̈ncide avec f en (n + 1) points régulièrement espacés sur [a,b]. Dès lors,
on a:
Z n Xn
F (y)dy ' Ci F (i) (7.37)
0 k=0
avec
Z n
y(y − 1)(y − 2)...(y − k + 1)(y − k − 1)...(y − n)
Ck = dy (7.38)
0 k(k − 1)(k − 2)...[k − (k − 1)][k − (k + 1)]...(k − n)
L’erreur associée à cette formule est: • Pour n impair:
Z
hn+2 f (n+1) (α) n
R(f ) = y(y − 1)(y − 2)...(y − n)dy (7.39)
(n + 1)! 0
• Pour n pair:
Z ³
hn+3 f (n+2) (α) n
n´
R(f ) = y− y(y − 1)(y − 2)...(y − n)dy, (7.40)
(n + 2)! 0 2
7.3. LES QUADRATURES CLASSIQUES: FORMULES DE NEWTON-COTES 99
où α est compris entre a et b et h = (b − a)/n. Exemple 1: Cas n=2 D’après (7.38), on
a:
Z 2 Z 2 Z 2
(y − 1)(y − 2) 1 (y − 0)(y − 2) 4 (y − 0)(y − 1) 1
C0 = dy = , C1 = dy = , C1 = dy = ,
0 (0 − 1)(0 − 2) 3 0 (1 − 0)(1 − 2) 3 0 (2 − 0)(2 − 1) 3
(7.41)
L’erreur qui y est associée est:

Z
h5 f (4) (α) 2 h5
Es = y(y − 1)2 (y − 2)dy = − f (4) (α), (7.42)
4! 0 90
où x0 ≤ α ≤ x2 . Ainsi, la formule de Simpson avec l’erreur correspondante peut s’écrire:
Z x2
h h5
f (x)dx = [f (x0 ) + 4f (x1 ) + f (x2 )] − f (4) (α), (7.43)
x0 3 90
avec h = (x2 − x0 )/2.
Exemple 2: Cas n=3

Z x3
3h 3h5 (4)
f (x)dx = [f (x0 ) + 3f (x1 ) + 3f (x2 ) + f (x3 )] − f (α), (7.44)
x0 8 80
avec x0 < α < x3 . Exemple 3: Cas n=4 (Villarceau)

Z x4
2h 8h7 (6)
f (x)dx = [7f (x0 ) + 32f (x1 ) + 12f (x2 ) + 32f (x3 ) + 7f (x4 )]− f (α), (7.45)
x0 45 945
avec x0 < α < x4 .
Théorème
Le degré de précision d’une formule de Newton-Cotes à (n+1) points est:
– 1+n si n est pair.
– n si n est impair.
7.3.2.2 Méthode composite

Ici, on suppose que n est paire et on va considérer l’intégrale de f sur les intervalles
[a,a + 2h], [a + 2h,a + 4h],...,[a + (n − 2)h,a + nh = b]. En appliquant Simpson sur chaque
sous-intervalle précédent, on a:
Z x2 =a+2h
h h5
f (x)dx = [f (a) + 4f (a + h) + f (a + 2h)] − f (4) (θ02 ), a < θ02 < a + 2h.
x0 =a 3 90
Z a+4h
h h5 (4)
f (x)dx = [f (a + 2h) + 4f (a + 3h) + f (a + 4h)]− f (θ24 ), a+2h < θ24 < a+4h.
a+2h 3 90
Z a+nh
h h5
f (x)dx = [f (a + (n − 2)h) + 4f (a + (n − 1)h) + f (b = a + nh)]− f (4) (θn−2,n ),
a+(n−2)h 3 90
En additionnant membre à membre, on obtient:
Rb
a
f (x)(x)dx = h3 {f (a) + f (b) + 2[f (a + 2h) + f (a + 4h) + ... + f (a + (n − 2)h)] +
4[f (a + h) + f (a + 3h) + ... + f (a + (n − 1)h)} + Esc .
(7.46)
avec
X n−2
h5
Esc = − f (4) f (4) [(θi,i+2 )], (7.47)
90 i=0
d’où le théorème:
Théorème
Pour f ∈ C 4 ([a,b]), on a:
Z b " n−2 n−1
#
h X X
f (x)(x)dx = f (a) + f (b) + 2 f (a + ih) + 4 f (a + ih) (7.48)
a 3 i=2,pair i=1,impair
ou encore
 
Z b N/2−1
X N/2−1
X
h
f (x)(x)dx = f (a) + f (b) + 4 f (a + (2p + 1)h) + 2 f (a + 2ph) (7.49)
a 3 p=0 p=1
dont l’erreur est telle que
(b − a)
R(f ) ≤ max|f (4) (x)|, (7.50)
90n4
7.4 Méthode de Gauss

7.4.1 Principe de la Méthode
Cette méthode très précise utilise des points non régulièrement espacés, et convenable-
ment choisis. Elle peut donc s’appliquer lorsque l’intégrale f (x) est connue analytiquement,
ou lorsqu’elle est tabulée numériquement en ces points précis. Elle ne peut pas s’appliquer
lorsque f (x) est donnée par les valeurs qu’elle prend en un certain nombre de points
différents de ces points privilégiés. Nous ne donnerons pas les détails de calcul, mais seule-
ment l’idée directrice et la manière d’appliquer la méthode. En effet, dans cette méthode,
on développe f (x) dans une base de polynômes orthogonaux. Les ξi sont alors les racines
de ces polynômes et sont irrégulièrement espacés. On peut alors utiliser les polynômes de
Jacobi, Tchebychev, Laguerre, Hermite,..., mais les plus couramment utilisés sont ceux
de Legendre. Ceux-ci étant définis dans l’intervalle [−1,1], les formules d’intégration de
Gauss-Legendre sont généralement exprimées dans le cas où les bornes d’intégration de la
fonction f sont -1 et 1. Ces formules d’intégration dont données par la relation :
Z 1 n
X
f (ξ)dξ ≈ ci f (ξi ) (7.51)
−1 i=1
7.4. MÉTHODE DE GAUSS 101
Où les points privilégiés ξi et les coefficients ci (encore appelés poids, ou encore facteur
de pondération) dépendent du choix de n. En choisissant les points ξi racine du polynôme
de Legendre de degré n, et en utilisant les coefficients appropriés, la formule d’intégration
(7.51) est exacte pour les polynômes de degré au moins égal à 2n − 1. Par exemple,
Pour deux points, n=2 , on a :
Z 1 √ √
f (ξ)dξ ≈ c1 f (ξ1 ) + c2 f (ξ2 ) = f (−1/ 3) + f (1/ 3) (7.52)
−1
Pour trois points, n=3 , on a :

Z 1 p
5 8 5 p
f (ξ)dξ ≈ c1 f (ξ1 ) + c2 f (ξ2 ) + c3 f (ξ3 ) = f (− 3/5) + f (0) + f ( 3/5) (7.53)
−1 9 9 9
Las valeurs des paramètres ξi et ci de la quadrature de gauss, pour n = 2,3,4 sont données
dans le tableau suivant. Notons que les ξi sont deux à deux symétriques par rapport à zéro.
n ξi√ ci
2 ±1/
p3 1
3 0, ± 3/5 8/9, 5/9
4 ±0.8611363116, ± 0.3399810436 0.3478548451, 0.6521451549
Dans le Cas général où les bornes d’intégration ne coı̈ncident plus avec -1 et 1, il
faut alors effectuer sur x un changement de variable linéaire transformant x ∈ [a,b] en
ξ ∈ [−1,1]. Cette transformation linéaire est
b−a b+a
x= ξ+ . (7.54)
2 2
Ainsi,
Z b Z b Z 1
b−a b+a b−a
f (x)dx = f( ξ+ )dx = F (ξ)dξ (7.55)
a a 2 2 2 −1
avec
b−a b+a
F (ξ) = f ( ξ+ ). (7.56)
2 2
On a donc
Z b n
b−aX
f (x)dx = F (ξi ), (7.57)
a 2 i=1
où les ξi et ci sont données dans la table ci-dessus pour n = 2,3,4.
7.4.2 Formule composite : cas n=3

Pour obtenir la formule composite, dans le cas de trois points, on se refère à la méthode
de Simpson qui utilise aussi trois points d’intégrations. Pour cela on évalue l’intégrale de
f sur les intervalles [a,a + 2h], [a + 2h,a + 4h],...,[a + (n − 2)h,a + nh = b]. En appliquant
Gauss à 3 points sur chaque sous-intervalle précédent, on a:
Z xi+2
(xi+2 − xi )
f (x)dx = (c1 F (ξ1 )+c2 F (ξ2 )+c3 F (ξ3 )) = h(c1 f (X1i )+c2 f (X2i )+c3 f (X3i )).
xi 2
(7.58)
Comme
(xi+2 − xi ) (xi+2 + xi )
Xi = ξ+ = hξ + (i + 1)h + a = xi+1 + hξ, (7.59)
2 2
on aura
X1i = xi+1 + hξ1 , X2i = xi+1 , et X3i = xi+1 + hξ3 , (7.60)
puisque ξ2 = 0. Ainsi l’intégrale de f sur a et b peut se décomposer comme suit :

Z b Z x2 Z x4 Z xi+2 Z xN
f (x)dx = f (x)dx + f (x)dx + ... + f (x)dx + ... f (x)dx. (7.61)
a x0 x2 xi xN −2
En utilisant la relation (7.58) dans chaque sous-intervalle, on obtient finalement

 
Z b N/2−1
X N/2−1
X N/2−1
X
f (x)dx = h c1 f (X1p ) + c2 f (X2p ) + c3 f (X3p ) . (7.62)
a p=0 p=0 p=0
où
Xjp = x2p+1 + hξj , j = 1,2,3. (7.63)
La relation (7.62) donne donc la formule composite de la quadrature de Gauss utilisant le

polynôme de Legendre pour déterminer les points privilégiés ξi .
7.5 Méthode d’extrapolation : Méthode de Romberg

Cette méthode utilise une extrapolation de Richardson à partir de résultats obtenus
par la méthode des trapèzes. Elle est basée sur le fait que l’intégrale de f(x) peut s’écrire :
Z b
I= f (x)dx = T (h) + c2 (h2 ) + c4 (h4 ) + c6 (h6 ) + ... (7.64)
a
avec
" n−1
#
h X
T (h) = f (a) + f (b) + 2 f (a + ih) (7.65)
2 j=1
où c2 , c4 et c6 dépendent de f(x) et de ses dérivées, mais ne dépendent pas de h. T (h) est
l’évaluation de I par la méthode des trapèzes.
La question que s’est posée Romberg est : comment peut-on obtenir une évaluation
plus précise de I?
Une première solution consiste à utiliser des pas plus nombreux et par conséquents plus
petits. Ainsi, en doublant par exemple le nombre de pas, h est divisée par 2 et l’équation
(7.64) devient :
I = T (h/2) + c2 (h/2)2 + c4 (h/2)4 + c6 (h/2)6 + ... (7.66)

7.6. PROGRAMMATION INFORMATIQUE DES FORMULES CLASSIQUES 103
En diminuant le pas, on obtient une suite T (h), T (h/2), T (h/4), ... qui converge vers I.
Une autre solution consiste à utiliser T (h) et T (h/2) pour obtenir une autre valeur T 0
plus précise. En effet, les équations (7.64) et (7.66) s’écrivent :
T (h) = I−c2 (h2 )−c4 (h4 )−c6 (h6 )+...T (h/2) = I−c2 (h/2)2 −c4 (h/2)4 −c6 (h/2)6 +... (7.67)
En multipliant la première équation par 4 et en retranchant la seconde, il vient:

1
4T (h/2) − T (h) = 3I + c4 h4 (1 − ) + ... (7.68)
4
soit :
1 1
I = [4T (h/2) − T (h)] − c4 h4 − ... (7.69)
3 4
On voit que cette valeur est une approximation de I au 4e ordre alors que T (h) et T (h/2)
ne sont approchées qu’au 2e ordre. Ceci constitue l’extrapolation de Richardson et donne
une estimation analogue à celle de Simpson :
1
I = [4T (h/2) − T (h)] + o(h4 ). (7.70)
3
On peut obtenir une expression plus précise en élevant le degré d’extrapolation.
7.6 Programmation informatique des formules clas-

siques
7.6.1 Formule des Trapèzes
Program Trapeze;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* Ce programme integre une fonction F(x) *****
******* *****
******* dans l’intervalle [a,b] *****
******* *****
******* par la methode des Trapezes *****
******* *****
******* *****
******* *****
*****************************************************************
*****************************************************************)
uses Dos,printer;
Var x, a,b, integral, somme, h:real;

i,N:integer;
ce:char;
begin
f:=4/(1+x*x);
end;
Begin
{clrscr;}
N:=128; {nombre de pas dans l’intervalle [a,b]}

a:=0.0; b:=1.0; {bornes d’integration}
integral:=3.1415926535897932; {valeur exacte de l’integrale}
somme:=0.0;
h:=(b-a)/N; {pas du maillage ou pas de discretisation}
{Debut de l’integration}
for i:=1 to N-1 do
begin
x:=a+i*h;
somme:=somme+f(x);
end;
somme:=(h/2)*(f(a)+f(b)+2*somme);
writeln;
writeln(’valeur approchee :’, somme:16:15);
writeln(’valeur exacte :’, integral:16:15);
writeln; writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Integration par la $$$$’);
writeln(’$$$$$$ Methode des Trapezes $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
7.6.2 Formule de Simpson

Program Simpson;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* *****
******* *****
******* par la methode de Simpson *****
******* *****
******* *****
******* *****
*****************************************************************
*****************************************************************)
uses Dos,printer;
Var x, a,b, integral, somme, h:real;

i,N:integer;
ce:char;
Function F(x:real):real;
begin
F:=4/(1+x*x);
end;
Begin
{clrscr;}
N:=512; {1024; {nombre de pas dans l’intervalle [a,b]}

somme:=0.0;
for i:=1 to N-1 do
begin
x:=a+i*h;
if odd(i) then
somme:=somme+4*f(x)
else
somme:=somme+2*f(x);
end;
somme:=(h/3)*(f(a)+f(b)+somme);
writeln;
writeln; writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Methode des Trapezes $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
7.6.3 Formule de Gauss-Legendre

Program Gauss;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* *****
******* *****
******* par la methode de Gauss: *****
******* cas n=3 *****
******* *****
******* *****
*****************************************************************
*****************************************************************)
uses Dos,printer;
Var c1,c2,c3,t1,t2,t3:real;
x1,x2,x3, a,b, integral, s1,s2,s3,somme, h:real;
p,N,N2:integer;
ce:char;
Function F(x:real):real;
var temp:real;
begin
F:=4/(1+x*x);
end;
Begin
{clrscr;}
{points de Gauss pour n=3 et dans le systeme de reference avec leur poids}
t1:=-sqrt(3/5); c1:=5/9;
t2:=0.0; c3:=5/9;
t3:=sqrt(3/5); c2:=8/9;
N:=128; {nombre de pas dans l’intervalle [a,b]}

s1:=0.0; s2:=0.0; s3:=0.0;
N2:=N div 2;
for p:=0 to N2-1 do
begin
x2:=a+h*(2*p+1); s2:= s2+F(x2);
x1:=x2+h*t1; s1:= s1+F(x1);
x3:=x2+h*t3; s3:= s3+F(x3);
end;
somme:=h*(c1*s1+c2*s2+c3*s3);
writeln;
writeln; writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Methode de Gauss $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
109
Chapitre 8
Résolution numérique des équations

différentielles
8.1 Problème de Cauchy

8.1.1 Rappel des résultats fondamentaux sur les équations différentielles
du premier ordre
Définition 1
Soit I un intervalle de R, φ(.,.) une application de I × R dans R, y(.) une application de I
dans R telle que la fonction dérivée y 0 (.) existe et est définie sur I. La relation
y 0 (x) = Φ(x,y(x)), ∀x ∈ I (8.1)
s’appelle une équation différentielle de 1er ordre. On désire trouver une fonction y(.) qui
vérifie la relation (8.1) et la condition suivante :
y(a) = α, (8.2)
Avec I = [a,b] où a , b et α sont des réels donnés. La condition (8.2) est appelée condition
initiale ou condition de Cauchy.
Le résultat suivant (dû à Cauchy- Lipchitz) donne les conditions d’existence et d’uni-
cité d’une solution du système (8.1) et (8.2).
Théorème 1(Cauchy- Lipchitz)

Si les conditions suivantes sont remplie :
1. Φ est continue dans [a,b] × R,
2. ∃L > 0, ∀x ∈ [a,b], ∀(ξ1 ,ξ2 ) ∈ R2 , on a : |Φ(x,ξ1 ) − Φ(x,ξ2 )| ≤ L|ξ1 − ξ2 |
alors le système (8.1) et (8.2) admet une solution unique.
Exemple 1. Soit le système :

½ 0
y (x) = − xy(x) + log1 x , ∀x ∈ [e,5],
log x (8.3)
y(e) = e.
Ici, Φ(x,ξ) = − xy(x)

log x
+ 1
log x
d’où
110CHAPITRE 8. RÉSOLUTION NUMÉRIQUE DES ÉQUATIONS DIFFÉRENTIELLES
|Φ(x,ξ1 ) − Φ(x,ξ2 )| = | xξ1log

−ξ2
x
| ≤ 1e |ξ1 − ξ2 |.
La condition de Lipchitz par rapport à la deuxième variable est donc satisfaite (avec
L=1/e) et Φ(.,.) est continue sur [e,5] × R. Il résulte du théorème 1 que le système (8.3))
admet une solution unique.
Vous vérifierez à titre d’exemple que y(x) = x/logx est une solution.
Exemple 2. Trouver une fonction y telle que :

½ 0 p
y (x) = y(x),
(8.4)
y(0) = 0, ∀x ∈ [0,1].
Ce problème de Cauchy admet 2 solutions: y = 0 et y = (x/2)2 . Il est clair que Φ(∗,∗) ne
vérifie pas la condition ii) sur [0,1].
Théorème 2 (Condition suffisante pour avoir ii) du théorème 1)

Si la dérivée partielle de Φ par rapport à la deuxième variable notée ∂Φ/∂ξ est continue
et bornée sur [a,b] × R, alors Φ est Lipchitzienne par rapport à la deuxième variable.
8.1.2 Systèmes différentiels du premier ordre

Définition 2
Soit I un intervalle inclus dans R, φ(∗,∗) une application de I × Rn dans Rn , y(∗) une
application de I dans Rn telle que la fonction dérivée existe sur I. En posant I = [a,b], la
relation
y 0 (x) = Φ(x,y(x)), ∀x ∈ [a,b] (8.5)
s’appelle système différentiel du premier ordre.
Notons que y = [y1 ,y2 ,y3 ,...,yn ] et Φ(x,y) = [φ1 (x,y),φ2 (x,y),φ3 (x,y),...,φn (x,y)] et le
système (8.5) est :
 0

 y = φ1 (x,y1 ,y2 ,...,yn )
 10
y2 = φ2 (x,y1 ,y2 ,...,yn )
edeq6 (8.6)

 ...
 0
yn = φn (x,y1 ,y2 ,...,yn ). y(a) = α, α ∈ Rn
8.1.3 Equations différentielles d’ordre supérieur à 1

Pour résoudre une équation différentielle d’ordre supérieur à 1, il suffit de se ramener
à un système différentiel du premier ordre en faisant un changement de variable. On a par
exemple :

 y” = f (x,y,y 0 )
y(a) = α, (8.7)
 0
y (a) = β
Posons, y = y et z = y 0 , d’où le système :
 0
 z = f (x,y,z)
y 0 = z, (8.8)

z(a) = β, y(a) = α
8.2. DISCRÉTISATION DES ÉQUATIONS DU PREMIER ORDRE 111
8.2 Discrétisation des équations du premier ordre

8.2.1 Principe d’analyse numérique
On désire trouver une approximation de la fonction y. On choisit des points xi ∈ [a,b],
on cherche alors une approximation yi de y(xi ). On distingue deux cas :
– Le calcul où yn fait intervenir les valeurs de xn−1 et yn−1 et les données : ce sont des
méthodes à un pas.
– Le calcul de yn fait intervenir les valeurs (xn−1 , xn−2 , y − n − 1, et yn−2 ) : ce sont des
méthodes à plusieurs pas.
Pour déterminer la fonction approchée yi , on peut utiliser dans certains cas les techniques
d’intégration numériques exposées au chapitre précédent qui aide à résoudre de façon
simple le problème de Cauchy précédent. En effet, lorsque Φ(x,y(x)) = Φ(x), on intro-
duit une subdivision de l’intervalle [a,b] à l’aide de la suite arithmétique (xi ) définie par
xi = a + ih, i = 0,1,,N où N est un entier positif donné (de façon arbitraire) et destiné à
tendre vers +∞ ; h = (b−a)/N . Le fait de réaliser une telle subdivision s’appelle maillage
du domaine et on pose usuellement : Ω =]a,b[ ; Ωh = {xi }N i=0 s’appelle maillage par abus
de langage. Les xi sont les nuds du maillage.
En intégrant sur [xi ,xi+1 ] l’équation différentielle (8.1), on obtient:

Z xi+1 Z xi+1
0
y (t)dt = Φ(t,y(t))dt (8.9)
xi xi
Soit
Z xi+1
y(xi+1 ) = y(xi ) + Φ(t,y(t))dt (8.10)
xi
Si on approche l’intégrale dans le second membre de (8.10) par la formule des trapèzes, on
obtient :
Z xi+1
h h3
g(t)dt = [g(xi ) + g(xi+1 )] − g”(θi ) (8.11)
xi 2 12
avec
g(t) = Φ(t,y(t)) et θi ∈]xi ,xi+1 [. (8.12)
En reportant (7) dans (6), on obtient le problème discrétisé suivant :

h h3
y(xi+1 ) = y(xi ) + [g(xi ) + g(xi+1 )] − g”(αi ), 1 ≤ i ≤ N − 1, (8.13)
2 12
La quantité −h3 /12g”(αi ) est appelée erreur de consistence aux points xi . Pour h assez
petite, l’équation (8) peut s’écrire :
h
y(xi+1 ) = y(xi ) + [Φ(xi ,y(xi )) + Φ(xi+1 ,y(xi+1 ))] (8.14)
2
En approchant y(xi ) = ỹi , ∀i = 0,1,...,N le problème (1) et (2) devient :
½
ỹi+1 = ỹi + h2 [Φ(xi ,y(xi )) + Φ(xi+1 ,y(xi+1 ))],
(8.15)
y0 = y(a),
avec i = 0,1,...,N − 1.
Le système (10) est appelé problème discrétisé de Cauchy ou problème de Cauchy

discrétisé. Dans la suiste du chapitre, nous allons dévelloper d’autres méthodes de discrétisation
du problème de Cauchy et répondre à la question centrale : Est-ce que kyh −yh k → 0 lorque
h → 0?
8.2.2 Méthode d’Euler

On reprend le problème de Cauchy posé au paragraphe précédent,i.e. de trouver une
fonction x → y(x) telle que
½ 0
y (x) = Φ(x,y(x)),
(8.16)
y(a) = α, ∀x ∈ [a,b]
où Φ est une fonction continue sur [a,b]×R et Lipschitienne par rapport à sa deuxième
variable (avec consistance de Lipschitz indépendante à la première variable). L’objectif de
ce paragraphe est de présenter la méthode d’Euler pour la discrétisation du problème de
Cauchy.
On commence par considérer une subdivision de l’intervalle [a,b] à l’aide des xi définis
par : xi = a + ih, i = 0,1,...,N avec h = (b − a)/N , où N est un entier arbitrairement choisi
et destiné à tendre vers +∞, (a,b ∈ R). On écrit le développement de Taylor au voisinage
de x = xn (n = 0,1,...,N − 1):
y(xn+1 ) = y(xn ) + y 0 (xn )h + O(h2 ) (8.17)
On écrit alors :
y(xn+1 ) − y(xn )
y 0 (xn ) = + O(h). (8.18)
h
D’autre part, si y est une solution exacte du problème de Cauchy, on a:
y 0 (xn ) = Φ(xn ,y(xn )), n = 0,1,...,N − 1 (8.19)
En reportant (8.19) dans (8.18), on obtient:
y(xn+1 ) = y(xn ) + hΦ(xn ,y(xn )) + O(h2 ), (8.20)
En approchant h → 0 pour rendre O(h2 ) négligeable, on note yn une approximation de

y(xn ), on peut définir le vecteur y = (yn ) comme étant la solution du système:
½
yn+1 = yn + hΦ(xn ,yn ),
(8.21)
y(0) = y(x0 ) = α,
Le système (8.23) s’appelle schéma d’Euler pour la discrétisation du problème de Cauchy.
Cette méthode fait partie d’une famille de méthodes appelées méthodes explicites ca-
ractérisées par la relation :
Yn+1 = F (xn ,yn ,h). (8.22)

Ces méthodes sont d’une mise en oeuvre sur ordinateur facile, mais la contrepartie est la
stabilité.
Exemple.
½ 0
y (x) = y(x),
(8.23)
y(0) = 1 sur [0,5].
La solution exacte est y(x) = ex . Le schéma d’Euler (explicite) de ce problème est:
yn+1 = yn + hΦ(xn ,yn ) = yn + hyn = (1 + h)yn
Ce schéma donne une solution approchée yn qui définit une suite géométrique de raison
1 + h et de premier terme 1. Donc,
yn = (1 + h)n , avec n = 0,1,...,N.
On introduit l’erreur ponctuelle en = y(xn ) − yn . En prenant h = 2−6 on a le tableau

suivant:
xn 1 2 3 .. 5
en -0.02093 -0.1139 -0.46055 .. -5.6282
L’un des problèmes de l’analyse numérique est de prévoir l’ordre de grandeur de l’erreur.
Cet erreur peut tre due à plusieurs causes:
– L’erreur de discrétisation due au procédé de calcul. Dans la méthode d’Euler on
approche la courbe par sa tangente.
– Les erreurs d’arrondis dues au perte de chiffres dans les opérations arithmétiques.
Les qualités à exiger d’un schéma de discrétisation sont:
1. La consistence,
2. La stabilité.
La consistence plus la stabilité entraine la convergence.
8.2.3 Schéma général

Les méthodes de discrétisation à un pas vérifient la relation suivante:
½
yn+1 = yn + h∆(xn ,yn ,h)
(8.24)
y0 = α, α ∈ R
Choisir une méthode c’est choir la forme de ∆. Définition 3
Une méthode est dite convergente lorsque

· ¸
max
lim |yn − y(xn )| → 0 (8.25)
N →+∞ 0 ≤ n ≤ N
et ceci quelque soit la condition initiale.
Définition 4 (Stabilité théorique)

Soit {yn ,0 ≤ n ≤ N } et zn ,0 ≤ n ≤ N les solutions respectives du système:

½
(8.26)
y0 ∈ R
½
zn+1 = zn + h[∆(xn ,yn ,h) + ²]
(8.27)
z0 ∈ R
La méthode est dite théoriquement stable s’il existe deux constantes M1 (N ) et M2 (N )
telle que
max max
|yn − zn | ≤ M1 |y0 − z0 | + M2 |²n | (8.28)
0≤n≤N 0≤n≤N
Définition 5
Le schéma:
½
(8.29)
y0 donne
est dit consistent avec le Problème de Cauchy si en posant:

1
en,h = [y(xn+1 − y(xn )] − ∆(xn ,yn ,h), (8.30)
h
on a
lim = 0∀0 ≤ n ≤ N − 1 (8.31)

h→0
où la fonction y est une solution exacte du problème de Cauchy. Théorème 3
Si une méthode à un pas est consistante et stable, alors elle converge.
Théorème 4
Si ∆ vérifie la condition de Lipschitz par rapport à la deuxième variable avec constante

de Lipschitz indépendante de sa première variable, i.e.:
∃L > 0/∀ξ1 ∈ [a,b], ∀(ξ1 ,ξ2 ) ∈ R, ona|∆(ξ1 ,ξ2 ,h) − ∆(ξ1 ,ξ2 ,h)| ≤ L|ξ2 − ξ2 | (8.32)
pour h assez petit et L indépendant de h, alors la méthode est stable.
Remarque
Si la fonction ∆ vérifie
1. ∆(ξ1 ,ξ2 ,0) = Φ(ξ1 ,ξ2 )
2. ∃L > 0/|∆(ξ1 ,ξ2 ,h) − ∆(ξ1 ,ξ2 ,h)| ≤ L|ξ2 − ξ2 |
∀ξ1 ∈ [a,b], ∀ξ2 ,ξ2 ∈ R et pour h assez voisin de zéro, alors la méthode ∆ converge.
Définition 6 (ordre d’une méthode)
Une méthode est dite consistente d’ordre p > 0 si pour toute solution de
½ 0
y (x) = Φ(x,y(x)) sur [a,b]
(8.33)
y(0) donne,
on a:
max 1
| [y(xn + h) − y(xn )] − ∆(xn ,y(xn ),h)| = O(hp ), (8.34)
n h
soit
max 1
| [y(xn + h) − y(xn )] − ∆(xn ,y(xn ),h)| ≤ Chp (8.35)
n h
avec C indépendant de h.
Théorème 5
Si ∆ vérifie la condition de Lipschitz par rapport à sa seconde variable et si la méthode
est consistente d’ordre p > 0, alors:
max max
|en | = |y(xn ) − yn | = O(hp ). (8.36)
n n
La méthode converge comme un O(hp ).
8.2.4 Construction de ∆(x,y,h) consistant d’ordre p par Taylor

On commence par développer la quantité [y(x + h) − y(x)]/h au moyen de la formule
de Taylor à l’ordre p. Ce qui donne:
y(x + h) − y(x) 0 h h2 hp−1 (p) hp

= y (x)+ y”(x)+ +...+ y (x)+ y (p+1) (x+θh) (8.37)
h 2! 3! p! (p + 1)!
avec 0 < θ < 1. (On suppose que y est de classe C (p+1) sur [a,b]). Nous avons:
y 0 (x) = Φ[x,y(x)],
y”(x) = dΦ dx
= ∂Φ
∂x
+ Φ ∂Φ
∂y (8.38)
y (3) (x) = dy”
dx
= ...
Si on prend
h hp−1 (p−1)
∆(x,y,h) = Φ(0) (x,y) + Φ(1) (x,y) + ... + Φ (x,y) (8.39)
2 p!
où on a posé:
(0) (0)
Φ(0) = Φ; Φ(1) = ∂Φ∂x + Φ(0) ∂Φ∂y ;
(k−1) (k−1) (8.40)
Φ(k) = ∂Φ∂x + Φ(0) ∂Φ∂y , ∀k ≥ 1.
On définit ainsi une méthode d’ordre p.
8.2.5 Méthode de Runge-Kutta

Soit à résoudre le Problème de Cauchy:
½ 0
y (x) = Φ(x,y(x)) sur [a,b]
(8.41)
y(0) donne,
où Φ(.,.) vérifie les conditions de Cauchy-Lipschitz (relatives à l’existence et à l’unicité de

la solution), par une méthode numérique. Soit le schéma numérique de (8.41) défini par:
½
(8.42)
y0 = y(a),
on dit que (8.42) est une méthode de Runge-Kutta si ∆ est de la forme:

q
X
∆(x,y,h) = λi Ki (x,y,h) (8.43)
i=1
où les λi ∈ R et les Ki donnés par :

( ³ P ´
Ki+1 = Φ x,αi+1 h,y + h ir=1 βr Kr , ∀1 ≤ i ≤ q − 1
(8.44)
K1 = Φ(x,y),
avec les αi , βr des scalaires. On a le résultat fonfamental suivant:
Théorème 6
Pour que ∆(x,y,h) soit une méthode de Runge-Kutta d’ordre p, il faut et il suffit que:
1. ∆ soit de la forme (8.43),
2. ensuite,
∂k∆ 1
k
(x,y,0) = Φ(k) (x,y); k = 0,1,...,p − 1 (8.45)
∂h k+1
où on posé:
∂Φ(k−1) ∂Φ(k−1)
Φ(k) = +Φ (8.46)
∂x ∂y
Application
a) Runge-Kutta d’ordre 2
Déterminer les relations entre les constantes a1 , a2 , p1 , et p2 qui interviennent dans la
fonction
∆(x,y,h) = a1 Φ(x,y) + a2 Φ[x + p1 h,y + hp2 Φ(x,y)] (8.47)
de telle sorte que cette méthode soit consistante d’ordre 2.
Solution
* cette expression est de la forme (8.43) avec a1 = λ1 , a2 = λ2 et α2 = p1 ,β1 = p2 .
* Vérifions si ∆ satisfait à la seconde relation du théorème 6.
-k=0
∆(x,y,0) = a1 Φ(x,y) + a2 Φ(x,y) = (a1 + a2 )Φ(x,y) (8.48)
La consistance entraine que
∆(x,y,0) = Φ(x,y), Φ (8.49)

Cette condition est assurée si a1 + a2 = 1.
- k = 1 vérification de la seconde relation du théorème 6

∂∆
∂h
(x,y,h) = a2 p1 ∂Φ
∂x
+ a2 p2 Φ(x,y) ∂Φ
∂y
(8.50)
= a2 p1 ∂Φ
∂x
[x + p1 h,y + hp 2 Φ(x,y)] + a2 p2 Φ(x,y) ∂Φ
∂y
[x + p1 h,y + hp2 Φ(x,y)]
soit:
∂∆ Φ(x,y) Φ(x,y)
(x,y,0) = a2 p1 + a2 p2 Φ(x,y) (8.51)
∂h ∂x ∂y
La deuxième relation du théorème 6 est vérifiée ssi

µ ¶
∂∆ 1 (1) 1 ∂Φ ∂Φ
(x,y,0) = Φ = +Φ (8.52)
∂h 2 2 ∂x ∂y
soit:
µ ¶
Φ(x,y) Φ(x,y) 1 ∂Φ ∂Φ
a2 p1 + a2 p2 Φ(x,y) = +Φ (8.53)
∂x ∂y 2 ∂x ∂y
Par identification, on a:
1 1
a2 p1 = , a2 p2 = (8.54)
2 2
Le schéma est consistent d’ordre 2 si:

 a1 + a2 = 1
a2 p1 = 12 (8.55)

a2 p2 = 12
soit p1 = p2 = 1/2a2 ; a1 = 1 − a2 avec a2 6= 0. Ainsi la méthode obtenue s’écrit:

· ¸
h h
∆(x,y,h) = (1 − a2 )Φ(x,y) + a2 Φ x + ,y + (8.56)
2a2 2a2
© ª
où a2 joue le rôle de paramètre réel. Pour a2 ∈ 21 ,1 . On retrouve deux exemples très
classiques qui sont:
– a2 = 1/2
h
yn+1 = yn + [Φ(xn ,yn ) + Φ(xn + h,yn + hΦ(xn ,yn ))] (8.57)
2
connue sous le nom de méthode d’Euler améliorée.
– a2 = 1
· ¸
h h
yn+1 = yn + h Φ(xn + ,yn + Φ(xn ,yn ) (8.58)
2 2
a) Runge-Kutta d’ordre 4
A partir des relations (8.43) (8.45)et (8.46) du théorème 6, construire le schéma de

Runge-Kutta d’ordre 4 et en déduire le schéma:
1
∆(x,y,h) = [K1 + 2K2 + 2K3 + K4 ] (8.59)
6
avec

 K1 = Φ(x,y),K2 = Φ(x + h2 ,y + h2 K1 )
K = Φ(x + h2 ,y + h2 K2 ) (8.60)
 3
K4 = Φ(x + h,y + hK3 )
est un cas particulier.
La formule (8.60) est la plus utilisée et est connue sous le nom de méthode de Runge-
Kutta(RK).
8.3 Formules à pas multiples:Méthodes d’Adams

Les formules d’Adams sont l’une des catégories de formules à pas multiples. Comme
toutes les formules, on peut les classer en formule ouverte ou fermée.
8.3.1 Formules d’Adams ouvertes ou Méthode d’Adams-Bashforth

Considérons à nouveau l’équation
½ dy
= Φ(x,y)
dx (8.61)
y0 donne
Un développement en série de Taylor autour de x donne:
h2 h3
y(x + h) = y(x) + hy 0 (x) + y” + y (3) (8.62)
2 6
compte tenu de (8.62), on a:
y 0 = Φ(x,y); y” = Φ0 (x,y), etc... (8.63)
L’équation (8.62) écrite au point xi donne:
h2 0 h3
yi+1 = yi + hΦi + Φ + Φ”i + ... (8.64)
2 i 6
On montre que (8.64) peut se mettre sous la forme:
n
X
yi+1 = yi + hΦi + h βnk Φi−k + O(hn+2 ) (8.65)
k=0
Le tableau ci-dessous donne les valeurs de βnk jusqu’à n = 5 (formule d’ordre 6). La
formule la plus couramment utilisée est celle d’ordre 4.
h
yi+1 = yi + (55Φi − 59Φi−1 + 37Φi−2 − 9Φi−2 ) + O(h5 ) (8.66)
24
8.3. FORMULES À PAS MULTIPLES:MÉTHODES D’ADAMS 119
n..k 0 1 2 3 4 5 ordre.
0 1 .. .. .. .. .. 1
1 3/2 -1/2 .. .. .. .. 2
2 23/12 -16/12 5/12 .. .. .. 3
3 55/24 -59/24 37/24 -9/24 .. .. 4
4 1901/720 -2774/720 2616/720 -1274/720 251/720 .. 5
5 4277/1440 -7923/1440 9982/1440 -7298/1440 2877/1440 -475/1440 6
8.3.2 Formules d’Adams fermés ou Méthode d’Adams-Moulton

Le schéma d’Adams fermé est donné par:
n
X
yi+1 = yi + hΦi + h γnk Φi+1−k + O(hn+2 ) (8.67)
k=0
les valeurs de γnk sont données par un tableau jusqu’à n=5. Ainsi, pour l’ordre 4 (n=3)
on a:
h
yi+1 = yi + (9Φi+1 + 19Φi − 5Φi−1 + Φi−2 ) + O(h5 ) (8.68)
24
n..k 0 1 2 3 4 5 ordre.
0 1 .. .. .. .. .. 1
1 1/2 1/2 .. .. .. .. 2
2 5/12 8/12 -1/12 .. .. .. 3
3 9/24 19/24 -5/24 1/24 .. .. 4
4 251/720 646/720 -264/720 106/720 -19/720 .. 5
5 4475/1440 1427/1440 -798/1440 482/1440 -173/1440 27/1440 6
On voit que les formules fermées étant ittératives consomme plus de temps machine que
r
les formules ouverstes, puisqu’il faut calculer Φ(xi+1 ,yi+1 ) plusieurs fois. Toutefois
– Elles sont en fait bien plus précises que les formules ouvertes du mme ordre.
– Elles sont en général stables alors que les formules ouvertes sont souvent instables.
– Leur convergence est d’autant plus rapide (donc le temps de calcul d’autant plus
(0)
court) que l’estimation initiale yi+1 est plus proche de la valeur exacte yi+1 , de sorte
qu’un petit nombre d’itérations est suffisant en pratique.
En fait, on n’utilise ni les formules ouvertes, ni les formules fermées, mais une combinaison
des deux méthodes appelée méthode des prédiscteurs-correcteurs.
8.3.3 Méthode de prédicteur-correcteur: Méthode d’Adams-Bashforth-

Moulton
Ces méthodes profitent des avantages des méthodes fermées (très bonne précision) et
en éliminant les inconvénients du temps de calcul élevé: Il suffit de trouver une valeur
(0) (0)
estimée yi+1 proche de la valeur finale yi+1 . Pour cela yi+1 (appelée prédicteur) est obte-
(0)
nue par une formule ouverte de mme ordre. C’est cette valeur yi+1 qui est introduite dans
la formule fermée. En pratique, un à trois itérations seulement suffisent pour atteindre le
résultat yi+1 . Le prédicteur peut tre considérablement amélioré en le corrigeant de l’erreur
estimée de troncature. Ainsi, la procédure est la suivante: pour la méthode d’Adams au

4e ordre:
– Prédicteur: Adams-Bashforth
h
yi+1 = yi + (55Φi − 59Φi−1 + 37Φi−2 − 9Φi−3 ) (8.69)
24
(0)
– Modificateur (y0 est la valeur du prédicteur au pas précédent)
(0) (0) 251 (0)

yi+1 = yi+1 − (yi − yi (8.70)
270
– Correcteur: Adams-Moulton (Formule d’Adams fermé au 4e ordre)
½ h
yi+1 = yi + 24 (9Φi+1 + 19Φi − 5Φi−1 + Φi−2 )
(0) (0) (8.71)
Φi+1 = Φ(xi+1 ,yi+1
*Les estimations de y1 ,y2 ,y3 ne peuvent pas tre calculés à partir des équations (8.69)-
(8.71): elles sont calculées à partir de la méthode de Runge-Kutta.
(0)
* Etant donné que y3 n’exixte pas, on ne peut pas utiliser de modificateur pour
calculer y4 ; y4 est donc calculé à partir des formules (8.69) et (8.71).
(0) (0)
* y4 initiant l’itération (8.71), ce n’est qu’à partir de y5 qu’on estime y5 par (8.69),
(0) (0)
puis y5 par (8.70) et c’est cette valeur de y5 qui est injectée dans (8.71) pour itérer.
* L’erreur par pas dans le prédicteur-correcteur d’Adams au 4e ordre est:

19 (0)
Ei+1 = (yi+1 − yi+1 ) (8.72)
270
Notons qu’il existe d’autres méthodes de prédicteur-correcteur que celles d’Adams.
* Pour la plupart de problème, la partie qui consomme le plus de temps calcul est
la détermination de Φ(x,y).
*Nous avons déjà signalé que la forme de Runge-Kutta d’ordre 4 nécessitait dévaluer
4 fois Φ par pas. Pour un prédicteur-correcteur, ∀ son ordre, il faut calculer une
valeur de Φ, soit Φi , pour le prédicteur (les autres valeurs Φi−1 ,P hii−2 ,... ont déjà
été calculées et une évaluation de Φi+1 à cjaque itération. En pratique, une à deux
itérations suffisent pour atteindre la précision recherchée.
* Ainsi, un prédicteur-correcteur nécessite 2 ou 3 évaluations de Φ, rarement 4, de

sorte qu’un prédicteur-correcteur d’ordre 4 est plus précise, plus stable et plus rapide
que les méthodes de prédicteur-correcteur soient très utilisées.
8.4. PROGRAMMATION INFORMATIQUE DES MÉTHODES PRÉSENTÉES 121
8.4 Programmation informatique des méthodes présentées

8.4.1 Résolution des équations de premier ordre
8.4.1.1 Méthode de Runge-Kutta d’ordre 4
Program Runge_Kutta4;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* Ce programme resoud numeriquement une *****
******* *****
******* Equation differentielle de premier ordre *****
******* *****
******* par la methode Runge-Kutta *****
******* d’ordre 4 *****
******* *****
******* *****
*****************************************************************
*****************************************************************)
uses Dos,printer;
const p=10; {periode d’impression du resultat}
Var x0, y0,xf, h,h2,h6,x,y,xm:real;

k1,y1,k2,y2,k3,y3,k4,phi,yex:real;
i,npas:integer;
ce:char;
Function F(x,y:real):real;
begin
F:=1-y;
end;
Function yanal(x:real):real;
begin
yanal:=1-exp(-x);
end;
Begin
{clrscr;}
x0:=0.0; y0:=0.0; {conditions initiales}
xf:=20; {domaine d’integration}

npas:=200; {nombre de points de discretisation du domaine}
h:=(xf-x0)/npas; {pas d’integration}
writeln(’le pas d"iteration est h :=’,h:5:4);

h2:=h/2; h6:=h/6;
yex:=yanal(x0);
(* dbut de la procdure Rnge-Kutta d"ordre 4*)

x:=x0; y:=y0;
writeln(’ x ’, ’ y ’, ’ valeur exacte ’);
writeln(x:5:3,’ ’, y:10:8, ’ ’, yex:10:8);
for i:= 1 to npas do
begin
xm:=x+h2;
k1:=f(x,y);
y1:=y+h2*k1;
k2:=f(xm,y1);
y2:=y+h2*k2;
k3:=f(xm,y2);
y3:=y+h*k3;
x:=x+h;
k4:=f(x,y3);
phi:=k1+2*(k2+k3)+k4;
y:=y+h6*phi;
yex:=yanal(x);
if i mod p =0 then writeln(x:5:3,’ ’, y:10:8,’ ’, yex:10:8);
end;
writeln;
writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Resolution ED 1er ordre $$$$’);
writeln(’$$$$$$ par Methode de Runge Kutta $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
8.4.1.2 Méthode de Prédicteur-Correcteur: Adams-Bashforth-Moulton

Program Pre_corector4;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* Ce programme resoud numeriquement une *****
******* *****
******* Equation differentielle de premier ordre *****
******* *****
******* par la methode de Predicteur-Correcteur *****
******* d’ordre 4 *****
******* *****
******* *****
*****************************************************************
*****************************************************************)
uses Dos,printer;

epsi=1.0e-10;
countmax=20;
Type Vector=array[1..4] of real;
Var x0, y0,xf, h,h2,h6,h24,x,y,xm:real;

k1,y1,k2,y2,k3,y3,k4,phi,yex:real;
AA,yp,ypp,ym,yc,temp,Dy:real;
ff:vector;
i,npas,count,j:integer;
ce:char;
Function F(x,y:real):real;
begin
F:=1-y;
end;
begin
yanal:=1-exp(-x);
end;
Begin
{clrscr;}
x0:=0.0; y0:=0.0; {conditions initiales}
xf:=10.0; {domaine d’integration}

h2:=h/2; h6:=h/6; h24:=h/24;
AA:=251.0/270.0;
(* Demarrage de la procedure Predicteur-correcteur par Runge-Kutta d"ordre 4*)

x:=x0; y:=y0; ff[1]:=f(x,y); yex:=yanal(x0);
writeln(’ x ’, ’ y ’, ’ valeur exacte ’);
writeln(x:5:3,’ ’, y:10:8, ’ ’, yex:10:8);
for i:= 1 to 3 do
begin
xm:=x+h2;
k1:=f(x,y);
y1:=y+h2*k1;
k2:=f(xm,y1);
y2:=y+h2*k2;
k3:=f(xm,y2);
y3:=y+h*k3;
x:=x+h;
k4:=f(x,y3);
phi:=k1+2*(k2+k3)+k4;
y:=y+h6*phi; ff[i+1]:=f(x,y);
yex:=yanal(x);
if i mod p =0 then writeln(x:5:3,’ ’, y:10:8,’ ’, yex:10:8);
end; {fin Runge-Kutta 4}
(* Debut de la procedure predicteur-correcteur d’ordre 4 *)
For i:=4 to npas do

begin
x:=x+h;
{predicteur d’Adams ouvert au 4e ordre}
yp:=y+h24*(55*ff[4]-59*ff[3]+37*ff[2]-9*ff[1]);
{Modificateur}
if (i>4) then ym:=yp-AA*(y-ypp)
else ym:=yp;
{Correcteur d’Adams ferme au 4e ordre}
count:=0;
Repeat
count:=count+1; {compteur du nombre d’iterations}
Temp:=f(x,ym);
yc:=y+h24*(9*temp+19*ff[4]-5*ff[3]+ff[2]);
Dy:=abs(yc-ym);
ym:=yc;
until ((Dy<=epsi) or (count>=countmax));
if (count<countmax) then
begin
ypp:=yp;
y:=yc;
yex:=yanal(x);
writeln(x:5:3,’ ’, y:10:8,’ ’, yex:10:8);
end
else
begin
writeln(’Pas de solution faute de convergence’);
readln;
Halt;
end;
for j:=1 to 3 do ff[j]:=ff[j+1];
ff[4]:=f(x,y);
end; {Fin procedure Predicteur -correcteur}
writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Predicteur-Correcteur $$$$’);
writeln(’$$$$$$ d"ordre 4 $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
8.4.2 Résolution des systèmes déquations de premier ordre

8.4.2.1 Méthode de Runge-Kutta d’ordre 4
Program Runge_Kutta4;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* Ce programme resoud numeriquement un systeme *****
******* *****
******* d’ Equations Differentielles de premier ordre *****
******* *****
******* par la methode Runge-Kutta *****
******* d’ordre 4 *****
******* *****
******* *****
*****************************************************************
*****************************************************************)
uses Dos,printer;

omega=2*pi;
Var x0, y0,z0,xf, h,h2,h6,x,y,z,xm:real;

k1y,k1z,y1,z1,k2y,k2z,y2,z2,k3y,k3z,y3,z3,k4y,k4z,phiy,phiz,yex:real;
i,npas:integer;
ce:char;
Function F(x,y,z:real):real;
begin
F:=z;
end;
Function g(x,y,z:real):real;
begin
g:=-sqr(omega)*y;
end;
begin
yanal:=cos(omega*x);
end;
Begin
{clrscr;}
x0:=0.0; y0:=1.0; z0:=0.0; {conditions initiales}
xf:=1; {domaine d’integration}

h2:=h/2; h6:=h/6;
yex:=yanal(x0);
(* dbut de la procdure Rnge-Kutta d"ordre 4*)

x:=x0; y:=y0; z:=z0;
writeln(’ x ’, ’ z ’, ’ y ’,’ valeur exacte de y ’);
writeln(x:5:3,’ ’, z:10:8, ’ ’,y:10:8,’ ’, yex:10:8);
for i:= 1 to npas do
begin
xm:=x+h2;
k1y:=f(x,y,z); k1z:=g(x,y,z);
y1:=y+h2*k1y; z1:=z+h2*k1z;
k2y:=f(xm,y1,z1); k2z:=g(xm,y1,z1);
y2:=y+h2*k2y; z2:=z+h2*k2z;
y3:=y+h*k3y; z3:=z+h*k3z;
x:=x+h;
k4y:=f(x,y3,z3); k4z:=g(x,y3,z3);
phiy:=k1y+2*(k2y+k3y)+k4y; phiz:=k1z+2*(k2z+k3z)+k4z;
y:=y+h6*phiy; z:=z+h6*phiz;
yex:=yanal(x);
if i mod p =0 then writeln(x:5:3,’ ’, z:10:8, ’ ’,y:10:8,’ ’, yex:10:8);
end;
writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Resolution SED 1er ordre $$$$’);
writeln(’$$$$$$ par Methode de Runge Kutta $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.
8.4.2.2 Méthode de Prédicteur-Correcteur: Adams-Bashforth-Moulton

Program Pre_corector4;
(****************************************************************
*****************************************************************
******* *****
******* *****
******* Ce programme resoud numeriquement un systeme *****
******* *****
******* d’ Equations differentielles de premier ordre *****
******* *****
******* par la methode de Predicteur-Correcteur *****
******* d’ordre 4 *****
******* *****
******* *****
*****************************************************************
*****************************************************************)
uses Dos,printer;

eps=1.0E-10;
countmax=20;
omega=2*pi;
Type Vector=array[1..4] of real;
Var x0, y0,z0,xf, h,h2,h6,h24,x,y,z,xm:real;

k1y,k1z,y1,z1,k2y,k2z,y2,z2,k3y,k3z,y3,z3,k4y,k4z,phiy,phiz,yex:real;
AA,yp,zp,ypp,zpp,ym,zm,yc,zc,tempy,tempz,Dy,Dz:real;
ff,gg:vector;
i,npas,count,j:integer;
ce:char;
Function F(x,y,z:real):real;
begin
F:=z;
end;
Function g(x,y,z:real):real;
begin
g:=-sqr(omega)*y;
end;
begin
yanal:=cos(omega*x);
end;
Begin
{clrscr;}
x0:=0.0; y0:=1.0; z0:=0.0; {conditions initiales}
xf:=1.0; {domaine d’integration}

h2:=h/2; h6:=h/6; h24:=h/24;

AA:=251.0/270.0;
(* Demarrage de la procedure Predicteur-correcteur par Runge-Kutta d"ordre 4*)

x:=x0; y:=y0; z:=z0; ff[1]:=f(x,y,z); gg[1]:=g(x,y,z); yex:=yanal(x);
writeln(’ x ’, ’ z ’, ’ y ’,’ valeur exacte de y ’);
writeln(x:5:3,’ ’, z:10:8, ’ ’,y:10:8,’ ’, yex:10:8);
for i:= 1 to 3 do
begin
xm:=x+h2;
k1y:=f(x,y,z); k1z:=g(x,y,z);
y1:=y+h2*k1y; z1:=z+h2*k1z;
y2:=y+h2*k2y; z2:=z+h2*k2z;
y3:=y+h*k3y; z3:=z+h*k3z;
x:=x+h;
k4y:=f(x,y3,z3); k4z:=g(x,y3,z3);
phiy:=k1y+2*(k2y+k3y)+k4y;
phiz:=k1z+2*(k2z+k3z)+k4z;
y:=y+h6*phiy;
z:=z+h6*phiz;
ff[i+1]:=f(x,y,z);
gg[i+1]:=g(x,y,z);
yex:=yanal(x);
end; {End Procedure Runge-Kutta}
readln;
(* Debut de la procedure predicteur-correcteur d’ordre 4 *)
For i:=4 to npas do

begin
x:=x+h;
{predicteur d’Adams ouvert au 4e ordre}
yp:=y+h24*(55*ff[4]-59*ff[3]+37*ff[2]-9*ff[1]);
yp:=y+h24*(55*gg[4]-59*gg[3]+37*gg[2]-9*gg[1]);
{Modificateur}
if (i>4) then
begin
ym:=yp-AA*(y-ypp);
zm:=zp-AA*(z-zpp);
end
else
begin
ym:=yp;
zm:=zp;
end;
{Correcteur d’Adams ferme au 4e ordre}
count:=0;
Repeat
count:=count+1; {compteur du nombre d’iterations}
Tempy:=f(x,ym,zm);
Tempz:=g(x,ym,zm);
yc:=y+h24*(9*tempy+19*ff[4]-5*ff[3]+ff[2]);
zc:=z+h24*(9*tempz+19*gg[4]-5*gg[3]+gg[2]);
Dy:=abs(yc-ym); Dz:=abs(zc-zm);
ym:=yc;
zm:=zc;
until (((Dy<=eps) and (Dz<=eps)) or (count>=countmax));
if (count<countmax) then
begin
ypp:=yp; zpp:=zp;
y:=yc; z:=zc;
yex:=yanal(x);

end
else
begin
writeln(’Pas de solution faute de convergence’);
readln;
Halt;
end;
for j:=1 to 3 do
begin
ff[j]:=ff[j+1];
gg[j]:=gg[j+1];
end;
ff[4]:=f(x,y,z); gg[4]:=g(x,y,z);
end; {Fin procedure Predicteur -correcteur}
writeln;
writeln;
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$ Predicteur-Correcteur $$$$’);
writeln(’$$$$$$ d"ordre 4 $$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
writeln(’$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$’);
Readln;
END.

Partie II Méthodes Numériques

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

Partie II Méthodes Numériques

Transféré par

Droits d'auteur :

Formats disponibles

TABLE DES MATIÈRES 1

Table des matières

2 Éléments de base du langage Turbo Pascal 9

2.8 Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3 Dérivation de fonctions : méthode de différences finies 31

4 Résolution numériques d’équations 39

5 Introduction à la résolution numérique des systèmes linéaires 61

5.3 Méthodes itératives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

6 Approximation des fonctions numériques... 83

7 Intégration numérique des fonctions. 93

8 Résolution numérique des équations différentielles 109

8.3.1 Formules d’Adams ouvertes ou Méthode d’Adams-Bashforth . . . . 118

1.1 Utilité des langages informatiques

En effet, un physicien, un ingénieur,...etc., c’est d’abord un spécialiste d’une discipline

1.2 Utilité et limitations des méthodes numériques

1.2.1 Nécessité des méthodes numériques

La plupart des phénomènes physiques, biologiques, économiques et même sociaux sont

Bien plus, dans de nombreux domaines de pointes (industrie aéronautique, industrie

En revanche, les résolutions analytiques ou exactes quoique fort intéressantes, car

– les différences finies,

1.2.2 Limitations des méthodes numériques

1.3 Outils de base des méthodes numériques

(x − a)2 ” (x − a)n (n)

(x − a)2 ” (x − a)n (n)

(x − a)2 ” (x − a)n (n)

Éléments de base du langage Turbo

2.1 Les données

2.1.1 L’alphabet Pascal

2.1.3 Mots réservés ou mots-clés

2.1.4 Les types de données

2.1.5 Les déclarations

Le mot-clé var suivi du nom de la variable et de sa nature. Exple.

2.1.6 Les commentaires

2.2 Structure d’un programme Pascal

2.2.2 structure globale d’un programme

2.3 Les actions de base dans un programme : lire,

2.3.2 Instructions Write et Writeln

Nombre de lignes : 15 et Nombre de colonnes : 8

La procédure writeln fonctionne de la même manière que la procédure write, à la seule

Writeln(’ valeur de x :’, x );

affichera le résultat suivant

Writeln(’ valeur de x :’, x :5 )

affichera le résultat suivant

Writeln(’ valeur de x :’, x :7 :2 ) affichera le résultat suivant

Writeln(’ valeur de x :’, x :18 :10 ) affichera le résultat

2.3.3 Instructions Read et Readln

Read (var1,var2,...,varn) ou Readln (var1,var2,...,varn)

2.4 Les opérateurs

2.4.2 Opérateurs de comparaison

Opérateur Description Opérateur Description

Exemple : x=1.00, y=2.00, le résultat de l’opération x > y est faux.

2.4.3 Opérateurs logiques

Exemple : x=1.00, y=2.00, a=-10.00 et b=35.23.

2.4.4 Priorité des opérateurs et évaluation des expressions

Pour déterminer l’ordre d’évaluation d’une expression quelconque, le compilateur procède

a+b/c+d sera evalue comme a+(b/c)+d.

2.5 Les fonctions

Fonction Type de l’argument Type du résultat Description

2.6 Texts et Choix : instructions conditionnelles

IF (expression à valeur logique) THEN instruction exécutable

dont l’action peut se représenter par l’organigramme de la figure (2.1):

donne la valeur vrai. Voici donc la séquence de ce programme pascal:

2.6.2.2 Séquence conditionnée : IF .. Then Begin..end