PHY-1234

INTRODUCTION
À LA
PHYSIQUE NUMÉRIQUE

Notes de cours
par

Paul Charbonneau et David Lafrenière

Département de Physique
Université de Montréal

Automne 2022
ii
 iii

MINI-PRÉFACE

Ces notes contiennent l’essentiel de la matière couverte dans le cours PHY-1234, “Introduction à
la Physique Numérique”. Certains éléments plus techniques portant spécifiquement sur le langage de
programmation utilisé et sur les particularités des phénomènes à modéliser en laboratoire seront présentés
dans des notes de laboratoire séparées. Divers ouvrages de références sont proposés à travers le document de
notes, en particulier au début du chapitre 2 pour ce qui est des outils de référence pour la programmation.
Ce document de notes – à l’exception des chapitres 2 et 3 – et le contenu du cours dans sa forme
actuelle ont été développés par Paul Charbonneau, qui a enseigné le cours de 2008 à 2013. Je dois donc
dire un gros merci à Paul pour m’avoir généreusement transmis le produit de son excellent travail !
En prenant la charge du cours en 2014, j’ai opté pour un nouveau langage de programmation : Python.
Effectivement le cours était enseigné avec le langage C auparavant, mais je crois que le langage Python est
plus approprié pour les fins du cours et surtout, qu’il vous sera plus utile de maitriser ce langage pour la
suite de vos études de baccalauréat, pour vos études supérieures, et possiblement pour votre futur emploi.
Les principales motivations pour ce choix de langage sont données à la section 1.7. Donc, le principal
changement par rapport au document de notes préparé par Paul est que j’ai adapté le tout à ce nouveau
langage de programmation : ceci comprend une bonne révision de quelques sections du chapitre 1, et la
conversion des différents exemples de codes montrés dans les notes. De plus, en 2015, j’ai rédigé deux
nouveaux chapitres (chap. 2 et 3) pour introduire les principaux éléments de programmation Python que
vous aurez besoin pour le cours ; certaines parties de ces deux chapitres sont inspirées d’éléments figurant
dans d’anciennes notes pour ce cours préparées par Normand Mousseau et Suzanne Talon et dans certains
ouvrages de références mentionnés au chapitre 2. J’ai révisé ces deux chapitres en 2016 et encore cette
année, en y ajoutant certains éléments. Au-delà de ces changements, je n’ai fait que des modifications que
l’on pourrait qualifier de mineures par rapport aux notes préparées par Paul.
Enfin, vous pouvez contribuer à améliorer la qualité de l’ensemble ces notes et la qualité du cours
en me faisant part de tous commentaires, suggestions, critiques (en particulier constructives) : passages
obscurs, diagrammes portant à confusion, manque de détails ici, détails superflus là, fautes de frappw ou
d’autographe, etc. Merci d’avance !

–David Lafrenière
7 août 2017
iv
Table des matières

1 La physique numérique 1
1.1 La modélisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Les algorithmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 La programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.4 Représentations numériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5 L’analyse numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.6 La physique numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.7 Pourquoi le Python ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2 Python : la base 9
2.1 Notions préliminaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2 Modes d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.3 Identificateurs (noms d’objets) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4 Assignation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5 Types de variables et d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.5.1 Entier (int) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5.2 Réel (float) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5.3 Complexe (complex) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5.4 Booléen (bool) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.5.5 Chaîne de caractères (str) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5.6 Liste (list) et Tuple (tuple) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.5.7 Transformation de type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5.8 Autres types par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.6 Opérateurs de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.6.1 Opérateurs arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.6.2 Opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.6.3 Opérateurs relationnels (de comparaison) . . . . . . . . . . . . . . . . . . . . . . . 19
2.6.4 Opérateurs de chaînes de caractères, de listes et de tuples . . . . . . . . . . . . . . 20
2.7 Entrées et sorties standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.8 Le contrôle du flux d’instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.8.1 L’instruction conditionnelle if ... . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.8.2 Boucles conditionnelles : l’instruction while . . . . . . . . . . . . . . . . . . . . . . 23
2.8.3 Boucles inconditionnelles : l’instruction for . . . . . . . . . . . . . . . . . . . . . . 23
2.8.4 Les commandes break et continue . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.9 Fonctions et méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.9.1 Librairie de fonctions standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2.9.2 Définition de fonctions originales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
2.9.3 Modules et importations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.9.4 Espace de noms et résolution des identificateurs . . . . . . . . . . . . . . . . . . . . 29
2.10 Écriture d’un code source . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

v
vi TABLE DES MATIÈRES

3 Python : quelques notions supplémentaires 31

3.1 Manipulations de chaînes et listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.1.1 Affichage formaté avec la fonction format() et la méthode .format() . . . . . . . 31
3.1.2 Déballage de séquence en argument . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.2 Entrées et sorties sur fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2.1 Ouverture et fermeture de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2.2 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2.3 Écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3 Le module NumPy et les tableaux numériques . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.3.1 Création d’un tableau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.3.2 Manipulation des tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3.3.3 Opérations sur les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.4 Figures et graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3.4.1 La fonction plot() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.4.2 Sauvegarder un graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.4.3 Personnalisation d’un graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.4.4 Affichages de symboles, exposants, indices, etc. . . . . . . . . . . . . . . . . . . . . 43
3.4.5 Figures, graphiques et axes multiples . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.4.6 Approche “objet” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

4 Dérivées, interpolation et intégration 49

4.1 Le développement en série de Taylor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.2 Dérivées d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2.1 Discrétisations d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
4.2.2 Les différences finies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
4.2.3 Exemple : dérivée numérique de sin θ . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.2.4 Précision, troncation et double précision . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3 Interpolation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.3.1 Interpolation linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.3.2 Interpolation d’ordre plus élevé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.3.3 Interpolation versus extrapolation . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.4 Intégration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.4.1 La méthode du trapèze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.4.2 Les règles de Simpson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.4.3 Intégration de Romberg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.5 Coda, en plus qu’une variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.5.1 Discrétisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.5.2 Dérivées partielles et différences finies . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.5.3 Interpolation multidimensionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.5.4 Intégrales multidimensionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

5 Monte Carlo 75
5.1 Nombres aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
5.2 Fonctions de distributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
5.3 Distributions non-uniformes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.3.1 Distribution exponentielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.3.2 Distributions gaussiennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.4 Évaluation d’intégrales par Monte Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.5 L’approche à l’équilibre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
5.5.1 Formulation en équation différentielle . . . . . . . . . . . . . . . . . . . . . . . . . 87
5.5.2 Formulation Monte Carlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5.6 Réalisme physique et irréversibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
5.6.1 Comment choisir les alternatives en modélisation ? . . . . . . . . . . . . . . . . . . 91
5.6.2 L’irréversibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
TABLE DES MATIÈRES vii

6 Racines et optimisation 95
6.1 La diffraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
6.2 La bissection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
6.3 La méthode de Newton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
6.4 Maximisation (et minimisation) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
6.5 Méthodes de grimpe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
6.6 La grimpe stochastique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

7 Équations différentielles ordinaires 113

7.1 Repenser F = ma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
7.2 La méthode d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
7.2.1 Euler explicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
7.2.2 Euler explicite avec extrapolation linéaire et méthode de Heun . . . . . . . . . . . 116
7.3 Le pendule linéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7.3.1 Solution analytique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
7.3.2 Reformulation en deux équations d’ordre 1 . . . . . . . . . . . . . . . . . . . . . . 119
7.3.3 Euler explicite, bis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
7.3.4 Euler explicite avec extrapolation linéaire, bis . . . . . . . . . . . . . . . . . . . . . 122
7.4 Le pendule nonlinéaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
7.5 Au delà d’Euler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

8 Nonlinéarité et chaos 129

8.1 Encore le pendule... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
8.2 L’espace de phase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
8.3 Le pendule amorti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
8.4 Le pendule forcé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
8.5 Le pendule forcé et amorti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
8.6 Bifurcations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
8.7 Le chaos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
8.8 Chaos ̸= aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

9 Marche aléatoire et diffusion 145

9.1 Les processus stochastiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
9.2 Marche aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
9.3 Diffusion = marche aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
9.4 Marche aléatoire sur réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
9.5 Agrégation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
9.6 L’invariance d’échelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
9.7 Les fractales et leur mesure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
9.8 La dimension fractale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164

10 Complexité 173
10.1 La complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
10.2 Le modèle Tas-De-Sable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
10.3 La criticalité auto-régulée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
10.4 Le modèle Feu-de-Forêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
10.5 Retour sur l’invariance d’échelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
10.6 Le modèle embouteillage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
10.7 Complexité ̸= Stochasticité ̸= chaos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
10.8 Complexité et émergence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
viii TABLE DES MATIÈRES
 1

Chapitre 1

La physique numérique

La représentation mathématique des théories physiques, et la formulation numérique des observations

et résultats expérimentaux que ces théories cherchent à expliquer, sont des concepts tellement centraux
de la physique moderne qu’il nous est difficile d’imaginer qu’il puisse ou qu’il ait pu en être autrement.
Cependant, cette union de fait entre les mathématiques, la physique, l’observation et la manipulation
expérimentale est un phénomène relativement récent dans l’histoire de ces sujets. Les historiens des sciences
la retracent au dix-septième siècle, et résument sa genèse en disant “de Galilée à Newton”. Dans son Il
Saggiatore, un ouvrage polémique publié en 1623, Galilée écrit :
“La philosophie est écrite dans ce grand livre, l’univers, perpétuellement ouvert à nos yeux.
Mais le livre ne peut être lu sans en avoir d’abord compris la langue et appris à lire l’alphabet.
Il est écrit dans la langue des mathématiques, et ses caractères sont les triangles, cercles et
autres figures géométriques sans lesquels il est humainement impossible d’en comprendre un
seul mot.”
Ce n’est pas que la mathématique n’ait pas été utilisée pour décrire (ou même prédire) des phéno-
mènes naturels ; déjà il y plus de 2000 ans, les Babyloniens avaient développé des recettes arithmétiques
permettant une prédiction passablement précise des éclipses du soleil. Et au quatrième siècle, Claudius
Ptolémé avait perfectionné un modèle mathématique du mouvement des planètes d’une complexité et
d’une précision impressionnantes. Mais tous ces modèles mathématiques étaient vus comme des outils pu-
rement descriptifs, sans réalité physique. C’est Galilée qui le premier a insisté sur le fait que des modèles
mathématiques basés sur l’observation et l’expérimentation peuvent se proclamer physiques, dans le sens
moderne du terme. Si ce genre de considérations scientifico-philosophiques vous intéresse, ne manquez pas
de vous inscrire au cours PHY-3315...

1.1 La modélisation
Nous devons tout d’abord faire la distinction entre une théorie et un modèle. Un exemple devrait
suffire. La très célèbre deuxième loi de Newton,

F = ma , (1.1)

nous informe qu’une force agissant sur un mobile produit une accélération dans la direction de la force
appliquée, et de grandeur inversement proportionnelle à la masse m du mobile en question. Ceci exprime
une théorie (dynamique) du mouvement accéléré.
Considérons maintenant l’application de cette théorie à la chute libre d’un caillou vers le sol. Travaillant
en coordonnées cartésiennes avec z pointant vers le haut, la force gravitationelle s’écrit,

F = −mgêz , (1.2)

où êz est un vecteur unitaire pointant dans la direction de l’axe-z, m est la masse du caillou, et g = 9.8 m
s−2 . On en déduit que a ≡ a â = g (−êz ), et la position d’un corps relaché d’une hauteur z0 est donnée
par la petite équation qu’on vous a fait mémoriser au secondaire :
a
z(t) = z0 + v0 t + t2 , (1.3)
2

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

2 CHAPITRE 1. LA PHYSIQUE NUMÉRIQUE

où v0 est la vitesse initiale du corps, nulle ici pour la situation considérée. Les équations (1.2)—(1.3)
définissent un modèle de la chute d’un corps. C’est un modèle parce qu’à partir de l’éq. (1.1) nous
avons fait certains choix arbitraires (e.g., le choix des coordonnées cartésiennes), et surtout plusieurs
approximations :
1. La gravité pointe exactement vers le bas ;
2. La gravité est supposée constante, à une valeur g = 9.8 m s−2 ;
3. La seule force agissant sur le corps est la gravité.
La première approximation s’avère excellente, et ce même si vous êtes aux environs du Mont Everest
ou collé sur le plus sphérique de vos mononcles ; la seconde ne tient que si le corps est relâchée d’une
hauteur beaucoup plus petite que le rayon terrestre ; et la troisième devient rapidement mauvaise dès que
le corps atteint une vitesse de quelques dizaines de mètres par secondes (ce qui ne prendra que quelques
secondes !), après quoi la résistance de l’air représente une force de grandeur comparable à la gravité. La
prise en considération de cette force demanderait, au minimum, la spécification de la forme du corps, et
une connaissance de la densité et coefficient de viscosité de l’air.
Un modèle est donc une représentation approximative de la réalité, basée sur des théories qui se veulent
exactes (jusqu’à preuve du contraire). Théories et modèles n’ont pas nécessairement besoin d’être expri-
més mathématiquement, mais depuis Galilée, en physique les deux habituellement le sont. Les équations
mathématiques décrivant le modèle peuvent être solutionnées analytiquement, comme pour le mouvement
rectiligne uniformément accéléré considéré ci-dessus, mais pour un modèle le moindrement complexe ces
équations doivent le plus souvent être solutionnées numériquement sur ordinateur.

1.2 Les algorithmes

De façon générale, un algorithme est une suite finie et non ambiguë d’opérations ou d’instructions
permettant d’accomplir une tâche voulue. Par exemple, une recette de gâteau constitue un algorithme,
tout comme l’ensemble d’instructions données par Google Maps pour se rendre du point A au point B.
Dans le contexte du calcul scientifique, un algorithme est une séquence finie d’étapes conduisant
au calcul numérique d’une quantité d’intérêt. Considérons par exemple l’algorithme suivant, qui sert à
calculer un estimé du nombre irrationnel π :
1. Initialiser la variable s à la valeur 0 ;
2. Générer deux nombre aléatoires – r1 , r2 – entre zéro et un ;
3. Si r12 + r22 ≤ 1, alors ajouter 1 à s ;
4. Répéter 106 fois les étapes 2 et 3 ;
5. Calculer 4 × s/106 , qui donne l’estimé de π voulu.
Étudiez bien la structure générale : on initialise les variables du problème (ici s = 0), ensuite des
groupes d’opérations mathématiques ou logiques sont effectuées séquentiellement (étapes 2 et 3) de manière
répétées (ici un million de fois), conduisant à un résultat final (étape 5), ici un estimé de π. Remarquez
également que certaines opérations (étape 3) ne sont pas effectuées à toutes les itérations du processus
répétitif.
Un algorithme n’est ni une théorie, ni un modèle dans le sens décrit précédemment. C’est une “recette”
complètement déterministe consistant en une séquence d’étapes à exécuter l’une à la suite de l’autre. Il
existe évidemment une théorie derrière cette approche plutôt bizarre au calcul de π, mais elle n’est pas
particulièrement évidente ici (elle le deviendra au chapitre 5).

1.3 La programmation
La programmation consiste à exprimer un algorithme sous une forme déchiffrable par l’ordinateur.
C’est habituellement un processus en trois étapes : l’algorithme est d’abord écrit en un langage de
programmation sujet à des règles syntaxiques spécifiques ; le code source ainsi produit est ensuite
compilé ou interprété, selon le langage de programmation utilisé, c’est-à-dire traduit en instructions
spécifiques à l’architecture du processeur de calcul de l’ordinateur ; et les instructions ainsi produites sont
finalement exécutées. Le petit bout de code source suivant correspond à une implémentation en langage
Python de notre algorithme de calcul de π :

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 1.3. LA PROGRAMMATION 3

Code Python pour un calcul de PI par Monte Carlo

1 # Ce programme calcule un estimé de la valeur de pi par Monte Carlo
2

3 # importation de fonctions ou de modules

4 from random import random
5

6 npt=1000000 # nombre de points aléatoires

7 somme=0.
8

9 for i in range(0,npt):
10 x=random() # un nombre aléatoire entre 0 et 1
11 y=random() # et un autre
12 if (x**2 + y**2) <= 1:
13 somme+=1
14

15 estimePi=4*somme/npt
16 print("valeur estimée de pi = {0}".format(estimePi))

Le code source est habituellement “lisible” par un humain familier avec le langage de programmation,
et même si vous ne connaissez encore rien à Python vous devriez être capable d’y reconnaitre les diffé-
rent éléments de notre algorithme. Remarquez l’indentation du bloc d’instructions devant êtres répétées
(lignes 10–13 du code, étapes 2 et 3 dans l’algorithme ci-dessus), et à l’intérieur de ce bloc, l’indentation
additionnelle d’une ligne indiquant l’instruction sujette à une exécution conditionnelle (ligne 13, étape 3
de l’algorithme). De telles indentations sont essentielles en Python, ceci fait partie des règles syntaxiques
de ce langage de programmation ; nous y reviendrons aux deux prochains chapitres et en labo. Notez
également que la fonction random est une fonction prédéfinie que l’on doit importer à partir d’un module
nommé random (en général les fonctions ne portent pas le même nom que le module dans lequel elles
sont définies, mais cela peut arriver comme ici). La fonction random produit un nombre réel aléatoire
dans l’intervalle semi-fermé [0, 1), tel que requis pour notre algorithme. Il existe toute une batterie de
ces fonctions prédéfinies à travers plusieurs modules ; nous reviendrons également sur l’importation de
fonctions et de modules aux deux prochains chapitres et en labo.
Sur mon ordinateur portable MAC, l’exécution du code source ci-haut produit, après environ 0.6
seconde, la sortie suivante :
valeur estimee de pi = 3.142452
ce qui approxime bien π (= 3.1415926536...) à 0.04% près. Comme vous pouvez certainement l’imaginer,
un algorithme donné peut s’exprimer de différentes manières même si écrit dans le même langage de
programmation. C’est comme au primaire, quand on vous demandait une production écrite de 10 lignes
sur Le Brontosaure ; votre texte pouvait bien dire essentiellement la même chose que celui d’un(e) de
vos petits(es) camarades, mais son style était assurément différent, et certains styles se lisent mieux que
d’autres. Il y a également des styles en programmation, qui souvent visent un compromis entre la lisibilité
du code source, la modularité, et la vitesse d’exécution du code une fois compilé. Par exemple, le code
suivant produit exactement la même sortie que le précédent en seulement ∼0.036 seconde, mais est un
peu plus opaque pour un(e) débutant(e) :
Code Python pour un calcul de PI par Monte Carlo
#Ce programme calcule un estimé de la valeur de pi par Monte Carlo
import numpy as np
npt=1000000
estimePi=4*[Link]((([Link](npt)**2+[Link](npt)**2) <= 1))
print("valeur estimée de pi = {0}".format(estimePi))

Personnellement, c’est plutôt comme ça que j’aurais tendance à coder l’algorithme (quoique j’y ajou-
terais certainement quelques explications en commentaires). Comme en littérature ou en musique, le goût
personnel y est également pour quelque chose. Nous aurons l’occasion de revenir sur les questions stylis-
tiques au fil des chapitres qui suivent. Au niveau du “ligne-par-ligne”, le calcul scientifique revient souvent

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

4 CHAPITRE 1. LA PHYSIQUE NUMÉRIQUE

à encoder, utilisant les règles syntaxiques du langage utilisé, des équations mathématiques exprimant des
lois physiques 1 . Tous les opérateurs arithmétiques de base y trouvent leur pendant, parfois direct, comme
les symboles “+” et “−” pour les additions et soustractions, parfois via un symbole différent, comme, en
Python, l’utilisation du “∗” pour la multiplication, le “/” pour la division, et le “**" pour l’exponentiation.

1.4 Représentations numériques

Sans trop entrer dans le détail de la manière dont les ordinateurs encodent l’information dans leur
mémoire ou sur disque, il importe d’examiner un peu la représentation numérique des nombres, car celle-ci
peut avoir des impacts importants sur la solution de problèmes physiques sur ordinateurs.
Sur la majorité des ordinateurs, la représentation numérique se limite à deux grandes classes de “nom-
bres” : les entiers et les réels. Les premiers sont presque universellement encodés en mode binaire, tel
qu’illustré au Tableau 1.1. Chaque position dans la chaine de “0” et “1” est appelée un bit, et 8 bits
forment on octet (l’anglicisme byte étant souvent utilisé). Le bit le plus à droite correspond au nombre
20 , le suivant en se déplaçant vers la gauche correspond à 21 , et ainsi de suite. Le bit le plus à gauche est
utilisé pour encoder le signe de l’entier : 0 ≡ +, 1 ≡ −.

Table 1.1 – Représentation binaire (32-bits) de quelques entiers bien connus

0 000000000000000000000000000000
1 000000000000000000000000000001
2 000000000000000000000000000010
3 000000000000000000000000000011
4 000000000000000000000000000100
5 000000000000000000000000000101
. .
68 000000000000000000000001000100
. .
143 000000000000000000000010001111
. .
. .

La représentation numérique des entiers est donc exacte, cependant selon l’architecture du processeur
de calcul de l’ordinateur et/ou le langage de programmation utilisé, la longueur de la chaîne de bits
pouvant définir un entier peut être limitée, ce qui pose une limite supérieure à sa grandeur possible. Par
exemple, pour une limite à 32 bits, l’entier le plus grand est 231 − 1 (= 2147483647), pour 64 bits c’est
263 − 1, etc. Avec Python, la taille des entiers n’est pas limitée.
Les nombres réels sont également encodés en utilisant une chaîne de bits, mais les bits en questions ne
sont plus une simple expression en base-2 comme ci-haut. Un nombre réel (“float”, pour “floating-point
number”, en anglais) est d’abord généralement (mais pas toujours) exprimé comme

(−1)S × (1 + M ) × bE−e , (1.4)

où S est un bit encodant le signe +/−, 0 ≤ M < 1 est la mantisse (ou la significande), b est un entier
représentant la base, E est l’exposant encodé comme un entier, et e est un entier de décalage de l’exposant
ayant une valeur pré-établie pour une architecture donnée (en général e ≡ 127 en mode 32-bits et e ≡ 1023
en 64-bits, ce qui est le défaut en Python pour une variable de type “float”). Notez que la quasi-totalité
des architectures utilisent b ≡ 2, et, comme e, ceci est une constante pré-établie et donc qui n’a pas besoin
d’être incluse explicitement dans l’encodage d’un nombre réel. La longueur de la chaine de bits définissant
la mantisse M est en général restreinte à 23 en mode 32-bits et à 52 en mode 64-bits. La mantisse est
habituellement encodée en fraction binaire, c’est-à-dire que le n-ième bit de la mantisse représente la valeur
2−n . Chacune des chaines de bits représentant S, E et M sont concaténées en une seule longue chaine
de bits, S:E:M , qui est alors la représentation interne du nombre réel. Par exemple, en mode 32-bits la
1. Le tout premier langage de programmation scientifique avait d’ailleurs été baptisé FORTRAN, pour “FORmula
TRANslation.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

1.5. L’ANALYSE NUMÉRIQUE 5

charge électrique élémentaire,

q = 1.602177 × 10−19 C , (1.5)
pourrait s’encoder comme, 2
S=0, M = 0.4777474(539891875) , b=2, E = 64 . (1.6)
Contrairement à la représentation des entiers, la représentation des réels n’est pas exacte car elle est
sujette à une erreur d’arrondissement. Dans l’exemple précédent encodé en base 2, nous sommes forcés
de tronquer (ou d’arrondir) M à ∼7 chiffres décimaux pour être en mesure de l’encoder en fraction binaire
dans la chaîne de bits correspondant à la mantisse dont la longueur est limitée à 23 en mode 32-bits ; les
chiffres contenus dans la parenthèse ci-haut sont donc “perdus’ et il en résulte une perte de précision à un
niveau relatif de < −7
∼10 . Ces erreurs d’arrondissement (ou précision numérique limitée) peuvent avoir des
effets indésirables pour des applications en physique numérique, il est important d’y porter attention ! De
plus, comme l’encodage de l’exposant E est également sujet à une limite sur la taille de la chaine de bits
le représentant (8 en 32-bits, 11 en 64-bits), il existe une grandeur maximale (et minimale) aux nombres
réels pouvant être représentés.
Vous ferez très bientôt connaissance (si ce n’est pas déjà fait) avec les nombres dits complexes ; ces
derniers sont simplement représentés comme deux réels, le second correspondant à la partie imaginaire
du nombre complexe, et le premier à sa partie réelle.

1.5 L’analyse numérique

L’analyse numérique est une branche des mathématiques dédiée à l’analyse mathématique de diverses
propriétés importantes des algorithmes : précision, taux de convergence, stabilité, etc. C’est un sujet
immense, que nous ferons qu’effleurer occasionnellement dans ce cours. Dans notre exemple du calcul
d’un estimé de π, l’analyse numérique nous permettrait (entre autre) de prédire le nombre d’itérations
requises du processus de calcul de π pour atteindre un niveau de précision spécifié a priori pour notre
estimé. Plusieurs cours sont offerts sur le sujet au département de mathématique, et si vous vous mettez
sérieusement à la simulation numérique en physique, vous aurez intérêt à approfondir ce sujet.

1.6 La physique numérique

Qu’est-ce donc que la physique numérique ? On a l’habitude de compartimenter la physique en
blocs associés à des théories comme “l’électromagnétisme”, “la relativité”, “la mécanique quantique”, “la
thermodynamique”, etc. Cette tendance est par ailleurs très fortement reflétée dans la structure de cours
de votre Bac en physique ! La physique numérique ne cadre pas très bien dans cette structure, puisqu’elle
consiste plutôt en une approche à la formulation des problèmes physiques, et à leur solution. Tout ceci
peut vous paraitre ésotérique à ce stade, mais d’ici la fin du cours vous devriez avoir saisi de quoi il en
ressort.

1.7 Pourquoi le Python ?

Python est un langage de programmation générale de haut-niveau créé par Guido van Rossum en
1989 ; il tire son nom de la série télévisée Monty Python dont l’auteur était adepte. Dans le cadre du cours
PHY 1234, le choix de ce langage est motivé principalement par les éléments suivants :
• Python est gratuit et est directement portable sur la plupart des plates-formes informatiques (Mac
OS X, Windows, Linux).
• Python est un langage très moderne à la popularité grandissante, autant dans la communauté
scientifique, dans l’industrie, que chez les enthousiastes de l’informatique.
• Python est facile à apprendre et très bien adapté pour une introduction à la programmation in-
formatique. Sans être une boîte noire, il permet de parvenir plus rapidement à exécuter des tâches
complexes dans divers domaines.
2. M est ici exprimé en fraction décimale, mais en pratique dans la mémoire de l’ordinateur la mantisse serait encodée
sous forme de fraction binaire et la chaîne de 23 bits correspondante serait 01111010010011011010100.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

6 CHAPITRE 1. LA PHYSIQUE NUMÉRIQUE

• Python favorise une bonne lisibilité du code, et sa syntaxe, simple, permet d’exprimer des concepts
en moins de lignes de code qu’il ne le serait possible dans d’autres langages tels que le C.
• Python jouit d’une très grande bibliothèque de modules fournissant des outils pour accomplir effica-
cement des tâches dans divers contextes (calculs scientifiques/statistiques, analyse de données, pro-
duction de graphiques/animations, création d’interfaces graphiques, production de contenu HTML,
traitement vidéo/audio, etc.).
• Python peut être utilisé en mode interactif.
• Python supporte autant la programmation structurée que la programmation orientée objet.
• Python est très facile à combiner avec d’autres langages de programmation, comme Fortran, C,
C++, Java, etc.
Pour plus d’information sur le langage Python, vous pouvez consulter le site web [Link], ou
encore son entrée Wikipédia. Notez que même si nous utilisons Python pour les fins de ce cours,
vous apprendrez d’abord et avant tout la logique de la programmation informatique ainsi
que les principaux éléments et concepts propres à la programmation dans tout langage. Vous
serez donc en mesure d’apprendre plus rapidement plusieurs autres langages de programmation lorsque le
besoin se fera sentir. Ceci étant dit, je vous garantis que vous adorerez Python et que vous le réutiliserez
tout au long de votre baccalauréat, et même après.
Un dernier commentaire sur le choix du langage, ou plus précisément sur la version de Python que
nous utiliserons. La 3e version de Python, Python 3, a été introduite en 2008 et représente un changement
majeur par rapport à la version précédente, Python 2. Notamment, certaines fonctions de la librairie de
base et d’autres aspects du langage ont été modifiés de sorte que Python 3 n’est pas rétrocompatible
avec Python 2, c’est-à-dire qu’un script (ou code source) composé selon les normes et fonctions de Python
2 ne pourra être compris et exécuté par l’interprèteur de Python 3, et vice-versa. Plusieurs personnes
ayant construit au fil du temps une banque de scripts personnels continuent donc encore aujourd’hui
à travailler et à développer de nouveaux programmes avec Python 2 plutôt que Python 3. Cependant,
pour quelqu’un qui se lance dans la programmation en Python, sans expérience préalable, l’utilisation de
Python 3 m’apparait un meilleur choix. D’ailleurs de plus en plus d’utilisateurs chevronnés de Python
décident maintenant de faire le saut vers la version 3, et on peut supposer que cette version dominera le
paysage sous peu.
Bon, un dernier dernier commentaire et je m’arrête là-dessus. Même s’il est utile et puissant pour le
calcul scientifique, Python, comme la plupart des langages interprétés, n’est pas le langage de choix pour
effectuer des calculs de “haute-performance" où la rapidité d’exécution doit primer. Pour de tels calculs,
des langages comme le C ou le Fortran sont plus appropriés.

Exercices:

1. Déterminez les valeurs de S, M et E encodant le nombre π = 3.1415926536..., en mode 32-bits

avec b = 2 et e = 127.
2. Calculez le plus grand et le plus petit réel positif pouvant être encodé selon l’éq. (1.4), en mode
32-bits et 64-bits.

Bibliographie:

Les notes que vous avez/aurez en main contiennent toute la matière qui sera couverte en PHY-1234. À
moins d’être déjà absolument et totalement convaincu(e) que vous ne toucherez plus au calcul scientifique
de votre vie (ce qui risque de fort limiter vos options de carrière, soit dit en passant...), le livre suivant
pourrait vous être utile :
Press, W.H., Teukolsky, S.A., Vetterling, W.T., & Flannery, B.P., Numerical Recipes : the Art of
Scientific Computing, Cambridge University Press (1992–2007)
Ce sera fort probablement le premier et dernier dans lequel vous aurez à investir sur ce sujet. Plusieurs
versions du bouquin existent, et ne varient qu’au niveau du langage de programmation utilisé. Dans la
troisième édition (2007) les auteurs ont opté pour le langage C++, un langage basé pour le C mais incluant

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

1.7. POURQUOI LE PYTHON ? 7

des fonctionnalités additionnelles au niveau de la programmation dite “orientée objet”. Mais bon, l’essen-
tiel demeure la présentation des algorithmes, qui peuvent ensuite être programmés dans n’importe quel
langage. Cet ouvrage demeure également inégalé (à mon avis) dans l’équilibre qu’il atteint entre l’analyse
numérique, la conception d’algorithmes simples et robustes, et les bonnes habitudes de programmation.
Plusieurs ouvrages, traitant spécifiquement de modélisation numérique en physique ont été écrits et
les meilleurs souvent réédités au fil des années. Parmi ces grands classiques, l’ouvrage suivant demeure
recommandable :
Gould, H., & Tobochnik, J., An Introduction to Computer Simulation Methods, 3e éd., Addison-Wesley
(2006).
Même si la troisième édition est relativement récente, à bien des points de vue elle conserve la “saveur” de
l’édition originale. À un niveau physique et mathématique plus avancé que celui de ce cours, j’aime bien :
Pang, T., An Introduction to Computational Physics, 2e éd., Cambridge University Press (2006).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

8 CHAPITRE 1. LA PHYSIQUE NUMÉRIQUE

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 9

Chapitre 2

Python : la base

Avant de se lancer dans le vif du sujet du cours, soit différents algorithmes et diverses approches
utiles à la physique numérique, il importe de poser les bases de la programmation en Python, langage que
nous utiliserons pour mettre en application tout ce que nous verrons dans les chapitres suivants. Dans ce
chapitre je présente donc les notions et les commandes de bases en Python, c’est-à-dire les éléments qui
sont indispensables à quiconque veut utiliser ce langage. Le matériel de ce chapitre devrait vous suffire
pour faire vos premiers pas en Python et pour aborder les laboratoires du cours sans problème. Quelques
notions plus avancées seront présentées au chapitre suivant, dans les notes de laboratoire et en classe.
En plus des notes qui vous sont fournies, un bon livre de référence sur Python vous sera certainement
utile pour ce cours et pour vos autres besoins futurs en programmation Python. Il existe peu d’ouvrages
en français, du moins à ma connaissance, mais en voici deux assez intéressants, et de surcroit ils sont
gratuits ! Donc procurez-vous les.

Swinnen, G. Apprendre à programmer avec Python 3, version 5, disponible à [Link]

swi/[Link].
Cordeau, B. & Pointal, L., Une introduction à Python 3, version 1.618c, disponible à [Link]
[Link]/pointal/python:courspython3.

Le premier s’adresse aux débutants les plus néophytes en programmation et se lit très facilement ; il a à
l’origine été conçu pour des élèves du secondaire, mais il demeure tout à fait approprié pour des débutants
de tous âges, même des universitaires ! Le deuxième s’adresse probablement plus aux gens ayant une
certaine base en programmation, sans toutefois avoir de notions de Python ; c’est un livre écrit de façon
très succincte, presque télégraphique. En anglais, je vous recommande :

Langtangen, H.P., A Primer on Scientific Programming with Python, 5e éd., Springer (2016), version
HTML disponible à [Link]
Swaroop, C. H., A byte of Python, disponible à [Link]

Le premier est un livre bien construit et fort approprié pour des étudiants en physique. D’ailleurs, plu-
sieurs exemples sont basés sur des problèmes de nature physique. L’emphase est mise sur le comment
“penser comme un programmeur" et sur l’utilisation de la programmation comme outil pour résoudre
des problèmes. Au-delà de l’enseignement de Python, ce livre traite aussi de plusieurs sujets que nous
verrons dans le cours. Notez que la 4e édition en format PDF est disponible gratuitement à ici 1 , et que
la 3e édition en format PDF est offerte gratuitement sur le site web des bibliothèques de l’Université de
Montréal. Le deuxième livre est une bonne introduction qui s’adresse à un publique plus général ; il est
aussi disponible gratuitement en format électronique à l’adresse indiquée. D’autres livres d’introduction
sont suggérés ici 2 .

Il existe aussi plusieurs tutoriels et ressources en ligne. Je vous encourage à visiter le site et l’excellent
tutoriel interactif Python de Code Academy 3 , ainsi que le tutoriel de Python 3 4 offert par [Link].

1. [Link]
2. [Link]
3. [Link]
4. [Link]

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

10 CHAPITRE 2. PYTHON : LA BASE

Un outil intéressant pour les débutants en programmation est le Python tutor 5 , qui montre de façon
interactive et illustrée ce qui se produit lors de l’exécution d’un script en Python.
Certaines ressources en français pour Python sont compilées ici 6 , vous pouvez y jeter un coup d’oeil.
Notamment, un tutoriel d’introduction à Python en français est offert ici 7 par l’université de Waterloo.

Un dernier conseil : Malgré toutes ces références, vous ferez inévitablement face à certains problèmes
pour lesquels la solution semblera vous échapper. Dans une telle situation, pourquoi ne pas demander de
l’aide “au monde entier” ! Allez-y, tapez simplement vos questions dans Google ! et quelqu’un, quelque part
aura fort probablement déjà répondu à votre question. Et je vous encourage à formuler vos recherches en
anglais, si vous le maitrisez raisonnablement, car ceci augmentera vos chances de tomber sur la réponse
recherchée. Dans le même genre, il y a Stack Overflow 8 , un site de questions-et-réponses pour program-
meurs professionnels et enthousiastes. C’est généralement sur ce site que je trouve moi-même la réponse
à mes questions.

2.1 Notions préliminaires

En termes simples, la programmation est un processus par lequel un utilisateur (vous) commande à
l’ordinateur de faire une série d’opérations sur des données (exécuter un algorithme) afin d’obtenir un
certain résultat désiré. Les opérations commandées par l’utilisateur sont généralement spécifiques à ses
propres besoins et ne sont généralement pas directement faisables à l’aide d’un logiciel standard, d’où
le besoin pour l’utilisateur de “faire son propre programme”. Comme vous (l’utilisateur) ne pouvez pas
parler directement au microprocesseur de votre ordinateur, vous devez lui transmettre vos commandes
par l’intermédiaire d’un interpréteur et dans un langage que l’on appelle langage de programmation, en
l’occurrence ici le langage Python. L’interpréteur Python est essentiellement un logiciel qui comprend le
langage Python et qui est capable de le traduire dans un langage compris par le microprocesseur : le
langage machine. Vous devez donc apprendre à “parler Python”, et vous serez ensuite capable de parler
au microprocesseur par l’intermédiaire de l’interpréteur Python. Comme toute langue écrite, le langage
Python possède un vocabulaire et un ensemble de règles de syntaxe qu’il faut respecter ; c’est ce que nous
verrons dans les sous-sections qui suivent. Mais d’abord, voyons quelques définitions.

Code source Expression d’un algorithme complet dans un langage de programmation. Il s’agit de toute
la série d’instructions nécessaire à l’exécution de l’algorithme, rédigée avec le vocabulaire et les règles de
syntaxe du langage de programmation. Le code source est lisible et compréhensible par l’utilisateur. Le
code source est parfois appelé script, code, ou encore programme, bien qu’on réserve souvent ce dernier
terme pour l’expression de l’algorithme dans un langage compréhensible par le microprocesseur. L’encadré
de la page 3 est un exemple de code source. Le code source est sauvegardé dans un fichier de type “texte”,
dont le contenu représente uniquement une suite de caractères. 9

Fonction Partie autonome d’un code qui accomplit une tâche spécifique. Une fonction est nommée et
invoquée par un identificateur unique. Les fonctions peuvent ou non comporter des arguments à l’aide
desquels les opérations codées dans la fonction seront effectuées. Plusieurs fonctions sont disponibles par
défaut en Python, et on peut en créer de nouvelles. On utilise parfois les termes routine ou procédure pour
désigner une fonction.

Commande Une instruction donnée à l’ordinateur pour qu’il exécute une certaine tâche ou opération.
Le code source est essentiellement formé d’une série de commandes. Les commandes correspondent souvent
à l’invocation de fonctions.

Expression Petite partie de code qui peut être évaluée lors de l’exécution, produisant une valeur. Par
exemple, “a>b” ou “x+10”. Les expressions peuvent être composées et peuvent faire intervenir des fonctions.
5. [Link]
6. [Link]
7. [Link]
8. [Link]
9. Notez qu’un logiciel de traitement de texte tel que Microsoft Word ne sauvegarde pas ses documents dans des fichiers
de type texte.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

2.2. MODES D’EXÉCUTION 11

Objet Dans le cadre de la programmation en Python, il s’agit de la représentation d’une donnée ou

d’un ensemble de données, au sens le plus large du terme. Essentiellement tout en Python est un objet :
les valeurs numériques, les fonctions, les variables, les programmes eux-mêmes, etc. Chaque objet a une
identité (et un identificateur), un type et une valeur.
Identificateur Nom assigné à un objet. Les identificateurs sont utilisés dans les commandes, les fonc-
tions et les expressions pour référer aux objets désirés.
Type Le type d’un objet détermine (i) les opérations que l’on peut faire sur ou avec cet objet, (ii) les
attributs qu’il possède, et (iii) les valeurs possibles qu’il peut prendre. Par exemple un objet peut être de
type int (pour integer qui signifie un nombre entier) ou de type str (pour string qui signifie une chaîne de
caractères). En Python, le type est équivalent à la classe de l’objet. Ce dernier terme est parfois utilisé
pour référer à un type défini par l’utilisateur, par opposition aux types d’objets définis par défaut en
Python, mais cette distinction n’est pas nécessaire.
Attribut Un attribut est un objet lié à un autre objet donné. C’est généralement une variable emma-
gasinant la valeur d’une certaine propriété de l’objet le détenant, ou une fonction permettant de calculer
une de ses propriétés ou de faire une certaine opération sur lui. Lorsqu’une fonction est l’attribut d’un
objet, on dit alors qu’elle est une méthode.
Variable Une valeur (ou un ensemble de valeurs) qui est reliée à un identificateur.

2.2 Modes d’exécution

Avant de poursuivre davantage, il importe de distinguer les deux principaux modes d’utilisation de
Python : mode interactif et mode scripté.

Mode interactif Dans ce mode, l’utilisateur peut taper une commande au clavier pour que l’interpré-
teur Python l’exécute immédiatement et, le cas échéant, affiche le résultat. L’utilisateur peut, à son gré,
enchainer avec une autre commande et accéder immédiatement au résultat, d’où “l’interactivité”. Pour
démarrer Python en mode interactif, il suffit de taper la commande python à l’invite de commande d’une
fenêtre terminal. 10 Après avoir lancé cette commande, un message similaire à celui-ci s’affiche :

Python 3.6.1 |Anaconda custom (x86_64)| (default, Mar 22 2017, 19:25:17)

[GCC 4.2.1 Compatible Apple LLVM 6.0 (clang-600.0.57)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

Les trois caractères >>> marquent l’invite de commande (prompt) de l’interpréteur Python. C’est à cette
invite de commande que l’on peut taper une instruction (et commander son exécution/évaluation en
appuyant sur entrée). Le résultat de l’exécution de la commande (ou de l’évaluation de l’expression)
s’affiche sur la ligne suivante dans la fenêtre du terminal. Pour quitter l’interpréteur Python, tapez la
commande exit() ou la combinaison de touches Ctrl-D.
Il existe une alternative à l’interpréteur Python de base, soit IPython. Pour exécuter IPython, il suffit
de tape la commande ipython dans un terminal. Au lancement de cette commande, un message similaire
à celui-ci s’affiche :

Python 3.6.1 |Anaconda custom (x86_64)| (default, Mar 22 2017, 19:25:17)

Type 'copyright', 'credits' or 'license' for more information
IPython 6.0.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]:

Notez que l’invite de commande n’est plus “>>>”, comme avec l’interpréteur Python de base, mais plutôt
“In [n]:”, où n est le numéro de la ligne d’Input. Le résultat de l’exécution d’une instruction don-
née s’affiche sur la ligne suivante, comme auparavant, sauf qu’avec IPython cette ligne est précédée de
10. Selon la configuration du système utilisé, le nom de la commande pourrait différer légèrement, par exemple il pourrait
être python3.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 12 CHAPITRE 2. PYTHON : LA BASE

“Out [n]:”, pour “Output” (sortie). Mis à part ces petits changements, le fonctionnement est sensible-
ment le même que pour l’interpréteur de base. Les principaux attraits de IPython sont, à mon avis, la
coloration de syntaxe, la possibilité d’exécuter un script (voir mode scripté) à partir du mode interactif à
l’aide de la commande run, l’accès dynamique à l’information d’un object ou d’une fonction donné à l’aide
de la commande ? ou ??, et l’accès aux commandes systèmes à l’aide de la commande !. Par exemple,
la commande ?round affichera l’information sur la fonction round(), ?var affichera l’information sur la
variable var, et la commande !ls exécutera la commande système ls qui affiche le contenu du répertoire
courant. IPython affiche également des messages d’erreurs plus complet lors d’erreur d’exécution d’un
code.
Le mode interactif est utile pour faire rapidement des calculs simples ou pour expérimenter avec de
nouvelles commandes.

Note : Dans ce chapitre des notes, plusieurs exemples seront présentés en répliquant ce que verrait un
utilisateur en mode interactif : les instructions entrées par l’utilisateur apparaitront à droite de l’invite de
commande (>>>) et les résultats de leur exécution apparaitront sur la ligne suivante. En voici un exemple :

1 >>> 5+12
2 17

Mode scripté Dans ce mode, l’interpréteur Python lit et exécute séquentiellement une série d’instruc-
tions enregistrées dans un fichier : le code source. L’usager n’entre pas les instructions une à une, et il
n’intervient pas non plus au cours de l’exécution de l’ensemble des instructions contenues dans le code
source. Ce mode est le plus utilisé 11 car il permet d’automatiser l’exécution de plusieurs opérations plus
complexes, sans avoir à retaper les instructions une à une à chaque fois que l’on veuille faire une modifi-
cation ou répéter leur exécution. Pour exécuter un code en mode scripté, il suffit de taper la commande
python suivie du nom du fichier code source à l’invite de commande du terminal. 12 Par exemple, en
supposant que le code source soit contenu dans le fichier [Link], il faudrait taper la commande “python
[Link]”. Le cas échéant, les résultats seront affichés directement dans le terminal au cours de l’exécution.
Après l’exécution de toutes les instructions du code source, le système revient à l’invite de commande du
terminal.
Pour utiliser le mode scripté, il est possible de travailler avec un logiciel d’environnement de déve-
loppement intégré (ou IDE pour Integrated Development Environment, en anglais). Il s’agit d’un logiciel
qui intègre au minimum un éditeur de texte pour composer un script et différentes fonctionnalités pour
lancer son exécution. Avec la distribution Python Anaconda, le logiciel IDE Spyder est automatiquement
installé, celui-ci inclut un éditeur de texte et intègre l’interpréteur IPython pour exécution des scripts.

Il existe aussi une autre façon d’utiliser Python, qui n’est pas à travers un mode d’exécution propre à
Python, mais plutôt à l’aide de l’application Jupyter Notebook 13 , laquelle peut agir de concert avec Python
pour permettre une utilisation dans un mode que l’on pourrait qualifier d’hybride entre le mode interactif
et le mode scripté. Cette application utilise une interface web pour afficher une séquence ordonnée de
cellules pouvant contenir du code, du texte, des équations, des graphiques, etc. On peut entrer une ou
plusieurs lignes de code (des commandes) dans chaque cellule et exécuter d’un coup toutes les commandes
contenues dans une cellule donnée, dans lequel cas le résultat s’affichera immédiatement sous la cellule.
On peut aussi modifier les commandes de chaque cellule et les ré-exécuter à notre guise. Une illustration
de cette application est montrée à la figure 2.1.
L’aspect interactif de l’application Jupyter Notebook et sa capacité à exécuter en bloc un grand nombre
de commandes, cellule par cellule, la rend très utile pour le développement et le déboggage de nouveaux
codes. De plus, en classe nous ferons souvent des exemples interactifs en utilisant Jupyter Notebook.

11. C’est d’ailleurs le seul mode possible pour plusieurs autres langages de programmation, comme le C, le C++, et le
Fortran.
12. Il est aussi possible d’utiliser la commande ipython.
13. [Link]

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

2.3. IDENTIFICATEURS (NOMS D’OBJETS) 13

Figure 2.1 – Illustration de l’application Jupyter Notebook.

2.3 Identificateurs (noms d’objets)

Tel que mentionné plus haut, l’identificateur est simplement le nom que l’on assigne à une variable
dans un code, ou de façon plus générale c’est le nom que l’on assigne à tout objet Python (variable,
fonction, méthode, classe, etc.). Les règles suivantes s’appliquent aux identificateurs :

1. Un identificateur peut inclure toute combinaison de lettres (sans accent), de chiffres, et le caractère
de soulignement (_). Toutefois, le premier caractère de tout identificateur ne peut pas être un
chiffre.
2. La longueur maximale de chaque identificateur est de 256 caractères.
3. On distingue les majuscule des minuscules ; ainsi, les identificateurs votreNom, VotreNom, et votrenom
réfèrent à trois objets distincts.
4. Python réserve certaines chaînes de caractères pour définir des mots-clés qui jouent un rôle spé-
cifique au niveau de la programmation ; s’il vous vient la brillante idée de définir un identificateur
ayant le même nom, il pourrait vous arriver des choses É-POU-VAN-TA-BLES ! ! Voici une liste
alphabétique de ces mots-clés à éviter comme identificateur :

and del from None True

as elif global nonlocal try
assert else if not while
break except import or with
class False in pass yield
continue finally is raise
def for lambda return

Une bonne pratique stylistique, largement répandue, consiste à nommer les variables et les fonc-
tions par un identificateur commençant par une lettre minuscule, et si plusieurs mots sont joints en-
semble pour former l’identificateur, à commencer chaque mot suivant par une majuscule. Par exemple,
ceciEstUnNomDeVariable. Selon cette convention, les identificateurs des classes commencent par une ma-
juscule, pour les distinguer des variables. Enfin, les constantes numériques (e.g. la variable représentant
la valeur numérique de la constante de Boltzmann) ont un identificateur formé entièrement de majuscules
(e.g. KBOLTZ).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 14 CHAPITRE 2. PYTHON: LA BASE

2.4 Assignation
L’assignation, aussi appelée affectation, est le processus par lequel on crée un lien entre un identificateur
et un objet. Dans le cas simple d’une variable, ceci revient essentiellement à donner un nom et une valeur
à la variable. L’assignation se fait à l’aide de l’opérateur “=” en utilisant la syntaxe suivante :

identificateur = valeur_ou_objet_ou_expression

Cette instruction lie l’identificateur apparaissant à gauche avec la valeur ou l’objet apparaissant à droite.
Si la partie de droite est une expression, alors l’expression est d’abord évaluée et c’est le résultat de cette
évaluation qui est lié à l’identificateur apparaissant à gauche. Voici quelques exemples d’assignations :

1 a=5
2 b=a+10
3 a=a+1
4 c=a

À la ligne 1, on assigne la valeur 5 à l’identificateur a ; à la ligne 2, on évalue d’abord l’expression a + 10

(donc 5 + 10) et on assigne la valeur du résultat (15) à l’identificateur b ; à la ligne 3, on évalue d’abord
l’expression a+1 et on assigne la valeur du résultat (6) à l’identificateur a, écrasant ainsi son lien précédent
vers la valeur 5 ; et enfin à la ligne 4, on assigne un nouvel identificateur (c) à l’objet a, cet objet (valeur
6) porte dorénavant deux identificateurs : a et c.

Il est possible de faire des assignations parallèles (en une seule ligne) en fournissant plusieurs identifica-
teurs séparés par des virgules à gauches du “=” et un nombre correspondant de valeurs/objets/expressions
à droite. En voici un exemple qui permet d’assigner la valeur 5 à a et la valeur 10 à b :

1 a,b=5,10

Vous aurez donc compris qu’en programmation Python (ainsi que dans bien d’autres langages de
programmation), l’opérateur “=” n’a pas le même sens qu’en mathématiques : il ne signifie pas qu’il
y a égalité entre les termes apparaissant à sa gauche et à sa droite. Il s’agit plutôt d’un opérateur
unidirectionnel qui effectue une assignation de l’objet de droite vers l’identificateur de gauche.

Note : Pour qu’un identificateur puisse être utilisé dans une commande, il faut impérative-
ment qu’il ait été défini au préalable par une assignation.

2.5 Types de variables et d’objets

Le type d’un objet et tous les attributs qui lui sont associés sont définis automatiquement lors de la
création de l’objet, qui correspond généralement à l’assignation de l’objet. Python offre plusieurs types
d’objets par défaut et nous ne présentons ici que les principaux en commençant par les types servant
à emmagasiner des données numériques ou alpha-numériques simples, lesquels sont résumés dans le ta-
bleau 2.2.
Pour vérifier le type d’un objet donné, il suffit d’utiliser la commande type(objet_ou_identificateur).
Par exemple :

1 >>> type(5)
2 <class 'int'>
3 >>> a=5
4 >>> type(a)
5 <class 'int'>

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 2.5. TYPES DE VARIABLES ET D’OBJETS 15

2.5.1 Entier (int)

Le type int (pour integer qui signifie entier) sert à emmagasiner des valeurs numériques entières. Les
valeurs de ce type doivent être écrites sans point et peuvent être précédées d’un signe plus (+) ou moins
(−). Les représentations suivantes sont des entiers valides :

1 12
2 0
3 -2345
4 9999999999

Toutefois 1 234 ou 1,234 ne sont pas valides.

La représentation des valeurs entières est exacte et leur taille n’est limitée que par la mémoire de
l’ordinateur. 14

2.5.2 Réel (float)

Le type float sert à représenter des valeurs numériques réelles. Le nom de ce type provient de l’ex-
pression floating point, qui réfère au fait que l’on puisse placer le point décimal à divers endroits par
rapport aux chiffres formant un nombre, selon la base et l’exposant choisis pour le représenter. En nota-
tion standard, les valeurs de ce type doivent obligatoirement être écrites avec un point décimal (la virgule
n’est pas acceptée). La notation scientifique (en base 10) est aussi permise, en précédant l’exposant d’un
E ou d’un e. Par défaut, toutes les variables de ce type ont une précision finie correspondant à 64 bits.
Voici quelques valeurs réelles valides :

1 12.
2 12E4
3 12e-4
4 1.234

2.5.3 Complexe (complex)

Le type complex sert à représenter des nombres complexes. Les valeurs complexes sont écrites en
notation cartésienne, qui consiste en une partie réelle et une partie imaginaire, laquelle est terminée par
un j ou un J, les deux parties étant séparées par un + ou un −. Au niveau interne, ces deux nombres
sont traités comme des variables réelles et possèdent donc les limites et les propriétés décrites dans la
section précédente. Toutefois, les opérations numériques appliquées aux nombres complexes suivent les
règles mathématiques complexes. Voici quelques valeurs complexes valides :

1 12. + 3.0J
2 12E4 - 0.04j
3 21.887e+3J + 12e-4

2.5.4 Booléen (bool)

Le type bool permet seulement deux valeurs : True ou False (vrai ou faux). Ce type est utilisé pour
exprimer les résultats de vérifications logiques (par exemple, est-ce que a est plus petit que b ?). Les
données de type bool peuvent être combinées au sein d’expressions à l’aide des opérateurs logiques not,
and et or, que nous verrons plus loin.

14. Ce n’est pas le cas dans la plupart des autres langages de programmation, pour lesquels les valeurs entières sont
représentées à l’aide d’un nombre fixe de bits, ce qui limite le domaine des valeurs représentables.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 16 CHAPITRE 2. PYTHON : LA BASE

2.5.5 Chaîne de caractères (str)

Le type str (pour string) sert à représenter une séquence de caractères Unicode. Les valeurs de ce type
de variables sont écrites en les insérant entre deux apostrophes (’) ou entre deux guillemets ("). On peut
aussi définir une chaîne de caractères multi-lignes à l’aide des triple guillemets. Voici quelques valeurs de
chaînes de caractères valides :

1 'allo'
2 'Bonjour le monde!'
3 "Bonjour le monde!"
4 "L'écriture d'apostrophes"
5 'Écriture de "guillemets"'
6 """Une chaîne
7 de caractères formée de
8 trois lignes"""

À l’intérieur d’une chaîne de caractères, le caractère “\” donne une signification spéciale à certaines
séquence de caractères ; ces “séquences d’échappement” sont présentées à la table 2.1. Certaines de celles-ci
ont un effet visible seulement lors de l’affichage de la chaîne à l’écran.

Table 2.1 – Séquences d’échappement des chaînes de caractères

Séquence Signification
\\ affiche un antislash
\’ apostrophe
\" guillemet
\a sonnerie (bip)
\b retour arrière
\f saut de page
\n saut de ligne
\r retour en début de ligne
\t tabulation horizontale
\v tabulation verticale
\N{nom} caractère sous forme de code Unicode nommé
\uhhhh caractère sous forme de code Unicode 16 bits
\Uhhhhhhhh caractère sous forme de code Unicode 32 bits
\ooo caractère sous forme de code octal
\xhh caractère sous forme de code hexadécimal

2.5.6 Liste (list) et Tuple (tuple)

Le type list permet d’emmagasiner une séquence ordonnée et modifiable d’objets de toutes sortes.
On dit qu’un tel objet est un conteneur, puisqu’on peut y placer plusieurs objets. Pour spécifier une liste,
on doit écrire chaque élément séparé par une virgule et entourer le tout de crochets, comme dans les
exemples ci-bas :

1 [5,49,17]
2 ['Bonjour','le','monde!']
3 [24,'heures']
4 [12. + 3.0J, True, 22, a, x, 'test', [4,5,6]]
5 ['A']
6 []

Notez que chaque élément d’une liste peut être n’importe quel objet, de tous les types. On peut aussi
créer une liste vide, comme montré à la dernière ligne ci-dessus. Les liste sont modifiables, c’est-à-dire que

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 2.5. TYPES DE VARIABLES ET D’OBJETS 17

l’on peut changer leur contenu comme bon nous semble : changer la valeur de ses éléments, ajouter ou
retirer des éléments, changer l’ordre de ses éléments, etc. On peut accéder à chaque élément d’une liste à
l’aide d’indices spécifiants leur position dans la séquence ordonnée. Nous verrons comment faire un peu
plus tard.
Un objet de type tuple est essentiellement la même chose qu’une liste, à la différence qu’il n’est pas
modifiable : on ne peut pas changer la valeur de ses éléments ou ajouter/retirer des éléments. Une fois
créé, un tuple est immuable. Pour spécifier un tuple, on doit écrire chaque élément séparé par une virgule
et entourer le tout de parenthèses, comme dans les exemples ci-bas :

1 (5,49,17)
2 ('Bonjour','le','monde!')
3 (24,'heures')
4 (12. + 3.0J, True, 22, a, x, 'test', [4,5,6])
5 (2,)

Notez que pour définir un tuple d’un seul élément il faut obligatoirement écrire la virgule après celui-ci
(ligne 5), sans quoi les parenthèses marqueraient uniquement une priorité dans l’ordre d’évaluation d’une
expression. L’intérêt du tuple, par rapport à la liste, est qu’il conduit à une exécution plus rapide du
programme ; on a donc avantage à l’adopter si on n’a pas besoin de modifier les éléments d’une séquence
donnée.
Table 2.2 – Sommaire des types d’objets de base

Type d’objet Exemples

Entier 4893774, −546 aussi long que nécessaire
Réel 2.34, 1.034E−4, 8.1e+232 jusqu’à ≈1e±308
Complexe 3.0 + 4j, 5.23J + 17.67 pas d’espace entre chiffre et “j” ou “J”
Booléen True, False
Chaîne de caractères 'chaine', "L'autre"
Liste [1,10,’element’], [’A’]
Tuple (1,10,’element’), (’A’,)

2.5.7 Transformation de type

Des fonctions sont disponibles pour convertir un objet ou une variable d’un certain type vers un autre,
ou pour forcer le résultat d’une opération à prendre un certain type voulu. Les fonctions de conversion
principales sont int(), float(), complex(), bool(), list(), et tuple(). Une opération faite à l’aide de
ces fonctions est appelée conversion forcée. Par exemple, pour convertir une variable de type réel vers le
type entier, on fera,

1 >>> int(15.4 + 23.345 + 11.2212)

2 49

Le résultat produit (49) est de type entier.

2.5.8 Autres types par défaut

Bien que nous n’en ferons pas usage dans le cadre du cours, les types d’objet par défaut suivants
peuvent être très utiles pour certaines applications. Une très brève description est fournie ici par souci de
complétude.
set Ensemble non-ordonné d’objets uniques. Ces ensembles supportent les opérations mathématiques
d’union, d’intersection et de différence. Utile pour vérifier l’appartenance d’un objet à un ensemble
donné. Défini à l’aide des caractères {}, chaque élément étant séparé par une virgule, par exemple
s={’bleu’,’rouge’,’vert’}.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 18 CHAPITRE 2. PYTHON : LA BASE

dict Ensemble non-ordonné de paires “clé–objet”, où clé est un identifiant unique (généralement une
chaîne de caractères ou un chiffre) qui est utilisé pour accéder à l’objet auquel il est lié. Ce type d’objet
tire son nom du mot “dictionnaire”. Défini à l’aide des caractères {}, chaque paire étant séparée par
une virgule, et la clé et l’objet d’une paire étant séparés par un deux-points. Par exemple le dictionnaire
d={’nom’:’Mathieu’, ’age’:30, ’taille’:180.} contient trois paires clé–objet, le deuxième objet
(30) pouvant être accédé à l’aide de la clé “age” : d[’age’].
bytes Séquence ordonnée d’octets unitaires (i.e. une séquence d’entiers entre 0 et 255, ou une séquence
de caractères ASCII).

2.6 Opérateurs de base

2.6.1 Opérateurs arithmétiques
On peut faire la plupart des opérations arithmétiques de base sur des valeurs numériques à l’aide
des opérateurs présentés à la table 2.3. Les règles de priorité des opérateurs suivies par Python sont les
règles conventionnelles. Les multiplications et divisions, par exemple, sont appliquées avant les opérateurs
d’addition et de soustraction. En dépit de ces règles, c’est une bonne idée d’ajouter des parenthèses
afin d’indiquer clairement l’ordre des opérations qui doivent être faites. En plus de prévenir les erreurs,
l’utilisation de parenthèses rend l’algèbre plus facile à suivre pour le programmeur.

Table 2.3 – Opérateurs arithmétiques de base

Type Symbole Expression

Addition + a+b
Soustraction − a−b
Multiplication ∗ a∗b
Division réelle / a/b
Division entière // a//b
Modulo (reste) % a%b
Puissance ∗∗ a ∗ ∗b

Notez bien la distinction entre les deux types de division : la division réelle (/) retourne toujours
un nombre réel correspondant à la valeur “exacte” de la division, alors que la division entière retourne
l’entier inférieur le plus près de cette valeur exacte, son type dépendra alors des types des variables avec
lesquelles la division est faite. Voici quelques exemples d’opérations arithmétiques de base et leur résultat
correspondant :

1 >>> 5+2
2 7
3 >>> 5+2.
4 7.0
5 >>> 5/2
6 2.5
7 >>> 6/2
8 3.0
9 >>> 5//2
10 2
11 >>> 5.//2
12 2.0
13 >>> -5.//2
14 -3.0

Promotion numérique : Afin de ne pas perdre d’information lorsqu’une opération est exécutée sur des
valeurs de types différents, Python promeut le type le plus bas vers le type le plus haut avant de faire
l’opération, selon l’ordre de priorité suivant : complex, float, int, bool. Ainsi, si on additionne un

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

2.6. OPÉRATEURS DE BASE 19

nombre de type int et un nombre de type float, alors le nombre int est converti en float avant de
calculer l’addition et le résultat sera un nombre de type float (lignes 3–4 de l’exemple ci-haut). De plus,
la division réelle de deux nombres de type int les promeut d’emblée vers le type float et produira un
résultat de type float, afin de ne pas “perdre” la partie décimale résultant de la division (lignes 5–6).
Vous aurez sans doute noté la présence du type bool dans la liste de priorité de promotion donnée
ci-haut, la raison est qu’il est bel et bien possible de faire des opérations arithmétiques avec des variables
booléennes. Dans ce cas, Python interprète la valeur True comme étant un entier valant 1, et la valeur
False comme étant un entier valant 0 ; les règles standards mentionnées ci-haut s’appliquent ensuite.
Ainsi, l’opération 2.3*False produira le résultat 0.0 de type float.
Il existe des opérateurs additionnels qui combinent une opération arithmétique à une opération d’as-
signation, ceux-ci sont indiqués à la table 2.4. On peut ainsi de façon succincte modifier la valeur d’une
variable existante en lui appliquant une opération arithmétique.

Table 2.4 – Opérateurs arithmétiques additionnels (on prend int a=3, i.e. un entier)

Opérateur Exemple Signification Résultat

d’expression (au moment de l’opération)
+= a+ = 3; a = a + 3; a=6
−= a− = 3; a = a − 3; a=0
∗= a∗ = 2; a = a ∗ 2; a=6
/= a/ = 2; a = a/2; a = 1.5
// = a// = 2; a = a//2; a=1
%= a% = 2; a = a%2; a=1
∗∗ = a ∗ ∗ = 2; a = a ∗ ∗2; a=9

2.6.2 Opérateurs logiques

Trois opérateurs logiques sont disponibles pour comparer des valeurs booléennes : not, and et or.
L’opérateur not est unaire, c’est-à-dire qu’il agit sur une seule valeur (True ou False), la transformant
vers l’autre valeur possible (resp. False ou True). La syntaxe pour inverser ainsi la valeur d’une variable
booléenne x est “not x”. Les deux autres opérateurs sont binaires et agissent selon la table 2.5.

Table 2.5 – Opérateurs logiques binaires et leur effet

a b a or b a and b
False False False False
False True True False
True False True False
True True True True

Lors d’une opération logique, la valeur zéro sous toutes ses formes (0, 0.0, 0.0+0.0j) est considérée
comme valant False ; toutes les autres valeurs numériques sont considérées comme valant True.

2.6.3 Opérateurs relationnels (de comparaison)

Les opérateurs relationnels permettent de comparer la valeur de deux variables et retournent un
résultat de type bool. Ils sont décrits dans le tableau 2.6.
Attention : Il ne faut pas confondre l’opérateur relationnel “==” avec l’opérateur d’affectation “=”. C’est
une erreur assez commune qui peut causer une bonne perte de temps lors du développement d’un code.
Notez également que, comme pour une opération arithmétique, on convertit le type d’une des deux
variables en suivant les règles de promotion décrites ci-dessus avant de faire une comparaison. Ainsi, avant
de comparer une variable de type float à une de type int, Python convertit la variable de type int à
float. Ces règles peuvent parfois causer des résultats inattendus, soyez vigilants !

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 20 CHAPITRE 2. PYTHON: LA BASE

Table 2.6 – Opérateurs relationnels. (On prend x = 2, y = 4 et z = [2, 5, 8].)

Opérateur Exemple Signification Valeur

d’expression
== x == y égal à False
!= x != y non égal à True
> x> y plus grand que False
< x < y plus petit que True
>= x >= y plus grand ou égal à False
<= x <= y plus petit ou égal à True
is x is y est le même objet que False
is not x is not y n’est pas le même objet que True
in x in z est un élément de True
not in x not in z n’est pas un élément de False

2.6.4 Opérateurs de chaînes de caractères, de listes et de tuples

Les chaînes de caractères (type str), les listes (type list) et les tuples (tuple) sont trois types d’objets
qui correspondent à des séquences ordonnées d’éléments. Pour une chaîne, les éléments individuels de cette
séquence sont les caractères qui la forment, alors que pour une liste/un tuple ce sont les objets qui la/le
forment. Cette propriété commune leur confère certains opérateurs communs : +, * et [].
L’opérateur + agissant sur deux chaînes de caractères, deux listes ou deux tuples produit leur conca-
ténation 15 , alors que l’opérateur * agissant sur une chaîne/liste/tuple et un entier, disons N , concatène
N répétitions de la chaîne/liste/tuple. Ces opérations sont illustrées dans les exemples suivants.

1 >>> 'Bonjour'+'Monde'
2 'BonjourMonde'
3 >>> 'Bonjour'*3
4 'BonjourBonjourBonjour'
5 >>> [2,3]+['Trou','Noir']
6 [2, 3, 'Trou', 'Noir']
7 >>> [2,3]*4
8 [2, 3, 2, 3, 2, 3, 2, 3]

L’opérateur [] est plus particulier, il permet d’accéder à un ou plusieurs éléments de la séquence pour
en obtenir la/les valeur(s) ou en assigner une(de) nouvelle(s). 16 À l’interne, Python assigne un indice
numérique (un nombre entier) à chaque élément de la séquence, en commençant par 0 pour le premier, 1
pour le deuxième, et ainsi de suite. C’est avec ces indices et l’opérateur [] que l’on peut accéder à un ou
plusieurs éléments d’une séquence.
Pour accéder à un seul élément, la syntaxe est la suivante : a[i], où a est l’identificateur de la séquence
et i est l’indice de l’élément désiré. Un indice négatif indique que l’on compte à partir de la fin.
Pour accéder à plusieurs élément adjacents, une sous-séquence ou une “tranche”, la syntaxe est la
suivante : a[i:j], où i est l’indice du premier élément désiré et j est la position du dernier élément désiré
(attention : le deuxième chiffre est la position et non l’indice du dernier élément désiré), de sorte que j − i
donne le nombre d’éléments dans la sous-séquence correspondante. On peut omettre l’un ou l’autre de
i ou j, ou les deux, dans lequel cas la sous-séquence va jusqu’au début ou jusqu’à la fin de la séquence
originale. Ces opérations sont illustrées dans la figure 2.2 et dans les exemples suivants.

1 >>> s=[1,2,3,4,5]
2 >>> s[3]
3 4
4 >>> s[3]=8
5 >>> s
15. mise bout à bout et liaison en une seule séquence
16. Sauf pour les tuples, qui sont immuables.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 2.7. ENTRÉES ET SORTIES STANDARDS 21

Figure 2.2 – Indexation d’une chaîne de caractères. Figure tirée de Cordeau et Pointal (Une introduction
à Python 3).

6 [1, 2, 3, 8, 5]
7 >>> s[1:4]
8 [2, 3, 8]
9 >>> s[-2:]=50,100
10 >>> s
11 [1, 2, 3, 50, 100]
12 >>> s[:]
13 [1, 2, 3, 50, 100]

2.7 Entrées et sorties standards

Selon le contexte, l’utilisateur peut avoir besoin d’interagir avec le programme, soit pour lui fournir
une valeur (une entrée) ou pour recevoir un résultat (une sortie). Par entrée “standard” on réfère à une
valeur entrée directement au clavier par l’utilisateur et transmise au programme, et par sortie “standard”
on réfère à un affichage à l’écran de la valeur d’une certaine variable ou expression (dans la fenêtre du
terminal).
La sortie standard se fait avec la fonction print(). Cette fonction affiche à l’écran une représentation
textuelle de l’objet/l’expression qui lui est fourni en argument. On peut fournir plusieurs arguments en
les séparant par une virgule. Voici quelques exemples d’utilisation de cette fonction :

1 >>> print('Bonjour!')
2 Bonjour!
3 >>> a,b=5,6
4 >>> print("a<b=",a<b)
5 a<b= True
6 >>> print("J'ai",5*' très','faim!')
7 J'ai très très très très très faim!

L’entrée standard se fait avec la fonction input(). Cette fonction interrompt l’exécution du pro-
gramme, affiche une invite à l’écran et attend que l’utilisateur entre une chaîne de caractères au clavier
et la valide en appuyant sur entrée. L’argument optionnel de cette fonction est le message à afficher au
moment de l’exécution de la commande, i.e. l’invite présentée à l’utilisateur pour qu’il entre quelque chose
au clavier. La valeur retournée par la fonction input() est toujours de type str (chaîne de caractères) ; si
on désire obtenir un chiffre, il faut convertir cette valeur vers le bon type (par exemple en entier ou réel).
Voici quelques exemples d’utilisation de cette fonction :

1 >>> nom=input('SVP entrez votre nom: ')

2 SVP entrez votre nom: David
3 >>> print(nom)
4 David
5 >>> a=input('SVP entrez un nombre: ')
6 SVP entrez un nombre: 225
7 >>> x=int(a)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 22 CHAPITRE 2. PYTHON : LA BASE

8 >>> print('2x'+a+'=',2*x)
9 2x225= 450

2.8 Le contrôle du flux d’instructions

Dans bien des situations de programmation que nous rencontrerons, nous aurons besoin d’instructions
permettant de contrôler l’exécution de certaines instructions ou de certains blocs d’instructions sur la
base de critères qui dépendent de la valeur de variables calculées durant l’exécution du code même, et
donc qui ne peuvent être posées a priori au moment de l’écriture du code source. Ce sont les instructions
dites conditionnelles. Également, la répétition d’une instruction ou d’un bloc d’instructions est un des
éléments de programmation les plus courants, que l’on appelle boucle de répétition. Le langage Python
permet de définir deux types de boucles, en fonction de la manière dont le contrôle de la répétition est
effectué. Les instructions requises pour effectuer ces opérations sont présentées dans cette section.

2.8.1 L’instruction conditionnelle if ...

Le canevas général d’une instruction conditionnelle simple a la forme :
if condition:
␣␣␣␣instruction1
␣␣␣␣instruction2
␣␣␣␣...
où condition est généralement une expression logique découlant d’une comparaison de variables, ou de
plusieurs comparaisons de variables combinées avec des opérateurs logiques. En fait, n’importe quelle
expression qui prend une valeur logique (booléenne) True ou False constitue une condition valable. De
plus, souvenez-vous que Python assigne au chiffre zéro (0, sous toutes ses formes) la valeur logique False
et à tous les autres chiffres, la valeur logique True ; de simples chiffres peuvent donc aussi être utilisés
comme condition. Bref, l’effet de l’instruction conditionnelle ci-haut est le suivant : si la condition est
vraie, alors les instructions instruction1, instruction2, ..., seront exécutées, alors que si la condition est
fausse, ces instructions seront ignorées.
Le symbole “␣” utilisé ci-haut indique explicitement un espace dans la ligne de code. De tels espaces
en début de ligne constituent une indentation et, en Python, une telle indentation est essentielle dans un
énoncé conditionnel et dans bien d’autres types d’énoncés que nous verrons plus tard. L’indentation sert
à définir un bloc d’instructions, qui dans notre cas correspond à l’ensemble des instructions à exécuter si
la condition est rencontrée. Il est à noter que :
1. toutes les instructions dans un même bloc doivent avoir la même indentation ;
2. la fin de l’indentation marque la fin du bloc d’instructions conditionnelles.
Le nombre spécifique d’espaces utilisés pour l’indentation n’est pas contraint, mais par convention il est
conseillé de toujours adopter une indentation de 4 espaces. Autre point important à noter : le symbole
“:” dans les commandes ci-haut est aussi essentiel, il sert à marquer la fin de la condition et la transition
vers les instructions.
Si une seule instruction conditionnelle doit être exécutée, plutôt qu’un bloc formé de plusieurs instruc-
tions, on peut utiliser la forme suivante,
if condition : instruction
Lorsqu’on a besoin d’une ou de plusieurs conditions alternatives, une instruction conditionnelle com-
posée a comme canevas :
if condition1:
␣␣␣␣instructions1
elif condition2:
␣␣␣␣instructions2
else:
␣␣␣␣instructions

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 2.8. LE CONTRÔLE DU FLUX D’INSTRUCTIONS 23

L’effet est le suivant : si la condition 1 est vraie, alors le premier bloc d’instruction est exécuté, sinon
(et seulement sinon) on vérifie la condition 2 et si elle est vraie alors le deuxième bloc d’instruction est
exécuté, et on continue ainsi tant qu’il y a des instructions elif, enfin si (et seulement si) aucune des
conditions n’est vraie alors le bloc d’instructions suivant le else est exécuté. Selon le besoin, on peut
omettre la partie elif ou else.
Les instructions conditionnelles peuvent être imbriquées, dans le sens qu’un bloc d’instructions sujet à
exécution conditionnelle peut lui-même contenir d’autres instructions conditionnelles impliquant une ou
plusieurs instructions if et/ou elif/else.

Test conditionnel “en ligne” Il existe une syntaxe simplifiée et bien pratique pour assigner une valeur
ou une autre à une variable selon qu’une condition soit vraie ou non. Cette syntaxe est la suivante :

a = (valeur1 if condition else valeur2)

2.8.2 Boucles conditionnelles : l’instruction while

La structure de base d’une boucle conditionnelle prend la forme :

while condition:
␣␣␣␣instructions

L’effet d’une telle boucle est simple : si la condition est vraie, on exécute le bloc d’instructions et on
ré-évalue ensuite la condition, si elle est toujours vraie on ré-exécute le bloc d’instructions, on ré-évalue
la condition, et on continue ainsi tant que la condition est vraie, dès que la condition est fausse on saute
par-dessus le bloc d’instructions et on continue l’exécution du programme. Par exemple, le petit bout de
code suivant écrirait en sortie les entiers de un à dix :

1 k=1
2 while k <= 10:
3 print(k)
4 k+=1

La boucle while est fort utile, mais notez bien le danger qu’une boucle se mette à tourner sans jamais
stopper, si la condition de contrôle ne se retrouve jamais fausse suite à une erreur conceptuelle ou de codage.
Si jamais cela se produit, ou si pour une toute autre “fausse manoeuvre” vous vous retrouvez dans une
situation où le code tourne “dans le vide”, vous pouvez stopper l’exécution en pressant simultanément sur
les touches “Ctrl+c” sur le clavier.

2.8.3 Boucles inconditionnelles : l’instruction for

Un moment de réflexion devrait vous convaincre que la boucle conditionnelle citée en exemple ci-dessus
est, fondamentalement, une boucle inconditionnelle puisque que l’on a décidé a priori, au moment de
l’écriture du code source, que l’on voulait écrire en sortie les entiers de 1 à 10, plutôt que de 3 à 17 ou de
1 à 31415926536. Dans une telle situation on peut utiliser une structure de boucle dite inconditionnelle.
Le canevas d’une telle boucle a la forme :

for i in sequence:
␣␣␣␣instructions

La boucle for ci-dessus répète le bloc d’instructions pour chaque élément i dans la séquence sequence.
Plus précisément, la variable i prendra initialement la valeur du premier élément de sequence et le bloc
d’instructions sera exécuté, la variable i prendra ensuite la valeur du deuxième élément de sequence et le
bloc d’instructions sera exécuté, et ainsi de suite jusqu’à ce que i ait pris la valeur de tous les éléments de
sequence. La séquence en question peut-être un objet de type list, str ou tuple, ou de tout autre type
correspondant à une séquence. Le nombre de répétitions est ici prédéterminé et correspond au nombre
d’éléments dans sequence. Par exemple, le code suivant,

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 24 CHAPITRE 2. PYTHON : LA BASE

1 mot='Bonjour'
2 for i in mot:
3 print(i)

écrira l’une après l’autre sur une ligne à part chaque lettre du mot “Bonjour”, et le code suivant,

1 xx=['Voici','les',7,'elements','de','la','liste']
2 for x in xx:
3 print(x)

écrira l’un après l’autre sur une ligne à part chaque élément de la liste xx.
Souvent, on désire itérer sur des nombres entiers et pour ce faire on peut utiliser la fonction range(),
qui est en fait un itérateur de nombres entiers. La syntaxe de cette fonction est range(debut,fin,pas),
ce qui produira une séquence d’itération partant du nombre debut et allant jusqu’au plus grand nombre
strictement plus petit que fin, avec un intervalle de pas entre chaque nombre de la séquence ; si pas est
omis alors une valeur de 1 sera adoptée par défaut. Le résultat de cette fonction est un objet qui a son
propre type : range. Si on le veut, on peut ne fournir que l’argument fin, dans lequel cas l’itération
débutera à 0 avec un intervalle de 1 entre chaque nombre.
Par exemple, le code suivant affichera un à un sur une ligne à part les chiffres de 1 à 10 (équivalent à
la boucle while présentée ci-haut) :

1 for x in range(1,11):
2 print(x)

Création de listes Une variation de la boucle for telle que construite ci-haut permet de créer des listes
de façon très compacte. Cette variation (appelée list comprehension en anglais) prend la forme suivante :
[expression(i) for i in sequence if condition]
Notez que les symboles “[” et “]” au début et à la fin sont ici essentiels pour marquer explicitement que
le résultat sera une liste. Par exemple, la commande suivante produira une liste contenant le carré des 10
premiers nombres entiers (incluant le zéro, donc de 0 à 9) :

1 >>> [i**2 for i in range(10)]

2 [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

2.8.4 Les commandes break et continue

On peut utiliser la commande break dans un bloc d’instructions pour sortir de la boucle en question,
c’est à dire terminer immédiatement la boucle et continuer l’exécution du programme. La commande
continue permet de passer immédiatement à la prochaine itération de la boucle sans exécuter les ins-
tructions qui la suivent dans le bloc d’instructions. Les commandes break et continue sont généralement
combinées à des instructions conditionnelles.

2.9 Fonctions et méthodes

En programmation, tel que mentionné au chapitre précédent, une fonction est simplement une collec-
tion d’instructions que l’on peut exécuter quand et où on le veut dans un programme en invoquant son
identificateur ; on peut fournir un ou des objets (ou variables) en entrée à la fonction (des arguments) et
celle-ci peut retourner un ou des objets en sortie.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 2.9. FONCTIONS ET MÉTHODES 25

Une méthode est quant à elle simplement une fonction liée à un objet (ou plus généralement à une
classe d’objets). La seule différence entre une fonction et une méthode est la façon dont elles sont invo-
quées. Les fonctions sont appelées par leur identificateur suivi de parenthèses, fonction(), les arguments
figurant à l’intérieur des parenthèses le cas échéant. Les méthodes sont appelées avec la notation ponctuée,
[Link](), et agissent sur l’objet lié à l’identificateur précédent le “.”, comme dans cet
exemple :

1 >>> a=[1,2,3,4]
2 >>> [Link]()
3 >>> a
4 [4, 3, 2, 1]
5 >>> [Link](3)
6 1

À la ligne 2, la méthode reverse() agit sur la liste a et son effet est d’inverser l’ordre de ses éléments. À
la ligne 5, la méthode count() agit sur a et retourne le nombre total de ses éléments dont la valeur est
égale à celle passée en argument.

2.9.1 Librairie de fonctions standards

Plusieurs fonctions sont disponibles d’emblée en Python, ce sont les fonctions de la “librairie standard”.
Nous avons déjà vu plusieurs de ces fonctions dans la section précédente, par exemple print(), input(),
type(), int(), range(), etc. Il en existe 72 en tout, la liste complète avec une brève explication pour
chacune est donnée ici 17 .
Certaines de ces fonctions méritent une introduction ici. D’abord, la fonction len() retourne le nombre
d’éléments contenus dans un objet, par exemple dans une liste ou dans une chaîne de caractères. Les
fonctions abs(), min() et max() calculent respectivement la valeur absolue d’un nombre (ou sa magnitude
pour un nombre complexe) ou le minimum/maximum d’une séquence de nombres.
On peut utiliser la fonction dir() pour obtenir la liste de tous les attributs d’un objet, laquelle inclut
toutes les méthodes applicables à cet objet. Par exemple :

1 >>> a=[1,2,3,4]
2 >>> dir(a)
3 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__',
4 '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
5 '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__',
6 '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__',
7 '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__',
8 '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index',
9 'insert', 'pop', 'remove', 'reverse', 'sort']

On voit bien dans la liste affichée aux lignes 3–9 la présence des méthodes reverse() et count() citées
en exemple plus haut.
La fonction repr() retourne une chaîne de caractères correspondant à la représentation de l’objet donné
en argument ; en particulier, cette représentation peut être affichée à l’aide de la fonction print(). Par
exemple, pour un objet de type chaîne de caractères, la fonction repr retournera une chaîne de caractères
qui inclura explicitement des apostrophes au début et à la fin, de telle sorte qu’en affichant cette chaîne
on verra les apostrophes et on saura que l’objet en question était du type chaînes de caractères :

1 >>> s='5'
2 >>> repr(s)
3 "'5'"
4 >>> print(repr(s))
5 '5'
17. [Link]

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 26 CHAPITRE 2. PYTHON : LA BASE

6 >>> print(s)
7 5
8 >>> print(5)
9 5

L’affichage de la ligne 4 ci-dessus nous permet de voir que l’objet “s” est une chaîne de caractères, alors
que l’affichage de la ligne 6 ne nous permet pas de distinguer “s” du nombre entier 5 (cf. ligne 8).
La fonction eval() est aussi intéressante pour certaines applications. Cette fonction accepte un argu-
ment de type chaîne de caractères, interprète cette chaîne de caractères comme si elle était une expression
Python, et l’évalue. Un des usages possibles (parmi bien d’autres) est pour simplifier l’assignation de
valeurs spécifiées par l’utilisateur à des variables, par exemple :

1 >>> x,y=eval(input('SVP entrez deux chiffres x,y: '))

2 SVP entrez deux chiffres (x,y): 10.,12.
3 >>> x
4 10.0
5 >>> y
6 12.0

En utilisant cette approche, on n’a pas besoin de séparer en deux la chaîne de caractères retournée par
input et de faire la conversion vers le type d’objet voulu. Une fonction similaire, exec(), permet d’exécuter
une instruction Python plutôt que d’évaluer une expression. Par exemple, on peut faire exec(’x=10’).
Enfin, lorsqu’on utilise des boucles d’itération, les fonctions zip() et enumerate() peuvent être inté-
ressantes. La fonction zip accepte deux ou plusieurs objets itérables comme arguments (e.g. des listes)
et retourne un itérateur de tuples, chaque tuple de cette itération contenant les éléments correspondants
des séquences données en argument. Par exemple :

1 >>> a=['A1','A2','A3']
2 >>> b=['B1','B2','B3']
3 >>> for z in zip(a,b):
4 ... print(z)
5 ...
6 ('A1', 'B1')
7 ('A2', 'B2')
8 ('A3', 'B3')
9 >>> for x,y in zip(a,b):
10 ... print('x={} et y={}'.format(repr(x),repr(y)))
11 ...
12 x='A1' et y='B1'
13 x='A2' et y='B2'
14 x='A3' et y='B3'

La fonction enumerate est similaire, elle accepte un seul objet itérable en argument, et retourne un
itérateur de tuples de deux éléments, chaque tuple de l’itération contenant l’indice de l’itération et l’élément
correspondant de l’objet donné en argument. Par exemple :

1 >>> for i,x in enumerate(a):

2 ... print('i={} et x={}'.format(repr(i),repr(x)))
3 ...
4 i=0 et x='A1'
5 i=1 et x='A2'
6 i=2 et x='A3'

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 2.9. FONCTIONS ET MÉTHODES 27

2.9.2 Définition de fonctions originales

En plus des fonctions de la librairie standard, il est possible de définir, à notre guise, de nouvelles
fonctions pour faire ce que l’on veut. De telles fonctions originales sont utiles pour éviter d’avoir à dupliquer
l’écriture de groupes d’instructions que l’on doit faire à plusieurs reprises à divers endroits dans un ou
plusieurs codes.
Le code Python ci-dessous illustre la syntaxe de définition d’une fonction simple de deux variables, qui
dans cet exemple calcule les coefficients d’une droite passant par deux points donnés.

1 def coeff_droite(p1,p2):
2 """
3 Calcule les coefficients (m et b) de l'équation de la droite y=m*x+b passant
4 par les points p1=(x1,y1) et p2=(x2,y2).
5 """
6

7 if p2[0]!=p1[0]:
8 m=(p2[1]-p1[1])/(p2[0]-p1[0])
9 b=p1[1]-m*p1[0]
10 else:
11 print('Erreur! x1 et x2 ont la même valeur')
12 m=b=None
13

14 return m,b

Une fonction débute avec def, suivi du nom de la fonction (ici coeff_droite), et ensuite d’une liste
d’arguments séparés par des virgules entre parenthèses (ici p1 et p2). Le bloc d’instructions propres à la
fonction suit sur les lignes suivantes avec une indentation appropriée. À la fin de la fonction, il est commun
de retourner un ou plusieurs objets à l’aide de la commande return (mais ceci est optionnel) ; si plusieurs
objets sont retournés, ils doivent être séparés par des virgules. Pour utiliser la fonction définie ci-haut
il suffit de l’invoquer comme on le ferait pour toute autre fonction, tant que la fonction a été “lue” au
préalable par l’interpréteur Python. Pour cette dernière raison, la définition de la fonction doit apparaître
dans le code avant le programme principal, de façon à ce que la fonction soit lue (et ainsi définie) avant
d’être invoquée plus bas dans le code.
Les arguments passés à une fonction peuvent être nommés et/ou positionnels. Les arguments nommés
(en anglais : keyword arguments) sont précédés d’un identificateur dans la définition de la fonction, ainsi
que dans l’appel à la fonction. 18 Les arguments positionnels n’ont pas d’identificateurs et doivent précéder
tous les arguments nommés dans la définition de la fonction. Par exemple, la définition de fonction suivante
déclare les arguments positionnels x0 et t0 ainsi que les arguments nommés dt et affichage. De plus,
on assigne une valeur par défaut aux arguments nommés, c’est-à-dire que si ces arguments ne sont pas
passés lors de l’appel de la fonction, alors ces valeurs par défaut seront utilisées.

1 def ma_fonction(x0,t0,dt=0.1,affichage=True):
2 if affichage:
3 print(' x0:',x0)
4 print(' t0:',t0)
5 print(' dt:',dt)
6 #normalement des instructions de la fonction suivraient ici
7

8 #instructions du programme principal

9 #...

Les lignes 8 et suivantes correspondent au programme principal, qui est placé après la définition de la
fonction tel que discuté plus haut. Les lignes ci-bas montrent différentes façon dont des arguments peuvent
être passés à cette fonction, avec le résultat correspondant :
18. En principe, l’identificateur d’un argument nommé peut être omis lors de l’appel à la fonction, dans lequel cas il est
considéré comme un argument positionnel. Cette pratique n’est toutefois pas recommandée.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 28 CHAPITRE 2. PYTHON : LA BASE

1 >>> ma_fonction(0.,0.,dt=0.01,affichage=True)
2 x0: 0.0
3 t0: 0.0
4 dt: 0.01
5 >>> ma_fonction(1.,0.)
6 x0: 1.0
7 t0: 0.0
8 dt: 0.1
9 >>> ma_fonction(5.,100.,affichage=0)
10 >>> ma_fonction(5.,100.,affichage=1,dt=10.)
11 x0: 5.0
12 t0: 100.0
13 dt: 10.0

L’erreur la plus commune dans l’écriture d’un code Python incluant des fonctions est d’introduire une
ou plusieurs incompatibilités dans le nombre et type des variables en argument ou en sortie à l’évaluation
de la fonction. Donc portez-y attention.

Pour plus d’information sur la définition de fonctions, vous pouvez consulter cette page. 19

2.9.3 Modules et importations

Un module est essentiellement un script Python qui contient un ensemble de définitions de fonctions
et de classes (types d’objets). Plusieurs fonctions très utiles (et classes d’objets et méthodes) sont définies
dans divers modules Python qui sont disponibles dans la bibliothèque standard de modules ; nous en
utiliserons quelques-uns dans le cours. Pour accéder aux fonctions et classes définies dans un module
donné à partir de n’importe quel code, on doit explicitement importer le module en question à l’aide
de la commande import. On utilisera le module NumPy comme exemple ici, qui est un module de la
bibliothèque standard. La forme de base de la commande import est la suivante :
import numpy
Une telle importation crée un nouvel objet, numpy dont le type est module, et rend toutes les fonctions
et classes (et sous-modules) définies dans ce module accessibles. Comme ce module importé est en fait
un “objet” Python, les fonctions de ce module sont en fait des méthodes, et conséquemment elles doivent
être appelées avec la notation pointée. Par exemple pour utiliser la fonction sin() – sinus – du module
numpy il faudra faire x=[Link](0.9).
On peut aussi utiliser la commande import de la façon suivante :
import numpy as np
Ceci importe le module numpy au complet en tant qu’objet, comme avant, mais lui assigne l’identificateur
np, de sorte que l’on puisse appeler la fonction sin(), par exemple, avec l’instruction [Link]().
Une fois un module importé, on peut voir la liste des fonctions qui y sont définies avec la commande
dir(module).
Enfin, on peut faire des importations des deux façons suivantes :
from numpy import sin,cos
from numpy import *
La première de ces lignes importe seulement les fonctions sin() et cos(), les autres fonctions du module
demeurant inaccessibles. De plus, cette syntaxe n’importe pas le module complet en tant qu’objet mais
importe directement les objets spécifiés, lesquels peuvent donc être appelés directement sans utiliser la
notation pointée. L’instruction suivante serait alors appropriée : x=sin(0.9). La deuxième ligne ci-dessus
importe toutes les fonctions du module numpy de façon similaire.
19. [Link]

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 2.10. ÉCRITURE D’UN CODE SOURCE 29

En programmation scientifique, les modules NumPy, SciPy, Matplotlib et Pyplot (qui est un sous-
module de Matplotlib) sont fréquemment utilisés et par convention on recommande fortement d’utiliser
les commandes d’importation suivantes :

import numpy as np
import scipy as sp
import matplotlib as mpl
import [Link] as plt

Il existe aussi un module Math définissant les fonctions mathématiques et quelques constantes de base,
mais celles-ci sont aussi (re)définies dans les modules NumPy et SciPy que l’on préfère généralement.

2.9.4 Espace de noms et résolution des identificateurs

Lorsque Python est en exécution, il doit garder une liste de tous les identificateurs qui ont été assignés
à des objets et des liens entres ceux-ci. Cette liste d’associations identificateur↔objets est appelée “espace
de noms” (namespace). L’espace de nom du programme principal est qualifié de “global”, celui-ci contient
tous les identificateurs et objets assignés dans le programme principal. Il existe aussi un espace de noms
“interne” qui contient tous les identificateurs et objets définis par défaut en Python ; les fonctions de la
librairie standard, par exemple, font partie de cet espace de noms interne.
Enfin, lors de l’exécution d’une fonction, un nouvel espace de noms “local” est créé pour les identifica-
teurs/objets créés au sein même de la fonction ; ceci permet entre autres d’utiliser un même identificateur
à l’intérieur d’une fonction et du programme principal sans qu’il ne réfère au même objet. L’espace de
noms local est effacé à la sortie de la fonction, de sorte que les variables locales ne peuvent pas être
référencées ultérieurement dans le programme qui a appelé la fonction.
Lorsqu’un identificateur est utilisé dans une commande, l’interpréteur Python cherche dans les diffé-
rents espaces de noms pour trouver l’objet correspondant à l’identificateur utilisé ; cette recherche se fait
selon l’ordre suivant : local d’abord, puis global, puis interne. C’est-à-dire que si l’exécution se trouve dans
une fonction, l’interpréteur cherche d’abord dans l’espace de noms local et si l’identificateur recherché y
est défini, alors l’objet correspondant est utilisé, sinon l’interpréteur reprend la recherche dans l’espace de
noms global, et au besoin se rendra jusqu’à l’espace de noms interne.
Vous aurez donc compris que les variables globales peuvent être utilisées à l’intérieur d’une fonction
(mais pas modifiées), mais seulement s’il n’y a pas de variables locales portant le même identificateur.

2.10 Écriture d’un code source

Les concepts introduits ci-haut sont déjà suffisants pour produire un code simple, qui tel que mentionné
au début du chapitre, consiste en une série d’instructions enregistrées dans un fichier texte. La chose
primordiale à savoir pour écrire un “bon code source” est que sa présentation visuelle et sa structure
doivent être claires, pour que vous ou un autre utilisateur puissiez aisément le comprendre en le lisant ;
voici quelques points pour vous aider à ce niveau :
— Ne pas placer plus d’une instruction par ligne ;
— Utiliser des lignes vides afin d’aérer le code et de simplifier sa lecture ;
— Utiliser des noms de variables qui soient informatifs, par exemple masse plutôt que m ;
— Utiliser des indentations formées de 4 espaces pour les blocs d’instructions ;
— Inclure des commentaires.
Les commentaires sont des bouts de code qui sont ignorés par l’interpréteur Python et qui servent
uniquement à faciliter la compréhension du code pour l’utilisateur qui le lit. Il existe deux façons de
commenter un programme en Python : le dièse (#) ainsi que les trois guillemets en paire : """. . .""".
Dans le premier cas, seuls les mots qui suivent le dièse sur la même ligne sont commentés ; dans le second
cas, le commentaire peut s’étendre sur plusieurs lignes ; voir les exemples suivants :

1 """
2 Ceci est un commentaire en bloc. Il permet de mettre
3 plusieurs lignes de texte dans un commentaire.
4 """

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 30 CHAPITRE 2. PYTHON : LA BASE

6 print('Bonjour!') # Ceci est un commentaire de ligne

Au niveau de la structure du code, il est utile d’adopter les conventions suivantes :

— Commencer le code par quelques commentaires expliquant ce qu’il fait ;
— Placer les importations de modules au début du code ;
— Définir toutes les constantes en haut du code (après les importations), incluant les constantes phy-
siques et les “valeurs constantes” propres au problème abordé (par exemple, une certaine longueur
d’onde) ;
— Définir toutes les fonctions originales avant le programme principal. De plus, si une telle fonction
utilise des fonctions provenant d’autres modules, il est préférable de faire l’importation de ces autres
modules avant la définition de la fonction plutôt qu’à l’intérieur de celle-ci, même si ces modules
ne sont pas requis par les autres fonctions ou dans le programme principal.
Donc la structure de base d’un code source pourrait avoir l’air de ceci :

1 ##############################################
2 #Entête:
3 #bref descriptif du programme, auteur, date
4 ##############################################
5

6 ##############################################
7 #Importation de modules et fonctions externes:
8

9 import numpy as np
10 import [Link] as plt
11 #etc...
12

13 ##############################################
14 #Définitions de (valeurs) constantes:
15

16 M_ELECTRON=9.10938215d-31 #kg
17 omegaB=200 #fréquence d'oscillation du champ B
18 #etc...
19

20 ##############################################
21 #Définitions locales de fonctions:
22

23 def fonction1(x,y):
24 """Cette fonction calcule ..."""
25 #instruction...
26

27 return z
28

29 ##############################################
30 #Programme principal:
31

32 #instructions...

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 31

Chapitre 3

Python : quelques notions

supplémentaires

Ce chapitre complète certaines notions introduites au chapitre précédent et en introduit de nouvelles,

lesquelles vous seront toutes fort probablement utiles à un moment ou à un autre pour les laboratoires
de ce cours. Au niveau de votre lecture, je vous suggère de d’abord faire un survol rapide des éléments
présentés, et d’y revenir ensuite pour les consulter plus en détail lorsque le besoin se fera sentir au fil du
cours.

3.1 Manipulations de chaînes et listes

Certaines opérations de base sur les chaînes et les listes ont déjà été présentées au chapitre précédent
(+, * et []). Ces opérations sont utiles mais ne sont généralement pas suffisantes pour accomplir tout ce
que l’on veut. Plusieurs méthodes permettent d’effectuer des opération plus complexes sur ces deux types
d’objets ; les plus utiles sont présentées dans les tables 3.1 et 3.2.

Table 3.1 – Méthodes utiles pour manipuler les listes

Instruction Signification
[Link](x) Ajoute l’objet x à la fin de la liste.
[Link](y) Ajoute tous les éléments de la séquence y à la fin de la liste.
[Link]() Ordonne les éléments en ordre croissant.
[Link]() Inverse l’ordre des éléments.
[Link](i) Retourne l’élément à l’indice i et l’élimine de la liste.
[Link](x) Élimine de la liste la première occurrence de la valeur de x.
[Link](x) Retourne l’indice du premier élément égal à x.
[Link](x) Retourne le nombre d’éléments dont la valeur est égale à celle de x.
[Link](i,x) Ajoute l’objet x à la position d’indice i.
[Link]() Crée une copie de la liste.

3.1.1 Affichage formaté avec la fonction format() et la méthode .format()

La fonction format() et la méthode .format() permettent de contrôler en détail la forme que prendra
la valeur d’une variable lorsqu’affichée en sortie à l’écran/dans un fichier ou lorsqu’insérée dans une chaîne
de caractères. La syntaxe de base de la fonction est :
format(variable,format_spec)
où la chaîne de caractères format_spec spécifie le formatage à appliquer à la variable fournie en argument
pour la convertir en chaîne de caractères ; les détails de format_spec sont donnés plus bas.
Pour la méthode maintenant, un exemple de canevas de base est le suivant :

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

32 CHAPITRE 3. PYTHON : QUELQUES NOTIONS SUPPLÉMENTAIRES

Table 3.2 – Méthodes utiles pour manipuler les chaînes de caractères

Instruction Signification
Méthodes retournant une nouvelle chaîne
[Link]() premier mot commence avec une majuscule, tous les autres avec une
minuscules.
[Link]() première lettre de chaque mot en majuscule.
[Link]() remplace toutes les majuscules par des minuscules.
[Link]() remplace toutes les minuscules par des majuscules.
[Link](n,s) centre la chaîne dans une chaîne de longueur n, en comblant de
chaque côté avec le caractère s au besoin.
[Link](n,s) justifie la chaîne à gauche dans une chaîne de longueur n.
[Link](n,s) justifie la chaîne à droite dans une chaîne de longueur n.
[Link](n) complète la chaîne à gauche avec des 0 jusqu’à une longueur de n.
[Link](s) enlève la chaîne de caractères s apparaissant à la fin de la chaîne, le
cas échéant. Si s n’est pas défini, les espaces seront enlevés.
[Link](s) enlève s au début de la chaîne, le cas échéant.
[Link](s) enlève s au début et en fin de chaîne, le cas échéant.
[Link](a,b,n) remplace la sous-chaîne a par b, un nombre maximal n de fois. Si n
est omis, on remplace toutes les occurrences de a.
[Link](s) découpe la chaîne en morceaux aux occurrences de la chaîne s. Si s
n’est pas spécifié, le découpage se fait aux espaces.
[Link](seq) concatène les chaînes de la séquence seq en les intercalant avec la
chaîne ch.
[Link]() pour affichage formaté de variables, voir la sous-section suivante.
Méthodes de test d’une chaîne
[Link]() vrai si ne contient que des chiffres
[Link]() vrai si ne contient que des lettres
[Link]() vrai si ne contient que des chiffres et des lettres
[Link] vrai si tous les caractères sont des majuscules.
[Link] vrai si tous les caractères sont des minuscules.
[Link](ch1,i1,i2) vrai si ch[i1:i2] commence par la chaîne ch1. Si i1 et i2 sont omis,
on considère la chaîne au complet.
[Link](ch1) vrai si ch[i1:i2] termine par la chaîne ch1.
[Link](ch1,i1,i2) compte le nombre de fois que ch1 est répété dans ch[i1:i2].
[Link](ch1,i1,i2) retourne la position de la première occurence de ch1 dans ch[i1:i2].

’Les deux valeurs sont {:format_spec} et {:format_spec}’.format(var1,var2)

où les caractères délimités par { et } forment ce que l’on appelle des champs de remplacement. Ceux-ci
sont associés aux variables passées en argument à la méthode .format() dans l’ordres où ils et elles
apparaissent et seront remplacés par ces variables lors de l’exécution. Ici chaque format_spec spécifie le
formatage à appliquer à la variable associée au champ de remplacement correspondant avant de faire le
remplacement ; notez que les “:” précédant cette chaîne de caractères sont essentiels.
Les éléments formant la chaîne de caractères format_spec sont, dans l’ordre requis,
[[fill]align][sign][#][0][width][,][.precision][type]
où les [] indiquent explicitement que chacun de ces éléments est optionnel. Pour avoir la description
complète de tous ces éléments, consultez cette page web 1 . Nous expliquerons seulement les principaux ici.
L’élément width doit être un entier et indique la largeur minimum (en nombre de caractères) à utiliser
pour afficher le champ. Précéder width avec un 0 indique de combler l’espace devant un chiffre avec des
caractères 0 jusqu’à la largeur spécifiée. L’élément type spécifie la façon dont la variable sera présentée, il
peut prendre les valeurs :
"b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%",
1. [Link]

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 3.1. MANIPULATIONS DE CHAÎNES ET LISTES 33

qui sont décrites à la page web mentionnée ci-haut. Par exemple, le type “f” affiche un nombre réel sous
forme décimale avec un nombre fixe de chiffres après le point. L’élément precision doit être un entier et
indique le nombre de chiffres devant apparaître après le point décimal pour les nombres réels formatés avec
le type f, F, e ou E, ou le nombre total de chiffres (avant et après le point décimal) pour les nombres réels
formatés avec le type g ou G. Rien ne vaut des exemples pour comprendre, alors en voici quelques-uns :

1 >>> pi=3.141592653589793
2 >>> format(pi,'10.4f')
3 ' 3.1416'
4 >>> format(pi,'-010.4f')
5 '00003.1416'
6 >>> format(pi,'.4e')
7 '3.1416e+00'
8 >>> print('Le résultat est {}'.format(pi))
9 Le résultat est 3.141592653589793
10 >>> print('Le résultat est {:10.4f}'.format(pi))
11 Le résultat est 3.1416
12 >>> print('Le résultat est {:010.4f}'.format(pi))
13 Le résultat est 00003.1416
14 >>> print('Le résultat est {:+010.4f}'.format(pi))
15 Le résultat est +0003.1416
16 >>> print('Le résultat est {:-010.4f}'.format(pi))
17 Le résultat est 00003.1416
18 >>> print('Le résultat est {:.4e}'.format(pi))
19 Le résultat est 3.1416e+00
20 >>> print('Le résultat est {:.4g}'.format(pi))
21 Le résultat est 3.142

3.1.2 Déballage de séquence en argument

Certaines fonctions requièrent une série d’arguments positionnels. Ces différents arguments sont parfois
emmagasinés dans une liste ou un tuple et pour les transmettre à la fonction en question il faut taper
au long le nom de la liste suivi de crochets et du bon numéro d’élément pour chaque argument. Par
exemple, si la variable iterParam est une liste contenant les 3 valeurs nécessaires pour construire une
certaine itération désirée (e.g. 10, 21, et 2, resp. pour début, fin et pas), on devra écrire la commande
“range(iterParam[0],iterParam[1],iterParam[2])”. Étant généralement paresseux, on peut trouver
ceci trop fastidieux... Heureusement, il existe un petit truc pour expédier ceci : le déballage de séquence,
ou en anglais le “list unpacking”. L’opérateur “*” placé immédiatement devant une séquence en argument
d’une fonction permet d’en déballer les éléments et de les passer à la fonction en tant qu’objets individuels
formant une séries d’arguments positionnels. En voici un exemple :

1 >>> iterParam=[10,21,2]
2 >>> for i in range(*iterParam):
3 ... print(i)
4 ...
5 10
6 12
7 14
8 16
9 18
10 20

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

34 CHAPITRE 3. PYTHON: QUELQUES NOTIONS SUPPLÉMENTAIRES

3.2 Entrées et sorties sur fichiers

Au chapitre précédent, nous avons vu comment lire des données entrées au clavier de façon interactive
(avec la commande input()) et comment afficher des données en sortie à l’écran (avec la commande
print()), mais dans bien des cas, il est beaucoup plus utile de lire des données directement à partir d’un
fichier et d’écrire des résultats en sortie directement dans un fichier ; c’est ce que nous ferons ici.
En Python, le principe de lecture/écriture de fichiers est assez simple : on ouvre un fichier avec la
commande open(), on lit/écrit des données dans ce fichier par diverses méthodes, et enfin on ferme le
fichier avec la méthode .close().

3.2.1 Ouverture et fermeture de fichiers

La syntaxe de la commande open() est la suivante,
fichier=open(’nomFichier’,mode=mode)
où mode peut prendre la valeur ’r’ pour indiquer que le fichier doit être ouvert en mode lecture, ’w’ pour
indiquer que le fichier doit être ouvert en mode écriture (notez que ceci écrasera le fichier du même nom
s’il existe déjà), ’x’ pour le mode écriture exclusive (ce qui signifie que le fichier ne doit pas exister au
préalable sinon la commande échouera), ’a’ pour le mode écriture ajoutée (ce qui signifie que l’on écrira
à la suite de ce qui est déjà présent dans le fichier existant). Il existe aussi d’autres options pour le mode
que vous pouvez voir dans l’aide de cette commande. L’exécution de la commande ci-haut crée un nouvel
objet de type “fichier texte” (text file) et l’assigne à l’identificateur fichier. Ce type d’objet est similaire
à une liste dont chaque élément serait une ligne du fichier en question. En outre, on peut itérer sur le
contenu de cet objet (i.e. sur chaque ligne) avec une boucle for.
Une fois toutes les opérations de lecture/écriture terminées, on ferme le fichier avec la commande,
[Link]()
Une alternative préférable à l’utilisation de open/close ci-haut est l’utilisation d’un bloc with, comme
suit,
with open(’nomFichier’,mode=mode) as fichier:
...instructions de lecture/écriture/autre...
...

Ceci ouvre le fichier pour lecture/écriture comme auparavant, mais a l’avantage d’automatiquement fermer
le fichier à la fin de l’exécution du bloc d’instructions.

3.2.2 Lecture
Lorsqu’un fichier est ouvert pour la lecture, il existe plusieurs méthodes pour lire les données qu’il
contient. On peut lire tout le fichier d’un seul coup avec l’une des deux méthodes suivantes :
contenu=[Link]()
contenu=[Link]()
La première de ces commandes place tout le contenu du fichier dans une seule chaîne de caractères, alors
que la deuxième crée une liste de chaînes de caractères, chacun des éléments de celle-ci étant une ligne
individuelle du fichier. On peut aussi lire le fichier ligne-par-ligne avec la méthode .readline(), qui lit
une seule ligne à la fois. Enfin, on peut itérer sur les lignes avec une boucle for, par exemple en faisant :

for ligne in fichier:

print(ligne)
...

Notez que les fins de lignes (i.e. les retours à la ligne) sont lues explicitement et retournent le caractère
“\n”. Si on veut les retirer, on peut facilement le faire en utilisant diverses méthodes présentées à la section
précédente (.split(’\n’), .replace(’\n’,”), ou .rstrip(’\n’)).
Par exemple, pour placer le contenu complet d’un fichier dans une liste dont chaque élément corres-
pondra à une ligne du fichier, et en éliminant les retours à la lignes, on pourra faire :

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 3.3. LE MODULE NUMPY ET LES TABLEAUX NUMÉRIQUES 35

1 fic=open('[Link]','r')
2 lignes=[Link]().split('\n')
3 [Link]()

3.2.3 Écriture
Pour l’écriture, on peut utiliser l’une des deux commandes suivantes :

[Link](chaine)
[Link](listeChaine)

où chaine est une chaîne de caractères et listeChaine est une liste de chaînes de caractères. Notez que
toute écriture dans un fichier est séquentielle, c’est-à-dire que les éléments y sont ajoutés à la suite, au
fur et à mesure que l’on écrit dans le fichier. De plus, si on veut faire un changement de ligne en écriture,
il faut explicitement écrire le caractère de fin de ligne ('\n') dans le fichier. Par exemple pour écrire une
chaîne sur une ligne et terminer cette ligne, on peut faire,

[Link](chaine+'\n')

et pour écrire chaque élément d’une liste sur sa propre ligne on peut d’abord joindre tous ces éléments
ensemble en y insérant le caractère '\n' avec la méthode .join(), et ensuite écrire la chaîne résultante,
comme suit,

[Link]('\n'.join(listeChaine))

3.3 Le module NumPy et les tableaux numériques

Les vecteurs et les matrices jouent un rôle important en programmation scientifique. Ainsi, supposons
qu’on veuille intégrer les équations du mouvement pour 1000 particules, on ne va certainement pas com-
mencer à traiter chacune des particules avec un nom de variable différent x1, x2, ..., x1000. Nous
voulons plutôt utiliser un vecteur contenant les 1000 positions en question. Nous pourrions accomplir
ceci avec une liste, une classe d’objet Python que vous avez déjà rencontré, mais les listes présentent
quelques désavantages pour les applications numériques. Par exemple, on ne peut appliquer une opération
mathématique sur tous les éléments d’une liste directement, il faut plutôt faire une boucle de répétition et
appliquer l’opération sur les éléments un à un. De plus, les éléments d’une liste ne sont pas nécessairement
emmagasinés côte-à-côte en mémoire, ce qui peut ralentir leur temps d’accès.
Il existe un type d’objet beaucoup plus approprié aux calculs numériques : le tableau multidimen-
sionnel homogène, de type ndarray. C’est l’objet principal définit par le module NumPy. Il s’agit
d’un tableau d’éléments (habituellement des chiffres) ayant tous le même type (entier, réel ou complexe),
indexés de la même manière qu’une liste par un entier positif (ou par plusieurs entiers positifs séparés
par des virgules si le tableau a plus d’une dimension). Les fonctions et méthodes du module NumPy,
combinées aux objets de type ndarray, permettent de manipuler les vecteurs et les matrices de manière
très naturelle et plus efficace. En outre, toute opération arithmétique effectuée sur un tableau retourne
un nouveau tableau contenant le résultat de cette opération appliquée sur chaque élément (aucun besoin
de faire une boucle sur chaque élément). En voici deux exemples :

1 >>> import numpy as np

2 >>> v=[Link]([1,2,3,4,5]) # création d'un tableau NumPy, voir sous-section ci-bas
3 >>> v
4 array([1, 2, 3, 4, 5])
5 >>> v+2
6 array([3, 4, 5, 6, 7])
7 >>> v*5
8 array([ 5, 10, 15, 20, 25])

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 36 CHAPITRE 3. PYTHON : QUELQUES NOTIONS SUPPLÉMENTAIRES

Notez comment l’effet des opérateurs + et * diffère ici de l’effet qu’ils auraient sur une liste. Plusieurs
autres opérations sur des tableaux NumPy agissent de façon similaire et sont optimisées de telle sorte
qu’elles s’exécutent beaucoup plus rapidement que si on les faisait sur des listes.
Les tableaux de type ndarray ont une taille fixe, établie lors de leur création ; il n’est pas possible de
les allonger ou les raccourcir comme on peut le faire pour les listes, à moins bien sûr de créer un nouveau
tableau (i.e. un objet différent). La taille d’un tableau est emmagasinée dans son attribut shape (pour
forme) ; cet attribut est de type tuple et chacun de ses éléments correspond au nombre d’éléments dans la
dimension correspondant à sa position. L’attribut size (pour taille), quant à lui, emmagasine le nombre
total d’éléments contenu dans le tableau. Enfin, le nombre de dimensions est emmagasiné dans l’attribut
ndim.
Aussi, tel que mentionné ci-haut, tous les éléments d’un même tableau ont le même type (tableau
homogène) ; la liste de tous les types numériques disponibles pour ces tableaux est donnée ici 2 , les prin-
cipaux sont int, float, complex et bool. Contrairement au type entier par défaut de Python, le type
entier de NumPy est représenté à l’aide d’un nombre fixe de bits (64 par défaut), leurs valeurs sont donc
limitées à un certain intervalle (±9223372036854775807 pour 64-bits). Le type des données contenues dans
un tableau est emmagasiné dans l’attribut dtype. Les exemples suivants illustrent ces différents concepts.

1 >>> v=[Link]([1,2,3,4,5])
2 >>> [Link]
3 (5,)
4 >>> [Link]
5 5
6 >>> [Link]
7 dtype('int64')
8 >>> v=[Link]([[1,2,3],[4,5,6]]) # tableau de 2 rangées et 3 colonnes
9 >>> v
10 array([[1, 2, 3],
11 [4, 5, 6]])
12 >>> [Link]
13 (2, 3)
14 >>> [Link]
15 6
16 >>> [Link]
17 2

Outre les tableaux homogènes, le module NumPy fournit aussi toutes les fonctions mathématiques
du module Math (sinus, round, exp, log, etc.) ; la liste complète des fonctions mathématiques est dis-
ponible ici 3 . NumPy fournit aussi plusieurs sous-modules pour des applications avancées, par exemple
[Link] pour la génération de nombres aléatoires, [Link] pour l’algèbre linéaire, ou [Link]
pour les transformées de Fourier discrètes.
Des manuels d’utilisation et de référence pour NumPy sont disponibles ici 4 et un tutoriel est disponible
ici 5 ; je vous encourage fortement à aller voir ce tutoriel.

3.3.1 Création d’un tableau

Il existe plusieurs façons de créer un tableau NumPy (type ndarray), les principales sont présentées à
la table 3.3 et la liste complète est disponible ici 6 .
On peut d’abord créer un tableau NumPy à partir d’une séquence déjà existante de valeurs à l’aide de la
fonction array(seq) ; cette opération est en fait une transformation de type vers ndarray. Par défaut, les
éléments du tableaux adoptent le type le plus élevé des valeurs de la séquence originale. On peut toutefois
2. [Link]
3. [Link]
4. [Link]
5. [Link]
6. [Link]

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 3.3. LE MODULE NUMPY ET LES TABLEAUX NUMÉRIQUES 37

forcer le type des éléments du tableau résultant en fournissant l’argument dtype (2e argument positionnel,
ou argument nommé), par exemple array(seq,’complex’) ou array(seq,dtype=’complex’).
On peut aussi créer des tableaux où tous les éléments ont la même valeur prédéfinie à l’aide des fonctions
ones() (valeur 1), zeros() (valeur 0) et full() (valeur spécifiée en argument). Pour ces fonctions, il faut
spécifier la forme (nombre d’éléments dans chaque dimension) par un argument. Alternativement, les
variantes de ces fonctions ayant le suffixe _like() permettent d’adopter directement la forme et le type
d’un autre tableau fournit en argument.
Enfin, on peut créer des tableaux contenant des intervalles de valeurs numériques à l’aide des fonctions
arange() et linspace().
La table 3.3 résume ces fonctions.
Table 3.3 – Principales fonctions de création de tableaux numériques NumPy

Fonction∗ Signification
À partir d’une séquence existante
array(seq) Convertit la séquence seq en tableau.
Avec assignations de valeurs prédéfinies
ones(shape) Tableau rempli de 1 de forme spécifiée par le tuple shape.
ones_like(a) Tableau rempli de 1 de la même forme que le tableau a.
zeros(shape) Tableau rempli de 0 de forme spécifiée par le tuple shape.
zeros_like(a) Tableau rempli de 0 de la même forme que le tableau a.
full(shape, v) Tableau rempli de valeurs v de forme spécifiée par le tuple
shape.
full_like(a, v) Tableau rempli de valeurs v de la même forme que le tableau a.
Intervalles numériques
arange([debut,] fin[, pas]) Intervalle allant de debut (inclusivement) à fin (exclusive-
ment) avec espacement de pas. Similaire à la fonction standard
range() mais retourne un tableau.
linspace(debut, fin[, num]) Exactement num valeurs espacées également dans l’intervalle al-
lant de de debut (inclusivement) à fin (inclusivement).
*
Toutes ces fonctions possèdent aussi l’argument positionnel/nommé dtype pour spécifier le type
de données voulu.

Voici quelques exemples d’utilisations de ces fonctions.

1 >>> v=[Link]((2,3))
2 >>> v
3 array([[ 1., 1., 1.],
4 [ 1., 1., 1.]])
5 >>> w=np.zeros_like(v)
6 >>> w
7 array([[ 0., 0., 0.],
8 [ 0., 0., 0.]])
9 >>> x=[Link](8.,12.5,5)
10 >>> x
11 array([ 8. , 9.125, 10.25 , 11.375, 12.5 ])

3.3.2 Manipulation des tableaux

On peut modifier la forme d’un tableau à l’aide de la méthode .reshape(s), où s est un tuple
spécifiant la nouvelle forme désirée. Cette opération doit préserver le nombre d’éléments du tableau. On
peut inverser l’ordre des dimensions du tableau à l’aide de la méthode .transpose(). On peut ramener
un tableau multidimensionnel à un tableau unidimensionnel avec la méthode .flatten().

1 >>> x=[Link](10)
2 >>> x

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 38 CHAPITRE 3. PYTHON: QUELQUES NOTIONS SUPPLÉMENTAIRES

3 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
4 >>> y=[Link]((2,5))
5 >>> y
6 array([[0, 1, 2, 3, 4],
7 [5, 6, 7, 8, 9]])
8 >>> [Link]()
9 array([[0, 5],
10 [1, 6],
11 [2, 7],
12 [3, 8],
13 [4, 9]])
14 >>> [Link]()
15 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

On peut accéder aux éléments d’un tableau de la même façon qu’on le fait avec une liste, c’est-à-dire
à l’aide de l’opérateur [i1:i2]. Si le tableau a plus d’une dimension, on utilise des virgules à l’intérieur
des crochets pour séparer les indices correspondant aux différentes dimensions. La correspondance entre
chaque élément d’un tableau à deux dimensions et leur indice selon chaque dimension est illustrée à la
figure 3.1 : le premier indice spécifie la rangée et le deuxième indice spécifie la colonne. À la même figure
sont aussi montrés quelques exemples de sélection de sous-section d’un tableau à deux dimensions.

Figure 3.1 – (Gauche) Correspondance des indices des éléments d’un tableau à deux dimensions. (Droite)
Illustration de l’effet de la sélection d’une sous-section d’un tableau avec l’opérateur [i1:i2] pour un
tableau à deux dimensions. Figures tirées du livre Python for data analysis, Wes McKinney, 2012.

Voici quelques exemples d’utilisation de l’opérateur [i1:i2] :

1 >>> x=[Link](10).reshape((2,5))
2 >>> x
3 array([[0, 1, 2, 3, 4],
4 [5, 6, 7, 8, 9]])
5 >>> x[1,3]
6 8
7 >>> x[1,2:4]
8 array([7, 8])

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 3.4. FIGURES ET GRAPHIQUES 39

9 >>> x[:,2:4]
10 array([[2, 3],
11 [7, 8]])
12 >>> x[1,[2,4]]
13 array([7, 9])
14 >>> a=[2,4]
15 >>> x[1,a]
16 array([7, 9])
17 >>> x[[1,0],[3,1]]
18 array([8, 1])

Notez que l’on peut remplacer le terme “i1:i2” par une liste d’indices, ce qui permet d’accéder à des
indices non-adjacents ; voir les exemples des lignes 12, 15 et 17 ci-haut. Si de telles listes sont fournies pour
plusieurs dimensions, alors elles doivent avoir la même taille, et le nombre d’éléments accédés correspondra
à la taille de ces listes.

3.3.3 Opérations sur les tableaux

Tel que mentionné précédemment, les opérateurs arithmétiques de base s’appliquent à chaque élément
du tableau de manière identique. Il en est de même pour les fonctions mathématiques de base. Une liste
assez complète des fonctions de NumPy qui agissent de cette façon, avec des exemples, est disponible ici 7 .

1 >>> x=[Link](10)
2 >>> y=[Link](10,5,'int')
3 >>> x
4 array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
5 >>> y
6 array([5, 5, 5, 5, 5, 5, 5, 5, 5, 5])
7 >>> x*2
8 array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])
9 >>> x+y
10 array([ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])
11 >>> x*y
12 array([ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45])
13 >>> [Link](x)
14 array([ 0. , 0.84147098, 0.90929743, 0.14112001, -0.7568025 ,
15 -0.95892427, -0.2794155 , 0.6569866 , 0.98935825, 0.41211849])

Plusieurs fonctions du module NumPy et plusieurs méthodes du type ndarray sont disponibles pour
faire des opérations plus complexes ; les principales sont présentées au tableau 3.4.

3.4 Figures et graphiques

Le module Matplotlib et son sous-module PyPlot rendent Python particulièrement puissant pour la
création de graphiques et la visualisation de données. Une brève introduction est fournie dans cette section ;
celle-ci est suffisante pour produire des figures complètes et esthétiques, mais ne touche tout de même
qu’à une fraction des possibilités offertes par PyPlot. En plus de ces notes, je vous encourage à consulter
le tutoriel de PyPlot 8 et la liste des principales commandes d’affichages PyPlot 9 .

Pour comprendre l’idée générale de l’utilisation de PyPlot pour la production de graphiques, commen-
çons par un exemple simple :

7. [Link]
8. [Link]
9. [Link]

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 40 CHAPITRE 3. PYTHON : QUELQUES NOTIONS SUPPLÉMENTAIRES

Table 3.4 – Principales fonctions/méthodes pour opérer sur des tableaux numériques NumPy

Fonction/méthode Signification
Méthodes∗
[Link]() Calcule la somme de tous les éléments de x.
[Link]() Calcule le produit de tous les éléments de x.
[Link](y) Calcule le produit scalaire de x avec y pour des tableaux 1D, ou
leur produit matriciel pour des tableaux 2D.
[Link]() Calcule la valeur minimum des éléments de x. Optionnellement, on
peut fournir un argument entier spécifiant la dimension sur laquelle
calculer le minimum.
[Link]() Similaire pour calculer la valeur maximum.
[Link]() Similaire pour calculer la valeur moyenne.
[Link]() Similaire pour calculer la déviation standard.
[Link](d) Arrondi chaque élément au nombre de décimales d spécifié.
[Link](amin,amax) Retourne un tableau où les valeurs plus petites que amin sont rem-
placées par amin et celles plus grandes que amax sont remplacées
par amax.
[Link]() Retourne l’indice de l’élément égal à la valeur maximum du tableau.
[Link]() Retourne l’indice de l’élément égal à la valeur minimum du tableau.
Fonctions
[Link](x) Arrondi chaque élément à l’entier inférieur (ne modifie pas le type).
[Link](x) Arrondi chaque élément à l’entier supérieur.
[Link](x) Calcule la valeur médiane des éléments d’un tableau.
[Link](x,y) Calcul le produit vectoriel de deux vecteurs.
[Link](x,y) Élément par élément, retourne le plus petit du tableau x ou y.
[Link](x,y) Élément par élément, retourne le plus grand du tableau x ou y.
[Link](condition) Retourne le tuple d’indices pour lesquels la condition est vraie.
np.logical_and(c1,c2) Opérateur logique and agissant élément par élément sur les ta-
bleaux booléens c1 et c2.
np.logical_or(c1,c2) Opérateur logique or agissant élément par élément sur les tableaux
booléens c1 et c2.
np.logical_not(c1,c2) Opérateur logique not agissant élément par élément sur le tableau
booléen c1.
*
Toutes ces méthodes possèdent une fonction équivalente. Par exemple [Link]() et [Link](x)
produiront le même résultat.

1 import numpy as np
2 import [Link] as plt
3

4 x=[Link](0.0,10.0,0.1)
5 y=[Link](x)
6

7 [Link](x,y)
8

9 [Link]([-0.5,10.5,-1.3,1.3])
10 [Link]('Abscisse')
11 [Link]('Ordonnée')
12 [Link]('Fonction sinus')
13

14 [Link]()

En bref, on importe le sous-module de fonction graphiques PyPlot (ligne 2), on prépare un graphique
(lignes 4–12), et on l’affiche à l’écran (ligne 14). Le code ci-haut produit le résultat montré à la figure 3.2.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

3.4. FIGURES ET GRAPHIQUES 41

Fonction sinus

1.0

0.5
Ordonnée
0.0

0.5

1.0

0 2 4 6 8 10
Abscisse
Figure 3.2 – Figure produite par le code montré ci-haut.

Examinons ces commandes un peu plus en détail. La fonction plot(x,y) crée une courbe spécifiée par
les vecteurs x et y sur un système d’axes à deux dimensions. La fonction axis([xmin,xmax,ymin,ymax])
permet de définir les limites des axes x et y du graphique. La fonction xlabel() permet de définir le titre
de l’axe des x, et ylabel() celui de l’axe des y. La fonction title() définit le titre du graphique. Enfin,
la fonction show() ouvrira une fenêtre montrant le graphique. Notez que lorsque la fenêtre d’affichage
graphique est ouverte, vous n’avez plus le contrôle de l’invite de commande Python (si vous êtes en mode
interactif) ou l’exécution est interrompue (si l’affichage est produit par un script), et ce sera ainsi tant que
la fenêtre graphique ne sera pas fermée. Pour éviter ce blocage, si on le veut, il faut fournir l’argument
block=0 à la commande show(), i.e. il faut utiliser show(block=0).

Notez que dans le corps du texte de cette section j’omettrai d’écrire le préfixe “plt.” devant chaque
fonction de PyPlot pour alléger le texte, mais souvenez-vous bien que ce préfixe doit être présent dans un
code si le module est importé avec la commande import [Link] as plt.

3.4.1 La fonction plot()

Cette fonction, à la base de l’affichage d’un graphique, mérite certaines explications. Par défaut,
plot(x,y) affiche une courbe en utilisant une ligne pleine, mais on peut très facilement modifier cet
affichage par défaut en fournissant un argument positionnel supplémentaire de “format” à cette commande.
Par exemple, la commande plot(x,y,’o’) affichera les points avec un symbole correspondant à un cercle,
alors que plot(x,y,’*’) affichera les points avec des étoiles. On peut aussi choisir la couleur de l’affichage
avec ce même argument positionnel de format, par exemple plot(x,y,’go’) affichera des cercles verts
(la lettre g est un raccourci pour green et indique la couleur verte, alors que la lettre o indique que le
symbole sera un cercle). Alternativement, plutôt que d’utiliser cet argument positionnel de formattage, on
peut utiliser des arguments nommés. Par exemple, plot(x,y,marker=’o’,linestyle=’ ’,color=’g’)
produira la même chose que plot(x,y,’go’).
De plus, on peut créer plusieurs courbes lors d’un seul appel à plot() en fournissant plusieurs paires
de vecteurs x et y. Par exemple, plot(x1,y1,x2,y2) ou plot(x1,y1,’g0’,x2,y2,’r*’). Si plusieurs
paires de vecteurs sont fournies et que des arguments nommés sont présents, alors l’effet de ceux-ci est
appliqué à toutes les courbes. Alternativement, pour créer plusieurs courbes sur un même graphique, on
peut simplement faire plusieurs appels à la commande plot() avant d’afficher le graphique.

Les principales couleurs sont ‘b’ (blue), ‘g’ (green), ‘r’ (red), ‘c’ (cyan), ‘m’ (magenta), ‘y’ (yellow), ‘k’
(black) et ‘w’ (white).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

42 CHAPITRE 3. PYTHON : QUELQUES NOTIONS SUPPLÉMENTAIRES

Les principaux styles de traits sont ’-’ (plein), '--' (hachuré), ’-.’ (hachuré-pointillé), ’:’ (poin-
tillé) et ’ ’ (pas de trait).

Les principaux symboles sont ’.’ (point), ’,’ (pixel), ’o’ (cercle), ’v’ (triangle bas), '^' (triangle
haut), ’<’ (triangle gauche), ’>’ (triangle droite), ’s’ (carré), ’p’
(pentagone), ’*’ (étoile), ’h’ (hexagone1), ’H’ (hexagone 2), ’+’ (plus),
’x’ (x), ’D’ (losange), et ’d’ (losange étroit).

Les principaux arguments nommés sont :

fontsize=12 taille des caractères

label=’description’ description de la courbe pour légende
linestyle=’;’ type de ligne
linewidth=3 épaisseur des lignes
marker=’,’ type de symboles
markeredgewidth=2 épaisseur du contour des symboles
markeredgecolor=’b’ couleur du contour des symboles
markersize=12 taille des symboles
color=’b’ définit la couleur

Pour plus d’aide sur cette fonction, incluant la liste complète des symboles, couleurs et arguments
nommés, consultez l’aide ici 10 . Sur cette page d’aide, vous verrez que les couleurs peuvent être spécifiées
de plusieurs façons, dont notamment par leur nom de couleur X11/CSS4 ; la liste de celles-ci est disponible
ici. 11

Graphiques avec axe(s) logarithmique(s) Trois fonctions analogues à plot() sont disponibles pour
tracer une courbe avec un ou deux axes logarithmiques : loglog() pour faire un graphique log-log,
semilogx() pour un graphique log-normal, et semilogy() pour un graphique normal-log. La syntaxe et
les arguments de ces fonctions sont identiques à ceux de la fonction plot(). Si ces fonctions sont utilisées
après un appel à plot() dans une même figure, alors les axes existants seront modifiés.

3.4.2 Sauvegarder un graphique

Vous pouvez sauvegarder un graphique dans un fichier avec la fonction savefig(nomFichier). Cette
commande doit être placée avant un appel à show(), le cas échéant. Le format du graphique produit
est déterminé automatiquement à partir de l’extension spécifiée dans le nom de fichier. Par exemple, la
commande suivante,

[Link](’[Link]’)

sauvegardera la figure dans un fichier au format PDF. Les formats de fichiers graphiques supportés
par Matplotlib sur le système esibac de l’UdeM sont : .png, .rgba, .svg, .eps, .ps, .pgf, .svgz,
.raw, .pdf. Il est possible que d’autres formats soient supportés sur vos ordinateurs personnels, pour voir
la liste vous pouvez taper la commande “print([Link]().canvas.get_supported_filetypes().keys())”.
La commande savefig([Link]) comporte plusieurs arguments optionnels ; vous pouvez
consulter sa référence ici 12 .

3.4.3 Personnalisation d’un graphique

On peut facilement personnaliser un graphique à l’aide de plusieurs fonctions, les principales sont
présentées à la table 3.5.

10. [Link]
11. [Link]
12. [Link]

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

3.4. FIGURES ET GRAPHIQUES 43

Table 3.5 – Principales fonctions PyPlot pour modifier l’apparence d’un graphique

Fonction∗ Description
title(’titre’) Définit le titre du graphique.
xlabel(’x’) Définit l’étiquette de l’axe des x.
ylabel(’y]) Définit l’étiquette de l’axe des y.
xscale(’log’) Établit/modifie l’échelle de l’axe des x, ’log’, ’linear’. Pour log
on peut aditionnellement spécifier une base (base 10 par défaut).
yscale(’log’) Établit/modifie l’échelle de l’axe des y.
axes([xmin,xmax,ymin,ymax]) Définit les limites des axes x et y.
xlim(xmin,xmax) Définit les limites de l’axe des x. On peut aussi utiliser les argu-
ments nommés xmin= ou xmax= pour ne modifier qu’une limite.
ylim(ymin,ymax) Définit les limites de l’axe des y. Ou arguments nommés ymin= ou
ymax=.
axis(’equal’) Adapte les limites des axes pour forcer une échelle identique sur les
deux axes (pour qu’un cercle paraisse circulaire, par exemple).
axis(’scaled’) Adapte la taille du graphique pour forcer une échelle identique sur
les deux axes.
axis(’off’) Omet les échelles et les marques sur les axes.
xticks(pos[,noms]) Place les graduations de l’axe des x aux positions spécifiées par
le tableau/liste pos. Optionnellement, la liste noms définit les éti-
quettes de ces graduations.
yticks(pos[,noms]) Similaire pour l’axe des y.
tick_params() Permet de modifier plusieurs paramètres des graduations des axes.
minorticks_on() Affiche des graduations secondaires.
legend(loc=’best’) Ajoute une légende. La description de chaque courbe corresponde
à l’argument label passé à plot(). (location : ’best’, ’upper
left’, ’center right’, etc.)
axvline(x) Ajoute une ligne verticale sur le graphique à la position x spécifiée.
axhline(y) Ajoute une ligne horizontale sur le graphique à la position y spéci-
fiée.
text(x,y,s) Ajoute le texte de la chaîne s à la position (x, y).
*
La plupart de ces fonctions ont plusieurs autres paramètres optionnels, consultez leur référence ici 13 pour les
connaître.

3.4.4 Affichages de symboles, exposants, indices, etc.

Pour produire de bons étiquettes d’axes sur vos graphiques, titres, ou toutes autres annotations, vous
aurez besoin d’afficher des symboles Grecs, des indices, des exposants, des fractions, etc. Ceci peut se
faire très facilement avec PyPlot en utilisant la syntaxe de l’écriture en mode mathématique de LATEX.
Mais d’abord, il faut indiquer que la chaîne de caractère correspondant à ce que l’on veut afficher doive
être interprétée de façon littérale (literal string), de sorte que certains caractères spéciaux comme le “\”
n’aient pas l’effet habituel (par exemple \t introduit habituellement un “tab” à l’affichage en sortie) mais
soient plutôt interprétés comme de simples caractères. On accomplit ceci en ajoutant la lettre “r” devant
l’apostrophe ou le guillemet marquant le début de la chaîne de caractères, comme dans l’exemple qui suit,

print(r'allo\ttoi')

qui affichera à l’écran le résultat “allo\ttoi” (sans le r devant la chaîne, print('allo\ttoi') afficherait
le résultat “allo toi”). Une fois cette précaution prise, il suffit d’insérer dans la chaîne de caractères
des commandes mathématiques LATEX (entre deux caractères $ comme on le ferait en LATEX). La liste des
commandes mathématiques LATEX supportées par PyPlot est donnée ici 14 ; consultez cette page si vous
n’êtes pas familiers avec LATEX.
Le code montré à la page 44 fournit quelques exemples de commandes pour l’affichage de symboles et
d’équations ; le résultat correspondant est montré à la figure 3.3.
14. [Link]

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 44 CHAPITRE 3. PYTHON: QUELQUES NOTIONS SUPPLÉMENTAIRES

3.4.5 Figures, graphiques et axes multiples

PyPlot opère selon un concept de “figure courante” et “d’axes courants” ; toutes les commande d’affi-
chage s’appliquent aux axes courants de la figure courante. Une figure est simplement une “fenêtre” dans
laquelle on peut afficher des choses, ou un “conteneur” dans lequel on peut placer des choses à afficher ;
en Matplotlib, la figure est le conteneur du plus haut niveau possible. Les axes définissent une région par-
ticulière de la figure où des données peuvent être affichées ainsi que la correspondance entre les positions
dans la figure et les valeurs à afficher, en plus de définir l’apparence des axes eux-mêmes (graduations,
étiquettes, etc.). En Matplotlib, le système d’axes est aussi un conteneur (inclut dans une figure), qui
contiendra les axes, leurs étiquettes, leurs graduations, etc., mais aussi les courbes et les diverses annota-
tions. On peut définir une nouvelle figure à l’aide de la fonction figure() et de nouveaux axes à l’aide
de la fonction axes(). Normalement on n’a pas besoin de se soucier de ces détails car la fonction plot()
le fait automatiquement si ce n’est pas déjà fait. Par contre pour afficher et manipuler plusieurs figures,
graphiques et systèmes d’axes simultanément on doit s’en préoccuper.
La fonction figure(n) crée une nouvelle figure (ou plutôt un nouvel objet de type figure) et lui
assigne le numéro n, si cette figure n’existe pas déjà. Si la figure n existe déjà, alors cette commande la
rend active. Cette fonction comporte plusieurs arguments que vous pouvez voir ici 15 . Un argument utile
est figsize=(l,h) qui définit la largeur (l) et la hauteur (h) de la figure, en pouces.
La fonction axes() crée un nouveau système d’axes dans la figure courante. Par défaut, les axes
occupent toute la surface de la figure (en laissant l’espace nécessaire aux étiquettes d’axes, titres, etc.).
Alternativement, on peut spécifier la position et la taille des axes avec axes([g,b,l,h]), où les 4 nombres
réels de la liste spécifient respectivement la position gauche, la position du bas, la largeur et la hauteur de
la zone correspondant au système d’axes, dans des unités de fraction de la taille de la figure (ces nombres
sont donc compris entre 0 et 1). Les commandes d’affichages qui suivront (plot(), etc.) se feront dans ce
nouveau système d’axes courant.
La fonction subplot(nc,nr,i) crée un nouveau système d’axes occupant une sous-section de la figure
courante : les axes occuperont l’espace correspondant à la section numéro i lorsque l’on subdivise la figure
en une grille de nc colonnes et nr rangées, en commençant à compter les sections par 1 et en augmentant
d’abord selon les rangées. C’est simplement une façon d’éviter d’avoir à calculer soi-même la position et la
taille de la zone du système d’axes avec un appel à axes([g,b,l,h]). La fonction axes([g,b,l,h]) offre
toutefois plus de flexibilité et est parfois préférable. Notez aussi que la fonction axes() sans argument est
équivalente à subplot(1,1,1).
La fonction twinx() crée un 2e système d’axes partageant le même axe x que le système d’axes courant
mais utilisant un nouvel axe y dont les étiquettes seront affichées à droite. Tout appel à plot() fait après
cette commande twinx() utilisera ce 2e système d’axe. Similairement, la fonction twiny() crée un 2e
système d’axes partageant le même axe y que le système d’axes courant mais utilisant un nouvel axe x
dont les étiquettes seront affichées en haut.
Enfin, les fonctions subplots_adjust() et tight_layout() permettent de contrôler certains para-
mètres d’espacements des différents systèmes d’axes pour en améliorer l’apparence visuelle de la figure.
Le code donné en exemple ci-bas illustre ces différents concepts et produit le résultat montré à la figure 3.3.

1 import numpy as np
2 import [Link] as plt
3

4 x = [Link](0.0, 5.01, 0.1)

5

6 [Link](1,figsize=(6.5,3.5),dpi=200)
7

8 [Link](2, 2, 1) # 2 rangees, 2 colonnes, section 1

9 [Link](x, [Link](-x)*[Link](2*[Link]*x), 'bo')
10 [Link](-1,1)
11 plt.tick_params(labelbottom=0,labelsize='small')
12 [Link](r'$f(x)=e^{-x}\cos{(2\pi x)}$',size='small')
13 plt.minorticks_on()

15. [Link]

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 3.4. FIGURES ET GRAPHIQUES 45

14

15 [Link](2, 2, 3) # 2 rangees, 2 colonnes, section 3

16 [Link](x, [Link](-([Link]()/2)**2), 'g--')
17 [Link](0,1)
18 plt.tick_params(labelsize='small')
19 [Link](r'$f(x)=e^{-(x-'+str([Link]()/2)+r')^2}$',size='small')
20 [Link](r'$x$')
21 plt.minorticks_on()
22

23 [Link](1, 2, 2) # 1 rangee, 2 colonnes, section 2

24 [Link](x,[Link](2*[Link]/5*x), 'r')
25 plt.tick_params(labelsize='small')
26 [Link](color='r')
27 [Link](r'$f(x)=\sin{(\frac{2\pi x}{5})}$',color='r',size='small',labelpad=0)
28 [Link](r'$x$')
29 plt.minorticks_on()
30

31 [Link]()
32 [Link](x,x**4,'b')
33 [Link](color='b',size='small')
34 [Link](r'$f(x)=x^4$',color='b',size='small')
35 plt.minorticks_on()
36

37 plt.tight_layout(pad=0.5,h_pad=0)
38

39 [Link]()

1.0 1.0 700

f(x) = e−x cos(2πx)

0.5 600
0.0 0.5 500
0.5
5 )

400
f(x) =sin(2πx

1.0
f(x) = x4
1.0 0.0
300
0.8
2
f(x) = e−(x−2.5)

0.6 0.5 200

0.4
100
0.2
0.0 1.0 0
0 1 2 3 4 5 0 1 2 3 4 5
x x
Figure 3.3 – Figure produite par le code montré à la page 44.

Notez que l’on aurait pu obtenir le même résultat en utilisant des appels à axes([g,b,l,h]) plutôt
qu’à subplot() avec le code suivant :

1 #...
2 [Link]([0.106,0.571,0.345,0.385])
3 [Link](x, [Link](-x)*[Link](2*[Link]*x), 'bo')

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 46 CHAPITRE 3. PYTHON: QUELQUES NOTIONS SUPPLÉMENTAIRES

4 #...
5

6 [Link]([0.106,0.147,0.345,0.385])
7 [Link](x, [Link](-([Link]()/2)**2), 'g--')
8 #...
9

10 [Link]([0.556,0.147,0.345,0.8])
11 [Link](x,[Link](2*[Link]/5*x), 'r')
12 plt.tick_params(labelsize='small')
13 #...
14 [Link]()
15 [Link](x,x**4,'b')
16 #...

La fonction gca() retourne une référence à l’objet correspondant aux axes courants. Pour savoir la
position et la taille des axes courants dans la figure on peut utiliser la commande print([Link]()), et
se baser sur ces valeurs pour positionner un autre système d’axes à notre guise.

3.4.6 Approche “objet”

Les commandes présentées ci-haut devraient vous suffire pour produire la majorité de vos graphiques,
pour ce cours et pour les autres cours de votre bacc. Toutefois, toute la puissance de Matplotlib peut être
plus facilement exploitée en adoptant une approche plus “objet”. Tel que mentionné déjà, tout en Python
est un objet, et ceci vaut pour les figures, les axes, les courbes, le texte, etc. L’idée de l’approche objet est
d’assigner des identificateurs aux objets créés et de modifier leurs propriétés à l’aide de méthodes agissant
directement sur eux ; toutes leurs propriétés peuvent ainsi être facilement modifiées, ce qui donne un plus
grand contrôle. Les principaux objets pour la production de graphique sont les figures, les axes, les courbes
et le texte. Dans le jargon de Matplotlib, on réfère à ces types d’objets principaux comme des “artistes”.
Je vous recommande d’ailleurs d’aller voir ce petit tutoriel sur les artistes 16 .
L’essentiel pour en arriver à produire des figures par cette approche “objet” est de savoir quels sont
les principaux types d’objets, comment les créer, et quelles sont les méthodes pouvant agir sur eux, alors
voici :
— La fonction [Link]() crée un objet de type “Figure” (plus exactement de type : matplotlib.
[Link]) ; la liste des propriétés et méthodes de ce type d’objet est donnée ici 17 .
— La méthode fig.add_axes() crée un système d’axes dans la figure fig et retourne une objet de
type “Axes” (plus exactement : [Link]) ; la liste des propriétés et méthodes de ce
type d’objet est donnée ici 18 . Ceci est aussi valide pour fig.add_subplot().
— La méthode [Link]() trace une courbe dans le systèmes d’axes ax et retourne une liste d’objets de
type “Ligne” (plus précisément : [Link].Line2D) ; la liste des propriétés et méthodes
de ce type d’objet est donnée ici 19 . Ceci est aussi valide pour les autres variantes de [Link](),
comme [Link](), [Link](), etc.
— La méthode [Link]() ajoute du texte dans le systèmes d’axes ax et retourne un objet de type
“Texte” (plus précisément : [Link]) ; la liste des propriétés et méthodes de ce
type d’objet est donnée ici 20 .
Puisqu’un exemple vaut mille mots, voici un exemple simple qui illustre la façon de procéder, le résultat
est montré à la figure 3.4.

1 import numpy as np
2 import [Link] as plt
3

4 t = [Link](-[Link],[Link],2000)
16. [Link]
17. [Link]
18. [Link]
19. [Link]
20. [Link]

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 3.4. FIGURES ET GRAPHIQUES 47

5 r = (1+0.3*[Link](5*t))*(1+0.1*[Link](50*t))
6 x = r*[Link](t)
7 y = r*[Link](t)
8

9 fig1=[Link](figsize=(4.3,4),dpi=200) # crée une figure

10 ax1=fig1.add_axes([0.18,0.13,0.75,0.8]) # crée un système d'axes dans fig1
11 ax1.set_ylim(-1.3,1.7) # définit les limites de l'axe des x
12 ax1.set_aspect('equal') # définit l'aspect des axes
13 c1=[Link](x,y) # trace une courbe dans le système d'axes ax1
14 c1[0].set_linewidth(2) # modifie l'épaisseur de la courbe
15 ax1.set_xlabel(r'$x=r\,\cos{(\theta)}$') # étiquette d'axe x
16 ax1.set_ylabel(r'$y=r\,\sin{(\theta)}$') # étiquette d'axe y
17 ax1.minorticks_on() # graduations mineures
18 [Link](-1.4,1.5,r'$r=(1+0.3\,\sin{(5\theta)}) \times\, (1+0.1\,\sin{(50\theta)})$')
19 [Link](-1.4,1.35,r'$-\pi < \theta < \pi$')
20

21 [Link]()

1.5 r−=(1 +0.3 sin(5θ)) × (1 +0.1 sin(50θ))

π <θ <π
1.0
0.5
y = r sin(θ)

0.0
0.5
1.0
1.5 1.0 0.5 0.0 0.5 1.0 1.5
x = r cos(θ)
Figure 3.4 – Figure produite par le code montré à la page 46.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

48 CHAPITRE 3. PYTHON : QUELQUES NOTIONS SUPPLÉMENTAIRES

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 49

Chapitre 4

Dérivées, interpolation et intégration

Dans ce chapitre et deux autres à venir, nous allons voir comment effectuer numériquement sur ordina-
teur la série de grandes manoeuvres mathématiques qu’on vous a appris en calcul intégral et différentiel :
calculer des dérivées et intégrales (ce chapitre), solutionner des équations différentielles simples (chapitre
7), et trouver les zéros et extrema d’une fonction (chapitre 6).
Nous devrons en fait d’abord discuter le contexte mathématique qui est à la base du calcul numérique
des dérivées et intégrales, soit le développement en série de Taylor (§4.1). Nous examinerons ensuite
le processus de discrétisation d’une fonction, pour en arriver au calcul de formules dites de différences
finies pour le calcul numérique des dérivées (§4.2). Nous examinerons ensuite l’interpolation (§4.3), ce
qui paraitra être un détour mais nous fournira une base solide pour passer au calcul numérique des
intégrales (§4.4). Nous concluerons en généralisant toutes ces grandes manoeuvres aux fonctions de plus
d’une variable (§4.5).

4.1 Le développement en série de Taylor

On vous a appris au CEGEP (ou peut-être même avant) que la dérivée d’une fonction f (x) évaluée à
x = x0 correponds à la pente d’une droite tangente à f (x) au point x0 . Mathématiquement, ceci revient
à écrire :

df (x) f (x0 + ∆x) − f (x0 )

= lim (4.1)
dx x0 ∆x→0 ∆x
avec ∆x ≡ x − x0 . Comme l’illustre la Figure 4.1, l’utilisation de l’équation (4.1) avec un ∆x de taille
finie produira une erreur sur le calcul de la pente, qui cependant s’amenuise à mesure que ∆x devient de
plus en plus petit.
On ne vous l’a pas appris comme ça à l’époque, mais l’équation (4.1) résulte en fait d’une troncation
d’un développement plus général, dit en série de Taylor, d’une fonction continue f (x) dans les environs
de x0 :
df (∆x)2 d2 f (∆x)3 d3 f
f (x0 + ∆x) = f (x0 ) + (∆x) + + + ...
dx x0 2! dx2 x0 3! dx3 x0

∞
X (∆x)n dn f
= f (x0 ) + , (4.2)
n=1
n! dxn

où n! est la fonction factorielle, définie comme :

n! ≡ n × (n − 1) × (n − 2) × ... 2 × 1 . (4.3)

La Figure 4.2 illustre l’idée générale d’un tel développement. La fonction développée est ici un polynôme
quartique de la forme :

f (x) = 1 + x4 . (4.4)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

50 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.1 – La dérivée comme un procesuss de calcul de pente dans la limite ∆x → 0. Plus ∆x est
petit, plus la droite passant par x et x + ∆x a une pente se rapprochant de la tangente à f (x) au point
x0 (droite en tirets).

Les quatre autres courbes résultent de l’utilisation du développement (4.2), en ne conservant que 1, 2,
3 ou 4 termes, tel qu’indiqué sur la Figure. Ne conserver que le premier terme revient à dire que f (x)
assume une valeur constante :

f (x0 + ∆x) = 1 + x40 . (4.5)

Conserver les deux premier termes conduit à :

f (x0 + ∆x) = 1 + x40 + 4(∆x)x30 , (4.6)

tandis que conserver trois ou quatre termes donne :

f (x0 + ∆x) = 1 + x40 + 4(∆x)x30 + 6(∆x)2 x20 , (4.7)

f (x0 + ∆x) = 1 + x40 + 4(∆x)x30 + 6(∆x)2 x20 + 4(∆x)3 x0 . (4.8)

Examinez bien la Figure 4.2, pour vous convaincre que le développement devient de plus en plus précis à
mesure que le nombre de termes retenus dans le développement augmente, ou que l’intervalle ∆x diminue.
Remarquez également qu’une fois les dérivées évaluées, le développement se retrouve à prendre la forme
d’un polynôme en puissances de ∆x.
La précision du développement peut évidemment être améliorée en subdivisant l’intervalle ∆x en sous-
pas, et en reévaluant les dérivées au membre de droite de (4.2) après chaque sous-pas. Un exemple est
présenté à la Figure 4.3, toujours pour notre polynôme quartique. Comparant cette Figure à la Fig. 4.2,
notez comment la précision de l’estimé de f (x0 +2∆x) d’ordre n est comparable à celui de l’estimé d’ordre
n + 1 quand le pas est deux fois plus grand.
Si ∆x → 0, chaque terme successif au membre de droite de l’éq. (4.2) est plus petit que le précédent
par un facteur ∆x, donc si ∆x ≪ 1 on peut s’attendre à ce que le développement soit dominé par les

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.2. DÉRIVÉES D’UNE FONCTION 51

Figure 4.2 – Développement en série de Taylor d’un polynôme quartique (trait noir), en ne conservant
qu’un, deux, trois ou quatre termes dans le développement, tel qu’indiqué. Le développement devient
de plus en plus précis à mesure que le pas ∆x diminue, et/ou le nombre de termes conservés dans le
développement augmente.

quelques premiers termes, et je vous laisse vérifier que l’équation (4.1) est obtenue en ne conservant que
les deux premiers.
Le développement en série de Taylor apparaitra de manière récurrente dans les chapitres qui suivent.
Pour l’instant, nous nous limiterons à la situation suivante : on cherche à évaluer de manière discrète les
dérivées d’une fonction continue d’une variable f (x). On suppose que cette fonction est calculable pour
tout x, mais a une forme telle qu’il nous est impossible d’en calculer la dérivée analytiquement.

4.2 Dérivées d’une fonction

4.2.1 Discrétisations d’une fonction
Nous devons d’abord introduire l’idée de la discrétisation d’une fonction continue f (x), soit sa repré-
sentation en terme d’un nombre fini de valeurs numériques, processus incontournable lorsqu’on cherche à
obtenir une solution numérique de quoi que ce soit. Le point de départ est la définition d’une maille (ici
en 1D) sur laquelle f (x) est évaluée à un nombre fini de noeuds (ou points de maille) xj :

x → {x1 , x2 , ..., xN }, xj+1 > xj , (4.9)

Un maillage est dit régulier si les intervalles entre chaque xj successifs sont égaux :

xj+1 − xj ≡ h ∀j. (4.10)

L’évaluation de f (x) aux xj produit une ensemble de N valeurs de f , qui collectivement définissent la
discrétisation de f (x) :

fj ≡ f (xj ) , j = 1, 2, ..., N . (4.11)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

52 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.3 – Semblable à la Figure 4.2, sauf que le pas ∆x est subdivisé en deux, et les dérivées
apparaissant dans le développement reévaluées à la position x0 + ∆x pour obtenir un estimé final à
x0 + 2∆x.

Cette procédure de discrétisation est illustrée à la Figure 4.4, pour une fonction parabolique discrétisée
sur un maillage régulier avec N = 8.

4.2.2 Les différences finies

Le développement en série de Taylor est à la base du calcul des dérivées d’une fonction discrétisée. Par
exemple, en tronquant tous les termes au membre de droite de l’éq. (4.2) sauf les deux premiers, on peut
immédiatement obtenir une approximation pour la dérivée première de la fonction discrétisée f (xk ) :

df fj+1 − fj
= + O(h) . (4.12)
dx xj h

Le terme en O(h) au coté droit de cette formule de différences finies indique que l’erreur de dis-
crétisation y étant associée décroit proportionnellement à h (≡ ∆x) dans la limite h → 0, conséquence
directe de notre omission ici des termes en (∆x)2 , (∆x)3 , ... dans l’éq. (4.2). Notez que cette approche de
troncation “brute” fonctionne pour la dérivée première, mais ne nous permet pas de produire de formule
équivalente pour la dérivée seconde. Voyons comment faire mieux.
Notre point de départ consiste à établir les deux développements suivants pour f (xj ± h) au voisinage
de xj :

df h2 d2 f h3 d3 f
fj+1 ≡ f (xj+1 ) ≡ f (xj + h) = f (xj ) + h + + + ... (4.13)
dx xj 2! dx2 xj 3! dx3 xj

df h2 d2 f h3 d3 f
fj−1 ≡ f (xj−1 ) ≡ f (xj − h) = f (xj ) − h + − + ... (4.14)
dx xj 2! dx2 xj 3! dx3 xj

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.2. DÉRIVÉES D’UNE FONCTION 53

Figure 4.4 – Discrétisation d’une fonction parabolique sur un maillage régulier, avec N = 8. Plus N est
grand, plus la discrétisation donne une représentation précise de la fonction.

De nouvelles formules de différences finies sont obtenues par manipulations algébriques simples des
éqs. (4.13)—(4.14) ; par exemple, en soustrayant l’équation (4.14) de (4.13) et en éliminant les termes
proportionnels aux puissance de h de trois et plus, on peut isoler ∂f /∂x et on obtient :
df fj+1 − fj−1
= + O(h2 ) . (4.15)
dx xj 2h

Et voilà pour la dérivée première. Maintenant, On peut aussi additionner les équation (4.14) et (4.13) et
isoler d2 f /dx2 , ce qui produit
d2 f fj+1 − 2fj + fj−1
= + O(h2 ) , (4.16)
dx2 xj h2

Par utilisation récursive des éqs. (4.13) et (4.14) on peut ensuite obtenir des formules de différences finies
pour les dérivées d’ordre plus élevées :

d3 f fj+2 − 2fj+1 + 2fj−1 − fj−2

= + O(h2 ) , (4.17)
dx3 2h3
xj

d4 f fj+2 − 4fj+1 + 6f j − 4fj−1 + fj−2

= + O(h2 ) . (4.18)
dx4 h4
xj

Qu’avons nous gagné ici ? Le terme en O(h2 ) aux cotés droits des éqs. (4.15)—(4.16) indique que l’erreur
de discrétisation associée à ces formules de différences finies pour la dérivée première décroit maintenant
proportionnellement à h2 dans la limite h → 0. Ces différences finies sont donc dites d’ordre 2. En
principe la formule (4.15) calcule la même chose que l’éq. (4.12), mais pour une maille donnée, est en
général plus précise.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

54 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Par d’autres manipulations des éqs. (4.13) et (4.14) et utilisation récurrente des formules d’ordre
O(h) and O(h2 ) ci-dessus, on peut obtenir des formules alternatives, caractérisées par des erreurs de
discrétisation d’ordre plus élevé :

∂f −fj+2 + 8fj+1 − 8fj−1 + fj−2

= + O(h4 ) , (4.19)
∂x xj 12h

d2 f −fj+2 + 16fj+1 − 30fj + 16fj−1 − fj−2

= + O(h4 ) . (4.20)
dx2 xj 12h2

Les formules de différences finies (4.15)—(4.20) sont dites centrées sur le noeud xj où la dérivée est
évaluée. Elles ne peuvent dont pas être utilisées sur le premier (j = 1) et dernier (j = N ) noeud de
la maille. Cependant d’autres manipulation algébriques des éqs. (4.13) et (4.14) peuvent produire des
formules de différences finies avant ou arrière. Les intéressé(e)s peuvent consulter les références citées
en fin de chapitre.

4.2.3 Exemple : dérivée numérique de sin θ

Pour apprécier la signification de l’ordre de discrétisation, considérons l’exemple suivant. Suite à une
année sabbatique particulièrement mouvementée, vous avez complètement oublié que la dérivée d’un sinus
est un cosinus :
d sin θ
= ????? , (4.21)
dθ
ce qui est excessivement problématique dans votre cours de mécanique (entre autre), mais votre calculatrice
vous permet heureusement de calculer sin θ. La Figure 4.5 montre l’erreur associée à l’utilisation des
éqs. (4.12), (4.16), et (4.19), pour évaluer la dérivée de sin θ (= cos θ ! !) à θk = π/6. On suppose ici que

fk = sin θk , fk−1 = sin(θk − h) , fk+1 = sin(θk + h) . (4.22)

La mesure de l’erreur utilisée ici est

d sin θ
ε= − cos θ , (4.23)
dθ

où la dérivée est évaluée à l’aide de nos trois différences finies pour la dérivée première, soit les équations
(4.12), (4.15), et (4.19). On remarque que dans tous les cas l’erreur diminue à mesure que h diminue, mais
que l’ordre de la formule utilisée détermine le taux auquel diminue l’erreur à mesure que h diminue :

O(h) : ε ∝ h1 , O(h2 ) : ε ∝ h2 , O(h4 ) : ε ∝ h4 , (4.24)

puisque les axes sur la Fig. 4.5 sont logarithmiques. La figure 4.6 montre aussi l’erreur associée au calcul
de la dérivée de sin θ, mais cette fois sur la plage de x allant de 0 à 2π et pour différents pas de mailles,
en utilisant la formule de l’éq.(4.16). On remarque ici que l’erreur dépend non seulement de la taille du
pas de maille, mais aussi de la forme de la fonction à dériver au point x où le calcul est fait. Ici, l’erreur
est minimisée aux extrema de sin θ alors qu’elle est plus importante aux extrema de cos θ ; en fait avec la
formule utilisée on peut montrer que l’erreur est ∝ d3 f (x)/dx3 × h2 .
Les données requises pour construire les courbes sur la Figure 4.5 se calculent en Python à l’aide du code
ci-dessous (ici pour la formule O(h2 ) donnée par l’éq. (4.15)). Ce code utilise les fonctions mathématiques
prédéfinies sin(x) et cos(x), qui sont importées du module math au début du code. Il en est de même
pour la valeur de π (la variable pi), qui est définie dans le même module (et dans bien d’autres, comme
NumPy par exemple). Remarquez comment, à chaque itération de la boucle, la valeur du pas spatial h
utilisé pour le calcul de la dérivée décroit d’un facteur 1.1.
Code Python pour calculer les erreurs portées en graphique à la Fig. 4.5
"""
Ce programme calcule la derivee de sin(x), i.e. cos(x), par differences finies,
a une valeur de x donnee (pi/6) et pour differents pas de mailles.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.2. DÉRIVÉES D’UNE FONCTION 55

10 0

10 -1
O(h)
10 -2
O(h 2 )
O(h 4 )
Erreur

10 -3

10 -4

10 -5
10 0 10 -1 10 -2
Taille du pas de maille (h)
Figure 4.5 – Variations de l’erreur de discrétisation en fonction de la taille du pas, pour l’évaluation
numérique de la dérivée de sin θ à θ = π/6, utilisant les formules de différences finies données par les
éqs. (4.15) (△), (4.12) (∗) et (4.19) (⋄). Notez bien que les deux axes sont logarithmiques, et que l’abscisse
est telle que h décroit de la gauche vers la droite.

"""

#importation de certaines fonctions/constantes du module math

from math import sin,cos,pi

niter=25 #nombre d'iterations

h=1. #pas de maille initial
t=pi/6. #angle auquel evaluer la derivee

for i in range(0,niter):
deriv=(sin(t+h)-sin(t-h))/(2.*h) #formule O(h^2)
err=abs(deriv-cos(t)) #erreur
print("h:",h,"erreur:",err)
h/=1.1

Aussi à titre d’exemple, le code nécessaire pour réaliser la Figure 4.6 est montré ci-dessous.

Code Python pour produire le graphique de la Fig. 4.6

"""
Ce programme calcule la derivee de sin(x), i.e. cos(x), par differences finies,
sur la plage x=0..2*pi, pour differents pas de mailles.
"""

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

56 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

10-1 1.0

10-2
0.5
10-3
Erreur absolue

10-4

sin(x)
0.0
10-5

10-6
0.5
10-7

10-8 0 1 2 3 4 5 6
1.0
Angle (rad)
Figure 4.6 – Variations de l’erreur de discrétisation (points) pour l’évaluation numérique de la dérivée
de sin θ en fonction de θ et de la taille du pas de maille, en utilisant la formule de différences finies donnée
par l’éq. (4.12), menant à une erreur ∝ h2 . Les pas de mailles sont de 2π/10 (bleu), 2π/50 (vert), 2π/100
(rouge), et 2π/1000 (turquoise). Notez bien que l’axe des y est logarithmique. Pour référence, la courbe
en bleu associée à l’axe y de droite montre la fonction sin θ.

import numpy as np
import [Link] as plt

npts=[11,51,101,1001]
for npt in npts:
x=[Link](0,2*[Link],npt)
h=x[1]-x[0]
y=[Link](x)

deriv=[Link](npt)
deriv[1:npt-2]=(y[2:npt-1]-y[0:npt-3])/(2.*h)

[Link](x[1:npt-2],abs([Link](x[1:npt-2])-deriv[1:npt-2]),'.')

[Link]('log')
[Link]('Angle (rad)')
[Link]('Erreur absolue')
[Link]([0,2*[Link],1.e-8,0.1])

[Link]()
[Link](x,[Link](x))
[Link]('sin(x)')
[Link]([0,2*[Link],-1,1])

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.3. INTERPOLATION 57

[Link]('[Link]',bbox_inches='tight')
[Link]()

Dans le choix de l’une ou l’autre des formules de différences finies listées ci-dessus pour traiter un
problème numériquement, il est recommandé d’utiliser des formules ayant le même ordre de discrétisa-
tion pour toutes les dérivées quelque soit leur ordre. Il faut également garder en tête que les erreurs
de discrétisation associées aux différentes formules (O(h2 ), etc) ne tiennent vraiment que dans la limite
d’un maillage serré, i.e., h → 0 ; si le maillage spatial n’est pas suffisamment serré pour bien résoudre la
fonction discrétisée, l’éq. (4.20) produira des résultats probablement d’aussi piètre qualité que l’éq. (4.16).
Mais “suffisamment”, c’est combien ? Il n’y a pas de réponse unique à cette question ; mais en première
approximation on peut s’attendre à ce que h doive être pas mal plus petit que l’échelle sur laquelle varie
la fonction pour qu’un résultat soit crédible.

4.2.4 Précision, troncation et double précision

À strictement parler, toutes les formules de différences finies listées ci-dessus deviennent exactes dans
la limite h → 0. Mais évaluées sur un ordinateur où le nombres de chiffres significatifs définissant un
nombre réel est restreint, il existe un h en dessous duquel les erreurs d’arrondissement en viennent à
dominer. Ceci est illustré sur la Figure 4.7, d’un format identique à la Fig. 4.5 mais s’étendant à des h
et ε beaucoup plus petits. On y voit bien que pour des variables encodées avec une précision de 32-bits,
lorsque l’erreur chute sous un certain seuil, entre 10−4 et 10−6 dépendant de la formule utilisée, l’erreur
ne décroit plus à mesure que h diminue mais devient plutôt erratique et même augmente légèrement. La
même chose se produirait pour une précision de 64-bits, mais à des valeurs de h et ε encore plus petites
que montrées sur la figure. Cette figure illustre bien la subtile différence entre les erreurs de troncation
(associée à l’ordre de la formule de différence finie choisie) et les erreurs d’arrondissement, associées au
choix de la représentation numérique —ici float32 versus float64. Une fois que le pas h devient petit
au point où les diverses évaluations de sin(x ± h) ne diffèrent plus que dans le dernier chiffre significatif
pouvant être encodé dans la mantisse M du nombre réel (cf. eq. (1.4)), toutes les formules de différences
finies se mettent à déconner, quelque soit leur ordre de troncation. Bien qu’on ait pu imaginer à prime
abord qu’il soit souhaitable de choisir un h le plus petit possible afin de justifier notre omission des
termes d’ordre élevé en h (≡ ∆x) dans le développement en série de Taylor, les restrictions associées à
nos représentations numériques des nombres réels posent une limite inférieure incontournable à la taille
du pas ; loin d’améliorer la précision de nos estimés des dérivées, pousser sous cette limite les dégrade !

4.3 Interpolation
Dans bien des situations en sciences, incluant en physique, vous tomberez sur des séries de mesures
expérimentales tabulées qui devront être utilisées comme base à des calculs subséquents. Considérons par
exemple les “données” portées en graphique sur la Figure 4.8, qui montrent cinq “mesures” de la variation
d’une quantité f en fonction d’une variable x dont dépend f . Ceci est typique des plusieurs types de
mesures expérimentales ; on peut bien faire un grand nombre de mesures, mais on se retrouve toujours
avec un échantillonnage discret et fini de la quantité mesurée.
Supposons maintenant que sur la base de ces mesures, on vous demande de calculer la valeur que
prendrait f si x = 5 ; problème, car vous disposez de mesures à x = 4 et x = 7, mais pas à x = 5. Vous
vous trouvez donc dans l’obligation de supposer que f varie d’une manière choisie a priori entre x = 4 et
x = 7, et ainsi produire un estimé de f à x = 5. Ce genre de tâche numérique s’appelle une interpolation.
On pourrait aussi vous demander quelque chose à prime abord de complètement différent, par exemple
d’évaluer, sur la base des mesures expérimentales, une intégrale définie du genre :
Z 10
f (x)dx (4.25)
1

Comme f (x) n’a pas une forme analytique connue, vous devrez encore une fois supposer que f varie d’une
manière analytiquement intégrable entre les points où les mesures de f sont disponibles. C’est là le lien
fondamental entre l’interpolation et l’évaluation numérique des intégrales définies.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

58 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

10 0
10 -1
10 -2
10 -3 O(h)
10 -4 O(h 2 )
O(h 4 )
Erreur

10 -5
10 -6
10 -7
10 -8
10 -9
10 -10 0
10 10 -1 10 -2 10 -3 10 -4 10 -5
Taille du pas de maille (h)
Figure 4.7 – Variations de l’erreur de discrétisation en fonction de la taille du pas, toujours pour le calcul
de la dérivée de sin(x) par différences finies. Les symboles donnent l’erreur associée au calcul des dérivées
avec une précision de 32-bits (float32) tandis que les traits plein donnent l’équivalent calculé avec une
précision de 64-bits (float64). Les traits pointillés délimitent l’intervalle couvert par la Figure 4.5

4.3.1 Interpolation linéaire

Commençons avec l’interpolation, en établissant soigneusement notre notation. Une interpolation ty-
pique est définie comme suit : on nous fournit un ensemble de N valeurs numériques fk d’une fonction
mesurée (ou discrétisée) sur une maille xk également donnée, et pas nécessairement équidistante, comme
sur la Fig. 4.8 :

f (x) → fk ≡ f (xk ) , k = 1, 2, ...N , (4.26)

x = [x1 , x2 , ..., xN ] . (4.27)

L’interpolation consiste à obtenir un estimé f ∗ de f (x∗k ) à un ensemble discret de P valeurs x∗k ne coincidant
habituellement pas avec les xk :

x∗ = [x∗1 , x∗2 , ..., x∗P ] . (4.28)

On exige habituellement que la fonction d’interpolation f ∗ (x) soit continue et exacte sur l’ensemble des
données étant interpolées, i.e.,

f ∗ (xk ) = f (xk ) , k = 1, 2, ...N . (4.29)

L’interpolation la plus simple qui satisfait à ces contraintes consiste à approximer la variation de f (x) entre
deux points successifs [xk , xk+1 ] par une droite. On décrit alors ceci comme une interpolation linéaire.
L’idée générale est illustrée à la Figure 4.9. Les points (xk , fk ) définissant la fonction à interpoler sont en

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.3. INTERPOLATION 59

Figure 4.8 – Une série de données artificielles correspondant à des mesures d’une certaine quantité f (x)
en fonction d’un ensemble fini de valeurs x dont dépend cette quantité.

noir, et les valeurs interpolées indiquées en gris. Notons déjà que la fonction d’interpolation est l’union
ici de quatre tronçons linéaires contigus qui se rejoignent aux xk ’s ; la fonction d’interpolation est donc
continue, mais sa dérivé première par rapport à x ne l’est pas, puisqu’elle varie de manière discontinue
aux xk ’s, et toutes ses dérivées d’ordre supérieur sont nulles.
Une fois la fonction d’interpolation choisie, son évaluation à chaque x∗p est un processus en trois étapes :
1. trouver la plage d’interpolation, soit l’intervalle [xk , xk+1 ] tel que xk ≤ x∗p < xk+1 ;
2. Calcul des paramètres de la droite passant par (xk , fk ) et (xk+1 , fk+1 ).
3. Calcul de fp∗ ≡ f ∗ (x∗p )

Chercher la plage
Étant donné un tableau x de dimension N contenant les abscisses de la fonction à interpoler, le
petit bout de code suivant détermine le k associé à la plage d’interpolation [xk , xk+1 ] pour un point
d’interpolation xetoile :

k=len(x)-1
while xetoile<x[k]: k-=1

La façon de faire ci-dessus est simple, compacte et lisible, mais n’est pas terriblement efficace du point de
vue numérique ; on verra plus loin comment faire mieux.

Calculer la droite
Avec xetoile= 4.5, disons, nous travaillons dans la plage d’interpolation c. Une droite est définie
paramétriquement par la relation

y = mx + b , (4.30)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

60 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.9 – Interpolation linéaire d’une fonction discrète définie par x = [1, 2, 4, 7, 9], f (x) = [1, 2, 3, 4, 7]
(N = 5, points noirs), aux points x∗ = [2.5, 4.5, 6.5, 8.5] (P = 4, points gris). La fonction d’interpolation
est ici définie par quatre plages d’interpolation, indiquées par a, b, c et d.

où m est la pente et b l’ordonnée à l’origine. Évaluons ceci aux points x3 et x4 qui définissent les limites
de la plage c :

f3 = mx3 + b , f4 = mx4 + b ; (4.31)

Comme les x3 ,, x4 , f3 et f4 sont connus, ceci représente un système de deux équations pour deux inconnues,
m et b. La solution en est :
f4 − f3 4−3 1
m= = = , (4.32)
x4 − x3 7−4 3

f4 − f3 4 5
b = f3 − x3 = 3 − = (4.33)
x4 − x3 3 3
L’interpolation dans la plage c est donc définie par :
x∗ 5
f ∗ (x∗ ) = + , x3 ≤ x∗ ≤ x4 . (4.34)
3 3

Calculer l’interpolation
C’est ici trivial. On n’a qu’à évaluer l’éq. (4.34) à la valeur de x∗ désirée. Dans le cas des données de
la Figure 4.9, on aurait donc

f ∗ (x∗2 ) = f ∗ (4.5) = 3.1666... f ∗ (x∗3 ) = f ∗ (6.5) = 3.8333... (4.35)

N’oubliez surtout pas que l’évaluation de f ∗ à x∗1 = 2.5 et x∗4 = 8.5 doit se faire dans les plages b et d
respectivement, où la droite (4.34) n’est pas valide ! La code Python ci-bas effectue l’interpolation illustrée

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.3. INTERPOLATION 61

à la Figure 4.9. Ici la fonction discrétisée fk ≡ f (xk ) est définie directement au début du code, mais la
valeur x∗ à laquelle l’interpolation est désirée est lue au moment de l’exécution, via la fonction input ;
une fois l’interpolation terminée, le programme se met en attente de la valeur suivante. Ceci est notre
premier exemple d’interaction entre le programme et l’usager durant l’exécution.

Code Python pour l’interpolation linéaire de la Figure 4.9

"""
Ce programme utilise l'interpolation lineaire pour estimer la valeur
d'une fonction discretisee a une valeur x fournie par l'utilisateur.
"""

#la fonction discretisee

x=[1.,2.,4.,7.,9.]
y=[1.,2.,3.,4.,7.]

#l'interpolation
while 1:
rep=input('SVP donner une valeur de x (q/Q pour quitter): ')
if [Link]() in 'qQ': break

try:
xx=float(rep)
except ValueError:
print('Entree invalide!')
continue

if xx<x[0] or xx>=x[-1]:
print("Valeur hors de l'intervalle! Recommencer.")
continue

k=len(x)-1
while xx<x[k]: k-=1

m=(y[k+1]-y[k])/(x[k+1]-x[k])
b=y[k]-m*x[k]
yy=m*xx+b
print('Resultat: x={:6.4f}, f(x)={:6.4f}'.format(xx,yy))

4.3.2 Interpolation d’ordre plus élevé

À examiner l’interpolation linéaire présentée à la Figure 4.9, il n’est pas difficile d’imaginer qu’une
meilleure interpolation puisse être obtenue en reliant les N points (xk , fk ) par quelque chose de mieux que
des segments de droites, par exemple un polynôme d’ordre plus élevé que y = mx + b. Ceci peut se faire
facilement avec les polynômes de Lagrange, qui ne sont effectivement rien de plus que les polynômes
classiques avec lesquels vous avez déjà fait connaissance au secondaire (linéaire, quadratique, cubique,
etc), mais réécrits d’une manière différente qui s’avère particulièrement appropriée aux tâches d’interpo-
lation. La principale différence en passant à un ordre plus élevé est que le nombre de points nécessaires à
l’évaluation des coefficients du polynôme, i.e. le nombre de points formant la plage d’interpolation, croit
avec l’ordre : 3 points pour ordre 2, 4 pour ordre 3, etc.
Si le calcul et l’évaluation des polynômes d’interpolation de Lagrange sont très simples (voir références
en fin de chapitre), l’interpolation en résultant souffre de certains défauts, non le moindre étant que
même pour les interpolations d’ordre plus grand que linéaire, les dérivées de la fonction d’interpolation
globale ne sont pas continues aux jonctions des plages d’interpolation, bien qu’elles le soient à l’intérieur
de chaque plage individuelle. Ce problème est clairement visible sur la Fig. 4.10, qui montre le résultat
d’une interpolation quadratique sur les deux plages de trois points définies par les données de la Fig. 4.8.
Les splines cubiques permettent d’éviter ce problème. Il ne s’agit de rien de plus qu’une interpolation

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

62 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.10 – Interpolation quadratique par polynômes de Lagrange des données de la Figure 4.8. Avec
N = 5, on a ici deux plages distinctes d’interpolation, a + b et c + d, l’interpolation dans chacune étant
définie par un segment de parabole. Remarquez la discontinuité de la dérivée première à la fonction des
deux plages (x = 4), et le minimum secondaire produit dans la plage c.

polynomiale cubique (plage d’interpolation de 4 points), avec une contrainte supplémentaire de continuité
des dérivés premières et secondes aux jonctions des plages d’interpolation. La Figure 4.11 en montre
un exemple, toujours pour les mêmes données que précédemment. Comparant aux Figs. 4.9 et 4.10, on
constate que la fonction d’interpolation est maintenant beaucoup plus lisse. Il existe plusieurs autres
façons d’interpoler des valeurs échantillonnées discrètement. Parmi celles-ci, on trouve l’interpolation sinc
(ou de Whittaker–Shannon) et l’interpolation par convolution cubique, qui sont particulièrement efficaces
pour interpoler des valeurs issues de fonctions limitées en bande et suffisamment bien échantillonnées ;
nous n’entrerons pas dans les détails ici, mais ces techniques sont importantes dans les applications de
traitement de signal et de traitement d’images.
La majorité des logiciels de traitements de données ou de graphisme incluent généralement des fonctions
prédéfinies effectuant une interpolation par spline cubique. La théorie sous-jacente est expliquée dans la
plupart des bouquins d’analyse numérique (voir bibliographie en fin de chapitre). En Python, le sous-
module interpolate du module scipy, i.e. [Link], fournit plusieurs fonctions et outils
pour l’interpolation.
Comparant les Figures 4.9, 4.10 et 4.11, il est clair que le choix de la méthode d’interpolation peut
avoir un impact substantiel sur les valeurs interpolées. Le Tableau 4.1, listant les valeurs numériques de
ces trois interpolations aux mêmes x∗ confirme cette impression. Les différences, qui atteignent les 10%
dans plusieurs cas, n’ont rien à voir avec des imprécisions dans les données, des erreurs d’arrondissement,
ou tout autre truc du genre ; elles résultent entièrement du choix de la méthode d’interpolation. Laquelle
est la meilleure ici ? Difficile à dire...
En général, on pourrait penser que l’interpolation par splines cubiques est à préférer, si ce n’est
parce que cette technique d’interpolation assure la continuité des dérivées de la fonction interpolée aux
frontières des plages d’interpolation. Mais les splines ne doivent pas être utilisés aveuglément. La Figure
4.12 présente un exemple d’une situation où une interpolation en splines cubiques produit des résultats
plus que douteux. Ici la fonction à interpoler (points noirs) a l’allure une fonction escalier, avec un f (x)

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.3. INTERPOLATION 63

Figure 4.11 – Interpolation par splines cubiques, à partir des mêmes données que sur les Figure 4.9 et
4.10. Les valeurs de f (x) aux points interpolés (gris) ne différent pas énormément de celles obtenues avec
l’interpolation linéaire, mais ici les dérivées première et seconde sont continues partout.

Table 4.1 – Comparaison de trois interpolations des mêmes données

x∗ Linéaire Quadratique Spline Cubique
2.5 2.25 2.37500 2.38013
4.5 3.16667 2.87500 3.07348
6.5 3.83333 3.54167 3.59796
8.5 6.25000 6.07500 6.12895

constant pour x ≤ 3, sautant à une valeur constante plus élevée pour x ≥ 4. Il est important de réaliser
que les données ne contiennent aucune information nous permettant de spécifier où exactement entre
x = 3 et x = 4 la discontinuité est située,... ou même si il y a vraiment une discontinuité dans l’intervalle,
par opposition à une variation très rapide mais continue en x.
Dans une telle situation l’interpolation par spline cubique produit une variation rapide et continue
entre x = 3 et x = 4, comme on s’y attendrait d’un polynôme d’ordre relativement élevé, mais dans les
deux intervalles voisins la contrainte de continuité de la fonction et de ses dérivées caractérisant les splines
cubiques produit des “sursauts” où f ∗ s’éloigne substantiellement de l’intervalle défini par les deux valeurs
constantes de la fonction (discrétisée) f étant interpolée ici. Dans un cas comme celui-ci, une interpolation
linéaire (tirets) serait probablement préférable.
Dernier commentaire de nature quasi-philosophique : qu’une interpolation se fasse par polynôme de
Lagrange ou par spline cubique, ultimement c’est de la tricherie ; il n’y a tout simplement pas d’information
entre les points (xk , fk ) où la fonction est échantillonnée ! Le choix d’un type d’interpolation ou d’un autre
est, en général, tout à fait arbitraire, et le plus souvent déterminé par nos préjugés et/ou attentes par
rapport au système ayant “généré” les données (xk , fk ).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

64 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.12 – Exemple d’une situation où une interpolation linéaire (tirets) est très possiblement plus
appropriée qu’une interpolation par splines cubiques.

4.3.3 Interpolation versus extrapolation

L’extrapolation est une procédure douteuse basée sur la même idée que l’interpolation, soit la repré-
sentation d’un échantillonnage discret d’une fonction inconnue par une fonction (habituellement simple)
de la variable indépendante. La Figure 4.13 illustre le danger inhérent à ce type de manoeuvre. On tra-
vaille toujours ici avec les données de la Figure 4.8 (points noirs), mais les polynômes d’interpolation sont
maintenant utilisés pour calculer une extrapolation à des valeurs de x∗ qui sont à l’extérieur de l’intervalle
couvert par les données (1 ≤ x ≤ 9). Ici l’extrapolation linéaire (tirets) vers x∗ = 15 utilise l’interpolation
linéaire dans la plage d, tandis que l’extrapolation quadratique (trait plein) est basée sur un polynôme
quadratique couvrant les plages c + d. Bien que dans la plage d les deux interpolations ne diffèrent que
par quelques pourcents (cf. Tableau 4.1 pour x∗ = 8.5), ici les deux extrapolations à x∗ = 15 diffèrent
par près d’un facteur deux. Je vous laisse imaginer de quoi tout ça aurait l’air si on avait la brillante idée
d’extrapoler jusqu’à x∗ = 100...
Dans le cas spécifique des données de la Figure 4.13, l’extrapolation jusqu’à x∗ ≃ 10 produirait des
résultats ne divergeant pas plus que pour les interpolations compilées au Tableau 4.1 ; on pourrait en juger
que l’extrapolation est alors “acceptable”. Il n’en demeure pas moins que l’extrapolation est toujours un
jeu très délicat à tous les points de vue.
L’extrapolation demeure parfois inévitable et nécessaire. La Figure 4.14 vous en montre un des exemple
les plus médiatisé des dernières quelques décennies, soit l’augmentation prédite de la température moyenne
de la Terre au cours du vingt-et-unième siècle. Huit extrapolations climatiques sont portées en graphique
ici, chacune correspondant à un modèle climatique différent ; différent pas seulement au sens purement nu-
mérique, mais aussi au niveau des processus physiques inclus, des hypothèses faites au niveau de l’évolution
de la population planétaire et de ses habitudes énergivores, etc. La “pathologie” est fondamentalement la
même que sur l’exemple simpliste de la Fig. 4.13. Tous ces modèles climatiques sont “ajustés” de manière
à bien reproduire la température moyenne observée dans la seconde moitié du vingtième siècle, et l’ac-
cord entre les modèle y est donc excellent (tout comme pour les traits plein et pointillés dans l’intervalle
1 ≤ x ≤ 9 sur la Fig. 4.13). Mais une fois extrapolés jusqu’en 2100, le réchauffement prédit varie d’un

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.4. INTÉGRATION 65

Figure 4.13 – Exemple d’une situation où le choix de l’une ou l’autre méthode d’interpolation (linéaire
et quadratique) conduit à des résultats divergents lorsque l’interpolation est utilisée pour extrapoler en
dehors (x∗ = 15) des plages d’interpolation (1 ≤ x ≤ 9). Les données (points noirs) sont les mêmes que
sur les Figures précédentes.

peu plus de 2 degrés C à presque 5◦ C. Les extrapolations ne sont pas contraintes, et donc évoluent selon
la dynamique interne (très complexe) de chaque modèle. Une différence de 3 degrés dans la température
moyenne terrestre peut paraitre mineure à prime abord, mais en pratique elle est en fait énorme : à +2◦ C,
il y a encore des écosystèmes arctiques ; à +5◦ C, non ; À +5◦ C Bangkok (population métropolitaine : 14.6
million d’habitants en 2010) est complètement sous l’eau ; à +2◦ C, pas encore. Maintenant vous savez
pourquoi, si vous commencez à parlez d’extrapolation à un(e) climatologue, vous allez sentir très vite le
niveau de stress monter...

4.4 Intégration
Passons maintenant au calcul numérique des intégrales, plus précisément des intégrales définies. De la
même façon que la dérivée d’une fonction en un point donné peut être interprétée comme la pente d’une
droite tangente à la courbe définie par la fonction en ce point, son intégrale définie entre deux points
peut être interprétée comme l’aire sous la courbe entre ces points. Tout comme la dérivée (voir éq. (4.1)),
l’intégrale définie peut être définie mathématiquement comme un passage à la limite ∆x → 0 :
Z b X
f (x)dx = lim f¯(xk )∆x (4.36)
a ∆x→0
k

où f¯(xk ) est une valeur représentative de f (x) sur le kième intervalle ∆x dans la plage [a, b]. L’idée de ce
passage à la limite conduisant à “l’aire sous la courbe” est illustrée schématiquement à la Figure 4.15.
Si la fonction f (x) est calculable pour tout x, le membre de droite de l’équation (4.36) peut être
directement utilisée pour évaluer l’intégrale, en choisissant un ∆x suffisamment petit (en se méfiant
toutefois des erreurs d’arrondissement...). Cependant, pour une fonction tabulée, comme sur la Figure

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

66 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.14 – Exemple concret d’une extrapolation, soit ici la température moyenne de la Terre jusqu’en
2100. Les prédictions ont été faites en 2007, à l’aide de huit modèles climatiques distincts, tous très “haut-
de-gamme”. Toutes les extrapolations sont calibrées sur la seconde moitié du vingtième siècle, et donc
y sont en excellent accord, mais divergent par la suite. Source : P.A. Rohde/The Global Warming Art
Project, téléchargé de [Link]

4.8, où la grandeur du ∆x est fixée, l’utilisation de l’éq. (4.36) peut conduire à des résultats plutôt
imprécis. Il est en fait assez facile de faire mieux.

4.4.1 La méthode du trapèze

La méthode du trapèze est un algorithme simple et robuste permettant d’intégrer numériquement
une fonction f (x) échantillonnée sur une maille couvrant le domaine d’intégration, mais dont les incréments
ne sont pas nécessairement équidistants :

(x1 , x2 , x3 , ..., xN ) , où il est possible que xk+1 − xk ̸= xk − xk−1 .

L’idée derrière la méthode du trapèze est simplement de supposer que la fonction f (x) varie linéairement
entre les points où elle est échantillonnée ; l’aire sous le segment de droite reliant les points (xk , fk ) et
(xk+1 , fk+1 ) est :
(fk+1 + fk )
fk × (xk+1 − xk ) + (fk+1 − fk ) × (xk+1 − xk )/2 = (xk+1 − xk ) ,
| {z } | {z } 2
rectangle triangle

d’où :
Z xN N −1
X (fk+1 + fk )
f (x) dx ≃ (xk+1 − xk ) + O(h2 ) , (4.37)
x1 2
k=1

avec comme d’habitude fk ≡ f (xk ). Plus la maille est serrée, plus la somme discrète au coté droit de
cette expression approximera bien l’intégrale au coté gauche. Dit autrement, plus la maille est petite, plus

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.4. INTÉGRATION 67

Figure 4.15 – Le passage à la limite ∆x → 0 dans le calcul d’une intégrale définie, correspondant à l’aire
contenue sous la courbe définie par f (x) entre les bornes d’intégrations a et b.

un développement en série de Taylor tronqué après le second terme offre une représentation adéquate de
la variation de la fonction dans l’intervalle d’intégration. L’erreur associée à la méthode du trapèze est
formellement O(h2 ). En Python, ça pourrait avoir l’air de ceci :
somme = 0.
for k in range(0,n-1):
somme+= 0.5*(f[k+1]+f[k])*(x[k+1]-x[k])

Ceci présuppose que les valeurs de f et x sur la plage désirée ont été déjà placées dans deux tableaux
1D chacun de longueur N . Notez l’utilisation d’une variable d’accumulation somme, qui, à la sortie de
la boucle, contiendra la valeur de l’intégrale. Il faut s’assurer d’initialiser cette variable à zéro avant le
début de la boucle calculant l’intégrale. Notez également que la boucle terminera à k = N − 2 plutôt que
N − 1, de manière à éviter un débordement de tableau sur évaluation de xk+1 et fk+1 à l’intérieur de la
boucle. Ce petit bout de code est une implémentation on ne peut plus directe de l’équation 4.37, mais elle
utilise une boucle for itérant sur tous les indices de f, et comme nous avons vu au chapitre 3, on devrait
éviter l’utilisation de telles boucles dans la mesure du possible. Donc réfléchissez un instant à une façon
de vectoriser ce petit bout de code, c’est-à-dire d’accomplir la même chose sans boucle for en exploitant
NumPy... est-ce possible ? Une fois votre réflexion terminée, continuez au paragraphe suivant.
Il est en fait assez simple de vectoriser l’intégration par la méthode du trapèze, la ligne suivante fait
exactement la même chose que le bout de code ci-haut :
somme = 0.5*[Link]( (f[1:]+f[:-1])*(x[1:]-x[:-1]) )

L’idée est la suivante. Le tableau f[1:] contient les valeurs f2 à fN de la fonction discrétisée (équivalent
aux éléments d’indices 1 à N − 1 du tableau f), et le tableau f[:-1] contient les valeurs f1 à fN −1
de la fonction discrétisée (équivalent aux éléments d’indices 0 à N − 2 du tableau f). Donc l’opération
f[1:]+f[:-1] calcule d’un seul coup, élément-par-élément, toutes les sommes fk+1 + fk pour k allant de
1 à N-1. Le calcul est similaire pour le tableau x. On fait ensuite le produit élément-par-élément des deux

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

68 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.16 – Calcul d’une intégrale définie par la méthode du trapèze. La fonction à intégrer (trait
noir) est ici un spline cubique basé sur les cinq valeurs discrètes indiquées par des points noirs.

tableaux résultants et enfin on somme le tout avec [Link](). Cette approche est de loin préférable à la
précédente du point de vue de la rapidité d’exécution.
Dans le cas particulier où la maille est régulière (i.e. incréments équidistants), il est inutile de calculer
chaque xk+1 − xk individuellement car on sait que ça donne toujours la même chose, on peut donc
sortir h ≡ xk+1 − xk de la somme et l’écrire comme simple facteur multiplicatif devant la somme sur
les (fk+1 + fk ), ce qui rend l’opération encore plus efficace. De plus, on peut voir que dans la somme à
effectuer, les valeurs f2 à fN −1 apparaissent chacune exactement deux fois alors que f1 et fN apparaissent
une fois. Donc, plutôt que d’additionner deux fois les f2 à fN −1 , on peut les additionner une seule fois
et multiplier par 2, ce qui rend l’opération encore plus efficace. Au final pour une maille régulière, on
obtient donc l’expression suivante pour l’intégration par la méthode du trapèze :
−1
Z xN N
!
h X
f (x) dx ≃ f1 + fN + 2 fk + O(h2 ) . (4.38)
x1 2
k=2

La ligne de code correspondante est la suivante :

somme = 0.5*h*( f[0]+f[-1]+2*f[1:-1].sum() )
La Figure 4.16 illustre l’application de la méthode du trapèze aux données de la Figure 4.9. Si ces
données correspondaient vraiment à la fonction définie par le trait plein, on voit que la méthode du trapèze
surestimerait les contribution à l’intégrale des plages c et d, sous-estimerait celle de la plage b, et serait
très raisonnable pour ce qui est de la contribution de la plage a.

4.4.2 Les règles de Simpson

L’idée d’introduire une forme d’interpolation entre les points de maille pour calculer une intégrale est
évidemment généralisable à des interpolations d’ordre plus élevé que linéaire. Dans le cas d’un maillage
équidistant (xk+1 − xk = h ∀ k), on peut ainsi produire des formules d’intégration relativement simples,

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.5. CODA, EN PLUS QU’UNE VARIABLE 69

connues sous le nom de Règles de Simpson. Voir les références cités en fin de chapitre si vous désirez
approfondir le sujet.

4.4.3 Intégration de Romberg

L’intégration de Romberg est un petit truc vraiment remarquable pour grandement améliorer
la précision d’une intégrale numérique, avec très peu d’effort supplémentaire. Considérons par exemple
l’utilisation de la méthode du trapèze sur une maille équidistante h = h1 . Pour une maille suffisamment
serrée, la solution obtenue (I (1) , disons) différera de la solution exacte (I ∗ ) par un facteur proportionnel
à h21 ; on peut donc écrire en toute généralité :

I (1) = I ∗ + Ch21 , (4.39)

où C est une constante qui est en fait une propriété de l’algorithme appliqué au problème donné, mais
pas du choix de la maille. Considérons maintenant une seconde solution obtenue sur une maille h2 ̸= h1 .
On aura encore une fois,

I (2) = I ∗ + Ch22 , (4.40)

et c’est là la clé, avec le même C ! Les équations (4.39) et (4.40) forment un système de deux équations
pour deux inconnues, I ∗ et C ; ce système peut être solutionné pour produire une évaluation de I ∗ :

h22 I (1) − h21 I (2)

I∗ = , méthodes O(h2 ) (4.41)
h22 − h21
Ceci représente en fait une forme d’extrapolation ; il sera donc judicieux de choisir une seconde maille h2
différant de manière significative de la première, e.g., h2 = h1 /2.

4.5 Coda, en plus qu’une variable

Nous allons clore ce chapitre par une brève présentation de la généralisation des formules de différences
finies, d’interpolation et d’intégration à plus d’une variable spatiale.

4.5.1 Discrétisation
La procédure de discrétisation d’une fonction continue introduite à la §4.2.1 se généralise facilement
à une fonction de plus d’une variable. Considérons par exemple une fonction f (x, y) de deux variables,
discrétisée sur une maille cartésienne régulière en deux dimensions spatiales (voir Figure 4.17) :

x → {x1 , x2 , ..., xN }, xj+1 > xj , (4.42)

y → {y1 , y2 , ..., yM }, yk+1 > yk . (4.43)

Une maille est dite cartésienne si toutes les lignes x = constante sont des droites parallèles les unes aux
autres, les y = constante le sont également, et chaque famille de droites coupe l’autre en formant des
angles droits ; autrement dit, comme sur du papier quadrillé ! On identifie chaque noeud du maillage 2D
par une paire d’indices (j, k), et on écrit pour la fonction discrétisée :

fj,k ≡ f (xj , yk ) , (4.44)

Je vous laisse imaginer comment ceci se généralise à des fonctions de plus de deux variables.

4.5.2 Dérivées partielles et différences finies

Commençons donc avec l’évaluation de dérivées par différences finies. Pour des fonctions de plus d’une
variable, on calcule habituellement les dérivées partielles, qui ne sont rien de plus que les dérivées de
la fonction par rapport à une de ses variables indépendantes, considérant les autres fixes. Un bon petit
exemple vaudra bien un long paragraphe ; considérons la fonction de deux variables suivante :

f (x, y) = 1 + xy − y 2 . (4.45)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

70 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.17 – Discrétisation d’une fonction de deux variables f (x, y) sur un maillage cartésien régulier,
ici équidistant dans les direction x et y et avec N = M = 11. Le noeud (j, k) est indiqué en noir.

Les deux dérivées partielles de cette fonctions seront données par,

∂f (x, y) ∂f (x, y)
=y , et = x − 2y . (4.46)
∂x ∂y
Remarquez bien comment, du point de vue de la dérivée partielle par rapport à x, le terme −y 2 est
considéré constant, et donc sa dérivée est nulle, tout comme l’est la dérivée du premier terme au membre
de droite de l’éq. (4.45). Ça continue de la même manière pour les dérivées secondes :

∂2f ∂ ∂f (x, y) ∂2f ∂ ∂f (x, y)

= =0, et = = −2 . (4.47)
∂x2 ∂x ∂x ∂y 2 ∂y ∂y
Notez que pour les dérivées secondes d’une fonction de deux variables, il existe aussi des dérivées dites
croisées ; ici on aurait :
∂2f ∂ ∂f (x, y) ∂2f ∂ ∂f (x, y)
= =1, et = =1. (4.48)
∂y∂x ∂y ∂x ∂x∂y ∂x ∂y
Ce n’est pas un hasard si les deux dérivées croisées donnent ici le même résultat ; ce sera toujours le cas
pour une fonction analytique, i.e., sans discontinuité dans la fonction ou ses dérivées de tout ordre.
La procédure décrite ci-dessus peut être appliquée au calcul des dérivées partielles d’une fonction
de plus d’une variable. Pour les formules d’ordres un et deux les expressions correspondantes sont des
applications directes des formules listées ci-dessus, avec les autres coordonnées fixées : par exemple, sur
une maille 2D :
∂f fj+1,k − fj−1,k
= + O(h2 ) , (4.49)
∂x xj ,yk 2∆x

∂f fj,k+1 − fj,k−1
= + O(h2 ) , (4.50)
∂y xj ,yk 2∆y

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.5. CODA, EN PLUS QU’UNE VARIABLE 71

∂2f fj+1,k − 2fj,k + fj−1,k

= + O(h2 ) , (4.51)
∂x2 xj ,yk (∆x)2

∂2f fj,k+1 − 2fj,k + fj,k−1

= + O(h2 ) , (4.52)
∂y 2 xj ,yk (∆y)2

∂2f fj+1,k+1 − fj+1,k−1 − fj−1,k+1 + fj−1,k−1

= + O(h2 ) , (4.53)
∂x∂y xj ,yk 4∆x∆y

où fj,k ≡ f (xj , yk ), et on a considéré que l’intervalle de maille en x (h = ∆x) puisse être différent de
l’intervalle en y (h = ∆y), ce qui est tout-à-fait légal sur une maille Cartésienne 2D. Notons que pour les
formules d’ordre plus élevé, les noeuds diagonaux (e.g. fj+1,k+1 ) font leur apparition. Voir les références
citées en bibliographie pour plus de détails.

4.5.3 Interpolation multidimensionnelle

En plus d’une dimension, l’interpolation d’ordre élevée (genre spline) devient rapidement très lourde.
L’interpolation multi-linéaire, par contre, demeure relativement simple. La première étape consiste à
identifier la plage d’interpolation. Dans le cas d’un maillage cartésien 2D comme sur la Figure 4.17, la
procédure utilisée en 1D (§4.3.1) est utilisée séparément dans les directions x et y. La plage d’interpolation
se retrouve à prendre la forme d’un rectangle dont les coins correspondent aux quatre noeuds (xj , yk ),
(xj+1 , yk ), (xj , yk+1 ), (xj+1 , yk+1 ). Il s’agit ensuite simplement de représenter, dans la plage d’interpola-
tion, la variation de f (x, y) comme un produit de fonctions linéaires le long de chaque axe de coordonnées.
L’algèbre est un peu fastidieuse, mais conduit éventuellement à la formule d’interpolation dite bilinéaire :
(x∗ − xj )(y ∗ − yk )
f ∗ (x∗ , y ∗ ) = fj+1,k+1
(xj+1 − xj )(yk+1 − yk )
(xj+1 − x∗ )(y ∗ − yk )
+ fj,k+1
(xj+1 − xj )(yk+1 − yk )
(xj+1 − x∗ )(yk+1 − y ∗ )
+ fj,k
(xj+1 − xj )(yk+1 − yk )
(x∗ − xj )(yk+1 − y ∗ )
+ fj+1,k . (4.54)
(xj+1 − xj )(yk+1 − yk )
Ceci revient à calculer une moyenne pondérée des valeurs de f évaluée aux quatres noeuds définissant
les coins de la plage d’interpolation, avec des facteurs de pondération qui confèrent un poids propor-
tionnellement plus grand aux noeuds situés plus près de (x∗ , y ∗ ). Plus spécifiquement, la pondération
est proportionnelle à la surface du rectangle défini par les droites x = x∗ et y = y ∗ situé en direction
diagonalement opposée à chaque noeud, comme l’illustre la Figure 4.18. Notez également que la forme
même de l’éq. (4.54) garantit que

f ∗ (xj , yk ) = fj,k , (4.55)

et en particulier, si (x∗ , y ∗ ) est situé exactement au centre de la plage d’interpolation, la relation ci-dessus
se réduit à :
1
f ∗ (x∗ , y ∗ ) = (fj+1,k+1 + fj,k+1 + fj,k + fj+1,k ) , (4.56)
4
soit la moyenne des quatres valeurs de f aux quatre coins de la plage d’interpolation. Ce résultat nous
servira maintenant à établir un équivalent de la règle du trapèze pour une intégrale en deux dimensions
spatiales.

4.5.4 Intégrales multidimensionnelles

Si ce n’est pas déjà fait, vous aurez l’occasion de tout apprendre sur les intégrales de fonctions de
plus d’une variable dans vos cours MAT. Dans le cas de fonctions de deux variables, l’analogie avec les

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

72 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Figure 4.18 – Interpolation bilinéaire en deux dimensions spatiales. L’interpolation de f (x, y) au point
(x∗ , y ∗ ) revient au calcul d’une moyenne pondérée de f évaluée aux quatre noeuds définissant la plage
d’interpolation, avec une pondération donnée par la surface du rectangle diagonalement opposé à chaque
noeud, tel qu’indiquée ici par le code couleur.

intégrales de fonctions d’une seule variable est simple : cette dernière correspond à calculer “l’aire sous
la courbe” délimitée par les bornes d’intégrations ; pour une fonction de deux variables, l’intégrale par
rapport à ces deux variables correspond à calculer le “volume sous la surface” (2D) délimitée par les
bornes d’intégration, qui sont maintenant des lignes ou courbes dans le plan [x, y].
Notez que dans certains cas, les intégrales sont séparables et on peut tout simplement les évaluer
comme le produit de deux intégrales 1D, e.g.,
Z Z Z Z Z  Z 
x+y x y x y
e dx dy = e e dx dy = e dx × e dy , (4.57)

tandis que d’autres ne le sont pas, e.g.,

Z Z p
x2 + y 2 dx dy . (4.58)

Supposons que la fonction f (x, y) à intégrer est définie sur une maille cartésienne régulière (comme sur
la Fig. 4.17). À partir de la fonction d’interpolation bilinéaire introduite ci-dessus, il est de nouveau
possible, par intégration directe, d’obtenir l’équivalent de la règle du trapèze applicable maintenant en
deux dimensions spatiales :
Z Z N −1 M −1
X X 1
f (x, y)dx dy = (fj,k + fj+1,k + fj,k+1 + fj+1,k+1 )(xj+1 − xj )(yk+1 − yk ) . (4.59)
j=1 k=1
4

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

4.5. CODA, EN PLUS QU’UNE VARIABLE 73

Remarquez que le nombre d’évaluations requises de la fonction f à intégrer augmente géométriquement

avec la dimensionalité de l’intégrale ; autrement dit, si N intervalles sont requis pour bien représenter les
variations de f dans l’une ou l’autre dimension spatiale, alors l’éq. (4.59) exigera (N + 1)2 évaluations de
f . Qui plus est, son équivalent en D dimensions demanderait (N + 1)D évaluations. On verra plus loin
des alternatives moins couteuses au calcul des intégrales en plusieurs dimensions.

Exercices:

1. Calculez le développement de Taylor d’un polynôme quartique d’ordre 4 de la forme générale :

f (x) = ax4 + bx3 + cx2 + dx + e

Commencez par démontrez qu’à partir de la troncation à l’ordre 4, le développement devient exact
quelque soit la grandeur de ∆x. Ensuite,
(a) Calculez maintenant le développement de Taylor d’une fonction sinus :

f (x) = sin(x) ;

(b) Comparez la précision des estimés f (x0 + ∆x) par rapport à la valeur exacte pour x0 = π/6
(rad) et ∆x = 0.01 rad, pour les développements tronqués aux ordres 1 à 4.
(c) Démontrez qu’aucun ordre fini de troncation ne peut conduire à un estimé exact, contrairement
au cas du polynôme quartique.
2. Écrivez un petit code en Python qui calcule la factorielle d’un entier n (voir éq. (4.3)).
3. À partir des formules de différences finies centrées pour les dérivées première et seconde (éqs. 4.15)
et (éqs. 4.16)), obtenez les formules de différences finies centrées pour les dérivées troisième et
quatrième ordres (éqs. 4.17) et (éqs. 4.18)).
4. Établissez la forme analytique de l’interpolation linéaire d’une fonction f (x) entre deux points x1
et x2 où la fonction vaut f1 et f2 , respectivement. Intégrez cette interpolation par rapport à x entre
x1 et x2 , et vérifiez que vous retrouvez bien la règle du trapèze.
5. Vérifiez que la solution du système d’équations algébriques (4.39)—(4.40) conduit bien à l’éq. (4.41).
6. Considérez l’intégrale définie suivante :
Z 1
sin(2πx)dx ,
0

(a) Calculez l’intégrale analytiquement ;

(b) Calculez numériquement l’intégrale à l’aide de la méthode du trapèze pour h = 0.1, 0.01 et
10−3 . Vérifiez que vos résultats sont compatibles avec le taux de convergence attendu.
(c) Utilisez maintenant vos résultats obtenus avec h = 0.01 et h = 10−3 pour obtenir un estimé
amélioré de l’intégrale via la méthode de Romberg.
7. Démontrez que l’intégration explicite d’une interpolation bilinéaire de la forme donnée par l’éq. (4.54)
conduit bien à la formule de quadrature donnée par l’éq. (4.59)
8. Utilisez la formule de quadrature (4.59) pour calculer l’intégrale suivante :
Z 1Z 1
sin(2πx) sin(2πy)dx dy ,
0 0

Répétant le calcul pour un maillage de plus en plus serré (avec ∆x = ∆y = h), déterminez si
cette formule d’intégration est d’ordre O(h), ou O(h2 ), etc., en mesurant l’erreur par rapport à la
solution exacte (facilement calculable ici puisque l’intégrale est séparable en x et y).
9. Par intuition, trouvez les fonctions d’interpolation requises pour une interpolation trilinéaire (i.e.,
d’ordre 2) d’une fonction de trois variables spatiales. Commencez par une comparaison attentive
des fonctions correspondantes en 1D et 2D.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

74 CHAPITRE 4. DÉRIVÉES, INTERPOLATION ET INTÉGRATION

Bibliographie:

Le calcul des formules de différences finies est traité dans tous les bouquins d’analyse numérique, in-
cluant Numerical Recipes cité en bibliographie au chapitre 1. J’ai gardé une préférence pour la présentation
du sujet faite à la §2.1 de
Lapidus, L., & Pinder, G.F. 1982, Numerical solution of partial differential equations in science and
engineering, John Wiley & Sons.
L’interpolation et l’intégration sont des sujets également traités dans tous les ouvrages de méthodes numé-
riques. Encore une fois le Numerical Recipes vaut la peine d’être consulté : chapitre 3 pour l’interpolation,
et chapitre 4 pour l’intégration. Les chapitres 3 et 4 de l’ouvrage suivant sont également une bonne
introduction :
Gerald, C.F. 1978, Applied numerical analysis, Addison-Wesley.
Sur l’interpolation, les matheux(ses) pourront consulter également le chapitre 2 de
Stoer, J., & Bulirsch, R. 1980, Introduction to numerical analysis, Springer.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 75

Chapitre 5

Monte Carlo

Supposons que vous vous voyez assigner la tâche (ingrate) de mesurer la superficie d’un étang de
forme irrégulière. Vous pourriez obtenir une carte topographique de l’étang et de ses environs immédiats,
quadriller le tout, compter le nombre de petit carrés contenus dans l’étang, et multiplier ce nombre par la
surface d’un de vos petits carrés (voir Figure 5.1A). Ceci revient en fait à une forme d’intégration en deux
dimensions spatiales, d’une fonction qui (par exemple) vaut un dans l’étang, et zéro sur la terre ferme. À
examiner la Figure 5.1A, vous pouvez fort bien imaginer que la principale source d’incertitude ici est le
degré auquel votre quadrillage réussit à bien capturer la forme du contour de l’étang, et que le plus fin
sera votre quadrillage de l’étang, le plus précis sera votre détermination de sa surface.
Vous avez aussi une autre option ; délimiter une surface A facilement calculable (e.g., un carré) en-
globant l’étang ; lancez ensuite un nombre N de cailloux distribués de manière complètement aléatoire
spatialement, et comptez le nombre P de fois où vous entendez un “plouf”. L’idée est illustrée à la Figure
5.1B, pour N = 103 . Pour un N très grand, la surface de l’étang sera donnée simplement par (P/N ) × A.
Certains d’entre vous auront reconnu que cette approche à la mesure de la superficie de l’étang est
celle sous-jacente à notre calcul de π du chapitre 1. L’équivalent de l’étang y est un quart de cercle de
rayon unitaire, et l’estimé de π vient du fait que l’aire d’un cercle (complet) de rayon unitaire vaut π,
donc celle d’un quart de cercle vaut π/4, et la surface d’un carré englobant ce quart de cercle de rayon
6
unitaire vaut 1. La boucle lance 10p cailloux à des positions aléatoires (x, y) = (r1 , r2 ), donc la distance
radiale à l’origine est donnée par r12 + r22 ; si cette distance est plus petite que un, le caillou est tombé
dans le quart de cercle, et on ajoute un au compteur. La valeur finale de ce compteur divisée par 106
correspond donc au rapport de la surface du quart de cercle à celle du carré l’englobant ; il ne reste plus
qu’à multiplier par 4, et on a le nombre π. Voilà !
Cette approche statistique au calcul de quelque chose qui en principe pourrait se faire de manière
déterministe est appelée une méthode Monte Carlo. Dans ce chapitre nous nous limiterons à deux
applications spécifiques, soit le calcul des intégrales (§5.4), et une modélisation de type Monte Carlo
qui revient effectivement à la solution de certaine classes d’équations différentielles (§5.5). Une troisième
emergera “spontanément” au chapitre suivant (§6.6). Si vous avez suivi l’exemple de l’étang, vous vous
doutez déjà qu’un aspect essentiel de l’approche Monte Carlo est la génération de nombres aléatoires, que
nous devons d’abord régler avant de passer au Monte Carlo comme tel.

5.1 Nombres aléatoires

Une séquence de nombres est dite aléatoire si la valeur numérique de chaque membre de la séquence
est complètement indépendante de celles des membres précédents dans la séquence. Par exemple, si vous
roulez un dé (non-pipé) douze fois de suite, vous pourriez tout aussi bien obtenir l’une ou l’autre des deux
séquences suivantes :

4−2−6−3−4−4−2−6−1−5−2−6 ,

6−6−1−2−3−3−5−6−3−6−2−3 .
Vous serez peut-être surpris de noter que la seconde séquence ne contient pas de “4”. La probabilité
de ne pas rouler 4 est 1 − 1/6 = 5/6 ; donc la probabilité de ne pas rouler un quatre 12 fois de suite

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

76 CHAPITRE 5. MONTE CARLO

Figure 5.1 – Deux approches fondamentalement différentes à la mesure de la surface d’une surface de
forme irrégulière (en gris ici). À gauche, un quadrillage cartésien régulier, où la détermination de la surface
revient à compter le nombre de carrés couvrant la surface. À droite, une approche statistique où la surface
est donnée par la fraction du nombre de lancers aléatoires tombant sur la surface (voir texte).

est (5/6)12 = 0.112, ce qui est petit mais bien loin de l’astronomiquement minuscule (contrairement à
votre probabilité de gagner au 6-49, qui elle l’est). Moins évident mais tout aussi vrai, si chaque lancer
est vraiment entièrement indépendant des précédents, la probabilité d’obtenir exactement l’une de ces
séquences est (1/6)12 , soit un minuscule 4.6×10−10 , et exactement la même que celle d’obtenir la séquence
qu’une majorité d’individus jugeraient (incorrectement) encore plus improbable :

1−2−3−4−5−6−1−2−3−4−5−6 ,

ou encore

6−6−6−6−6−6−6−6−6−6−6−6 .
Eh oui ! Si vous roulez maintenant le dé un très grand nombre de fois (N , disons), on s’attendrait
à obtenir N/6 fois le “1”, N/6 fois le “2”, et ainsi de suite jusqu’à 6. C’est la définition même d’un dé
non-truqué ! Le dé est donc un générateur de nombres aléatoires, ici des entiers distribués uniformément
dans l’intervalle [1, 6].
Il s’agit maintenant de produire l’équivalent d’un dé utilisable sur l’ordinateur. Ceci peut paraitre un
non-sens absolu et total ; un programme d’ordinateur est déterministe au plus haut point, dans le sens
que sur une architecture donnée, l’exécutable d’un algorithme auquel on fournit la même entrée produira
toujours la même sortie. Donc, si on revient à notre séquence de lancers d’un dé, le résultat du n-ième
lancer sera toujours complètement déterminé par l’état du générateur après le n−1-ième lancer, autrement
dit, les valeurs numériques des lancers n − 1 et n sont complètement corrélées, l’antithèse même de notre
idée de l’aléatoire !
La solution à ce paradoxe tient au fait que même si les lancers de pseudo-dés numériques sont corrélés
à 100%, il est possible de s’assurer que, tout comme avec un vrai dé, chaque valeur sort en moyenne
aussi fréquemment que les autres, et que sur l’ensemble de la séquence aucune corrélation n’existe en la
valeur numérique d’un lancer et celle du suivant. Ce sont ces propriétés statistiques de la séquence qui lui
méritent le nom d’aléatoire (certains puristes insisteraient ici sur l’appellation “pseudo-aléatoires”.
Les bases théorique, arithmétique, statistique et informatique de la génération des nombres aléatoires
pourraient nous tenir occupés bien longtemps. Pour nos besoin présents, il suffit de réaliser que la géné-
ration de séquences qui satisfont aux propriétés énoncées ci-dessus est possible mais non-triviale, et que
certains générateurs sur le marché sont nettement meilleurs que d’autres.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

5.2. FONCTIONS DE DISTRIBUTIONS 77

Par exemple, le module random de Python fournit la fonction [Link]() qui produit un nombre
(pseudo-)aléatoire réel distribué uniformément dans l’intervalle [0, 1). Le sous-module random du module
NumPy fournit une fonction équivalente, [Link](), qui offre de plus l’option (à l’aide d’un argu-
ment) de générer plusieurs nombres aléatoires avec un seul appel. L’un ou l’autre de ces deux générateurs
suffira à tous nos besoins pour le cours. 1
Un générateur de nombre aléatoire doit toujours être initialisé à une valeur (arbitraire) pour débuter
le processus de production de la séquence aléatoire. Cette valeur est appelée le germe (ou en anglais :
seed). Sa valeur numérique importe peu, mais doit être fournie. Une fonction apparemment sans germe,
comme random(), utilisera en fait un germe déterminé au moment de l’importation du module qui contient
cette fonction, et sa valeur correspond alors généralement au temps système actuel. Il est parfois utile
(et souvent important !) de pouvoir générer des séquences qui soient distinctes et/ou qui puissent être
reproduites à une date ultérieure. En définissant plusieurs germes distincts, il devient donc possible de
produire des séquences de nombres aléatoires complètement indépendantes l’une de l’autre.

5.2 Fonctions de distributions

Un aspect critique de l’approche Monte Carlo en modélisation physique est de bien comprendre et
contrôler la distribution statistique des nombres aléatoires utilisés pour l’analyse. On définit une
fonction de densité de probabilité (ci-après FDP) f (x) d’un processus (aléatoire ou non) produi-
sant une séquence de candidats xn , n = 1, 2, 3... où f (x)dx donne la probabilité que la valeur numérique
du candidat se retrouve entre x et x + dx. Par exemple, dans le cas du générateur uniforme de la section
précédente, on a
(
1 0<x≤1
f (x) = (5.1)
0 sinon

Une autre distribution avec laquelle vous avez probablement déjà fait connaissance est la distribution dite
normale (ou Gaussienne), notée N (µ, σ 2 ), pour laquelle la FDP est :
 2
1 −x
f (x) = √ exp . (5.2)
2πσ 2σ 2

Notons que, par leur définition même, les FDP sont des distributions normalisées, dans le sens que
Z
f (x)dx = 1 . (5.3)

Une fois la FDP connue, elle peut servir à calculer une multitude de caractéristiques globales de l’enemble
de valeurs de x ; la moyenne, par exemple, est donnée par
Z
⟨x⟩ = f (x) x dx . (5.4)

Le hic est que la distribution statistique d’une séquence de N valeurs discrètes de x produites par un
générateur basé sur de telles FDP deviendra identique à ces FDP seulement dans la limite N → ∞.
Comme en pratique on travaille toujours avec un N fini, il est important de comprendre, et de quantifier,
jusqu’à quel point les deux distributions dévient l’une de l’autre.
Travaillons avec la distribution uniforme associée à la FDP (5.1), et supposons que l’on a produit N
valeurs numériques rn ∈ [0, 1] à l’aide notre générateur de nombre aléatoire uniforme. Définissons d’abord
la fonction histogramme associée à cet ensemble de nombre aléatoires. Ces fonctions sont construites
comme suit : on définit une séquence de M intervalles d’échantillonnage contigus et de largeur fixe b :

[xm , xm + b] , xm + b = xm+1 , m = 1, ..., M (5.5)

1. Rappelez-vous que sur un ordinateur on ne peut représenter qu’un nombre fini de réels entre 0 et 1 (à cause de la
troncation numérique) : en 64-bits, il y a 262 − 252 ∼ 4.6 × 1018 nombre distincts entre 0 et 1. Cependant, la plupart des
générateurs de nombres aléatoires, de par l’algorithme qu’ils utilisent, n’utilisent qu’environ 252 ∼ 4.6 × 1018 de ceux-ci. En
d’autres termes, un générateur typique en 64-bits est équivalent à un dé ayant environ 5 milliards de milliards de faces, ça
en fait quand même beaucoup ! ! !

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

78 CHAPITRE 5. MONTE CARLO

avec ici x1 = 0 et xM + b = 1. Puisque les intervalles sont contigus, on a évidemment b = 1/M . On fait
ensuite le décompte Nm de toutes les valeurs de r tombant dans chaque intervalle :
(
1 sixm < rn ≤ xm + b
Nm = Nm + , m = 1, ..., M , n = 1, ..., N (5.6)
0 sinon

et la fonction histogramme hm est alors définie comme

Nm
hm (rn ; b) = , m = 1, ..., M . (5.7)
bN
Ici la notation “(rn ; b)” indique que la fonction histogramme est à la fois une fonction des données du
problème, soit les N valeurs de rn , ainsi que du choix de la largeur de l’intervalle d’échantillonnage b,
qui n’est pas une donnée du problème mais plutôt un choix de l’utilisateur (vous !) ; d’où l’utilisation du
point-virgule pour distinguer ces deux types de “variables” définissant la fonction histogramme. Notons
que la fonction histogramme satisfait à l’équivalent discret de la contrainte de normalisation (5.3) :
M
X
hm b = 1 . (5.8)
m=1

De plus, dans la limite N → ∞, on s’attendrait à ce que Nm = N/M (= N b) valeurs tombent dans chaque
“compartiment”, donc on aura

lim hm (rn ; b) = 1 , m = 1, ..., M , (5.9)

N →∞

démontrant bel et bien que la fonction histogramme est l’équivalent discret de notre FDP uniforme (5.1).
La Figure 5.2 montre des fonctions histogrammes construites à partir de séquences de nombres aléa-
toires produits par notre générateur uniforme, pour diverses valeurs de N . Dans tous les cas on a compar-
timenté ici l’intervalle [0, 1] en M = 20 intervalles d’échantillonnage. On voit immédiatement que plus N
est grand, plus les déviations par rapport à la valeur attendue hm = 1 sont petites. Changer l’initialisation
du générateur de nombre aléatoires changerait le détail de ces fonctions histogramme (i.e., quels hm se
retrouve au dessus ou au dessous de la valeur attendue), mais pas leur allure générale.
Essayons de quantifier un peu ce dernier énoncé. L’importance des déviations par rapport à la va-
leur moyenne d’un échantillon est souvent quantifiée par la variance de l’échantillon, aussi appelée
déviation quadratique moyenne, définie comme :
M
1 X
σ2 = (hm − ⟨h⟩)2 , (5.10)
M m=1

où la valeur moyenne ⟨h⟩ de l’échantillon est donnée par :

M
1 X
⟨h⟩ = hm . (5.11)
M m=1

La quantité σ comme telle est habituellement appelée “déviation RMS”, pour “Root-Mean-Squared”. Sa
variation avec N est illustrée à la Figure
√ 5.4, toujours pour nos nombres aléatoires uniformes. On remarque
que la déviation RMS y varie en 1/ N . Cette situation n’est pas particulière à une FDP uniforme, mais
caractérise en fait tous les processus statistiques sans effets de mémoire, dans la mesure où, comme
quand on roule un dé ou on tire à pile ou face, chaque mesure tirée de la distribution est complètement
indépendante des précédentes 2 .
Une autre mesure souvent intéressante (et importante) de la grandeur des fluctuation dans les distri-
butions construites pour un N fini est la valeur moyenne de la distribution même :
N
1 X
⟨r⟩ = rn . (5.12)
N n=1

2. Comment réconciliez-vous cet énoncé avec le fait que notre générateur de nombre aléatoire est complètement détermi-
niste, dans le sens qu’une fois initialisé, la valeur du nombre aléatoire rn est complètement déterminée par celle du nombre
rn−1 ?

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

5.2. FONCTIONS DE DISTRIBUTIONS 79

Figure 5.2 – Fonction de distribution des valeurs de séquences de N nombres aléatoires rn ∈ [0, 1], pour
quatres valeurs de N croissant par des facteurs 10 successifs. Les traits pointillés horizontaux indiquent
l’intervalle correspondant à ±1 déviations rms. Dans tous les cas la valeur attendue est f (x) = 1.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

80 CHAPITRE 5. MONTE CARLO

Figure 5.3 – Variation de l’écart rms (éq. (5.10)) sur la valeur attendue f (x) = 1, √en fonction du du
nombre N de candidats r produits. La droite en tirets indique une décroissance en 1/ N .

Figure 5.4 – Variation de l’erreur sur la moyenne de la distribution en fonction du nombre N de candidats √
r produits. L’erreur est définie ici selon l’éq. (5.14). La droite en tirets indique une décroissance en 1/ N .

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

5.3. DISTRIBUTIONS NON-UNIFORMES 81

Pour notre distribution uniforme dans [0, 1], on devrait évidemment avoir

1
lim ⟨r⟩ = , (5.13)
N →∞ 2
Donc on peut se définir ici une mesure d’erreur comme :

1
ε(N ) = ⟨r⟩ − . (5.14)
2

La variation de cette quantité avec N est portée

√ en graphique à la Figure 5.4 ; encore une fois, on constate
que l’erreur décroit grosso modo comme 1/ N .

5.3 Distributions non-uniformes

Dans bien des situations il est nécessaire de produire une séquence de nombres aléatoires extraits
d’une distribution qui ne soit pas uniforme. Il existe des techniques générales permettant de transformer
n’importe quelle FDP en une autre ; nous n’entrerons pas là-dedans ici (mais voir la bibliographie en fin
de chapitre), et nous nous limiterons plutôt à donner quelques “recettes” pour produire des distributions
souvent utilisées en simulations physiques. Ceux ou celles qui désirent approfondir ce genre truc, ou en
examiner les bases théoriques, trouveront de quoi s’occuper dans la bibliographie en fin de chapitre.
La méthode de transformation est basée sur l’idée que la distribution cumulative associée à une
FDP f (x) non-uniforme peut être interprétée comme un nombre aléatoire r extrait d’une distribution
uniforme dans [0, 1]. L’idée générale est illustrée à la Figure 5.5, qui montre comment une distribution
uniforme en y peut, via une fonction non-linéaire (ici une exponentielle décroissante), produire une dis-
tribution non-uniforme en x. Mathématiquement cette idée s’exprime selon la relation :
Z x
FX (x) = f (x′ )dx′ = r = R(x) , où R ∼ U (0, 1) . (5.15)
−∞

Si f (x) peut être intégré analytiquement, ceci offre une manière simple et efficace de produire des nombres
aléatoires extraits de distributions statistiques non-uniforme. Voyons comment ca marche avec un exemple
simple mais utile, soit la distribution exponentielle.

5.3.1 Distribution exponentielle

Dans plusieurs situations physiques, il est nécessaire de simuler des séquences d’événements se pro-
duisant de manière aléatoire dans le temps et/ou l’espace, sans effet de mémoire (i.e., l’événement b est
complètement indépendant de l’événement a l’ayant précédé). Un tel système obéit à la statistique dite de
Poisson, et on peut montrer que la distribution des temps d’attentes (ou distances) entre deux événements
successifs prend une forme exponentielle :
(
λ−1 exp(−x/λ) , 0 ≤ x ≤ ∞,
f (x) = , (5.16)
0 x<0

où λ est le facteur d’échelle contrôlant la décroissance de la distribution avec x. La fonction de distribution

cumulative est donc donnée par :
Z x Z x
x
f (x′ )dx′ = λ−1 exp(−x′ /λ)dx′ = [− exp(−x′ /λ)]0 = 1 − exp(−x/λ) (5.17)
−∞ 0

L’équation (5.15) donne alors :

1 − exp(−x/λ) = r , r ∈ [0, 1] , (5.18)

d’où on déduirait

x = −λ ln(1 − r), r ∈ [0, 1] , x ∈ [0, ∞] . (5.19)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

82 CHAPITRE 5. MONTE CARLO

Figure 5.5 – Illustration de la production d’une distribution non-uniforme en x à partir d’une distribution
uniforme en y, via une transformation nonlinéaire (voir texte). Si les y étaient des nombres aléatoires
∈ [0, 1] produits par un générateur du genre ran0 alors la distribution des x correspondants serait ici plus
concentrée aux petites valeurs de x.

Mais ici, comme la variable aléatoire 1 − r se distribue dans l’intervalle [1, 0] identiquement à la manière
dont r se distribue dans [0, 1], on peut tout aussi bien écrire :

x = −λ ln r , r ∈ [0, 1] , x ∈ [0, ∞] . (5.20)

La procédure pour générer un nombre aléatoire x respectant la distribution spécifiée par l’éq. (5.16)
est donc de générer un nombre aléatoire r uniforme entre 0 et 1, avec la fonction random() par exemple,
et ensuite de calculer x selon l’éq. (5.20).

5.3.2 Distributions gaussiennes

La distribution dite gaussienne (éq. (5.2) ci-dessus) est fort utile pour bien des applications, en parti-
culier pour les analyses ou simulations des erreurs expérimentales. La Figure 5.7 en montre un exemple
(traits pleins). Le paramètre clef ici est la variance σ 2 , qui contrôle l’étendue en x de la distribution (la
pleine largeur à mi-hauteur = 2.35σ). Si des nombres aléatoires sont extraits de cette distributions, 68.3%
seront situés à l’intérieur de ±σ, mais il demeure probable de produire occasionnellement des nombres
de taille passablement plus élevée. Cependant, l’intégrale d’une gaussienne ne peut être calculée analyti-
quement, il est donc difficile d’utiliser la méthode décrite dans la section précédente. Comment produire
une séquence de nombre aléatoires distribués de manière Gaussienne ? Il existe plusieurs techniques, mais
nous ne considérerons ici que celle basée sur la transformation dite de Box-Muller : ayant en main deux
nombre aléatoires r1 , r2 extraits d’une distribution uniforme dans l’intervalle [0, 1], on peut produire deux
nombres aléatoires g1 , g2 distribués de manière Gaussienne via les relations :
p
g1 = −2 ln r1 cos(2πr2 ) , (5.21)

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

5.4. ÉVALUATION D’INTÉGRALES PAR MONTE CARLO 83

Figure 5.6 – Fonction de distribution de probabilité de forme exponentielle, telle que décrite par
l’éq. (5.16), pour trois valeurs du facteur d’échelle (traits plein). L’histogramme est la distribution de
104 nombres aléatoires produits à l’aide de l’éq. (5.20) avec λ = 1.

p
g2 = −2 ln r1 sin(2πr2 ) , (5.22)

où g1 , g2 ∈ [−∞, ∞]. La Figure 5.7 en montre un exemple de la distribution produite ainsi, pour 104
nombres aléatoires calculés utilisant les relations ci-dessus. Cette procédure fonctionne, mais elle est loin
d’êre optimale au niveau du temps de calcul requis ; on peut en fait faire beaucoup mieux, mais je vous
laisse ça comme “lecture supplémentaire”.
En pratique, avec Python, vous n’aurez pas à appliquer cette méthode car une fonction pour générer
des nombres aléatoire selon une distribution Gaussienne de moyenne 0 et variance 1, i.e. N (0, 1), est déjà
fournie avec le module NumPy ; il s’agit de la fonction [Link](). Pour générer des nombres
aléatoires selon N (µ, σ 2 ), i.e. une distribution Gaussienne de moyenne µ et variance σ 2 , il suffit de faire
la commande suivante,
sigma * [Link](...) + mu

5.4 Évaluation d’intégrales par Monte Carlo

Appliquons maintenant l’approche Monte Carlo au calcul d’une intégrale définie d’une fonction f (x)
d’une variable ; nous choisirons un polynôme quartique :

f (x) = 1 + x4 , (5.23)

et, comme intégrale à évaluer :

1 !
1
x5
Z 
6
I= f (x)dx = x+ = . (5.24)
0 5 0 5

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

84 CHAPITRE 5. MONTE CARLO

Figure 5.7 – Fonction de distribution de probabilité de forme Gaussienne, telle que décrite par l’éq. (5.2),
pour trois valeurs de la largeur à mi-hauteur (traits plein). L’histogramme est la distribution de 104
nombres aléatoires produits à l’aide des éqs. (5.21)—(5.22).

Si on utilise la méthode du trapèze (§4.4) avec un maillage constitué de N points équidistants en x, on

aura :
N −1
X 1
I= (fn+1 + fn ) (xn+1 − xn )
n=1
2 | {z }
≡h

 
f1 + f2 f2 + f3 f3 + f4 fN −2 + fN −1 fN −1 + fN
= + + + ... + + ×h
2 2 2 2 2

−1
N
!
f1 + fN X
= + fn ×h , (5.25)
2 n=2

où ici le pas de maille h = 1/(N − 1). Notons, et retenons, que le nombre d’évaluations de f requis ici
est égal à N . L’expression ci-dessus ressemble dangereusement au calcul d’une valeur moyenne de f (x)
échantillonnée uniformément sur l’ensemble de l’intervalle, et c’est bien là une interprétation habituelle
de l’intégrale comme une aire sous la courbe (valeur moyenne de f dans l’intervalle fois la longueur de
l’intervalle, ici un).
Il y aurait d’autres façons de calculer cette valeur moyenne. Plutôt que d’échantillonner f (x) réguliè-
rement en x, on aurait pu choisir d’échantillonner f à N points positionnés aléatoirement (de manière
statistiquement uniforme) en x dans l’intervalle [0, 1]. La valeur de l’intégrale serait alors donnée par
N
1 X
I= f (rn ) , rn ∈ [0, 1] , (5.26)
N n=1

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

5.4. ÉVALUATION D’INTÉGRALES PAR MONTE CARLO 85

Figure 5.8 – Diminution de l’erreur dans le calcul de l’intégrale définie par les éqs. (5.23) et (5.24) en
fonction du nombre N d’évaluation de f (x), pour la méthode du trapèze et l’intégration Monte Carlo, tel
qu’indiqué. La droite pointillée correspond à une variation en N −1/2 .

où rn est un nombre aléatoire extrait d’une distribution uniforme couvrant l’intervalle [0, 1]. Pourquoi
pas ? Vous commencez j’espère à percevoir le lien avec l’exemple de l’étang... En fait, cette approche est
appelée intégration Monte Carlo. Dans une forme un peu plus générale, la formule correspondante serait,
b N
b−a X
Z
I= f (x)dx ≃ f (rn ) , rn ∈ [a, b] , (5.27)
a N n=1

où rn provient d’une distribution uniforme. En deux dimensions, on aurait

x2 y2 N
(x2 − x1 )(y2 − y1 ) X
Z Z
I= f (x′ , y ′ )dy ′ dx′ ≃ f (rn , sn ) , rn ∈ [x1 , x2 ] , sn ∈ [y1 , y2 ] , (5.28)
x1 y1 N n=1

où rn et sn proviennent de distributions uniformes. Et ainsi de suite en plus de dimensions.

Revenons maintenant à l’intégrale donnée par l’éq. (5.24). La Figure 5.8 montre la variation de l’erreur,
définie ici comme

ε(N ) = |1.2 − I(N )| , (5.29)

pour l’évaluation de notre intégrale par la méthode du trapèze (éq. (5.25)), et par la méthode Monte Carlo
(éq. (5.26)). La première converge en 1/N 2 , comme on s’y attendrait d’une méthode O(h2 ) √ ; la seconde
converge de manière beaucoup plus irrégulière, mais en moyenne comme un pitoyable 1/ N (droite
pointillée). Ici, la méthode Monte Carlo requiert en moyenne ∼ 105 évaluations de f pour en arriver à
ε = 10−3 , tandis que la méthode du trapèze atteint ce niveau d’erreur en seulement 17 évaluations de f .
Suis-je en train de vous faire perdre votre temps avec toutes ces histoires de Monte Carlo ?
Non. C’est certainement le cas qu’en une dimension spatiale, le Monte Carlo n’est jamais compétitif.
Mais en plusieurs dimensions spatiales, c’est une toute autre histoire. On peut montrer que l’équivalent

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

86 CHAPITRE 5. MONTE CARLO

à D dimensions spatiales de la méthode du trapèze, pour un échantillonnage uniforme avec pas h =

1/N dans chaque dimension, converge comme 1/N 2/D (retournez voir la Figure √ 5.1 et pensez-y à tête
reposée.). Cependant, l’intégration Monte Carlo converge toujours comme 1/ N , et ce quelle que soit la
dimension D ! ! Le taux de convergence des deux méthodes devient donc le même pour une intégrale en
4 dimensions, et aucune méthode de type Newton-Cotes ne demeure le moindrement compétitive en plus
de 10 dimensions spatiales.
Vous pourriez penser qu’une intégrale en plus de trois dimensions, ca n’a pas d’allure de toute façon,
mais détrompez-vous, vous allez en rencontrer en physique statistique qui montent beaucoup plus haut ;
par exemple, l’espace de phase d’un pendule à tige rigide pouvant osciller librement dans toutes les
directions est de dimension 4 ; et celui des deux atomes d’hydrogène et de l’atome d’oxygène formant
une molécule de H2 O est à 18 dimensions (3 coordonnées spatiales et trois composantes de la vitesse par
atome). En analyse Bayesienne, on doit évaluer des intégrales sur un espace où le nombre de dimensions
est égal au nombre de paramètres du modèle que l’on tente de contraindre, et on a régulièrement affaire à
des modèles contenant une dizaine de paramètres ou plus. Dans ces cas, l’approche Monte Carlo devient
incontournable.

5.5 L’approche à l’équilibre

Nous allons maintenant étudier un problème classique dit d’approche à l’équilibre, dans le contexte
du problème de mélange, illustré sur la Figure 5.9. Deux boîtes contiguës communiquent via un petit trou
percé dans leur paroi commune. Les deux boîtes contiennent respectivement N1 et N2 particules, disons
des boules de billiard. Ces particules vont continuellement se frapper entre elles ou rebondir sur les parois,
et de temps en temps, ces collisions vont faire qu’une particule passera de la boîte 1 à la boîte 2, ou
l’inverse. Nous tenterons maintenant de répondre aux trois questions suivantes :
1. Existe-t-il un état d’équilibre pour lequel le nombre de particules dans chaque boîte demeure
constant avec le temps ?
2. Si oui, quel est cet état ?
3. Toujours si oui, quel est le temps requis pour atteindre cet état d’équilibre à partir d’une condition
initiale arbitraire ?
Intuitivement, on peut s’attendre à ce que si l’on attend suffisamment longtemps (ici dans le sens d’un
intervalle de temps beaucoup plus grand que le temps entre deux collisions successives), chaque particule
ait ultimement la même probabilité de traverser le trou. Le nombre total de particules δN12 traversant
de la boîte 1 à la boîte 2 durant un intervalle de temps ∆t devrait donc être donné par quelque chose du
genre :

δN12 = αN1 ∆t , (5.30)

où α est la probabilité de passage par particule par unité de temps. C’est une quantité qui dépend de la
taille du trou, de la vitesse des particules, de leur taux de collision, mais pas de leur nombre, cette dernière
dépendance étant déjà explicitée au membre de droite. Et pour le nombre de particules passant de 2 à 1 :

δN21 = αN2 ∆t , (5.31)

avec la même valeur de α qu’à l’éq. (5.30). Pour avoir une situation stationnaire, il faudra qu’il n’y ait
plus de transfer net de particules d’une boîte à l’autre (sinon N1 et N2 varieront en conséquence, et donc
nous n’avons plus une situation stationnaire). Exiger que δN12 = δN21 nous donne alors immédiatement
la condition d’équilibre :

N1 = N2 , [equilibre] . (5.32)

Ce résultat concorde avec l’intuition. Supposons que les deux boîtes sont en fait deux classes remplies
d’étudiant(e)s, et que les particules sont en fait des macromolécules nauséabondes d’aftershave Irish Brut
45 Magnum dont un de vos petits camarades s’est trop généreusement aspergé le matin même, ayant
manqué de temps pour la douche. L’expérience montre que si l’on attend assez longtemps, ca puera
uniformément dans les deux classes, en d’autres mots le système a atteint un état d’équilibre où le nombre
de molécules puantes par unité de volume est le même partout. Voyons maintenant à quelle vitesse cet
état d’équilibre est atteint.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

5.5. L’APPROCHE À L’ÉQUILIBRE 87

Figure 5.9 – Deux boîtes communiquant par un petit trou contiennent un total de N particules, mais
l’une (ici celle de gauche) en contient un nombre N1 plus grand que l’autre, soit N2 < N1 . Les collisions
contre les parois et interparticules feront que le nombre de particules traversant de la gauche vers la droite
sera plus grand que dans le sens inverse, et ce tant et aussi longtemps que N1 > N2 . La solution d’équilibre
est ici N1 = N2 = N/2 (voir texte).

5.5.1 Formulation en équation différentielle

Considérant notre définition de α comme étant la probabilité qu’une particule de la boîte passe à la
boîte 2 par intervalle de temps ∆t, le nombre de particules dans les boîtes 1 et 2 au temps t + ∆t doit
être donnée par quelque chose comme :

N1 (t + ∆t) = N1 (t) + α∆tN2 (t) − α∆tN1 (t) , (5.33)

N2 (t + ∆t) = N2 (t) + α∆tN1 (t) − α∆tN2 (t) . (5.34)

Le premier terme au membre de droite est le nombre de particules déjà présentes dans chaque boîte au
temps t, le second terme correspond aux particules entrant dans la boîte, et le troisième aux particules
sortant de la boîte. Je vous laisse vérifier que la forme de ces expressions garantit que le nombre total de
particules est une quantité conservée, i.e., N1 (t) + N2 (t) = N . Un peu d’algèbre simple permet de ramène
ces expression à la forme suivante :

N1 (t + ∆t) − N1 (t)
= α(N2 (t) − N1 (t)) , (5.35)
∆t

N2 (t + ∆t) − N2 (t)
= α(N1 (t) − N2 (t)) . (5.36)
∆t
Examinez bien les membres de gauche de ces deux expressions. Vous réaliserez j’espère qu’ils ressemblent
fort à une différence finie d’ordre O(∆t) pour les dérivées temporelles de N1 et N2 . On peut donc écrire :

dN1
= α(N2 − N1 ) , (5.37)
dt

dN2
= α(N1 − N2 ) . (5.38)
dt

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

88 CHAPITRE 5. MONTE CARLO

Il s’avérera pratique d’exprimer le nombre de particules dans chaque boîte en terme de la fraction du
nombre total N de particules :

N1 N2
f1 = , f2 = . (5.39)
N N
Notre contrainte de conservation N1 + N2 = N devient simplement

f1 + f2 = 1 , (5.40)

ce qui permet d’exprimer les éq. (5.37)–(5.38) sous la forme :

df1
= α(1 − 2f1 ) , (5.41)
dt

df2
= α(1 − 2f2 ) . (5.42)
dt
Remarquez que l’utilisation de la contrainte de conservation a effectivement découplé nos deux équations
différentielles, ce qui fait que nous n’avons plus qu’à en solutionner une, et la solution de l’autre s’obtient
trivialement via l’éq. (5.40). Remarquez également que si l’on pose f1 = f2 = 0.5, on obtient bien
df1 /dr = df2 /dt = 0, comme on s’y attend pour une solution d’équilibre.
L’équation (5.41) est une équation différentielle ordinaire linéaire mais inhomogène, du à la présence
d’un terme constant α au membre de droite. Un simple changement de variable permet cependant de
convertir ça en une équation différentielle homogène qui se solutionne facilement. Introduisons une nouvelle
fonction ξ(t) définie selon

1
ξ(t) = f1 (t) − ; (5.43)
2
comme ξ et f1 sont reliées l’une à l’autre par une relation linéaire, on aura

dξ df1
= , (5.44)
dt dt
ce qui permet de réexprimer l’éq. (5.41) sous la forme

dξ
= −2αξ , (5.45)
dt
qui est l’équation homogène promise. Ceci a évidemment comme solution :

ξ(t) = ξ0 exp (−2αt) , (5.46)

où ξ0 correspond à la valeur de ξ à t = 0. Si l’on choisit comme condition initiale qu’à t = 0 toutes les
particules sont dans la boîte 1, alors f1 (t = 0) = 1, et on aura ξ0 = 1/2. On utilise finalement l’éq. (5.43)
pour exprimer ce résultat en terme de notre fonction primaire f1 :

1
f1 (t) = (1 + exp (−2αt)) . (5.47)
2
La solution asymptotique est bien

1
lim f1 (t) = , (5.48)
t→∞ 2
soit une répartition égale des particules dans les boîtes 1 et 2, atteinte exponentiellement avec une constante
de temps τ = 1/(2α) ; se rappelant que α est une mesure de la taille du trou, on voit bien que plus le
trou est petit, plus l’approche à l’équilibre est lente, ce qui est tout à fait logique puisque les particules
ont plus de difficulté à passer d’une boîte à l’autre.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 5.5. L’APPROCHE À L’ÉQUILIBRE 89

5.5.2 Formulation Monte Carlo

Maintenant, utilisons une approche Monte Carlo à notre problème d’approche à l’équilibre. Nous avons
déjà fait tout le travail théorique requis en écrivant les équations (5.33)–(5.34). Le bout de code nécessaire
pour modéliser ce système est donné ci-bas.

1 #Simule melange de particules entre deux boites contigues

2

3 import numpy as np
4

5 niter=200 #nombre d'iterations temporelles

6 n=1000 #nombre total de particules
7 alpha=0.01 #probabilite de traverser par iteration, par particule
8

9 #conditions initiales, ici toutes les particules debutent dans 1

10 n1=n
11 n2=n-n1
12

13 for i in range(niter):
14 de1a2=([Link](n1)<=alpha).sum() # nombre de particules passant de 1 a 2
15 de2a1=([Link](n2)<=alpha).sum() # nombre de particules passant de 2 a 1
16

17 n1+=de2a1-de1a2 #nouveau nombre de particules dans 1

18 n2+=de1a2-de2a1 #nouveau nombre de particules dans 2
19 print('Iteration {}: N1={}, N2={}'.format(i,n1,n2))

Notez bien comment, aux lignes 14 et 15, on compte le nombre de particules qui traversent d’une
boîte à l’autre : on génère d’abord un tableau contenant un nombre aléatoire (uniformément distribué
dans l’intervalle [0, 1]) pour chaque particule dans la boîte donnée, on applique ensuite une vérification
logique élément-par-élément sur ce tableau pour déterminer ceux qui sont inférieurs à la probabilité α,
i.e. le critère pour qu’une particule traverse, et enfin on somme le tableau booléen résultant pour avoir
le nombre total de particules qui traversent (rappelez-vous que pour une opération arithmétique, True
est considéré comme 1 alors que False est considéré comme 0). Vous pouvez facilement voir que poser
α = 0 ferait qu’aucune particule ne traverserait (test ci-dessus jamais satisfait), et α = 1 au contraire
conduirait à un passage de toutes les particules en un pas de temps, puisque le test probabiliste serait
alors toujours satisfait. Notez aussi que le “transfert” de particules d’une boîte à l’autre se fait seulement
une fois que toutes les particules ont été testées, dans les deux boîtes, les nombres à transférer de la boîte
1 vers la 2 et de la 2 vers la 1 étant accumulées dans des compteurs (ici les variables de1a2 et de2a1). Si
on transférait les particules immédiatement après vérification de chaque boîte, alors l’ordre dans lequel
on teste les boîtes (ici la 1 avant la 2) aurait une influence sur l’évolution.
Pour les intéressés, la somme des “succès” d’une séquence de N essais gouvernés par un processus
aléatoire de probabilité de succès p est représentée par une distribution statistique binomiale, B(N, p), et
on aurait donc pu remplacer les lignes 14 et 15 du code ci-haut par les deux lignes suivantes, complètement
équivalentes,

de1a2=[Link](n1,alpha)
de2a1=[Link](n2,alpha)

La Figure 5.10 montre le résultat de trois réalisations Monte Carlo de l’approche à l’équilibre, pour
des systèmes de 103 , 104 , et 105 particules, toutes initialement plaçées dans la boîte 1. Les entiers N1 et
N2 ont été convertis en fraction f1 et f2 selon l’éq. (5.39), mais ici la nature discrète de la variable est
bien évidente, en particulier pour la solution à N = 103 (en rouge).
La forme exponentielle de l’approche à l’équilibre est facilement visible ici, mais on remarque aussi
des déviations irrégulières par rapport à une exponentielle “pure”. Le détail de ces variations est différent
pour une initialisation différente du générateur de nombre aléatoire, mais elles sont toujours présentes. On
remarque également sur la Figure 5.10 que plus N est grand, plus ces déviations sont petites. La Figure
5.11 montre la variation de la déviation RMS évaluée à quatre temps différents durant l’évolution, à partir

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

90 CHAPITRE 5. MONTE CARLO

Figure 5.10 – Variation temporelle de la fraction de particules dans la boîte 1, pour un nombre total de
particules N = 102 (rouge), 103 (vert) et 104 (bleu). La variation correspondante de f2 est obtenue via
la contrainte de conservation f1 + f2 = 1, et correspond à une réflexion par rapport à la droite f1 = 0.5.
La décroissance est exponentielle dans les trois cas, mais les fluctuations diminuent rapidement à mesure
que N augmente (voir texte).

Figure 5.11 – Variation de l’écart relatif moyen en fonction du nombre total de particules N , associé
à des ensembles de 50 solutions statistiquement distinctes au problème de l’approche à l’équilibre. Les
différents symboles correspondent à des écarts mesurés à des temps différents, soit t = 50 (∗), t = 100 (+),
t = 150 (△) et t = 200 (⋄), avec t mesuré ici comme
√ le nombre d’itérations du processus Monte Carlo. Le
trait pointillé correpond à une décroissance en 1/ N .

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

5.6. RÉALISME PHYSIQUE ET IRRÉVERSIBILITÉ 91

d’un ensemble de 50 simulations statistiquement distinctes (i.e., utilisant une initialisation différente du
générateur
√ de nombres aléatoires). Ici encore, la fluctuation par rapport à la valeur moyenne décroit selon
1/ N , à n’importe quel temps durant l’approche à l’équilibre.

5.6 Réalisme physique et irréversibilité

Nous allons clore ce chapitre avec quelques observations et questions qui vont, je l’espère, vous faire
réfléchir un peu sur ce qu’on pourrait appeler la philosophie de la modélisation, et peut-être sur la nature
de la réalité physique (Mamma mia...).

5.6.1 Comment choisir les alternatives en modélisation ?

Nous avons donc développé deux approches de modélisation fondamentalement distinctes à notre
problème d’échange de particules entre deux boîtes : une approche déterministe basée sur la solution d’une
équation différentielle, et une approche stochastique de type Monte Carlo. Laquelle est la “meilleure” ici ?
La solution exponentielle décrite par l’éq. (5.47) est “propre” et mathématiquement concise ; on serait
tenté de lui donner préférence. Mais réfléchissez-y un peu plus profondément ; le système physique étudié
ici est formé d’un nombre fini (quoique possiblement très grand) de particules. L’approche déterministe de
la §5.5.1 convertit ceci en un problème continu pour les fractions f1 et f2 , en remplaçant les membres de
gauche des équations (5.35)–(5.36) par des dérivées temporelles, qui à strictement parler ne sont définies
que si N1 et N2 sont des variables réelles, pas des entiers ! En passant des éqs. (5.35)–(5.36) aux éqs. (5.37)–
(5.38), l’approche déterministe introduit une approximation qui n’est pas faite par l’approche Monte Carlo,
qui travaille directement à partir des équations (5.33)–(5.34). Quelle est l’approche la plus physiquement
raisonnable ici ? Fondamentalement, ce serait le Monte Carlo ! Cependant, si N est vraiment très grand
(genre, le nombre de macromolécules d’Irish Magnum 45 dans une salle de classe), l’approche Monte
Carlo peut devenir très lente, pour produire en bout de ligne un résultat qui ne pourra être distingué de
l’exponentielle décroissante au niveau de précision de votre ordinateur.
Si vous avez suivi le raisonnement ici, vous aurez anticipé que l’approche optimale consisterait à
utiliser Monte Carlo quand N est petit, et l’approche déterministe quand N est grand. Mais, comment
alors choisir la valeur de N à laquelle on change d’approche ? Il n’y a absolument pas de réponse facile
à cette question ; la réponse dépend du type d’information que vous cherchez à extraire de votre modèle.
Notez cependant qu’ici l’approche Monte Carlo fournit “naturellement”, en prime, une mesure statistique
des fluctuations pouvant être attendues dans le système. C’est là une information souvent précieuse.

5.6.2 L’irréversibilité
L’intuition physique, et nos modélisations mathématique et statistique du problème, indiquent toutes
que dans la situation illustrée à la Figure 5.9 le transfert net de particules se fera de la boîte 1 vers la boîte
2, donc que si l’on photographiait ce système à un temps ultérieur le nombre de particules dans la boîte
1 aura diminué, et celui dans la boîte 2 aura augmenté par la même quantité. Vous seriez fort surpris si
la photographie révélait que la boîte 2 s’était vidée de ses quelques particules au profit de la boîte 1, et
vous seriez fort tenté de conclure qu’un petit comique a inversé l’ordre des photos.
Un phénomène comme celui que nous avons modélisé ici, pour lequel il est possible de distinguer
“intuitivement” l’ordre temporel d’une séquence de photos du processus en action, est dit irréversible.
Notre procédure d’échange stochastique de particules entre deux boîtes communiquantes est une représen-
tation très simple d’un processus de diffusion, phénomène sur lequel nous reviendrons au chapitre 9. On
y verra que le mouvements des particules les faisant éventuellement traverser le trou est un ensemble de
mouvements rectilinéaires entrecoupés de collisions (élastiques) avec les parois ou avec d’autres particules.
Comme vous l’avez déjà vu au CEGEP ou même au secondaire, une collision élastique entre deux corps
est un processus réversible ; si vous filmez la collision, que vous rejouez le film à l’endroit ou à l’envers,
rien ne vous permet de distinguer la direction temporelle de l’expérience originale.
Nous avons donc la situation suivante ; à l’échelle “macroscopique” du système (les boîtes), l’évolution
temporelle est irréversible. À l’échelle “microscopique” du système, le phénomène qui en gouverne la
dynamique (les collisions) est lui parfaitement réversible. Comment une séquence d’événements réversibles
peut-elle produire une évolution globale du système qui soit irréversible ? Ceci est une des questions les
plus fondamentales à laquelle vous aurez à faire face durant vos étude en physique, et elle vous tiendra fort

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

92 CHAPITRE 5. MONTE CARLO

occupé(e)s pendant quelques cours entiers. Celà pourrait donc vous être utile de commencer à y cogiter
dès maintenant...

Exercices:

1. Écrivez un code utilisant l’approche Monte Carlo au calcul de la surface de l’étang (Fig. 5.1) pour
calculer le volume d’une “hypersphère” de rayon R en D dimensions ; une telle hypersphère est
définie par la relation :
x21 + x22 + x23 + ... + x2D = R2 ,
où les xk représentent les axes de coordonnées de votre hyperespace D-dimensionnel. Testez votre
code pour la sphère habituelle (D = 3), pour laquelle vous savez évidemment que V = 4πR3 /3.
2. La Loi dite de Gutenberg-Richter, établie empiriquement, nous informe que le nombre N de tem-
blement de Terre de magnitude entre m et m + dm varie selon la distribution :

N (m) = N0 m−1 , 1 ≤ m ≤ 10 .

Une telle distribution est appelée une loi de puissance.

(a) Déduisez la transformation mathématique qui permettra de produire une telle distribution à
l’aide de nombres aléatoires distribués uniformément, selon la procédure décrite à la §5.1 ;
(b) Générez 1000 “événements” distribués selon cette distribution, et vérifiez graphiquement que
leur histogramme prend bien la forme d’une loi de puissance ;
(c) Reprenez votre liste de 1000 événements, et calculez en la moyenne cumulative :
n
1X
⟨m⟩n = mk , n = 2, 3, ..., 103 .
n
k=1

Portez en graphique ⟨m⟩n versus n ; la moyenne est-elle une quantité statistiquement stable ici ?
Pourquoi ?
3. Calculez par Monte Carlo l’intégrale définie suivante :
p !
2 1 2 5/2 π 5/2
p
(u2 + x3 + y 2 + z 2 sin2 (2πv) cos( x2 + y 2 πw)
Z Z Z Z Z Z
3
+
1 0 −1 0 −π 1/2 2 (1 − sin(2v + z + π/2) cos(πy))2 exp(−(u + v + w)/3)

×(exp(−z w/2) − 1) du dv dw dx dy dz .
Le codage de l’intégrant devrait à lui seul représenter un excellent exercice... Ensuite,
(a) Portez en graphique le résultat en fonction du nombre d’évaluations Monte Carlo ; combien
d’évaluation sont requises pour obtenir un résultat stable au troisième chiffre significatif ?
(b) Appellons le nombre d’évaluation déterminé ci-dessus N ; comme il s’agit ici d’une intégrale en
six dimensions, calculer l’intégrale par méthode du trapèze généralisée à 6 dimensions avec le
même nombre N d’évaluations de l’intégrand imposerait donc une résolution de N 1/6 points
équidistants par dimension spatiale. Selon vous, considérant la forme de l’intégrand, est-ce
suffisant ?

Bibliographie:

Le chapitre 7 du Numerical Recipes offre une excellente présentation de la génération de nombres

aléatoires sur ordinateurs. Je vous recommanderais de consulter d’abord la seconde édition (1992), qui
traite des générateurs dits congruentiels. La grande référence classique sur la famille des générateurs de
nombres aléatoires dits congruentiels est :
Park, S.K., & Miller, K.W., Comm. of the ACM, 31, 1192 (1988).

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

5.6. RÉALISME PHYSIQUE ET IRRÉVERSIBILITÉ 93

La troisième édition du Numerical Recipes abandonne effectivement les générateurs congruentiels au

profit d’approches plus sophistiquées, mais plus difficile à saisir, autant au niveau de la théorie que de
l’implémentation numérique. C’est pourquoi je vous recommande de commencer par la seconde édition.
Tous les ouvrages de statistique le moindrement raisonnables discuterons de la production et des
propriétés de diverses FDP non-uniformes ; je trouve très pratique et instructive la compilation présentée
au chapitre 4 de l’ouvrage :
James, F., Statistical Methods in Experimental Physics, 2e éd., World Scientific (2006).
Le chapitre 2 de cet ouvrage offre également une bonne introduction aux probabilités, et à leur distribu-
tions. Un autre ouvrage notable dans la même veine est :
Roe, B.P., Probability and Statistics in Experimental Physics, Springer (1992).
Au niveau de l’approche Monte Carlo en modélisation physique, l’ouvrage de Gould & Tobochnik cité
en bibliographie au chapitre 1 contient d’excellent exemples. À un niveau physique plus avancé, et plus
centré sur les applications en physique des matériaux, l’ouvrage suivant me semble pas mal :
Frenkel, D., & Smit, B., Understanding Molecular Simulations, 2e éd., Academic Press (2002).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

94 CHAPITRE 5. MONTE CARLO

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 95

Chapitre 6

Racines et optimisation

Dans ce chapitre nous allons développer quelques algorithmes numériques permettant de traiter deux
classes de problèmes mathématiques à prime abord distincts : la recherche de racines, et celle d’extrema.
Une racine r d’une fonction f (x) est définie comme une valeur r telle que f (r) = 0. Par exemple, une
relation linéaire y = mx + b a une seule racine à r = −b/m, tandis qu’un polynôme quadratique de la
forme,

y = ax2 + bx + c = 0 , (6.1)

a ses deux racines à :

√
−b ± b2 − 4ac
r± = . (6.2)
2a
Vous n’aurez probablement pas oublié que déjà avec un polynôme cubique, les choses se compliquaient
sérieusement. Les premières sections du présent chapitre vous feront faire connaissance avec deux tech-
niques simples permettant le calcul numérique des racines d’une fonction f (x) d’une seule variable, soit
la bissection (§6.2) et la méthode de Newton (§6.3). Nous considérerons ensuite la recherche des valeurs
extrêmes, ou extrema, d’une fonction. Les extrema 1 viennent en deux classes, soit les minima et les
maxima ; un maximum est une valeur x∗ telle que f (x∗ ) > f (x) ∀ x ̸= x∗ , et l’inverse pour un minimum.
Le lien profond entre la recherche de racine et celle des extrema provient évidemment du fait que pour
un extremum on doit avoir df /dx = 0, ce qui fait que les problèmes de recherche d’extrema peuvent
souvent être convertis en problèmes de recherche de racines. Cependant, comme nous aurons l’occasion de
le constater plus loin dans ce chapitre, dès qu’on passe à une fonction de deux variables, il est rarement
avantageux d’effectuer cette conversion.
Une des tâches les plus courantes en physique expérimentale est d’ajuster un modèle (habituellement
défini en termes d’un ou plusieurs coefficients numériques ajustables) sur un ensemble de données expéri-
mentales ou observations. L’optimisation consiste à choisir les valeurs numériques des divers paramètres
ajustables de manière à offrir la meilleure représentation possible des données. Ceci est habituellement
fait en minimisant une mesure de l’écart entre les prévisions du modèle et les observations dont il doit
en principe offrir une représentation théorique. L’optimisation se retrouve donc souvent formulée comme
un problème de minimisation. Comme on le verra plus bas, le choix de l’une ou l’autre technique de
minimisation sera souvent dicté par la complexité de la relation mathématico-physique reliant le modèle
aux données.

6.1 La diffraction
Commençons par quelque chose que vous connaissez déjà, c’est toujours bon pour le moral. Vous avez
appris au CEGEP que la diffraction de la lumière par un orifice (comme une fente simple) peut être calculée
en invoquant le principe de superposition de Huygens, selon lequel les amplitudes des fronts d’onde associés
à une rangée de sources ponctuelles contiguës couvrant la fente s’additionnent linéairement, mais avec un
1. extrema : nominatif pluriel du latin extremum ; donc SVP pas de “s” à extrema (ou minima, maxima, etc). Et encore
moins à extremum, minimum, maximum, etc. Fin de la parenthèse culture générale...

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

96 CHAPITRE 6. RACINES ET OPTIMISATION

Figure 6.1 – Géométrie du problème de diffraction par une fente simple de largeur d illuminée par une
onde plane monochromatique de longueur d’onde λ. L’intensité lumineuse est mesurée au point P sur un
écran placé derrière la fente.

déphasage relatif correspondant à la différence du chemin optique parcouru. La superposition des fronts
d’onde produits par un ensemble de sources ponctuelles situées le long de la fente peut donc conduire à
une interférence constructive ou destructive, partielle ou totale. Pour une longue fente de largeur d éclairée
par un faisceau lumineux monochromatique de longueur d’onde λ, la variation de l’amplitude A(θ) de
l’onde lumineuse mesurée à un angle θ par rapport à la ligne reliant la fente au centre d’un écran placé
parallèlement et à une distance L de celui dans lequel est découpée la fente (voir Figure 6.1) varie selon,
sin x
A(x) = , (6.3)
x
où la variable x est définie comme :
πd
x= sin θ . (6.4)
λ

Ce profil d’amplitude est porté en graphique sur la Figure 6.2 avec une représentation synthétique du
profil d’intensité (∝ A2 ) tel qu’il serait observé sur l’écran. L’alternance régulière de bandes brillantes et
sombres est caractéristique du phénomème de diffraction, qui n’est évidemment pas restreint aux fentes
rectilignes.
Les minima d’intensité se produisent aux endroits où l’amplitude totale de l’onde plane diffractée est
nulle. La dépendance sinusoïdale du numérateur de l’éq. (6.3) indique que ces minima apparaitront aux
positions telles que,

x = ±nπ , n = 1, 2, 3... (6.5)

La question à savoir ce qui se passe à x = 0 se règle par la Règle de l’Hôpital, qui nous informe que
sin x cos x
lim = lim =1. (6.6)
x→0 x x→0 1

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

6.2. LA BISSECTION 97

Figure 6.2 – Profil d’amplitude du patron de diffraction d’une fente simple (courbe). L’image du haut
montre l’intensité lumineuse associée, qui est proportionnelle au carré de l’amplitude de l’onde. Le para-
mètre x mesure effectivement la distance à partir du centre du patron de diffraction (voir eq. 6.4). Les
tirets pointillés indiquent la position des minima d’intensité, et ceux en trait plein la position des maxima.

Pour trouver les positions des pics d’intensité nous n’avons qu’à dériver le membre de droite de l’éq. (6.3)
par rapport à x, et exiger que le résultat soit égal à zéro :
 
d sin x cos x sin x
= − 2 =0. (6.7)
dx x x x
Sauf que voilà, aucune manipulation algébrique légale connue ne permet d’isoler le x dans cette expression.
En fait, l’équation (6.7) définit un problème de recherche de racine pour une fonction f (x) que l’on pourrait
écrire comme :
f (x) = x cos x − sin x . (6.8)
Alternativement, on pourrait diviser cette équation par cos x et obtenir,
f (x) = tan x − x , (6.9)
qui est une seconde forme de la fonction ayant les mêmes racines. On vous a peut-être même déjà fait
solutionner ça via une méthode graphique, en mesurant sur du papier quadrillé les points d’intersection
des fonctions y = tan x et y = x. Au sens strictement mathématique, les équations (6.9) et (6.8) sont
évidemment équivalentes. Mais du point de vue d’une recherche numérique de racine, la version définie
par l’éq. (6.8) est préférable à (6.9), car cette dernière diverge là où cos θ = 0, soit à un ensemble discret
de valeurs x = (n + 1/2)π, n = 0, 1, ... Voyons maintenant comment trouver numériquement les racines
de telles fonctions.

6.2 La bissection
Nous cherchons donc les racines de l’éq. (6.8). Supposons que nous pouvons établir a priori un intervalle
[x1 , x2 ], tel que f1 ≡ f (x1 ) et f2 ≡ f (x2 ) soient de signes opposés, dans lequel nous cherchons une racine

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 98 CHAPITRE 6. RACINES ET OPTIMISATION

r devant être déterminée avec une précision donnée ε. Comme son nom l’indique, la méthode de la
bissection converge vers la racine par bissection successive de l’intervalle de recherche. L’idée de base ici
n’est rien de plus subtil que le fait que la racine de f (x) correspond ici au point où la fonction change
de signe. Étant donné un intervalle de départ [x1 , x2 ] et les valeurs correspondante f1 et f2 (de signes
opposés), on calcule un nouveau fm ≡ f (xm ) à mi-chemin entre x1 et x2 ; si fm est du même signe que
f2 , la racine doit être entre x1 et xm , et on reprend donc la bissection avec x2 = xm ; si par contre fm et
f2 sont de signes opposés, alors la racine est entre xm et x2 , et on reprend la bissection avec x1 = xm .
La valeur de xm correspond à l’estimé de la racine, et l’écart x2 − x1 à la précision absolue de cet estimé.
Un programme en Python effectuant une recherche de racine par bissection pour l’éq. (6.8) est donné
ci-dessous.
Code Python pour trouver une racine par bissection
1 #Ce programme calcule la racine d'une fonction d'une variable
2 #entre deux bornes x1 et x2, par la methode de la bissection.
3

4 from math import *

5

6 def fct(x): #Definition de la fonction dont on cherche la racine

7 return x*cos(x)-sin(x)
8

9 x1=pi+0.1 #Borne gauche

10 x2=2*pi-0.1 #Borne droite
11 delta=x2-x1
12 epsilon=1.e-5 #Precision requise pour la racine
13

14 f1=fct(x1)
15 f2=fct(x2)
16 if f1*f2>0: #verification
17 print("Fonction non valide ou aucune racine dans l'intervalle!")
18 delta=-1
19

20 while (delta>epsilon): #Boucle bissection

21 xm=0.5*(x1+x2) #Point milieu de l'intervalle
22 fm=fct(xm)
23 f2=fct(x2)
24 if fm*f2>0: #Une racine est a gauche
25 x2=xm #L'intervalle devient la moitie gauche
26 else: #Une racine est a droite
27 x1=xm #L'intervalle devient la moitie droite
28

29 delta=x2-x1 #Estime de la precision

30 print('racine de la fonction: {}+/-{}'.format(xm,delta))

La Figure 6.3 illustre l’application de la bissection dans le cas de notre problème de recherche d’ex-
tremum du patron de diffraction d’une fente simple, tel que décrit par l’éq. (6.8). Dans cette situation
le choix de l’intervalle de départ est facile, puisque, nous sommes en droit de supposer que l’extremum
est situé quelque part entre les premier et second minima, dont nous connaissons les positions : x = π et
x = 2π. La partie du bas de la Figure illustre l’évolution de la taille et position de l’intervalle de recherche,
les itérations allant du haut vers le bas. L’algorithme garantit que la largeur de l’intervalle de recherche
diminue comme 1/2n , où n est le décompte des itérations depuis le début du processus de bissection. Ceci
implique que le nombre total d’itérations requises pour atteindre une tolérance ε est donné par,
 
x2 − x1
n = log2 , (6.10)
ε
soit une quarantaine d’itérations pour ε = 10−12 et x2 − x1 ∼ 1.
La bissection offre plusieurs caractéristiques avantageuses. D’abords, cette méthode ne requiert que la
capacité d’évaluer la fonction f (x) à toute valeur de x, mais n’exige aucun calcul ou estimé de la dérivée

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

6.2. LA BISSECTION 99

Figure 6.3 – Fonctionnement de la méthode de la bissection pour la recherche du premier maximum

du patron de diffraction d’une fente simple. La partie du haut montre la variation du f (x) défini par
l’éq. (6.8) en fonction de x, et la partie du bas l’évolution de l’intervalle de bissection (en gris) pour le 10
premières itérations de l’algorithme (allant du haut vers le bas)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 100 CHAPITRE 6. RACINES ET OPTIMISATION

de cette fonction. De plus, elle garantit la détection d’une racine si une racine existe dans l’intervalle
spécifié. Remarquez cependant que si plusieurs racines se retrouvent dans l’intervalle initial, la méthode
convergera sur l’une d’elles sans donner d’indications que d’autres racines sont présentes. Si le changement
de signe entre x1 et x2 est dû à une discontinuité (comme pour tan x à x = (n + 1/2)π, n = 0, 1, ...), la
bissection vous trouvera la discontinuité sans rechigner.
Notons finalement un de ses désavantages, soit que cette méthode ne fonctionne que pour les racines
qui correspondent à un point où la fonction change de signe, et en tant que telle n’est pas applicable à
la recherche de racines pour toutes les fonctions, ou pour toutes les racines d’une fonction. Par exemple,
essayez de trouver la racine de la fonction (x − 0.3)2 dans l’intervalle [x1 , x2 ] = [0, 1] avec l’algorithme
ci-dessus, échec garanti !

6.3 La méthode de Newton

Si vous n’avez pas la patience d’attendre une quarantaine d’itérations, il existe toute une gamme de
méthodes de recherche de racines qui, quand tout va bien, convergent beaucoup plus rapidement que la
bissection. La méthode dite de Newton (oui, le même que F = ma) est une grande classique parmi ces
méthodes, mais elle n’est applicable efficacement qu’aux situations où la dérivée de la fonction dont les
racines sont recherchées est calculable analytiquement. Son point de départ est encore une fois notre très
fameux développement en série de Taylor d’une fonction f (x) dans le voisinage de x = x0 :

df (∆x)2 d2 f (∆x)3 d3 f
f (x0 + ∆x) = f (x0 ) + (∆x) + + + ... (6.11)
dx x0 2! dx2 x0 3! dx3 x0

Si l’on suppose maintenant que f (x) a une racine à x = r, et que cette racine n’est pas trop éloignée
de x0 , alors on peut définir un ∆x tel que x0 + ∆x = r, et tronquer le développement au second terme :
df
f (r) = f (x0 ) + (r − x0 ) . (6.12)
dx x0

Mais le membre de gauche est nul si r est une racine, et donc r devrait être donné par
f (x0 )
r = x0 − . (6.13)
df /dx

Évidemment, la racine r ainsi calculée ne sera pas exactement égale à la racine réelle, puisque son calcul
résulte de l’utilisation d’un développement tronqué, ce qui introduit automatiquement une erreur dans
le calcul de la racine. Mais le processus peut être répété en réévaluant f et sa dérivée à x = r, et en
réutilisant l’éq. (6.13) pour recalculer un nouvel estimé de r, et ainsi de suite itérativement jusqu’à ce que
la racine ait été localisée au niveau de précision numérique désirée. Un programme en Python effectuant
une recherche de racine par la méthode de Newton est montré ci-bas, toujours pour notre problème de
recherche des maxima du patron de diffraction. Notez que l’on doit spécifier une valeur de départ pour
x0 , et que l’on doit définir deux fonctions, la première calculant f (x), et la seconde sa dérivée df /dx. Ce
code est une implémentation minimale de la méthode de Newton ; en réalité il faudrait au moins ajouter
un test pour limiter la grandeur du pas delta, pour se protéger de situations où l’on atterrit à une valeur
de x pour laquelle df /dx ≃ 0. Ici, on a aussi introduit une variable pour compter le nombre d’itérations,
que l’on limite à une certaine valeur spécifiée par l’usager.
Code Python pour trouver une racine par Newton
1 #Ce programme calcule la racine d'une fonction d'une variable
2 #par la methode de Newton.
3

4 from math import *

5

6 def fct(x): #Definition de la fonction dont on cherche la racine

7 return x*cos(x)-sin(x)
8

9 def fctDer(x): #Definition de la derivee de la fonction fct

10 return -x*sin(x)

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 6.3. LA MÉTHODE DE NEWTON 101

Figure 6.4 – Les quatre premières itérations de la méthode de Newton pour la recherche de racines, ici
la racine r = 1 du polynôme quartique f (x) = x4 − 1.

11

12 epsilon=1.e-6 #Precision requise pour la racine

13 iterMax=20 #Nombre maximum d'iterations permises
14 x0=1.5*pi #Point de depart
15 prec=1. #Estime de la precision, initialise a >epsilon
16

17 k=0 #compteur d'iterations

18 while (prec>epsilon) and (k<iterMax): #Boucle Newton
19 dx=-fct(x0)/fctDer(x0) #increment en x
20 x0+=dx #nouvelle valeur de x0 (la racine)
21 prec=abs(dx) #estime conservateur de la precision
22 k+=1
23 print('racine de la fonction: {}+/-{}'.format(x0,prec))

La Figure 6.4 illustre les premières 4 itérations de ce processus, dans le cas de la recherche d’une
racine du polynôme f (x) = x4 − 1 ; ce polynôme compte quatre racines distinctes (±1, et ±i), et pour
une position de départ x0 = 1.8 la méthode de Newton converge très rapidement sur la racine r = 1. Tel
qu’illustré sur la figure, on notera que la méthode de Newton revient à utiliser la dérivée de f (x) pour
construire une extrapolation linéaire vers f (r) = 0.
La Figure 6.5 illustre le taux de convergence de la méthode de Newton (•), maintenant appliquée à la
recherche du premier pic (non-central) dans le patron de diffraction d’une fente simple. La convergence
est ici extrêmement rapide, avec l’erreur sur r chutant à 10−5 après seulement 2 itérations (et à ∼ 10−16
à la quatrième !). La bissection (△), en comparaison, converge beaucoup plus lentement.
On pourrait être tenté de conclure, après étude de la Figure 6.5, que la méthode de Newton devrait être
préférée à la bissection. En fait ce n’est pas le cas. La méthode de Newton est beaucoup plus rapide, mais

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

102 CHAPITRE 6. RACINES ET OPTIMISATION

100
10-1
10-2
10-3
10-4
10-5
ε

10-6
10-7
10-8
10-9
10-10
0 5 10 15 20 25
itération
Figure 6.5 – Convergence de la méthode de Newton (•) et de la bissection (△) sur la recherche du
premier maxima du patron de diffraction d’une fente simple. Les symboles indiquent les erreurs exactes à
chaque itération, alors que les lignes indiquent les précisions estimées par les deux méthodes.

beaucoup moins robuste, que la bissection. Pour une fonction monotoniquement croissante ou décroissante,
sans trop de changement de signe de la dérivée seconde (comme pour le polynôme quartique de la Fig. 6.4),
la méthode de Newton est imbattable. Mais imaginez maintenant une fonction de forme plus complexe, et
où une itération de la méthode de Newton vous fait atterrir à une valeur de x où df /dx ≃ 0 ; l’éq. (6.13)
garantit que votre prochaine estimé de r se retrouvera quelque part dans la galaxie d’Andromède (à
moins d’avoir eu la géniale idée d’ajouter un test de divergence à l’algorithme de base listé ici). Ou même
avec une fonction telle que celle que nous avons considérée pour les pics d’intensité de diffraction, si vous
choisissez mal votre point de départ la méthode pourrait foirer (essayez par exemple d’utiliser x0 = π +0.1
comme point de départ plutôt que x0 = 1.5π). De plus, la méthode de Newton appliquée à une fonction
présentant un profil antisymétrique sur réflexion par rapport à la racine peut se coincer dans un cycle
non-convergent. Ces problèmes ne se posent pas avec la bissection.
Une stratégie très judicieuse consiste à débuter la recherche de racine à l’aide de la bissection, et une
fois la racine localisée approximativement, de passer à la méthode de Newton afin d’aller chercher deux
ou trois chiffres de précision supplémentaires sans trop d’efforts. Ou encore, effectuer une ou deux étapes
de bissection entre deux itérations de la méthode de Newton, si la convergence semble trop lente 2 . Ce
genre de méthode hybride est souvent optimal, et on verra qu’il peut l’être également en optimisation,
sujet des prochaine sections.

6.4 Maximisation (et minimisation)

La maximisation d’une fonction f (x) consiste à trouver le (ou les) point(s) x∗ tel que

f (x∗ ) > f (x) , ∀x ̸= x∗ . (6.14)

Vous comprendrez j’espère que trouver le ou les maxima d’une fonction f (x) est absolument équivalent
à trouver les minima de −f (x), en conséquence de quoi nous allons nous restreindre aux problèmes de
maximisation sans aucune perte de généralité.
Pour une fonction d’une seule variable et exprimable analytiquement, la maximisation est souvent
convertie en problème de recherche de racine, comme nous l’avions fait à la §6.1 pour la recherche des
maxima d’intensité du patron de diffraction produit par une fente simple. En plus d’une variable cepen-
dant, cette approche est rarement utilisée. Considérons par exemple le patron de diffraction du à une
2. Vous trouverez un algorithme de ce genre au chapitre 9 du Numerical Recipes.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

6.5. MÉTHODES DE GRIMPE 103

Figure 6.6 – Le patron d’intensitée I(x, y) produit par la diffraction d’une onde plane à travers une
ouverture carrée, représenté sous la forme d’une surface dans le plan [x, y]. Le maximum est à I(0, 0)/I0 =
1.

ouverture carrée de coté d ; l’intensité I(x, y) est alors donnée par une expression du genre :
 2
I(x, y) sin x sin y
= , (6.15)
I0 x y
avec x et y donnés par des expressions semblables à l’éq. (6.4). La Figure 6.6 illustre la surface correspon-
dant à cette fonction de deux variables. Un maximum dans ce “paysage” bidimensionnel correspond à un
point (x∗ , y ∗ ) tel que
∂I(x, y) ∂I(x, y)
∇I(x, y) ≡ êx + êy = 0 . (6.16)
∂x ∂y
Comme l’opérateur gradient est un opérateur vectoriel, chacune des deux dérivées doit valoir zéro sépa-
rément pour un maximum de I(x, y). La substitution de (6.15) dans (6.16) produit donc un système de
deux équations algébriques nonlinéaires couplées, où chacune des équations décrit une courbe ou famille
de courbes (souvent topologiquement complexe) dans le plan [x, y], et les maxima correspondent aux in-
tersections de ces familles de courbes. Trouver ca numériquement, c’est du costaud. Il est habituellement
préférable de rechercher directement les maxima. Voyons comment.

6.5 Méthodes de grimpe

Les bouquins d’analyse numérique débordent de techniques, habituellement affublées de noms impro-
nonçables, pour la maximisation (ou minimisation) de fonctions de plusieurs variables. Fondamentalement,
la vaste majorité de ces méthodes sont basées sur la grimpe, et fonctionnent de la manière illustrée al-
légoriquement à la Figure 6.7, dans le contexte d’une fonction de deux variables. On commence par se
placer quelque part à un point (x, y) (possiblement choisi aléatoirement) dans le paysage bidimensionnel
(Fig. 6.7A) ; l’atterissage (en B) n’est habituellement pas problématique numériquement si la fonction est

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 104 CHAPITRE 6. RACINES ET OPTIMISATION

continue en x et y. Une fois remis sur pied, on explore le voisinage local du point (x, y) et on se déplace
dans une direction ascendante (en C). Le processus est répété séquentiellement jusqu’à ce qu’on se re-
trouve à un point (x∗ , y∗ ) où toutes les directions partant de ce point soient descendantes. Le maximum
est alors localisé (D). Caramba ! Pour traduire la Figure 6.7 en un algorithme exprimable en Python, nous
devons d’abord faire plusieurs choix pratiques :
1. Comment choisir la position de départ ;
2. Comment calculer la direction du déplacement ;
3. Comment calculer la grandeur du pas ;
4. Comment utiliser l’information accumulée aux pas précédents ;
5. Comment décider que le maximum est bel et bien localisé.
Ce sont les différentes réponses possibles à ces questions qui sont responsables de l’effrayante multipli-
cité d’algorithmes disponibles dans les bouquins. Nous allons ici en développer un qui est simple à coder,
relativement robuste, et facilement généralisable à des problèmes de maximisation pour des fonctions de
plus de deux variables. Il est basé sur l’utilisation du gradient de la fonction à maximiser pour choisir la
direction du déplacement. Le gradient d’une fonction scalaire (comme dans le cas de l’équation (6.16))
indique la direction de pente maximale dans un espace des paramètres dont ne nombre de dimensions
correspond au nombre de variables indépendantes de la fonction à maximiser. Dans les cas de la diffraction
de la lumière par une ouverture carrée, le gradient est un vecteur contenu dans le plan [x, y], dont les
composantes x et y sont données par ∂I/∂x et ∂I/∂y, avec I(x, y) donné par l’éq. (6.15). À partir d’une
position (x0 , y0 ), on pose simplement

δ ∂f δ ∂f
x = x0 + , y = y0 + , (6.17)
|∇f | ∂x |∇f | ∂y

où δ mesure la longueur du pas dans le plan [x, y], et

s 
2  2
∂f ∂f
|∇f | = + , (6.18)
∂x ∂y

est la norme du vecteur gradient. Si vous ne l’avez pas déjà deviné, cet algorithme est l’équivalent d’un
double développement en série de Taylor, tronqué aux seconds termes en x et y ! Les composantes du
gradient peuvent être calculées soit analytiquement, soit par différences finies ; par exemple, à l’ordre
O(h2 ),

∂f f (x + δ, y) − f (x − δ, y) ∂f f (x, y + δ) − f (x, y − δ)
= , = . (6.19)
∂x 2δ ∂y 2δ
Le bout de code Python ci-dessous utilise cet algorithme pour la recherche des maxima du patron de
diffraction d’une ouverture carrée, avec évaluation des composantes du gradient par différences finies
centrées. Étudiez bien ce bout de code, et notez bien qu’un test a été ajouté pour réduire la grandeur
du pas δ d’un facteur deux si le pas conduit à une position où f (x, y) < f (x0 , y0 ), afin d’empêcher
de sauter par dessus le maximum et/ou de se coincer dans un cycle non-convergent. Examinez bien, et
comprenez, le canevas if ... else ... contrôlant l’acceptation ou le rejet du pas (et de la nouvelle
valeur de x) en fonction des valeurs de la fonction produite à la nouvelle position. Notez aussi que dans ce
code le dénominateur des expressions de différences finies ont été omis du calcul des gradients, car ceux-ci
s’annulent exactement lors du calcul de la nouvelle valeur de la coordonnée par l’éq. (6.18).
Code Python pour trouver un maximum par la méthode de grimpe
1 #Maximisation d'une fonction de deux variables par methode de grimpe
2

3 from math import *

4

5 def fct(x,y): #la fonction a maximiser

6 return (sin(x)*sin(y)/x/y)**2
7

8 epsilon=1.e-5 #precision desiree (en terme de variation de f)

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

6.5. MÉTHODES DE GRIMPE 105

Figure 6.7 – Méthode de grimpe (allégorie).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 106 CHAPITRE 6. RACINES ET OPTIMISATION

9 iterMax=100 #nombre maximum d'iterations permises

10 h=0.1 #taille initiale du pas
11 delta=2*epsilon #variation de la fonction, initialisation a >epsilon
12

13 x,y=-0.6,0.75 #point de depart

14 f=fct(x,y) #valeur initiale de la fonction
15

16 k=0 #compteur d'iterations

17 while (delta>epsilon) and (k<iterMax):
18 dx=fct(x+h,y)-fct(x-h,y) #composante x du gradient
19 dy=fct(x,y+h)-fct(x,y-h) #composante y du gradient
20 grad=sqrt(dx*dx+dy*dy) #norme du gradient
21 xn=x+h*dx/grad #on fait le pas en x
22 yn=y+h*dy/grad #on fait le pas en y
23 fn=fct(xn,yn)
24 if fn>f: #on accepte le pas
25 x,y=xn,yn
26 delta=abs(fn-f)
27 f=fn
28 else: #on rejette le pas
29 h/=2 #et on reduit sa taille
30 k+=1
31

32 print('Maximum a x={:8.5f} et y={:8.5f}, '.format(x,y))

33 print("Nombre d'iterations: {}, valeur de la fonction: {}".format(k,fn))

La Figure 6.8 montre les trajectoires conduisant aux maxima, pour une série de points de départ
(x0 , y0 ) (indiqués par des • colorés) choisis aléatoirement. L’espace des paramètres a été restreint ici à
−π ≤ x ≤ π, −π ≤ y ≤ π, soit le pic central d’intensité du patron de diffraction 2D, et les pseudo-cercles
en noir correspondent à des courbes de niveau I(x, y) = constante. Quel que soit le point de départ,
l’algorithme aboutit à (0, 0), comme il se doit. Dépendant du (x0 , y0 ) initial, de 10 à 20 itérations sont
requises pour que l’erreur sur l’évaluation de f (0, 0) = 1 atteigne 10−4 ou moins. De toute évidence, ça
marche !
Mais il ne fait pas trop vite crier victoire... La Figure 6.9 montre le résultat de notre méthode de grimpe,
avec l’intervalle de recherche maintenant élargi à −2π ≤ x ≤ 2π, −2π ≤ y ≤ 2π. Il y a maintenant 50
points de départ, tous choisis aléatoirement mais distribués uniformément dans l’intervalle. Dans tous
les cas la méthode de grimpe fait son travail et livre la marchandise, dans le sens que les grimpes se
terminent toutes sur un maximum, mais dans bien des cas il ne s’agit pas du maximum le plus élevé
à (0, 0), mais plutôt de l’un ou l’autre des 8 autres maxima secondaires présents ici dans l’espace des
paramètres. Le maximum sur lequel converge la grimpe devient fonction de sa position de départ, une
situation embarrassante puisque dans bien des cas nous n’avons pas idée de la position du maximum
global, et donc ne sommes pas en mesure de fournir à l’algorithme un “bon” point de départ.
Les Figures 6.8 et 6.9 offrent conjointement une excellente illustration de la distinction entre un
problème d’optimisation locale versus l’optimisation globale. Cette dernière, qui consiste à trouver le
maximum absolu dans tout l’espace des paramètres, est beaucoup plus coriace numériquement. À l’heure
actuelle il n’existe aucun algorithme qui garantisse la détection d’un maximum global.
La grimpe itérée est une approche simple permettant d’aborder l’optimisation globale, et en fait son
mode de fonctionnement est déjà illustré sur la Figure 6.9. La grimpe itérée consiste simplement à faire
rouler à répétition une méthode de grimpe, chaque fois avec un point de départ différent (habituellement
choisi aléatoirement), et on accumule une liste des maxima ainsi détectés, et ce jusqu’à ce qu’on ne trouve
plus de nouveau maximum. Décider quand arrêter est évidemment l’aspect crucial de cette approche. Dans
bien des situations réelles, le calcul de la fonction f et/ou de ses dérivées peut en soi être une opération très
couteuse numériquement, et donc il existe souvent des limites purement pratiques au nombre de grimpes
successives qui puissent être effectuées.
On peut imaginer que la grimpe itérée puisse être accélérée si les grimpeurs ont accès à “l’information”
accumulée par les grimpeurs antérieurs relative à la structure de l’espace des paramètres, ou encore si les

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

6.5. MÉTHODES DE GRIMPE 107

Figure 6.8 – Application de notre méthode de grimpe à la recherche du pic central du patron de diffraction
d’une ouverture carrée. Les traits noirs sont des courbes de niveau de la fonction à maximiser, soit
l’éq. (6.15) ; son maximum est à (x∗ , y∗ ) = (0, 0), où I(x, y)/I0 = 1. Les points colorés correspondent à 10
positions de départ (x0 , y0 ) choisies aléatoirement, et les trajectoires en émanant résultent de l’application
répétée des éqs. (6.17), avec ajustement du pas δ (voir texte). Quel que soit le point de départ, l’algorithme
localise sans difficulté le maximum recherché.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

108 CHAPITRE 6. RACINES ET OPTIMISATION

Figure 6.9 – Même chose que la Figure 6.8, sauf que l’espace des paramètres couvre maintenant l’inter-
valle −2π ≤ x ≤ 2π, −2π ≤ y ≤ 2π, et 50 points de départ ont été choisis aléatoirement. Plusieurs de ces
points de départ convergent vers un maximum secondaire.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 6.6. LA GRIMPE STOCHASTIQUE 109

grimpeurs peuvent communiquer entre eux durant la grimpe. On verra comment au chapitre ??.

6.6 La grimpe stochastique

L’approche Monte Carlo s’applique également à la recherche d’extrema, sous la forme de la grimpe
stochastique. L’idée générale est la même que pour la méthode de grimpe classique considérée à la §6.5,
avec l’importante différence que les direction et grandeur du pas, plutôt que d’être choisies sur la base du
gradient de la fonction, le sont de manière aléatoire.
Aléatoire, mais quand même pas n’importe comment. On aimerait produire des pas qui puissent avoir
une taille comparable à celle de l’espace des paramètres, de manière à pouvoir “explorer” et se décoincer
d’un extremum local ; d’un autre coté, une bonne localisation d’un extremum demande un pas d’une taille
de l’ordre du niveau de précision requis. En résumé, on veut générer une distribution de pas couvrant
à la fois les grandes et les petites tailles. Une distribution ayant cette propriété est la distribution dite
gaussienne (éq. (5.2) et Fig. 5.7), que nous utiliserons donc ici.
Évidemment, si les pas de la grimpe sont choisis aléatoirement, plusieurs conduiront à une diminution
de la valeur de la fonction f à maximiser (dans le contexte d’une maximisation), donc seul les pas
conduisant à une augmentation de f sont “acceptés”. Le code Python présenté ci-dessous effectue une telle
grimpe stochastique. Comparez bien ce code au code montré plus haut pour la grimpe classique. Mis à
part quelques initialisations, la seule différence se trouve au niveau du calcul du pas. Examinez bien la
série d’instructions à l’intérieur de la boucle extérieure. La première boucle while peut générer jusqu’à
25 pas aléatoires, et si (et seulement si !) tous ces pas conduisent à une diminution de la fonction, alors la
variance de la distribution gaussienne de taille de pas est diminuée de moitié, et on passe à une nouvelle
itération. Cette situation correspond essentiellement au cas où, peu importe la direction qu’on emprunte
on voit la fonction diminuer : on doit donc se trouver près du sommet et il est approprié de réduire la
taille du pas pour chercher le sommet plus précisément. Mais si un des 25 pas a augmenté la valeur de
la fonction alors on passe à l’itération suivante sans toucher à σ. Notez enfin l’utilisation de la fonction
[Link](0,h) pour la génération de nombres aléatoires selon une gaussienne de moyenne 0 et de
variance h2 (déviation standard h).

Code Python pour trouver un maximum par la méthode de grimpe stochastique

1 #Maximisation d'une fonction de deux variables par methode de grimpe
2 from math import *
3 from random import gauss
4

5 def fct(x,y): #la fonction a maximiser

6 return (sin(x)*sin(y)/x/y)**2
7

8 epsilon=1.e-6 #precision desiree (en terme de variation de f)

9 iterMax=100 #nombre maximum d'iterations permises
10 essaiMax=25 #nombre maximum d'essais Monte Carlo
11 h=pi #largeur initiale de la Gaussienne
12

13 x,y=3,5 #point de depart

14 f=fct(x,y) #valeur initiale de la fonction
15 fn=f/2 #initialisation a <f
16 delta=2*epsilon #initialisation a >epsilon
17

18 k=0 #compteur d'iterations

19 while (delta>epsilon) and (k<iterMax):
20 j=0 #compteur de pas aleatoires
21 while (fn<=f) and (j<essaiMax): #boucle Monte Carlo
22 xn=x+gauss(0,h) #on fait le pas en x
23 yn=y+gauss(0,h) #on fait le pas en y
24 fn=fct(xn,yn)
25 j+=1
26

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 110 CHAPITRE 6. RACINES ET OPTIMISATION

27 if fn>f: #on accepte le dernier pas

28 x,y=xn,yn
29 delta=abs(fn-f) #variation de la fonction
30 f=fn
31 else: #on rejette le dernier pas
32 h/=2 #et on reduit la largeur de la Gaussienne
33 k+=1
34

35 print('Maximum a x={:8.5f} et y={:8.5f}, '.format(x,y))

36 print("Nombre d'iterations: {}, valeur de la fonction: {}".format(k,fn))

La Figure 6.10 montre le résultat de 10 grimpes stochastiques dans le cadre de notre désormais familier
problème de recherche du maximum central du patron de diffraction d’une ouverture carrée. Pour des
points de départ choisis aléatoirement entre −3π et +3π, on s’attendrait à ce que la grimpe classique
produise un taux de succès de ∼1/10. Avec la grimpe stochastique, on obtient ici un très honorable
8/10. Remarquez comment certaines solutions se “coincent” pendant quelques itérations sur un extremum
secondaire, mais finissent par atterrir sur le pic central suite à l’action d’un pas de taille substantiel ; on
voit ici l’avantage d’avoir utilisé une distribution gaussienne de taille de pas ; bien que leur probabilité soit
faible, de temps en temps un pas de taille substantiellement plus grand que la variance de la distribution
sera produit, ce qui permet de mieux échantillonner l’espace environnant, tout en ne freinant pas trop la
convergence vers l’extremum (qu’il soit local ou global).
Pour ce problème d’optimisation de dimension 2, la grimpe stochastique n’est pas particulièrement
avantageuse par rapport à la grimpe itérée, du point de vue du nombre requis d’évaluations de f (x)
pour en arriver à un niveau de précision donné. Comme dans le cas de l’intégration, l’approche Monte
Carlo à l’optimisation ne devient vraiment compétitive que pour des espace de recherche de plus haute
dimension. La situation est comparable à celle que nous avions rencontré avec le calcul des intégrales par
Monte Carlo ; évaluer numériquement les composantes du gradient d’une fonction de N variables via une
différence finie centré d’ordre deux requiert 2N évaluations de la fonction.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

6.6. LA GRIMPE STOCHASTIQUE 111

Figure 6.10 – Recherche du maximum central du patron de diffraction 2D par grimpe stochastique (ici
itérée sur plusieurs positions de départ). Remarquez comment certaines grimpes se coincent temporaire-
ment sur un extremum secondaire, mais parviennent à s’en dépêtrer suite à la production d’un pas de
longueur substantielle. Le taux de succès est ici de 8/10, ce qui se compare très avantageusement à la
grimpe itérée, pour laquelle on s’attendrait à ∼1/10 pour le même espace de paramètres.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

112 CHAPITRE 6. RACINES ET OPTIMISATION

Exercices:

1. Le code minimal pour la bisection présenté à la §6.2 peut être restructuré de manière telle qu’un
seul appel à la fonction fct(x) soit requis par itération. Faites-le.
2. Écrivez un petit bout de code qui, à partir d’un vecteur x contenant N éléments ordonnés de
manière croissante, utilise l’idée de la bissection pour localiser la plage d’interpolation associée
à une valeur x∗ . Démontrez que le nombre d’itération requis pour trouver cette plage varie en
moyenne comme log2 N , dans la limite où N est grand.
3. Écrivez une version du code pour la recherche de racine par la méthode de Newton qui s’assure
que la racine demeure à l’intérieur d’un intervalle [x1 , x2 ] spécifié par l’usager (comme pour la
bissection).
4. La méthode de grimpe, telle que codée ci-dessus, risque fort de vous péter au nez vers la fin du
processus de convergence, puisque très près du maximum on s’attend à ce que ∇f → 0, ce qui
conduira à des trucs du genre zéro-divisé-par-zéro. Ré-écrivez l’algorithme en terme d’un angle
décrivant l’orientation du gradient dans le plan [x, y]. Est-ce-que cela fonctionne mieux que l’algo-
rithme original ? Pourquoi ?
5. Modifiez le code pour la grimpe stochastique (Figure ??) pour en faire un code de grimpe stochas-
tique itérée, avec points de départ de chaque grimpe choisis aléatoirement.

Bibliographie:

Sur la recherche de racine et l’optimisation, je ne peux vraiment faire guère mieux que vous recom-
mander les chapitres 9 et 10 de l’ouvrage Numerical Recipes.
Pour tout ce qui concerne la modélisation de données, les erreurs de mesure, les χ2 , etc, je trouve l’ou-
vrage suivant absolument magnifique à tous les points de vue, allant de la photo en couverture jusqu’aux
aspects plus “philosophique” du sujet :
Taylor, J.R., An introduction to error analysis, University Science Books (1982).

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 113

Chapitre 7

Équations différentielles ordinaires

7.1 Repenser F = ma
Plus vous progresserez dans vos études de la physique, plus vous verrez ses grands principes (comme la
conservation de l’énergie, de la quantité de mouvement, etc) sous la forme d’équations différentielles, et
la capacité de solutionner ces équations deviendra essentielle. Ce chapitre vise à vous apprendre quelques
techniques numériques pour la solution d’équations différentielles dites ordinaires, soit une équation
impliquant des dérivées d’une variable dépendante par rapport à une seule variable indépendante.
Un exemple spécifique vaut bien une longue discussion. Prenons encore une fois la très justement
célèbre Loi de Newton :
F = ma . (7.1)
Ceci représente en fait trois équations, puisque la force et l’accélération sont des quantités vectorielles dont
la définition requiert trois composantes distinctes. Vous n’aurez certainement pas oublié que l’accélération
est la dérivée temporelle de la vitesse v, et que cette dernière peut être considérée comme une dérivée
temporelle du vecteur position x. L’équation (7.1) peut donc être écrite sous les formes alternatives :
dv F
= , (7.2)
dt m

d2 x F
= . (7.3)
dt2 m
Ces deux expressions sont en tout point physiquement équivalentes à (7.1).
Appliquée à un mouvement uniformément accéléré par une force de grandeur constante et exercée dans
la direction-x (disons), l’équation (7.3) devient
d2 x F
= , (7.4)
dt2 m
les composantes-y et z étant satisfaite trivialement (elles donnent 0 = 0 !). Deux intégrations successives de
cette expression consuisent à la célèbre formule que vous avez mémorisé déjà dans votre tendre jeunesse :
1
x(t) = x0 + v0 t + at2 , (7.5)
2
où ici a = Fx /m. Les quantités x0 et v0 sont les deux constantes d’intégration, correspondant aux position
et vitesse au temps t = 0. Je me permet de vous rappeler que la spécification de ces constantes d’intégration
est un aspect essentiel de la solution du problème. L’EDO étant ici d’ordre deux (la plus haute dérivée
est une dérivée seconde), deux conditions initiales doivent être spécifiées.
C’est la forme particulièrement simple —une constante— du membre de droite de l’équation (7.3) qui
permet une intégration analytique. Souvent, pour des forces ayant des dépendances explicites sur x et/ou
t, ceci n’est plus possible et on doit solutionner directement l’équation différentielle de manière numérique.
C’est ce que nous ferons dans ce chapitre, dans le contexte d’un problème physique que vous connaissez
bien, soit le mouvement du pendule. Mais pour commencer nous allons développer deux algorithmes
numériques dans le contexte d’une équation différentielle ordinaire encore plus simple.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

114 CHAPITRE 7. ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES

7.2 La méthode d’Euler

Considérons une fonction f (t) obéissant à l’équation différentielle ordinaire (EDO) du premier ordre
suivante :

df
≡ f ′ = g(t, f (t)) , f (t0 ) = f0 , t ∈ [a, b] . (7.6)
dt
Ici, la dépendance fonctionnelle de g(t, f (t)) sur ses deux arguments (t et f ) est connue/donnée, par
exemple g(t, f ) = −f 2 sin(ωt), mais la dépendance fonctionnelle de f (t) sur son argument t ne l’est pas,
c’est ce que l’on cherche. “Intégrer” cette EDO consiste à calculer la fonction f (t) satisfaisant à la fois à
l’EDO même, ainsi qu’à la condition initiale spécifiée. Premier point important ici : un problème bien posé
doit inclure non seulement l’EDO, mais des conditions initiales/limites (ici f (t0 ) = f0 ) , et un domaine
d’intégration (ici t ∈ [a, b]).
Une EDO de premier ordre telle que définie à l’éq. (7.6) est dite linéaire si la dépendance de g sur f est
strictement linéaire (e.g. aucun terme en f 2 , ln f , etc.), sinon elle est dite non-linéaire. Les EDOs linéaires
ont la particularité que si f1 (t) est une solution à l’EDO, alors il est possible de construire une infinité
de nouvelles solutions de la forme f2 (t) = a × f1 , où a est une constante, et de plus toute combinaison
linéaire de solutions satisfaisant à la condition initiale sera également une solution valide. Du point de
vue d’une solution numérique par Euler explicite comme nous le verrons ci-bas, il n’y a vraiment aucune
différence entre une EDO linéaire ou non-linéaire, mais ce serait loin d’être le cas si on cherchait plutôt
une solution analytique !
Comme premier cas de figure pour la discussion qui suit, nous considérerons l’EDO linéaire suivante,
df
=f , f (0) = 1 , t ∈ [0, 2] , (7.7)
dt
dont la solution analytique est donnée par la fonction exponentielle que vous connaissez bien :

f (t) = exp(t) ≡ et . (7.8)

En fait, l’EDO (7.7) peut être considérée comme une définition de la fonction exponentielle. Mais voyons
maintenant comment solutionner cette EDO numériquement.

7.2.1 Euler explicite

La méthode d’Euler explicite est basée directement sur le développement d’une fonction en série de
Taylor, tronqué au second terme :
df
f (t0 + h) = f (t0 ) + h ; (7.9)
dt t0

mais, selon l’EDO (7.6) on sait également que df /dt = g(t, f (t)), donc on peut reécrire ceci comme

f (t0 + h) = f (t0 ) + h × g(t0 , f (t0 )) . (7.10)

La stratégie consiste à utiliser cette expression pour “avancer” la solution dans le temps, à partir de la
condition initiale, pour un pas de temps h choisi a priori. Le calcul numérique de la solution commence
par la discrétisation de la variable indépendante t sur une maille couvrant l’intervalle désiré. Choisissons
une maille équidistante :
tk+1 = tk + h , k = 0, 1, 2, ...
où h mesure ici la grandeur (constante) du pas de temps, et où t0 correspond à la valeur de t à laquelle
est spécifiée la condition initiale. On peut donc appliquer l’éq. (7.10) séquentiellement à chaque point
de maille, en commençant par la condition initiale (connue !) fournie pour t0 , correspondant au point de
maille k = 0 :

fk+1 = fk + h × g(tk , fk ) , k = 0, 1, 2, ... (7.11)

où on a utilisé la notation fk ≡ f (tk ). On aurait pu arriver directement à cet algorithme en substituant

la formule de différence finie d’ordre O(h) (éq. (4.12)) au membre de gauche de l’éq. (7.6), ce qui est

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

7.2. LA MÉTHODE D’EULER 115

Figure 7.1 – Solution numérique de l’EDO (7.7) à l’aide de la méthode d’Euler explicite, pour différentes
tailles du pas de temps h, tel qu’indiqué. Le trait épais est la solution analytique donnée par l’éq. (7.8).

tout à fait équivalent à la dérivation ci-dessus puisque la dite formule de différence finie résulte d’un
développement en série de Taylor tronqué au second terme... !
Appliquons maintenant cette méthode à l’EDO (7.7), pour laquelle on obtient la formule très simple
suivante :

fk+1 = fk + h × fk , k = 0, 1, 2, ... (7.12)

En Python, cet algorithme tient en quelques lignes :

h=0.10
t=[Link](0.,2.,h)
f=np.empty_like(t)
f[0]=1.

for i in range(0,[Link][0]-1): f[i+1]=f[i]+h*f[i]

La Figure 7.1 montre le résultat de l’algorithme, pour 4 tailles de pas de temps. On note que plus le
pas de temps est petit, plus la solution numérique s’approche de la solution analytique (trait épais). Ceci
est tout à fait naturel, puisque la précision d’un développement en série de Taylor tronqué, sur lequel
est basé notre algorithme, s’améliore à mesure que la taille du pas diminue (retournez voir la Figure 4.5,
courbe en ∗ pour la formule O(h)). On remarquera aussi que, quel que soit la grandeur du pas, à tout t la
solution numérique se retrouve toujours systématiquement inférieure à la solution analytique. Ceci vient
du fait que la fonction exp(t) est concave, dans le sens que sa dérivée seconde est positive ; autrement
dit, sa dérivée première augmente avec t. Ceci implique que l’utilisation de fk pour estimer df /dt dans
le passage de l’éq. (7.9) à l’éq. (7.12) sous-estimera toujours la valeur “moyenne” de la dérivée dans
l’intervalle t ∈ [tk , tk+1 ], donc il est inévitable que fk+1 se retrouve sous la valeur “réelle” à tk . Vous aurez
déjà anticipé (j’espère...) que si la fonction intégrée avait été convexe plutôt que concave, alors la solution

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

116 CHAPITRE 7. ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES

numérique se serait systématiquement retrouvée au dessus de la solution exacte. Ce problème s’amenuise

évidemment à mesure que h diminue, mais pensez-y un peu et vous devriez réaliser qu’il persistera même
dans la limite h → 0. Voyons comment contourner cette difficulté.

7.2.2 Euler explicite avec extrapolation linéaire et méthode de Heun

La piètre performance de la méthode d’Euler explicite s’explique principalement par le fait que les
membres de gauche et droite de l’équation (7.6) sont traités différemment par rapport à la variable
temporelle. La différence finie avant, fk+1 − fk , peut se réinterpréter comme une différence finie centrée
sur un temps correspondant à un demi pas, tk+1/2 , en effet,

h h h h h h
f (tk + h) − f (tk ) = f (tk + + ) − f (tk + − ) = f (tk+1/2 + ) − f (tk+1/2 − ) . (7.13)
2 2 2 2 2 2
Dans un tel cas il deviendrait naturel d’évaluer le membre de droite, f ′ (tk ), également à tk+1/2 , par
exemple comme sa moyenne entre tk et tk+1 ; on pourrait alors écrire :
h ′
fk+1 − fk = (f + fk′ ) , k = 0, 1, 2, ... (7.14)
2 k+1
menant à
h
fk+1 = fk + [g(tk+1 , fk+1 ) + g(tk , fk )] , k = 0, 1, 2, ... (7.15)
2
Mais voilà, nous ne connaissons pas encore la valeur de fk+1 apparaissant aux membres de droite, puisque
nous sommes à ce stade encore en train d’essayer de calculer le pas k + 1 ! Cependant, il est possible
d’approximer ces quantités en effectuant une extrapolation linéaire à partir des valeurs au pas k, basée
sur devinez quoi, notre très cher développement en série de Taylor, tronqué après le second terme :

df
fk+1 = fk + h = fk + h × g(tk , fk ) , (7.16)
dt tk

La substitution de cette expression pour le fk+1 apparaissant au membre de droite de l’éq. (7.15), (mais
attention, pas pour celui du membre de gauche !), produit alors :

h
fk+1 = fk + [g(tk , fk ) + g(tk+1 , fk + h g(tk , fk ))] + O(h3 ) , k = 0, 1, 2, ... (7.17)
2
qui est notre algorithme d’Euler “amélioré”, qui s’appelle en fait la méthode de Heun. On peut montrer
(mais nous ne le ferons pas ici) que cette variation sur le thème de base suffit à réduire l’erreur totale de
discrétisation à O(h2 ).
En appliquant ceci à l’éq. (7.7), pour laquelle g(t, f ) = f , on obtient la formule suivante :
 
h h
fk+1 = fk + [fk + (fk + h fk )] = fk + h × fk + fk k = 0, 1, 2, ... (7.18)
2 2

En terme de code Python, ça aurait maintenant l’air de :

h=0.10
t=[Link](0.,2.,h)
f=np.empty_like(t)
f[0]=1.

for i in range(0,[Link][0]-1): f[i+1]=f[i]+h*(f[i]+h/2.*f[i])

Comparez bien ce bout de code à celui de la méthode d’Euler standard. Tout ce qui change est
l’évaluation de fk+1 , mais la structure générale demeure la même. La Figure 7.2 montre une comparaison
entre deux solutions avec le même pas de temps h = 0.5, l’un utilisant la méthode d’Euler explicite et la
seconde utilisant la version avec extrapolation linéaire introduite ci-dessus. Comparant ceci à la Fig. 7.1,

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

7.3. LE PENDULE LINÉAIRE 117

Figure 7.2 – Semblable à la Figure 7.1, sauf que cette fois le pas de temps est fixé à h = 0.5, et les deux
solutions numériques portées en graphiques ont été calculée à l’aide des méthodes d’Euler avec ou sans
extrapolation linéaire du membre de droite, tel qu’indiqué.

on constate que l’évaluation du membre de droite de l’EDO en terme d’une valeur moyenne à mi-pas
produit une solution ayant une précision comparable à celle caractérisant la méthode d’Euler explicite
opérant à un pas de temps 5 fois plus petit, et ce même si dans les deux cas la dérivée est approximée
par une formule de différences finies d’ordre O(h). Il y a un message important ici : l’ordre de l’erreur de
discrétisation contrôle le taux auquel diminue l’erreur dans la limite h → 0 ; mais le choix d’un algorithme
plutôt qu’un autre a également un fort impact sur le niveau d’erreur à une taille de maille donnée.
Comme deuxième exemple, prenons l’EDO suivante :

df
= at2 , (7.19)
dt
avec a une constante connue, les équations (7.11) et (7.17) deviendraient respectivement :

fk+1 = fk + h × a t2k , k = 0, 1, 2, ... [Euler explicite] (7.20)

h
fk+1 = fk + × a(t2k+1 + t2k ) , k = 0, 1, 2, ... [Euler avec extrapolation, ouHeun] (7.21)
2
Notons que dans ce dernier cas, l’extrapolation du membre de droite est triviale puisque t est la variable
dépendante, et donc tk+1 est directement calculable, sans extrapolation. Assurez vous de bien comprendre
comment arriver aux deux expressions ci-dessus à partir de l’éq. (7.19), avant de passer à la suite.

7.3 Le pendule linéaire

Maintenant que nous savons intégrer des EDOs, passons à un problème physique plus intéressant, soit,
ahem, le pendule...

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

118 CHAPITRE 7. ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES

Figure 7.3 – Géométrie et décomposition de la force gravitationnelle pour le problème du pendule

classique. La gravité pointe verticalement vers le bas, une direction qu’il s’avère pratique de faire coincider
avec θ = 0 dans le système de coordonnées polaires 2D (r, θ) utilisé pour mesurer la position de la masse
m, l’origine du système coincidant avec le point d’attache du pendule.

La “Loi du pendule”, soit le fait que la période d’oscillation d’un pendule n’étant pas déplacé trop
loin de la verticale ne dépende que de la longueur de sa corde (ou tige) est généralement attribuée à
Galilée. La légende veut que l’illustre personnage ait euréké sur la chose au début des années 1580,
alors qu’il n’était encore qu’un vulgaire petit étudiant sous-gradué en médecine à l’Université de Pise, en
observant l’oscillation d’une lampe suspendue à l’intérieur de la nef de la cathédrale de Pise (le sermon
devait être particulièrement gazant...). Les experts ayant décortiqué les écrits et la correspondance de
Galilée placent plutôt la découverte une vingtaine d’années plus tard. Ce qui semble certain, c’est que
Galilée avait rapidement réalisé que le pendule pouvait servir d’étalon de mesure du temps (avant 1603
Galilée utilisait son pouls comme mesure du temps dans ses expériences sur le mouvement des corps !). Il
fallut cependant attendre un demi-siècle et Christian Huygens (1629–1695) pour le perfectionnement de
la première véritable horloge basée sur le battement d’un pendule.

7.3.1 Solution analytique

On vous a déjà passablement assomé avec le pendule dans vos cours de physique au CEGEP, donc
nous pourrons passer rapidement sur l’idée générale (voir Figure 7.3). Une masse m est suspendue au
bout d’un fil ou tige de masse nulle et de longueur L. Initialement suspendue verticalement, la masse
est déplacée latéralement et relâchée, ce qui résulte en une oscillation dans le plan défini par la verticale
et la direction de déplacement initial du pendule. L’application de la Loi de Newton est facilitée si l’on
choisit de travailler en coordonnées polaires (r, θ), avec l’origine au point de suspension du pendule. Le
déplacement est alors uniquement dans la direction êθ , et la composante-r de F = ma se réduit à un
équilibre instantané entre la tension dans la corde (ou tige) et la composante de la force gravitationnelle
projetée dans la direction êr . La composante-θ conduit à quelque chose de plus intéressant. L’accélération
dans la direction êθ est donnée par

dvθ d2 θ
aθ = L =L 2 , (7.22)
dt dt

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

7.3. LE PENDULE LINÉAIRE 119

Comme la composante de la force gravitationnelle projetée dans la direction θ est donnée par mg sin θ
(voir Figure 7.3), la composante θ de F = ma conduit à :
d2 θ g
= − sin θ . (7.23)
dt2 L
Dans la limite où le déplacement angulaire du pendule (mesuré en radians) est très petit, on peut ap-
proximer les sinus et cosinus comme suit :
sin θ ≃ θ , cos θ ≃ 1 . (7.24)
L’équation (7.23) se réduit alors à :
d2 θ
= −ω 2 θ , (7.25)
dt2
où on a défini
r
g
ω= . (7.26)
L
Contrairement à l’éq. (7.23), cette dernière équation différentielle du 2e ordre est linéaire, puisqu’elle
dépend linéairement de θ. L’équation (7.25) accepte des solutions de la forme générale
θ(t) = A sin(ωt) + B cos(ωt) , (7.27)
où les constantes d’intégration A et B sont déterminées par les conditions initiales du problème, et ω
représente la fréquence angulaire d’oscillation (unités : rad s−1 ) par rapport à la position d’équilibre
θ = 0. Remarquez qu’on a ici deux constantes d’intégration, comme il se doit puisque l’éq. (7.25) est
d’ordre deux. Pour un pendule déplacé à un angle Θ0 de la verticale et relâché à t = 0 sans lui donner de
vitesse initiale, on a A = 0 et B = Θ0 . En terme de conditions initiales sur la variable θ(t), ceci revient à
exiger :
dθ
θ(0) = Θ0 , =0. (7.28)
dt t=0

Les équations (7.25) et (7.27) définissent le mouvement harmonique simple, dont les subtilités vous
tiendront fort occupé(e)s l’hiver prochain en PHY-1620...
Dans le contexte du pendule, tout ceci devrait vous être déjà familier. Utilisons maintenant nos nou-
velles habiletés numériques et voyons où ça nous mènera. Nous allons d’abord solutionner numériquement
l’équation du pendule linéaire (7.25), pour laquelle nous connaissons la solution analytique exacte (7.27),
à l’aide de la méthode d’Euler (§7.2). Nous allons par la suite (§7.4) nous concentrer sur la solution du
pendule nonlinéaire, telle que décrite par l’équation (7.23). Ça, ce sera définitivement du nouveau !

7.3.2 Reformulation en deux équations d’ordre 1

Du point de vue purement numérique, face à une EDO d’ordre élevé (ici d’ordre 2 pour l’éq. (7.25)),
il est préférable d’introduire des variables dépendantes additionnelles permettant de transformer l’EDO
en un système de deux EDOs couplées, chacune d’ordre 1. Dans le cas de l’éq. (7.25), il suffit de définir :
dθ
=v , (7.29)
dt
de telle sorte que l’éq. (7.25) devienne :
dv
= −ω 2 θ, (7.30)
dt
Le système de deux équations (7.29) et (7.30) est mathématiquement équivalent à l’éq. (7.25), mais il
s’avère souvent plus facile d’en obtenir des solutions numériques précises 1 . Quelque soit la formulation
mathématique utilisée, tout comme précédemment le problème du pendule nous offre un problème dit “aux
valeurs initiales”, c’est à dire qu’une condition initiale nous est donnée à t = 0, et doit être “avancée”
dans le temps.
1. Ceci peut paraitre bizarre, mais c’est en fait relié à l’application des conditions initiale à un niveau de précision
identique à celui de la discrétisation de l’EDO même.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 120 CHAPITRE 7. ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES

7.3.3 Euler explicite, bis

La première étape consiste encore une fois à discrétiser la variable indépendante t sur une maille, que
nous choisirons ici équidistante :

tk+1 = tk + h , k = 0, 1, 2, ...

où t0 correspond à la valeur de t à laquelle est spécifiée la condition initiale. Utilisons maintenant la

méthode d’Euler explicite, donnée par l’éq. 7.11, et appliquons-la aux deux EDOs données par les éq. (7.29)
et (7.30), ce qui conduit immédiatement aux deux équations suivantes,

θk+1 = θk + hvk , k = 0, 1, 2, ... (7.31)

vk+1 = vk − ω 2 hθk , k = 0, 1, 2, ... (7.32)

où (v0 , θ0 ) sont donnés en condition initiale. Pour un pendule déplacé de son point d’équilibre à un angle
Θ0 , et simplement relâché sans lui donner une vitesse initiale, comme auparavant, on a simplement :

[v0 , θ0 ] = [0, Θ0 ] . (7.33)

Connaissant la condition initiale [v0 , θ0 ], les équations discrétisées (7.31) et (7.32) permettent donc de
calculer (v1 , θ1 ), et ensuite (v2 , θ2 ), et ainsi de suite séquentiellement jusqu’au temps final d’intégration
désiré.
On aurait facilement pu re-dériver cet algorithme sans même avoir recours à l’éq. (7.11). En effet, tel
que mentionné à la section 7.2.1, l’algorithme d’Euler explicite peut être obtenu en substituant la formule
de dérivée première d’ordre O(h) au membre de gauche de l’ODE à intégrer. En appliquant ceci aux
éq. (7.29) et (7.30), on obtient,
θk+1 − θk
+ O(h) = vk , k = 0, 1, 2, ... (7.34)
h

vk+1 − vk
+ O(h) = −ω 2 θk , k = 0, 1, 2, ... (7.35)
h
et après quelques simples manipulations algébriques, on retrouve bien les éq. (7.31) et (7.32) données
ci-haut.
Le code Python suivant montre un exemple de code complet qui effectue cette intégration numérique
du pendule.
Code Python pour intégrer le pendule avec Euler explicite
1 import numpy as np
2

3 omega2=1. #omega**2
4 h=0.01 #taille du pas de temps
5 t=[Link](0,2*[Link]/[Link](omega2),h) #maille de temps
6 npas=[Link][0] #nombre de pas de temps a faire
7

8 theta=[Link](npas) #tableau pour l'angle

9 v=[Link](npas) #tableau pour la vitesse
10

11 theta[0]=1. #condition initiale

12 v[0]=0. #condition initiale
13

14 for k in range(0,npas-1):
15 theta[k+1]=theta[k]+h*v[k] #eq. 3.31
16 v[k+1]=v[k]-h*omega2*theta[k] #eq. 3.32

Le résultat est illustré à la Figure 7.4, pour trois choix de pas de temps h. Notez que la variable temps est
exprimée en unités de la période d’oscillation T = 2π/ω, et l’amplitude en unités du déplacement angulaire

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

7.3. LE PENDULE LINÉAIRE 121

Figure 7.4 – Solutions numériques de l’équation du pendule linéaire par la méthode d’Euler explicite,
pour différentes valeurs du pas de temps h : (ωh = 2π/25 → △, ωh = 2π/50 → ⋄, ωh = 2π/100 → +). Le
temps est exprimé en unités de l’inverse de la fréquence d’oscillation angulaire ω, donc la période d’oscil-
lation est égale ici à 1 dans ces unités. Les solutions utilisent la discrétisation définie par les éqs. (7.34)—
(7.35), soit l’utilisation d’une différence finie avant d’ordre O(h) pour évaluer la dérivée à tk . La partie (A)
compare ces diverses solutions à la solution exacte (trait plein), avec l’amplitude exprimée en unités de
l’amplitude Θ0 du déplacement angulaire initial. La partie B montre les erreurs des solutions numériques
par rapport à cette solution exacte.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

122 CHAPITRE 7. ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES

initial Θ0 . La partie A montre l’évolution temporelle des solutions numériques, utilisant différents pas de
temps tous relativement grands pour raisons didactiques, tandis que la partie B illustre la variation de
l’erreur (ε), définie ici comme la différence entre la solution numérique et la solution exacte cos(ωt) :
ε(tk ) = θk − cos(ωt) . (7.36)
Remarquons que :
1. Plus h est petit, plus la solution approche de la solution exacte ; on s’y attendait mais c’est tout
de même rassurant de constater que c’est bien ce qui se passe.
2. De manière générale, l’erreur croit avec le temps ; ceci est une conséquence de la nature séquentielle
de l’algorithme d’Euler ; toute erreur effectuée au pas k est “réinjectée” dans la solution au pas
k + 1, et est donc cumulative.
3. L’erreur de discrétisation conduit à une déviation au niveau de l’amplitude de la variation sinusoi-
dale, mais aussi de sa période.

7.3.4 Euler explicite avec extrapolation linéaire, bis

La précision de la méthode d’Euler explicite peut être encore une fois grandement améliorée en évaluant
les membres de droite des équations (7.29) et (7.30) à mi-pas, soit comme leur valeur moyenne entre entre
tk et tk+1 , et toujours en évaluant les membres de gauche avec la formule de dérivée première d’ordre
O(h) :
θk+1 − θk 1
+ O(h) = (vk+1 + vk ) , k = 0, 1, 2, ... (7.37)
h 2

vk+1 − vk ω2
+ O(h) = − (θk+1 + θk ) , k = 0, 1, 2, ... (7.38)
h 2
On approxime de nouveau les θk+1 et vk+1 aux membres de droite à partir des valeurs au pas k par
extrapolation linéaire basée sur un développement en série de Taylor, tronqué après le second terme :
dθ
θk+1 = θk + h = θk + hvk , (7.39)
dt

dv
vk+1 = vk + h = vk − hω 2 θk , (7.40)
dt
où les secondes égalités résultent de l’utilisation des éqs. (7.29) et(7.30) pour évaluer les deux dérivées
temporelles associées à l’extrapolation. L’algorithme devient alors :
h ω 2 h2
vk − hω 2 θk + vk = θk + hvk −


θk+1 = θk + θk , k = 0, 1, 2, ... (7.41)
2 2

ω2 h h2
 
2
vk+1 = vk − (θk + hvk + θk ) = vk − ω hθk + vk , k = 0, 1, 2, ... (7.42)
2 2
La seule modification à notre code Python pour la méthode d’Euler consiste à remplacer les deux lignes
de code (lignes 15 et 16) faisant le calcul de theta[k+1] et v[k+1] à l’intérieur de la boucle temporelle
par :

theta[k+1]=theta[k]+h*( v[k]-omega2*h*theta[k]/2.)
v[k+1]=v[k]-h*omega2*( theta[k]+h*v[k]/2.)

Il est important de réaliser que l’erreur associée à l’évaluation des dérivées temporelles aux membres de
gauche par différence finies est toujours O(h). Cependant, à un maillage donné cet algorithme s’avère
à produire des solutions beaucoup plus précises que l’algorithme d’Euler original, comme on peut le
constater en comparant la Figure 7.5 ci-dessous à la Fig. 7.4 ci-dessus. Notons déjà les échelles verticales
très différentes sur les parties B ! De toute évidence, notre ré-evaluation des membres de droite à mi-pas
a produit encore une fois une grande amélioration dans la précision des solutions pour une maille donnée.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

7.3. LE PENDULE LINÉAIRE 123

Figure 7.5 – Identique à la Figure 7.4, sauf qu’ici le membre de droite des équations est évalué comme
la moyenne aux pas k et k + 1, par extrapolation linéaire à partir du pas k (éqs. (7.41)) et (7.42)). Notez
le changement des échelles verticales, en particulier sur la partie B, par rapport à la Fig. 7.4.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

124 CHAPITRE 7. ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES

7.4 Le pendule nonlinéaire

Revenons à notre bon vieux pendule. Si nous ne faisons pas l’approximation du petit déplacement par
rapport à la position d’équilibre (sin θ ≃ θ), l’équation (7.23) demeure nonlinéaire en θ, et la séparation
en deux équations d’ordre 1 conduit maintenant à :
dθ
=v , (7.43)
dt

dv
= −ω 2 sin θ . (7.44)
dt
La méthode D’Euler explicite s’applique facilement à cette situation, produisant l’algorithme
dθ
θk+1 = θk + h = θk + hvk , (7.45)
dt

dv
vk+1 = vk + h = vk − hω 2 sin θk . (7.46)
dt
La première de ces expression est identique à son équivalent pour le pendule linéaire (éq. (7.39)), mais
la seconde est maintenant nonlinéaire au membre de droite ; cependant, dans le contexte de la méthode
d’Euler explicite θk est connu, et calculer sin θk ne présente donc aucune difficulté particulière. S’en tenant
à la méthode d’Euler explicite pour l’instant, on n’a qu’à changer la ligne 16 du code ci-haut par :

v[k+1]=v[k]-h*omega2*[Link](theta[k])

Calculons maintenant une série de solutions au problème du pendule nonlinéaire, obtenues à l’aide de
l’algorithme ci-dessus. Les conditions initiales correspondent à de grands déplacements angulaire initiaux
(voir Fig. 7.6), mais le pendule est encore une fois relâché sans lui donner de vitesse initiale. La Figure
7.7 illustre la variation temporelle du déplacement angulaire (mesuré en radians), pour un ensemble de
déplacement initiaux allant jusqu’à π/2, soit une position initiale du pendule à l’horizontale. La première
chose à remarquer est que la fréquence pd’oscillation dépend maintenant de la condition initiale, contrai-
rement au pendule linéaire où ω = g/L quelle que soit l’amplitude initiale. Ceux qui prendront le
cours de mécanique classique 2 verront qu’il est en fait possible de déterminer analytiquement la période
d’oscillation du pendule nonlinéaire, mais le calcul est beaucoup plus complexe que ce que nous avons vu
ci-haut. En bref, la solution analytique est exprimée sous forme d’intégrale comme suit,

Z π
4 2 dϕ
τ=p p , (7.47)
g/L 0 1 − sin (Θ0 /2) sin2 ϕ
2

où l’on voit clairement la dépendance de la période d’oscillation sur son amplitude Θ0 . Cette dépendance
de la fréquence d’oscillation sur l’amplitude explique pourquoi il est si difficile de demeurer synchronisé
avec un(e) petit(e) camarade, chacun sur sa balançoire ; même une petite différence d’amplitude conduira
déjà après quelques cycles d’oscillation à un déphasage perceptible.
Un autre truc qui n’est pas particulièrement évident sur la Figure 7.7, c’est que la forme de l’oscillation
n’est plus exactement sinusoidale ici. La différence ne devient visuellement perceptible que pour des
déplacements initiaux approchant π, comme l’illustre la Figure 7.8. Évidemment, si l’on veut considérer
des déplacements initiaux dépassant π/2 nous sommes forcé de supposer que la masse m n’est pas reliée
au point de pivot par une corde, mais par une tige rigide ; sinon la chute initiale de m se fera verticalement
vers le bas, et une corde plierait ; ceci nous entrainerait dans un tout nouveau régime dynamique.

7.5 Au delà d’Euler

La méthode d’Euler explicite est un algorithme d’une grande simplicité, facilement généralisable à des
systèmes d’EDOs, et même sans extrapolation linéaire du membre de droite est souvent suffisante dans bien
des applications. Cependant son erreur de discrétisation varie comme O(h), ce qui force l’utilisation d’une

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

7.5. AU DELÀ D’EULER 125

Figure 7.6 – Le pendule nonlinéaire : le déplacement angulaire initial (Θ0 = [0.1, 0.2, 0.5, 1.0, π/2]) de la
masse m est maintenant suffisamment grand pour que l’approximation sin θ ≃ θ ne tienne plus la route.

Figure 7.7 – Solutions numériques au problème du pendule nonlinéaire, pour des amplitudes initiales
Θ0 = [0.1, 0.2, 0.5, 1.0, π/2] radians, tel qu’illustré sur la Figure 7.6. On remarquera que la période d’oscil-
lation augmente avec l’amplitude du déplacement initial Θ0 . Les lignes verticales pointillées sont tracées
aux demi-périodes du régime linéaire.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

126 CHAPITRE 7. ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES

Figure 7.8 – Solutions numériques au problème du pendule nonlinéaire, pour une amplitude initiale
θ0 = 0.95 × π, i.e., la masse m est relachée à t = 0 d’un point situé presqu’exactement au dessus du pivot
du pendule. Le trait pointillé est une fonction sinusoidale ayant la même période et amplitude.

maille très serrée, qui se retrouve donc sensible à l’accumulation des erreurs d’arrondissement au niveau
des opérations arithmétiques. Si vous avez suivi le raisonnement dans notre discussion des formules de
différences finies au chapitre précédent, vous aurez peut-être déjà anticipé que des algorithmes plus précis
que la méthode d’Euler peuvent être obtenus en conservant plus de termes dans le développement en série
de Taylor de f (t), et/ou en développant les membres de droite en série. Parmi la quasi-infinité d’algorithmes
pouvant être produits de cette façon, celui que vous risquez de rencontrer le plus fréquemment est sans
nul doute la méthode de Runge Kutta d’ordre 4 (souvent simplement appelée la méthode de Runge-
Kutta tout court) ; l’idée ici est de subdiviser le pas de temps h en sous-pas à travers lesquels la solution
est avancée en réévaluant le membre de droite à chaque sous-pas. Appliqué à note EDO nonlinéaire
prototypique (7.6), l’algorithme prend la forme suivante :
h
fk+1 = fk + (G1 + 2G2 + 2G3 + G4 ) + O(h4 ) , (7.48)
6
où

G1 = g(tk , fk ) , (7.49)

G2 = g (tk + h/2, fk + (h/2)G1 ) , (7.50)

G3 = g (tk + h/2, fk + (h/2)G2 ) , (7.51)

G4 = g (tk+1 , fk + hG3 ) . (7.52)

Pour tous les détails concernant le design de ces algorithmes, voir le chapitre 2 de l’excellent ouvrage de
Golub & Ortega cité en bibliographie à la fin du chapitre. Le bouquin de Wood, également listé ci-dessous,
est aussi (à mon avis) une bonne référence, tout comme le chapitre 17 de Press et al. cité précédemment.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

7.5. AU DELÀ D’EULER 127

Nous n’avons fait ici qu’effleurer ce vaste sujet qu’est la solution numérique des équations différentielles
ordinaires. En particulier, nous n’avons considéré ici que des EDO décrivant des problèmes dits aux
valeurs initiales : on nous fournit une équation d’évolution (genre ∂/∂t = ...) et une condition initiale à
t = t0 , et le problème consiste à “avancer” cette condition initiale dans le temps. Un autre type de situation
décrite par une EDO est le problème dit aux valeurs limites : on nous fournit une EDO décrivant un
aspect d’un système défini sur un domaine (genre x ∈ [a, b]), et deux conditions limites à x = a et x = b ;
le problème consiste alors à obtenir une solution à l’EDO dans le domaine, qui soit compatible avec ces
conditions limites. Vous ferez connaissance avec ce genre de problème en mécanique quantique —entre
autres— lorsque vous solutionnerez l’équation de Schrödinger dans un puits de potentiel.
Les références listées en fin de chapitre devraient suffire à ceux et celles désirant équiper encore plus
leur “boite à outils” numérique de méthodes de solutions de ces diverses classes d’EDO. Pour nous ici, il
est maintenant temps de passer à autre chose.

Exercices:

1. Une unité de temps “naturelle” pour le problème du pendule est l’inverse de la fréquence d’oscil-
lation ω = g/L ; introduisez une nouvelle variable temps (t∗ ) telle que

t∗ = t × ω ,

et montrez que les deux équations différentielles d’ordre 1 décrivant le mouvement pendulaire (les
éqs. (7.29)–(7.30) prennent maintenant la forme :

dθ dv
=v , = −θ .
dt∗ dt∗

2. Déterminez jusqu’à quel angle θ∗ (en rad.) les approximations sin θ ∼ θ et cos θ ∼ 1 demeurent
valides à 10−3 , 10−4 et 10−5 près.
3. Pourquoi cette séparation de la “vraie” équation du pendule (éq. (7.25)) en deux équations différen-
tielles d’ordre 1 ? Utilisez une formule de différence finie pour la dérivée seconde pour produire un
algorithme semblable à la méthode d’Euler explicite ; codez le en Python, et comparez sa précision
(à pas de temps égal) à celle de l’algorithme standard.
4. Codez en Python la méthode d’Euler explicite et sa version avec extrapolation linéaire, pour le
problème du pendule linéaire. Intégrez sur une période complète d’oscillation, et examinez comment
varie l’erreur associée à cette valeur finale à mesure que le pas de temps diminue ; exprimez vos
résultats sous la forme d’un équivalent de la Figure 4.5.
5. Codez en Python la méthode de Runge-Kutta pour le problème du pendule linéaire. Produisez
l’équivalent des Figures 7.4 et 7.5. Comment se compare cette méthode aux deux autres considérées
dans ce chapitre, soit Euler explicite et Euler avec extrapolation linéaire ?

Bibliographie:

Le chapitre 17 du Numerical Recipes, cité en bibliographie au chapitre 1, discute de manière plus appro-
fondie les divers algorithmes décrits dans ce chapitre, en bien d’autres en plus. À un niveau mathématique
plus poussé, les deux ouvrages suivant demeurent des classiques incontournables :
Gear, C.W., Numerical Initial Value Problems in Ordinary Differential Equation, Prentice-Hall (1971),
Stoer, J., & Bulirsch, R., Introduction to Numerical Analysis, 3e éd., Springer (2002).
Plus accessible, quoique que toujours dans le costaud, je recommanderais :
Golub, G.H., & Ortega, J.M., Scientific Computing and Differential Equations, Academic Press (1992),
Wood, W.L., Practical time-stepping schemes, Oxford (1990).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

128 CHAPITRE 7. ÉQUATIONS DIFFÉRENTIELLES ORDINAIRES

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 129

Chapitre 8

Nonlinéarité et chaos

8.1 Encore le pendule...

Vous en serez peut-être surpris, mais notre bon vieux pendule a encore en poche de quoi nous tenir
occupé pendant tout un autre chapitre... Même avec le terme en sin θ conservé comme tel, l’équation (7.23)
demeure un modèle simplifié du mouvement pendulaire réel. Si vous avez déjà joué avec un pendule, vous
aurez certainement remarqué que le mouvement ne perdure pas à l’infini. Ceci est du à la force de friction
qui s’exerce entre la masse m (et le fil ou la tige) du pendule et l’air ambiant. Cette force de friction
dissipe l’énergie cinétique de la masse m, et donc ralentit inexorablement le pendule. Nous commencerons
par examiner ceci à la §8.3, non sans avoir tout d’abord introduit un concept physique qui sera fort utile,
soit l’espace de phase (§8.2). Si l’on désire maintenir le mouvement pendulaire, nous devons clairement
lui fournir de l’énergie, et ceci peut se faire par forçage mécanique du pendule, sujet de la §8.4. Nous
verrons ensuite comment la combinaison du forçage et de l’amortissement peut conduire à des solutions
stationnaires, dans le sens que le battement du pendule conserve une amplitude constante (§8.5). Cette
situation à prime abord pas trop excitante nous mènera à la notion de bifurcation (§8.6), et deviendra
encore plus surprenante quand nous examinerons le comportement de ces solutions plus “loin” dans
l’espace des paramètres (§8.7), ce qui nous plongera littéralement en plein chaos.

8.2 L’espace de phase

Que ce soit en version linéaire ou nonlinéaire, nous avons l’habitude de penser au mouvement du
pendule exclusivement en terme de la variation dans le temps de sa position angulaire θ (viz. Fig. 7.3).
Cependant, notre traitement numérique de l’éq. (7.23) a commencé par l’introduction d’une seconde
variable dynamique, v ≡ dθ/dt. Cette variable est dite dynamique car son évolution est décrite par
une équation différentielle impliquant une dérivée temporelle, au même titre que θ. D’un point de vue
strictement mathématique, rien dans notre système de deux équations différentielles couplées d’ordre 1,
soit les éqs. (7.43)—(7.44), ne confère à la variable θ un status particulier par rapport à la variable v.
Les variables θ et v peuvent être interprétées comme les coordonnées d’un “point” (θ, v) dans un
espace bi-dimensionnel, et l’évolution dynamique du système —ici le pendule— est entièrement décrite
par la trajectoire de ce points dans cet espace de phase bi-dimensionnel, à partir du point (θ0 , v0 )
correspondant à la condition initiale.
Revenons à la forme linéaire du problème du pendule ; on a vu que pour un pendule déplacé à une
distance angulaire θ0 (≪ 1) et relaché sans lui donner de vitesse initiale, l’évolution temporelle du dépla-
cement angulaire est donnée par un mouvement harmonique simple :
θ(t) = θ0 cos(ωt) , (8.1)
avec ω 2 = g/L ; la variable v évolue donc dans le temps selon :
1
v(t) = −θ0 sin(ωt) , (8.2)
ω
Les membres de droite des équations (8.1) et (8.2) sont les équations paramétriques d’un cercle de rayon θ0
centré sur (0, 0) dans un espace [θ, v/ω]. L’évolution temporelle du pendule est décrite par le déplacement

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

130 CHAPITRE 8. NONLINÉARITÉ ET CHAOS

Figure 8.1 – Espace de phase pour le pendule nonlinéaire (à tige rigide). Les trajectoires fermées (en
rouge) correspondent à des mouvements oscillatoires autour de la position d’équilibre (θ, v) = (0, 0).
Les courbes vertes délimitent la région des orbites fermées de celles des trajectoires ouvertes (orange),
correspondant à une masse tournant perpétuellement dans le sens horaire (v > 0) ou antihoraire (v < 0).
Les cinq plus petites orbites fermées correspondent aux solutions de la Figure 7.7.

à vitesse constante d’un point (θ, v/ω) dans le sens horaire. Le point (0, 0) correspond ici à une solution
d’équilibre où le pendule est au repos et pend directement vers le bas.
Si le déplacement initial du pendule ne satisfait pas la condition θ0 ≪ 1 nous permettant de remplacer
sin θ par θ, les trajectoires ne sont plus des cercles, mais l’évolution du pendule nonlinéaire peut toujours
être décrite par une trajectoire fermée dans l’espace de phase. Ceci est illustré par les trajectoires en rouges
sur la Figure 8.1. Partant du centre (0, 0), les cinq premières correspondent aux cinq solutions de la Figure
7.7, et la sixième a comme condition intiale (θ0 , v0 ) = (5π/6, 0). Notons que l’espace de phase du pendule
(linéaire ou non) est périodique dans la direction-θ, la périodicité étant de 2π puisque sin(θ ± 2π) ≡ sin(θ).
Seules les trajectoires centrées sur θ = 0 sont illustrées ici. Les solutions linéaires ne sont valides que très
près des points (θ, v) = (±2nπ, 0), avec n = 0, 1, ...
Le fait que ces trajectoires soient fermées est évidemment une conséquence directe de la périodicité du
mouvement. Cette périodicité est ici une conséquence directe de la conservation de l’énergie. Le contenu
énergétique de la masse m fixée au bout de notre pendule inclut deux contributions, soit son énergie ciné-
tique et son énergie potentielle gravitationnelle. Si on choisit comme point zéro du potentiel gravitationnel
la hauteur du pivot du pendule, on a :
1
E= mv 2 − mgL cos θ , (8.3)
2
En l’absence de toute friction avec l’air ambiant, cette quantité d’énergie, quelle qu’elle soit à t = 0,
doit être conservée pour tout t > 0, et ce que le pendule opère en mode linéaire ou nonlinéaire. Le
mouvement pendulaire peut donc être vu comme un échange cyclique entre l’énergie cinétique et potentielle
gravitationnelle de la masse m.
La transposition du mouvement accéléré dans son espace de phase nous permet de pousser plus loin
notre étude du pendule. Considérons un pendule orienté verticalement vers le haut (θ = π) et au repos
(v = 0). Pour une masse m montée au bout d’une tige rigide, c’est là une position d’équilibre, car la
force de gravité est complètement équilibrée par la rigidité de la tige. L’énergie est ici E = mgL. Sujet
maintenant à tout déplacement angulaire même des plus minuscules, l’équilibre sera rompu et le pendule
√ le sens du petit déplacement. Rendu en bas, à θ = 0, l’éq. (8.3) nous garantit
se mettra à tourner, dans
que la vitesse sera v = 2gL, et retombera à zéro une fois que le pendule aura complété un tour complet.
Que se passe-t-il maintenant si on donne une vitesse initiale v0 > 0 au pendule dans sa position
d’équilibre (instable) θ = π ? Comme auparavant le pendule accélérera durant la descente et décélérera

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

8.3. LE PENDULE AMORTI 131

durant la remontée, mais son tour complété et arrivé à θ = π sa vitesse sera redevenu égale à sa vitesse
initiale... et donc ca repart pour un second tour,
p et ainsi de suite ad aeternam. On est ici dans une situation
où la vitesse oscille entre des limites v0 et v02 + 4gL, et θ augmente continuellement. Ceci corresponds
aux trajectoires tracées en orange dans la moitié supérieure de l’espace de phase sur la Figure 8.1. Si la
vitesse initiale est négative, le mouvement sera décrit par les trajectoires oranges dans la moitié inférieure
de la Figure.
Les courbes vertes sur la Figure 8.1 définissent les séparatrices de l’espace de phase. Le point d’inter-
section de ces séparatrices avec la ligne v = 0 correspond au pendule en équilibre (instable) à la position
(θ, v) = ((2n ± 1)π, 0), n = 0, 1, ..., soit la masse m positionné verticalement exactement au dessus du
pivot.
Dans un système déterministe comme notre pendule, deux trajectoires ne peuvent pas se croiser dans
l’espace de phase ; il n’est pas possible non plus à une trajectoire de se croiser soi-même ; si c’était le cas,
au point de croisement il y aurait un “choix” à faire, à savoir laquelle des deux branches possibles prendre
pour la suite de l’évolution. Les points de croisement des séparatrices peuvent paraitre violer ce précepte,
mais on verra au chapitre 8 que le temps requis pour atteindre un de ces points tend vers l’infini. Et
attendre un temps infini, c’est très long, surtout vers la fin...

8.3 Le pendule amorti

Tout corps se déplaçant dans un fluide —et l’air compte comme un fluide— sera sujet (au minimum) à
une force de trainée (FD ) orientée dans la direction opposée à son vecteur vitesse. Pour des mouvements
relativement lents, dans le sens que la trainée ne développe pas de turbulence, la grandeur de cette force
de trainée se retrouve directement proportionnelle à la grandeur de la vitesse :

FD = −αv . (8.4)

où α (> 0) est un coefficient de friction (unités : N s/m). Remarquez déjà que si cette force de trainée est
la seule force en présence, la Loi de Newton
dv
ma = m = −αv . (8.5)
dt
nous indique immédiatement qu’un objet de masse m se déplaçant à une vitesse v0 verra sa vitesse
décroitre exponentiellement selon :
 α 
v(t) = v0 exp − t . (8.6)
m
Vous en apprendrez plus sur tout ça en ne manquant pas de vous inscrire à l’excellent cours PHY-3140,
Hydrodynamique, généralement enseigné à la session d’hiver par l’auteur de la version originale de ces
notes : Paul Charbonneau. Bon, bref, il ne s’agit plus que d’ajouter cette force au membre de droite de la
composante-θ de notre équation du mouvement. Comme ici la vitesse linéaire v ≡ Ldθ/dt êθ , on obtient

d2 θ αL dθ
L 2
= −g sin θ − , (8.7)
dt m dt
et notre séparation en deux équations différentielles ordinaires couplées d’ordre un nous donne maintenant :
dθ
=v , (8.8)
dt

dv
= −ω 2 sin θ − βv , (8.9)
dt
où on a de nouveau défini ω 2 = g/L, et également
α
β= . (8.10)
m
Ces deux équations ne diffèrent des équations (7.43) et (7.44) pour le pendule non-linéaire que par l’appa-
rition d’un deuxième terme (l’amortissement) dans l’équation différentielle pour v. En outre, il est trivial

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

132 CHAPITRE 8. NONLINÉARITÉ ET CHAOS

θ0 = π−0.1, ω =1
1.0 non amorti, β =0
amorti, β =0.05
amorti, β =0.3
0.5
θ(t)/θ0

0.0

0.5

1.0
0 5 10 15 20
ωt/2π

Figure 8.2 – Solutions numériques du mouvement du pendule nonlinéaire (à tige rigide) amorti obtenues
avec la méthode de Heun. Les deux traits en couleur ont la même condition initiale (θ0 , v0 ) = (π − 0.1, 0),
mais deux valeurs différentes de β représentant un faible ou un fort amortissement. Pour référence, le trait
noir montre la solution pour le pendule nonlinéaire non-amorti avec la même condition initiale.

de modifier notre algorithme précédent pour résoudre ces équations. La Figure 8.2 montre les solutions
numériques, pour l’angle θ en fonction de t, obtenues à l’aide de la méthode de Heun (§7.5) pour deux
valeurs distinctes de β mais la même condition initiale (θ0 , v0 ) = (π − 0.1, 0). Ces solutions correspondent
à une oscillation du pendule à partir de sa position de départ, avec une amplitude décroissant exponen-
tiellement avec le temps et une fréquence croissant avec le temps. La Figure 8.3 illustre ces deux mêmes
solutions mais cette fois dans l’espace de phase [θ, v] du modèle. Avec β = 0 (non montré), ces solutions sui-
vraient une trajectoire ayant la forme d’une orbite fermée collant de près la séparatrice (trait noir). Ici, en
présence d’amortissement, les trajectoires deviennent des spirales convergeant vers la position d’équilibre
(θ, v) = (0, 0).
Ici, en fait, quelle que soit la condition initiale ou la valeur de β (> 0), les solutions convergent toujours
vers la solution d’équilibre (θ, v) = (0, 0). On appelle un tel point un attracteur dans l’espace de
phase puisqu’il “attire” à lui toutes les solutions, quelles que soient les conditions initiales. La vitesse
de convergence des solutions vers l’attracteur dépendra évidemment de la valeur de β, et du contenu
énergétique de la condition initiale, mais si l’on attend assez longtemps cette convergence aboutira toujours
à (0, 0) ; ou, plus précisément, à l’un ou l’autre des points situés à (θ, v) = (2nπ, 0) , n = 0, 1, 2, ...

8.4 Le pendule forcé

Passons maintenant à une autre variation sur le thème du pendule. Cette fois il s’agit d’un pendule
dont le pivot est sujet à un forçage vertical harmonique ; par exemple, le pivot peut être monté sur un

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

8.4. LE PENDULE FORCÉ 133

Figure 8.3 – Trajectoires dans l’espace de phase pour les deux solutions du pendule nonlinéaire amorti
présentées à la figure 8.2. Dans les deux cas la trajectoire aboutit à (θ, v) = (0, 0).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

134 CHAPITRE 8. NONLINÉARITÉ ET CHAOS

Figure 8.4 – Géométrie du forçage pour le problème du pendule forcé (ici de manière exaggérée...).

mécanisme oscillant verticalement à une fréquence ω0 ajustable, selon un mouvement harmonique :

z(t) = z0 cos(ω0 t) . (8.11)

À un tel mouvement est associé une accélération également harmonique, qui n’est que la dérivée seconde
de cette expression :

gz (t) = −g0 cos(ω0 t) , g0 = z0 ω02 . (8.12)

L’idée générale est illustrée sur la Figure 8.4, pour un forçage passablement vigoureux. Pour un pendule
à tige rigide, cette accélération additionnelle sera transmise à la masse m par l’intermédiaire de la tige,
ce qui fait que la composante-θ de notre équation du mouvement aura maintenant l’air de :

d2 θ
L = −(g − g0 cos(ω0 t)) sin θ . (8.13)
dt2
La décomposition en deux équations différentielles d’ordre 1 donne alors :
dθ
=v , (8.14)
dt

dv
= −ω 2 (1 − γ cos(ω0 t)) sin θ , (8.15)
dt
où on a défini un paramètre γ mesurant l’amplitude relative du forçage par rapport à la gravité :
g0
γ= . (8.16)
g
Il y a donc maintenant deux paramètres additionnels contrôlant le comportement du pendule : la fréquence
ω0 et l’amplitude relative γ du forçage harmonique. Dépendant des valeurs choisies pour ces paramètres,
le pendule peut se comporter de manière carrément bizarre. En particulier, on pourrait s’attendre que
dans la limite γ → 0 le comportement du pendule devienne identique à celui du pendule non-forcé ; comme

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

8.4. LE PENDULE FORCÉ 135

Figure 8.5 – Opération du mécanisme d’excitation paramétrique, dans la situation où ω0 = 2ω. Le

diagramme illustre une demie-oscillation du pendule, ici de la gauche vers la droite. Les flèches verticales
rouges au haut du diagramme indiquent la phase et l’amplitude du forçage du pivot. On notera que le
forçage complète un cycle complet durant un demi-cycle d’oscillation du pendule.

on le verra dans ce qui suit, celà s’avère ne pas être toujours le cas, dépendant de la valeur choisie pour
la fréquence de forçage ω0 .

Certains comportements du pendule forcé harmoniquement sont merveilleusement contre-intuitifs.

L’excitation paramétrique l’est particulièrement. Considérons ce qui se passe si le forçage harmonique
p
du pendule se fait à une fréquence ω0 qui est un multiple pair de la fréquence d’oscillation ω = g/L (e.g.,
ω0 = 2ω). Si l’amplitude d’oscillation est suffisamment petite pour que le pendule opère dans le régime
linéaire, alors en relâchant notre pendule au moment opportun on se retrouve dans une situation où
durant la phase “descendante” du pendule, le forçage du pivot est en phase remontante, ce qui augmente
l’accélération angulaire de la masse m ; et quand le pendule reprend la phase remontante, le forçage est
vers le bas, ce qui réduit la gravité effective et fait que la masse m a moins tendance à ralentir (voir
Fig. 8.5). Ces deux effets feront que la masse m remontera plus haut qu’elle ne l’aurait fait en l’absence
du forçage. Mais puisque ω0 = 2ω, à la prochaine descente ça repart de la même façon. Donc, en un cycle
complet d’oscillation du pendule, la masse m subit deux cycles d’amplification par le forçage externe. Il
est donc possible, à partir d’une oscillations infinitésimale, de produire une oscillation de forte amplitude ;
aurement dit, de notre point de vue le pendule se met à osciller “spontanément”. Cette apparente violation
des lois de la physique n’en est évidemment pas une, puisque que le système dispose d’une source d’énergie
“externe”, soit le mécanisme faisant osciller le pivot. Le point important demeure que l’oscillation du pivot
peut transférer de l’énergie au pendule et amplifier son mouvement.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

136 CHAPITRE 8. NONLINÉARITÉ ET CHAOS

Figure 8.6 – Trajectoires dans l’espace de phase pour trois solutions numériques au problème du pendule
forcé et amorti. Toutes les solutions utilisent les valeurs de paramètres ω0 = 2ω, γ = 0.25, et β = 0.03.
les conditions initiales sont indiquées par des • colorés.

8.5 Le pendule forcé et amorti

Il est maintenant temps de combiner l’amortissement hydrodynamique et le forçage harmonique. Nous
solutionnons donc maintenant :
d2 θ αL dθ
L = −(g − g0 cos(ω0 t)) sin θ − , (8.17)
dt2 m dt
comme d’habitude exprimée sous la forme de deux équations différentielles d’ordre 1 :

dθ
=v , (8.18)
dt

dv
= −ω 2 (1 − γ cos(ω0 t)) sin θ − βv , (8.19)
dt
avec γ et β donnés par les éqs. (8.16) et (8.10), comme auparavant.
Intuitivement, on peut imaginer que même en présence de l’amortissement il puisse exister un état
stationnaire autre que (θ, v) = (0, 0), puisqu’une source d’énergie extérieure peut amplifier le mouvement
pendulaire. La Figure 8.6 montre les trajectoires dans l’espace de phase de trois solutions numériques de
l’équation (8.17) par la méthode de Heun, toutes avec ω0 = 2ω, γ = 0.25, et α = 0.03, mais différant au
niveau de la condition initiale. Quelle que soit cette dernière, les trajectoires aboutissent toutes sur l’orbite
décrite par le trait noir épais. Nous avons de nouveau affaire ici à un attracteur, mais cette fois-ci ce n’est
plus un point mais une figure géométrique plus complexe, soit une courbe fermée décrivant une oscillation
quasi-harmonique d’amplitude constante.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

8.6. BIFURCATIONS 137

Figure 8.7 – Amplitude maximale de battement dans l’état stationnaire, pour une séquence de solutions
avec ω0 = 2ω et β = 0.05 (vert) et β = 0.1 (rouge), en fonction de de l’amplitude γ = g0 /g du forçage
harmonique.

8.6 Bifurcations
Si sur la Figure 8.6 la forme de l’attracteur dans l’espace de phase ne dépend pas de la condition initiale,
elle dépend cependant des paramètres physiques du problème, soit le paramètre γ mesurant l’amplitude
de forçage (éq. (8.16)), et le paramètre β mesurant l’importance de l’amortissement par la friction de l’air.
Considérons la procédure suivante. Gardant tous les paramètres du modèles fixes autres que le paramètre
de forçage γ, on produit une séquence de solutions pour des valeurs de γ de plus en plus grandes. Pour
chaque solution, on intègre jusqu’à la convergence sur l’attracteur, et on mesure le rayon de l’orbite (plus
précisément, la valeur maximale Θm atteinte par la variable angulaire (e.g., Θm = 1 rad sur la Figure 8.6).
On porte ensuite en graphique ces valeurs de Θm , en fonction de la valeur du paramètre γ. Le résultat
est illustré à la Figure 8.7, pour deux valeurs du paramètre d’amortissement β (points verts et rouge).
Certains aspects de cette Figure sont satisfaisant intuitivement. À forçage égal, les solutions avec plus
faible amortissement se retrouvent à produire des amplitudes de battement plus élevées ; et à amortisse-
ment égal, plus l’on force fort plus l’amplitude de battement est grande. Cependant le détail de la variation
de Θm avec γ est pas mal moins intuitif. Pour un β donné, il existe de toute évidence une valeur de γ
en dessous de laquelle il n’y a pas du tout de croissance de l’amplitude par excitation paramétrique, et
quand elle débute, elle débute de manière soudaine et rapide. La valeur de γ à laquelle ceci se produit est
appellée point critique, et le changement dans la dynamique globale du système se produisant quand
on croise ce point est appelé bifurcation. On notera que la solution d’équilibre demeure une solution
tout-à-fait valide même au delà du point de bifurcation ; cependant, cette solution se retrouve instable
par rapport à la solution oscillatoire, mais seulement si l’énergie injectée par le mécanisme de forçage peut
dépasser l’énergie perdue en friction contre l’air. C’est pourquoi le point critique a une valeur numérique
finie, qui croit à mesure que β augmente.
La bifurcation est un phénomène typique des systèmes nonlinéaires. Dans bien des situations que vous

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

138 CHAPITRE 8. NONLINÉARITÉ ET CHAOS

avez déjà rencontrées dans vos études de la physique, il existe une relation linéaire entre une “cause” et
un “effet”. Avec F = ma par exemple, quelle que soit la valeur de F, si vous l’augmentez de 1% (disons)
vous vous attendez à une augmentation directement proportionnelle de l’accélération a. Contrastez ceci
à la situation présentée à la Figure 8.7, par exemple pour β = 0.1 (points rouge). Si γ = 0.1, le pendule
n’oscille pas, et une augmentation de γ par 1% (à γ = 0.101) ne le fera pas osciller plus. À γ = 0.4
par contre, une augmentation de 1% à γ = 0.404 produira une augmentation quasi-proportionnelle de
l’amplitude maximale d’oscillation. Mais à γ = 0.2, une petite augmentation de 1% nous fait passer d’un
système qui n’oscille pas du tout à un système qui oscille avec une amplitude substantielle, Θm ≃ 0.5 rad.
En fait, au point de bifurcation même on a dΘm /dγ → ∞. Même à un niveau purement qualitatif (osciller
ou ne pas osciller, zattize ze quèstcheune...), la réponse du système à une petite variation d’un paramètre
dépend donc de manière très sensible de la valeur exacte de ce paramètre ; quand un point de bifurcation
est traversé, le système passe à un état dynamique différent. C’est ce qui fait toute la complexité des
systèmes nonlinéaires.

8.7 Le chaos
Une orbite stable dans l’espace de phase, telle qu’illustrée à la Figure 8.6 est possible ici en présence
d’un amortissement important en raison du fait que la fréquence de forçage a été judicieusement choisie
afin de profiter de la résonance par excitation paramétrique. Qu’en est-il de l’évolution du pendule forcé
si la fréquence de forçage n’a pas une valeur permettant l’excitation paramétrique ? Le forçage transfère
toujours de l’énergie au système, donc ou pourrait s’attendre à ce que pour un amortissement pas trop
important et/ou une amplitude de forçage suffisamment élevée, le mouvement pendulaire puisse perdurer.
Quelle forme prend alors ce mouvement ?
La Figure 8.8 montre l’évolution temporelle d’un pendule forcé et amorti, avec valeurs de paramètres
ω0 = 1.3ω, γ = 0.75, et β = 0.03, et une condition intiale (θ0 , v0 ) = (5π/6, 0). La solution est obtenue ici
par la méthode de Heun, avec un pas de temps h = 0.014. Chaque image montre le pendule à 10 époques
successives équidistantes dans le temps, avec la teinte de gris codant le temps : le pendule le plus pâle
correspond au premier pas de temps du groupe de dix, et le plus foncé au dernier. Chaque image représente
la suite de la précédente, de gauche à droite et du haut vers la bas, tel que numéroté ; le pendule en noir
sur la première image est donc à la même position que celui en gris le plus pâle sur la seconde, en ainsi de
suite d’une image à l’autre 1 . Le mouvement est de toute évidence très complexe, et pas harmonique ou
quasi-harmonique du tout ! Notez en particulier comment le pendule parvient parfois à effectuer quelques
tours complets successifs autour du pivot (e.g., images 17→20).
La Figure 8.9 montre l’évolution de la même solution, cette fois dans le sous-espace de phase [θ, v] du
système. On parle de sous-espace ici parce que l’espace de phase complet inclut maintenant une troisième
dimension, soit celle de l’amplitude de forçage du pivot, qui ajouterait ici une déviation harmonique des
trajectoires hors du plan de la feuille. C’est pourquoi la trajectoire semble se croiser occasionnellement
ici, chose impossible dans l’espace de phase complet d’un système déterministe. On voit que le pendule
est parfois “capturé” par l’un ou l’autre des points fixes à (θ, v) = (2nπ, 0) pendant quelques orbites,
mais la grande amplitude de forçage utilisée ici (γ = 0.75) réussit à l’en extirper malgré l’amortissement
substantiel (β = 0.03), ce qui fait que la solution “vagabonde” d’une cellule périodique de l’espace de
phase à l’autre, d’une manière en toute apparence erratique. Un saut d’une cellulle correspond à une
révolution complète du pendule autour du pivot, dans le sens horaire (saut à droite) ou antihoraire (saut
à gauche).
Mathématiquement parlant, le mouvement du pendule est en fait ici plus qu’erratique, il est chaotique.
Le chaos est une notion qui a été apprêtée à toutes les sauces, et il est donc important de bien spécifier
(et même quantifier) ce que l’on appelle chaos ici.
Considérons deux solutions ayant des valeurs de paramètres identiques, soit β = 10−4 , ω0 = 1.3ω,
γ = 0.25, mais ne diffèrant que par leur condition initiale, et même là vraiment très peu :

(θ, v)1 = (π/2, 0) , (θ, v)2 = (π/2 + 10−4 , 0) . (8.20)

On utilise encore une fois ici la méthode de Heun, avec un pas de temps h = 0.019. Au début, les deux
solutions sont évidemment indistingables “à l’oeil”... mais seulement pendant trois cycles d’oscillation ;
vers ωt/2π = 25, une différence devient notable, et à partir de ωt/2π ≃ 30 les deux solutions divergent
1. Une animation de cette solution peut être visionnée sur la page Studium du cours.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

8.7. LE CHAOS 139

Figure 8.8 – Battement d’un pendule nonlinéaire amorti et forcé (ω0 = 1.3ω, γ = 0.75, β = 0.03).
Chaque image montre 10 positions successives du pendule espacées également dans le temps, selon une
séquence allant du gris clair vers le noir. Chaque image successive reprend là où la précédente se termine,
de la gauche vers la droite, et du haut vers le bas, tel que numéroté.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

140 CHAPITRE 8. NONLINÉARITÉ ET CHAOS

Figure 8.9 – Évolution de la même solution qu’illustrée sur la Figure 8.8, cette fois dans le sous-espace
de phase [θ, v] du système. Le codage en teintes de gris de la trajectoire suit celui de la Figure 8.8, chaque
segment successif gris→noir correspondant à une image.

complètement l’une de l’autre. Cette divergence n’est pas due à un effet d’instabilité numérique associée à
une erreur d’arrondissement, ou rien du genre ; la divergence des deux solution a lieu même si on diminue
ou augmente la taille du pas de temps, ou si on passe à Runge-Kutta, etc. L’effet est réel, et nous devons
en comprendre l’origine.
Commençons par nous définir une mesure quantitative de l’écart entre les deux solutions ; il est naturel
d’utiliser la distance entre les deux solutions dans le sous-espace de phase [θ, v], définie comme :
p
δ(t) = (θ1 (t) − θ2 (t))2 + (v1 (t) − v2 (t))2 . (8.21)

En vertu des conditions initiales adoptées ici, la distance initiale entre les deux solutions est de δ =
10−4 à t = 0. La Figure 8.10 montre l’évolution temporelle de cette quantité, avec une échelle verticale
logarithmique. On remarquera que l’écart entre les deux solutions croit exponentiellement, essentiellement
depuis t = 0, jusqu’à ce que les deux solutions divergent complètement. Quelle que soit la condition
initiale, ou l’amplitude de l’écart introduit à t = 0, pour des valeurs des paramètres β, ω0 , et γ fixes, cette
croissance exponentielle se fait toujours au même taux Λ, correspondant à la pente du trait vert sur la
Fig. 8.10. En d’autres mots, on peut écrire :

δ(t) = δ0 exp(Λt) . (8.22)

La constante Λ est appelée exposant de Lyapunov, et le fait que cet exposant soit positif définit le
système comme étant chaotique.
Il nous reste à comprendre ce qui mets fin à la phase exponentielle de croissance de l’écart entre les
deux solutions. Pour ce faire il s’avèrera utile de considérer l’évolution des deux solutions dans l’espace
de phase [θ, v], tel qu’illustré au haut de la Figure 8.11.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

8.8. CHAOS ̸= ALÉATOIRE 141

Figure 8.10 – Évolution de la distance dans l’espace de phase, définie selon l’éq. (8.21) entre deux
solutions au problème du pendule forcé et amorti, toutes les deux ici avec les même valeurs de paramètres
ω0 = 1.3ω, β = 10−4 , et γ = 0.25. Les deux solutions ne diffèrent que très légèrement au niveau de
leur condition initiale : (θ, v) = (π/2, 0) et (π/2 + 10−4 , 0). Le trait vert indique la phase de croissance
exponentielle de l’écart (voir texte).

Les deux trajetoires débutent sur une orbite fermée centrée sur (θ, v) = (0, 0), mais après trois orbites
le forçage les fait approcher, puis sauter la séparatrice, après quoi les solutions se dirigent vers le point
répulseur (θ, v) = (π, 0) (voir premier encadré). Les deux solutions sont redéviées le long de la séparatrice.
Cependant, la solution en rouge est maintenant “retardée” par rapport à la bleue, ayant pris plus de
temps à contourner (θ, v) = (π, 0). Les deux solutions sont donc maintenant partiellement déphasées par
rapport au forçage harmonique ; comme on peut le voir sur l’encadré du bas, elles croisent et recroisent la
séparatrice à différent temps et à différentes positions sur la séparatrice. Une fois une révolution supplé-
mentaire complétée, à l’approche du prochain point répulseur à (θ, v) = (3π, 0), la solution rouge est au
dessus de la séparatrice tandis que la bleue est en dessous ; la première repart donc vers le haut, tandis
que la deuxième continue vers le bas sur une orbite fermée autour de (θ, v) = (2π, 0). Du point de vue du
pendule dans notre “vrai” espace physique, la première solution correspond à un pendule qui, oscillant
avec une forte amplitude, approche, ralentit, mais parvient tout de même à dépasser le point d’équilibre
instable, tandis que la seconde solution décrit une solution qui ralentit au point mort tout juste avant
d’avoir atteint la verticale θ = π, et repart en sens inverse. C’est donc aux alentours du point d’équilibre
instable que se décide la décorrélation du système.

8.8 Chaos ̸= aléatoire

Notre étude du chaos s’est limité ici à un système physique très simple, soit le pendule amorti et
forcé. Le chaos s’observe cependant dans bon nombres de systèmes physiques ou biologiques, naturels
ou artificiels : orbites d’astéroides, certains circuits électriques, turbulence dans les fluides, interactions

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

142 CHAPITRE 8. NONLINÉARITÉ ET CHAOS

Figure 8.11 – Trajectoires dans l’espace de phase des deux solutions de la Figure 8.10, avec deux zoom
successifs sur la région où se produit la décorrélation (voir texte). Les courbes en vert correspondent aux
séparatrices dans l’espace de phase. Sur l’encadré du bas, les • colorés sont tracés à des intervalles de
temps constant ; remarquez comme la solution en rouge “ralentit” plus que la bleue, en passant plus près
du point (θ, v) = (π, 0).

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

8.8. CHAOS ̸= ALÉATOIRE 143

prédateur-proie, certaines formes d’arythmie cardiaque, réactions chimiques, chavirement des navires par
les vagues, fluctuations dans les cavités laser, pour n’en nommer que quelques-uns. Si on avait à trouver
un point commun à la dynamique de ces systèmes si divers, ce serait leur grande sensibilité par rapport
aux conditions initiales. Une minuscule différence entre deux solutions tend à s’amplifier avec le temps. Et
comme vous pourrez le vérifier en faisant le problème 4.4 ci-dessous, cette “petite différence” peut même
être produite par le choix du schéma numérique utilisé pour solutionner le problème.
Mais comment reconnaitre le chaos dans un système naturel ou artificiel ? Un comportement “désor-
donné” (“chaotique” dans le sens colloquial du terme) est un indice mais non une preuve. Un système
évoluant selon une dynamique stochastique (par exemple la marche aléatoire que nous découvrirons dans
quelques semaines) évolue également de manière “désordonnée”, mais on est très loin du chaos. Ajoutez
à ça l’inévitable présence d’erreurs de mesure dans une observation ou une manip expérimentale, et faire
la part observationnellement entre un système stochastique et un autre étant chaotique peut devenir un
solide défi. Les références listées en bibliographie en fin de chapitre pourront vous montrer la voie si ce
genre de trucs vous intéresse.

Exercices:

1. Ce problème vise à vous faire cogiter un peu plus sur le concept d’espace de phase ;
(a) Tracez la trajectoire, dans un espace de phase hauteur-vitesse, d’une masse m lancée verticale-
ment vers le haut à partir du sol, à une vitesse initiale v0 (à gravité constante).
(b) Tracez “intuitivement” une seconde trajectoire, dans un cas ou le déplacement de la masse m
est influencé de manière appréciable par la friction de l’air.
2. Revenons au pendule nonlinéaire classique, i.e. sans amortissement ou forçage (comme au chapitre
7). Obtenez une séquence de solutions numériques à l’aide de la méthode de Heun, pour des
conditions initiales du genre v = 0 et θ0 = π − ϵ, où ϵ → 0. Calculez le temps T requis pour faire
une oscillation complète, en fonction de ϵ. Utilisez vos résultats pour vérifier que :

lim T → ∞
ϵ→0

Attention : ce problème, comme tous les problèmes de type “stabilité”, est très délicat du point de
vue numérique. Assurez-vous de travailler en double précision.
3. Passons maintenant au pendule amorti, mais non-forcé. Toujours à l’aide de la méthode de Heun,
calculez une séquence de solutions, toutes avec la condition initiale (θ, v) = (3π/4, 0), pour des
valeurs du paramètre d’amortissement β allant de 0.01 à 1.0. Pour chacune de vos solutions, mesurez
le temps T requis pour que l’amplitude d’oscillation chute et demeure sous θ = 10−2 rad. Sur la
base de vos résultats, essayer d’établir la relation mathématique décrivant la variation de T avec
β.
4. Calculez deux solutions au problème du pendule forcé et amorti dans le régime chaotique, utilisant
toutes la même condition initiale et le même pas de temps. Utilisez pour la première la méthode
d’Euler explicite, et pour la seconde la méthode de Heun. Combien de temps s’écoule avant la
décorrélation des deux solutions ?

Bibliographie:

Le chaos est sujet qui a produit une littérature gigantesque et souvent indigeste. Parmi la douzaine de
bouquins techniques que je connais sur le sujet, je recommenderais les deux suivants :
Mullin, T., The Nature of Chaos, Oxford University Press (1993),
Hilborn, R.C., Chaos and Nonliner Dynamics, 2e éd., Oxford University Press (2000).
Parmi la quasi-infinité d’ouvrages à saveur plus philosophique, j’ai bien aimé :
Prigogine, I., Les Lois du Chaos, Flammarion (1994)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

144 CHAPITRE 8. NONLINÉARITÉ ET CHAOS

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 145

Chapitre 9

Marche aléatoire et diffusion

9.1 Les processus stochastiques

Le problème de l’approche à l’équilibre considéré à la §5.5 offre un exemple d’un système physique
dont le comportement est contrôlé par un processus dit stochastique. Bien qu’en principe les collisions
faisant passer les particules par le petit trou puissent se modéliser à l’aide de la mécanique Newtonienne,
en pratique le nombre de particules à suivre, et de collisions à calculer, dépasse de vraiment très loin
tout ce que vous seriez jamais en mesure de calculer même si l’on mettait tous les processeurs du système
ESIBAC à votre disposition pendant une semaine (ou même un million d’années). Souvent, la seule
approche pratique est de simuler le comportement du système pour en extraire des mesures qui, bien que
de nature statistique, n’en sont souvent pas moins d’une grande utilité.
Dans ce chapitre, nous allons nous concentrer sur un processus stochastique prototypique, soit la
marche aléatoire (§9.2). Nous examinerons ensuite le lien profond existant entre la marche aléatoire et
la diffusion (§9.3), un processus physique de grande importance en sciences environnementales. Nous
poursuivrons en examinant une variante de la marche aléatoire, soit la marche sur réseau (§9.4), qui
nous permettra d’aborder les processus d’agrégation (§9.5), prototypiques de l’émergence de structures
cohérentes aux grandes échelles à partir de mécanismes stochastiques opérant aux petites échelles. La
caractérisation des ces structures (§9.6) nous entrainera finalement dans le monde déroutant des structures
fractales (§9.7 et §9.8).

9.2 Marche aléatoire

Dans sa forme la plus simple, la marche aléatoire décrit la variation d’un déplacement Dn suite à une
séquence de n pas sn de longueur constante s mais orientés aléatoirement dans l’espace. Nous considérerons
d’abord ici une version unidimensionnelle de ce processus, où le pas est contraint à s = ±1 le long d’une
droite, chacun des deux pas possibles (s = +1 ou s = −1) étant équiprobable et aucunement influencé par
la valeur du pas précédent. On parle alors d’un processus stochastique sans mémoire. Par exemple,
il est très tard l’après-midi du jour de l’initiation, vous sortez avec difficulté des toilettes et tentez de vous
rendre à Planck ; si les festivités sont suffisamment avancées, un pas dans la direction Est (vers la porte du
D-460) est aussi probable qu’un pas dans la direction Ouest (vers la Planck). Dénotons par sn la valeur
(±1) du n-ième pas, et par Dn le déplacement net fait depuis le premier pas (attention, pas la distance ! la
distance totale parcourue est évidemment n × s, pour un pas de longueur s). On aura de toute évidence :

Dn = Dn−1 + sn , n = 1, 2, 3... (9.1)

Le carré du déplacement net au pas n est donnée par :

Dn2 = (Dn−1 + sn )2 = Dn−1

2
+ s2 + 2Dn−1 sn . (9.2)

Considérons non pas un, mais un ensemble d’étudiant(e)s tentant laborieusement de rejoindre la Planck,
et dénotons par des crochets ⟨...⟩ la moyenne effectuée sur l’ensemble des marcheurs ; ceci s’appelle une

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

146 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

moyenne d’ensemble, et est défini selon

M
1 X
⟨x⟩ = x(m) , (9.3)
M m=1

où x(m) dénote la valeur de la mesure x pour le m-ième membre de l’ensemble, ici de taille M . Donc,
par exemple, ⟨Dn ⟩ représenterait le déplacement moyen du groupe sortant des toilettes. Il s’agit ici d’un
opérateur linéaire, satisfaisant les propriétés :

⟨x + y⟩ = ⟨x⟩ + ⟨y⟩ , ⟨ax⟩ = a⟨x⟩ , (9.4)

où a est un coefficient numérique quelconque. Appliquons cet opérateur à l’éq. (9.2) :

Dn2 = Dn−1
2
+ s2 + 2Dn−1 sn = Dn−1
2
+ s2 + 2⟨Dn−1 sn ⟩ , (9.5)

en vertu de la linéarité de notre opérateur de moyenne d’ensemble. Si la marche est vraiment aléatoire, et
qu’aucune communication n’existe entre les marcheurs leur permettant de synchroniser leurs titubations,
chaque marche est statistiquement indépendante des autres ; autrement dit, l’ensemble des valeurs ±1 du
pas sn pour l’ensemble des marcheurs a la forme d’une distribution discrète pour deux valeurs, +1 et −1,
qui sont équiprobables et ne présentent aucune corrélation avec les Dn−1 , comme l’on s’y attend d’un
processus stochastique sans mémoire. Ceci implique donc que,

⟨Dn−1 sn ⟩ = ⟨Dn−1 ⟩⟨sn ⟩ = 0 . (9.6)

Comprenez bien pourquoi, c’est vital pour tout ce qui suit. L’éq. (9.5) devient alors :

Dn2 = Dn−1
2
+ s2 . (9.7)

Si l’on suppose maintenant que D0 = 0 (i.e., l’origine du système de coordonnées est à la porte des
toilettes), alors on aura :

D12 = s2 , (9.8)
D22 = D12 +s 2 2
= 2s , (9.9)
D32 = D22 2
+ s = 3s ,2
(9.10)
... = ... (9.11)

et donc après n pas :

Dn2 = n s2 . (9.12)

Maintenant, si l’on interprète le décompte n des pas comme une variable temps (genre, un pas chaque trois
secondes), cette expression nous indique que le déplacement quadratique moyen augmente linéairement
avec le temps, d’où :
p √
⟨Dn2 ⟩ = s n . (9.13)

Ceci s’appelle la moyenne quadratique du déplacement. Le point crucial de cette petite analyse est
évidemment l’éq. (9.6) ; ceci est valide pour un processus stochastique sans mémoire et seulement dans
la limite d’un nombre de marcheurs tendant vers l’infini. Et l’infini, c’est un gros chiffre ; beaucoup plus
grand que le nombre d’Avogadro, beaucoup plus grand que le nombre d’atomes d’Hydrogène dans l’univers,
beaucoup plus grand que le plus grand chiffre que vous pouvez possiblement imaginer (surtout qu’il ne
faut qu’y additionner 1 pour en produire un encore plus grand...). Bref, peut-on vraiment s’attendre à ce
que l’éq. (9.13) tienne, et si oui à quel niveau de précision ?
Nous tenterons ici de répondre à cette question en simulant la marche aléatoire unidimensionnelle, ce
qui ne requiert finalement qu’un générateur de nombre aléatoire qu’on force à produire un chiffre égal
à soit +1 ou −1. Le petit code ci-dessous montre comment faire à partir d’un générateur de nombres
aléatoires uniformes dans [0, 1), comme random().

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 9.2. MARCHE ALÉATOIRE 147

Code Python pour marche aléatoire en 1D

1 #Marche aleatoire en 1D: nM marcheurs font nPas pas de longueur
2 #unitaire, et le deplacement quadratique moyen est calcule
3

4 import numpy as np
5

6 nM=100 # nombre de marcheurs

7 nPas=1000 # nombre de pas
8 x=[Link](nM,dtype='int') #positions des marcheurs, initialement a 0
9

10 for j in range(nM): # boucle sur les marcheurs

11 for k in range(nPas): # boucle sur les pas
12 pas=2*round([Link]())-1 # pas de +/- 1
13 x[j]+=pas # Le marcheur j se deplace
14

15 xQuadMoy=(x**2).mean() #calcule la moyenne des valeurs de x**2

16 print("Deplacement quadratique moyen:", xQuadMoy)

Le canevas global du code est simple : une boucle extérieure sur le nombre nM de marcheurs, et une
boucle intérieure calculant les nPas de chacun de ces marcheurs. La seule partie “corsée” est le calcul
d’un pas pouvant valoir soit +1, soit −1. Ceci est effectué à partir du générateur générique random().
Séquentiellement :
1. La fonction random() produit un nombre aléatoire réel distribué uniformément entre 0 et 1 ;
2. La fonction round() arrondi son argument à l’entier le plus près, donc round(random() est un
entier qui vaut soit zéro, soit un, de façon équiprobable ;
3. En conséquence de quoi, 2*round(random())-1 est un entier qui vaut soit −1, soit +1, de manière
équiprobable. Voilà !
La Figure 9.1 montre 10 trajectoires de 104 pas résultant d’une telle marche aléatoire unidimensionnelle,
débutant à x = 0. On peut déjà remarquer que les courbes définissent un genre de “cone” plus ou moins
symétrique par rapport à x = 0 (trait pointillé), et que certains marcheurs réussissent à se retrouver
vraiment pas loin de x = 0 même après 104 pas !
On peut mieux quantifier tout ça en construisant, à chaque pas, la distribution des déplacements as-
sociés à l’ensemble des marcheurs. Ceci est illustré à la Figure 9.2 (histogrammes) pour quatre temps
spécifiques, tel qu’indiqué, les distributions étant construites ici à l’aide de 1000 marcheurs. Les distribu-
tions sont concentrées près de x = 0 au début et s’étalent en x à mesure que le temps s’écoule. Le fait
qu’elles demeurent symétriques par rapport à x = 0 indique que le déplacement moyen ⟨Dn ⟩ est nul !. Le
fait que les distributions demeurent maximales à x = 0 même après un grand nombre de pas indique que
le déplacement le plus probable est toujours zéro !.
Les distributions de la Figure 9.2 ont une allure qui devrait vous rappeler quelque chose... (sinon voir
la Figure 5.7...). Pourrait-il s’agir d’une gaussienne ? bin oui ! les traits minces représentent une série de
fonctions gaussiennes collées aux différents histogrammes en ajustant leur amplitude et déviation standard
(σ dans l’éq. (5.2)) par minimisation du χ2 (effectivement). L’ajustement est excellent dans tous les cas !
Ayant ainsi extrait σ à différents pas de temps, on peut examiner comment σ varie avec t. Ceci est illustré
à la Figure 9.3. Le graphique est ici de type log-log, et dans ce graphique les σ se distribuent parfaitement
le long d’une droite de pente 1/2 ; autrement dit, on peut écrire :

1
log(σ) = b + log(n) = b + log(n1/2 ) , (9.14)
2
d’où
1/2 1/2
10log(σ) = 10b+log(n )
= 10b 10log(n )
, → σ(n) = σ0 n1/2 , (9.15)

avec σ0 ≡ 10b . Ceci implique que, √

collectivement, les marcheurs composant la distribution s’éloignent de
l’origine à une vitesse moyenne ∝ n, en accord avec l’éq. (9.13).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

148 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.1 – Variation en fonction du temps (mesuré en pas n) du déplacement Dn de 10 marcheurs

aléatoires en 1D, débutant tous à x = 0. Bien que plusieurs trajectoires réussissent à s’éloigner de zéro
et “progresser” soit dans les directions positive ou négative le long de l’axe de la marche, plusieurs se
retrouvent très près de zéro même après 104 pas.

Figure 9.2 – Étalement avec le temps (ici représenté par le nombre de pas n) de la distribution (histo-
gramme) des déplacements associés à 1000 marcheurs aléatoires en 1D, débutant tous leur marche à x = 0.
Les traits fins et continus sont des distributions Gaussiennes ajustées aux histogrammes correspondants.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.2. MARCHE ALÉATOIRE 149

Figure 9.3 – Augmentation de la déviation standard de la distribution des déplacements d’un groupe de
en fonction du temps, mesuré ici en nombre de pas n. Le trait pointillé
1000 marcheurs aléatoires en 1D, √
correspond à une dépendance en n collée à la première mesure à n = 100.

Ces résultats ne sont pas du tout restreints à la marche aléatoire en une dimension spatiale. En plus
d’une dimension les déplacement et pas deviennent des quantités vectorielles, et on remplacerait l’éq. (9.1)
par :

Dn = Dn−1 + sn , n = 1, 2, 3... (9.16)

où le pas sn est de longueur unitaire mais est orienté aléatoirement dans l’espace. Le carré du déplacement
au pas n devient :

Dn2 = (Dn−1 + sn ) · (Dn−1 + sn ) = Dn−1

2
+ s2 + 2Dn−1 · sn . (9.17)

Si le pas est vraiment orienté aléatoirement, alors moyenné sur en ensemble de marches aléatoires on aura
⟨Dn−1 · sn ⟩ = 0, ce qui conduit de nouveau directement à :

Dn2 = Dn−1
2
+ s2 . (9.18)

La suite est exactement comme auparavant, et aboutit de nouveau à l’éq. (9.12). C’est une propriété
remarquable de la marche aléatoire : quelle que soit la dimension du problème, le déplacement quadratique
moyen varie toujours comme n1/2 .
Le code ci-haut pour la marche aléatoire en 1D est trivial à modifier pour passer à la marche aléatoire
2D, la boucle intérieure devenant simplement :

ang=2*[Link]*[Link]() # angle entre 0 et 2*pi

x[j]+=[Link](ang) # Le marcheur j se deplace en x
y[j]+=[Link](ang) # Le marcheur j se deplace en y

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

150 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.4 – Les dix-huit premiers pas d’une marche aléatoire en deux dimensions spatiales et débutant
à (x, y) = (0, 0). Le dix-neuvième pas atterrira quelque part sur le cercle de rayon unitaire centré sur la
position au pas 18, mais se fera à un angle dont la valeur est complètement aléatoire et indépendante de
la grandeur et orientation du vecteur-déplacement au dix-huitième pas (segment de droite en rouge).

où x et y sont maintenant des tableaux de type float. Évidemment le déplacement quadratique est
maintenant donné par (x**2+y**2).mean().
La Figure 9.4 montre les quelques premiers pas d’une marche aléatoire en 2D, débutant à (x, y) = (0, 0).
Le trait en tirets indique le vecteur-déplacement net après le dix-huitième pas. Ce vecteur déplacement
sous-tend ici un angle θ18 par rapport à un système de coordonnées cartésiennes dont l’origine est à
(x, y) = (0, 0). Le dix-neuvième pas de la marche fera atterrir notre marcheur quelque part sur le cercle
de rayon unitaire centré sur sa position au dix-huitième pas, à un angle aléatoire dont la valeur mesurée
par rapport à un système cartésien local peut être n’importe quoi entre 0 et 2π. Dénotons la valeur de
cet angle par α19 ; l’angle entre le vecteur-déplacement D18 et le pas s19 sera donc donné par α19 − θ18 ,
et donc on aura :
D18 · s19 = D18 s19 cos(α19 − θ18 ) . (9.19)
À ce stade l’angle θ18 est fixé, donc c’est une constante entre 0 et 2π ; et α19 est aléatoire distribué
uniformément entre 0 et 2π. Donc, et en vertu de la périodicité des fonctions trigonométriques, l’angle
α19 − θ18 sera aussi uniformément distribué entre 0 et 2π, et son cosinus a donc autant de chance d’être
positif que négatif, ce qui assure qu’une moyenne d’ensemble du produit scalaire ci-dessus sera toujours
nulle.
La Figure 9.5 illustre quelques marches aléatoires en 2D, chacune de 100 pas.
p Le cercle tracé a un
rayon égal à la taille du déplacement quadratique moyen attendu, soit ici R = ⟨D100 2 ⟩ = 10s = 10. Ca

colle !

9.3 Diffusion = marche aléatoire

Considérons la variation suivante sur le thème de la marche aléatoire en une dimension spatiale :
chaque marcheur, comme auparavant, fait un pas s = ±1, mais la marche est limitée par deux “murs” à

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.3. DIFFUSION = MARCHE ALÉATOIRE 151

Figure 9.5 – Quatre marches aléatoires de n = 100 pas unitaires, en deux dimensions spatiales.
√ Tous
les
√ marcheurs débutent au point noir au centre, et le cercle correspond à un déplacement D ≡ D·D=
n = 10.

x = 100 et x = −100, et les marcheurs frappant le mur “rebondissent” d’un pas dans la direction opposée.
De plus, choisissons une condition initiale où tous les marcheurs débutent à des positions distribuées de
manière aléatoire mais statistiquement uniformes dans le sous-intervalle −100 < x ≤ 0, soit dans la moitié
gauche du domaine. Tous les marcheurs font leur pas de manière synchronisée dans le temps, mais sinon
de manière totalement découplée l’un de l’autre.
La Figure 9.6 montre une séquence temporelle d’histogrammes décrivant la distribution des positions
des marcheurs à mesure que la marche aléatoire progresse. La distribution, initialement très raide à x = 0,
s’étale graduellement avec le temps, mesuré en pas de marche aléatoire. Cet étalement résulte du fait
que plus de marcheurs traversent de la moitié gauche du domaine vers la moitié droite que dans le sens
inverse, en raison du simple fait qu’il y a initialement beaucoup plus de marcheurs du coté gauche. Ce
n’est que lorsqu’il y aura autant de marcheurs de chaque coté de x = 0 que le système pourra devenir
statistiquement stationnaire.
La Figure 9.7 montre l’évolution en fonction du temps du nombre de marcheurs situés dans les in-
tervalles [−100, 0] (trait noir) et [0, +100] (trait gris). Au début de la simulation le premier diminue
rapidement tandis que le second augmente évidemment tout aussi rapidement puisque leur somme doit
demeurer constante (ici 1000 marcheurs). Après quelques dizaines de milliers d’itérations, les nombres de
marcheurs de chaque coté de x = 0 sont devenus essentiellement égaux, mis à part des petites fluctuations
par rapport à la valeur moyenne (500 marcheurs). J’espère que vous commencez à voir une similitude
avec la situation considérée à la §5.5 dans le contexte de notre modélisation Monte Carlo de l’approche à
l’équilibre... et que vous pouvez conséquemment anticiper que si la simulation était effectuée avec un plus
grand nombre de marcheurs, ces fluctuations diminueraient d’un facteur proportionnel à la racine carrée
du nombre total de marcheurs...
Cet étalement graduel d’une concentration de “particules” décrivant chacune une marche aléatoire est
représentatif des processus dits de diffusion. Ce terme a déjà été introduit à la §5.5 dans le contexte de
notre discussion de l’approche à l’équilibre d’un système de deux boites contiguës communiquant via un
petit trou. On y avait mentionné que ce qui fait que des particules réussissent à traverser d’une boite à
l’autre, ce sont les fréquentes collisions inter-particules et/ou avec les parois des boites.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

152 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.6 – Évolution temporelle de la distribution de 30000 marcheurs aléatoires 1D confinés à

l’intervalle [−100 ≤ x ≤ +100], et initialement tous localisés aléatoirement dans le sous-intervalle
[−100 ≤ x ≤ 0]. Les lignes verticales le long de l’abscisse indiquent la position moyenne des marcheurs au
temps correspondant, tel que codé par la couleur du trait.

Comment réconcilier cet énoncé avec le fait que dans notre discussion de la marche aléatoire à date,
les marcheurs se déplacent complètement indépendamment les uns des autres, i.e., sans collisions ou
autres interactions ? Il faut revenir à l’image facétieuse des molécules de Brut 45 Magnum répandant
leur odeur dans une pièce ; si les molécules nauséabondes diffusent dans la pièce, c’est par une forme de
marche aléatoire où la direction de chaque pas est déterminée par les aléas des collisions inter-particules,
leur longueur par la distance interparticule moyenne dans la pièce, et la durée du pas par le temps moyen
s’écoulant entre deux collisions successives. Mais, et c’est là la clef de notre paradoxe apparent, puisque les
molécules d’air (essentiellement N2 et O2 ) sont beaucoup plus nombreuses que celles de Brut 45 Magnum
(heureusement d’ailleurs), ces dernières feront des collisions presqu’uniquement avec O2 ou N2 , et presque
jamais avec une autre molécule de Brut 45. Donc la marche aléatoire de chaque molécule de Brut est
complètement découplée des autres. On dirait ici du Brut 45 Magnum qu’il est un contaminant trace
diffusant dans l’air (Voir aussi Figure 9.8).
Revenons à notre marche aléatoire en 1D confinée à l’intervalle −100 ≤ x ≤ 100 (Figs. 9.6 et 9.7).
Examinons ce qui se passe à une position x0 quelconque ; seules les particules situées dans l’intervalle
x0 − |s| < x < x0 + |s| ont une chance de traverser x au prochain pas de marche, mais seulement si le
pas se fait dans la bonne direction (s = +1 pour les particules situées dans x0 − |s| < x < x0 , et s = −1
pour celles dans dans x0 < x < x0 + |s|). Pour des directions équiprobables, la moitié des particules dans
chaque intervalle feront ce pas dans la “bonne” direction. Donc le nombre net δN de particules traversant
la position x0 vers la droite sera donné par quelque chose comme
1 1
δN (x0 ) = N (x0 − |s|) − N (x0 + |s|) . (9.20)
2 2
Considérons maintenant l’intervalle x0 − |s| < x < x0 + |s| dans son ensemble, et dénotons par N (x0 , t)

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.3. DIFFUSION = MARCHE ALÉATOIRE 153

Figure 9.7 – Variation temporelle du nombre de marcheurs situés dans la région x < 0 (trait noir) et
x > 0 (trait gris). Pas besoin de l’oeil du lynx pour deviner ici une tendance exponentielle vers un état
d’équilibre ou les marcheur sont distribués uniformément en fonction de x, et où leurs nombres de chaque
coté de x = 0 deviennent égaux, à quelques fluctuations statistiques près (et qui décroitront comme la
racine carrée du nombre de marcheur, comme vous l’aurez déjà deviné). Ne manquez pas de comparer
ceci à la Fig. 5.10.

le nombre de particules contenues dans cet intervalle au temps t. Le nombre au temps t + ∆t sera donné
par le nombre au temps t plus ce qui est entré du coté gauche (à x0 − |s|) moins ce qui est sorti du coté
droit (à x0 + |s|). Évaluant l’éq. (9.20) à x0 − |s| et x0 + |s|, on arrive à :

N (x, t + ∆t) = N (x, t) + δN (x − s) − δN (x + s)

   
1 1 1 1
= N (x, t) + N (x − 2s) − N (x) − N (x) − N (x + 2s)
2 2 2 2
1
= N (x, t) + (N (x + 2s) − 2N (x) + N (x − 2s)) , (9.21)
2
où on largué l’indice “0” sur le x et la valeur absolue sur s afin d’alléger la notation. Divisant les membres
de gauche et de droite par ∆t, on peut réécrire cette expression sous la forme équivalente :

(2s)2
   
N (x, t + ∆t) − N (x, t) 1 N (x + 2s) − 2N (x) + N (x − 2s)
= × . (9.22)
∆t 2 ∆t (2s)2

La seconde parenthèse au membre de droite ressemble à quelque chose que vous avez déjà vu au chapitre
2, soit une formule de différence finie centrée pour la dérivée seconde par rapport à x pour un pas spatial
h ≡ 2s (voir l’éq. (4.16)), tandis que le membre de gauche ressemble tout autant à une formule de différence
finie avant pour la dérivée temporelle, pour un pas temporel h ≡ ∆t (voir l’éq. (4.12)). Si l’on accepte
ces interprétations, l’éq. (9.22) représenterait alors une discrétisation par différences finies de l’équation

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

154 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.8 – Représentation schématique d’un fluide à deux composantes, ici des molécules d’air (com-
posante 1, en gris) et de Brut 45 Magnum (composante 2, en noir), vu ici à l’échelle microscopique.
La composante (2) agit comme un contaminant trace en autant que son nombre de particules N (2)
est ≪ N (1) ; dans une telle situation, les paramètres thermodynamiques du gaz (densité, température,
pression, etc.) sont complètement déterminés par la composante 1, et la diffusion de la composante 2
s’apparente à une marche aléatoire où les collisions avec la composante 1 réorientent aléatoirement la
direction de déplacement des constituants microscopiques de la composante 2.

différentielle suivante :
∂N (x, t) ∂ 2 N (x, t)
=D , (9.23)
∂t ∂x2
où on a défini le coefficient numérique,

1 (2s)2
D= , (9.24)
2 ∆t
qu’on appelle coefficient de diffusion. C’est une quantité qui mesure le taux auquel se disperse le
contaminant trace dans le milieu ambiant ; remarquez que D varie comme s2 /∆t, donc un gaz peu dense
(grande distance interparticule) conduira à une diffusion plus rapide. De même, dans un gaz chaud les
constituants microscopiques se déplacent plus rapidement, et donc (à densité égale) le temps inter-collisions
est plus court, ce qui nous ferait prédire que D augmente avec la température. Ces deux attentes s’avèrent
conformes à l’expérience. L’équation (9.23) est le prototype d’une équation de diffusion, qui s’avère
décrire autant le transport de chaleur par conduction que la diffusion de polluants. Ceux et celles qui
choisiront de suivre PHY-3140 auront l’occasion de traiter ces sujets en plus de profondeur.
Si on accepte que l’éq. (9.23) est une représentation continue valide de notre problème de marche
aléatoire en 1D contrainte, alors on devrait pouvoir solutionner directement cette équation et retomber
sur les mêmes résultats. Vérifions donc ça. L’idée générale est la même qu’au chapitre 7, c’est-à-dire qu’on
introduit des formules de différences finies pour approximer les dérivées sur un maillage. On a cependant
ici affaire à une équation aux dérivées partielles, où la variable dépendante N (x, t) dépend de deux
variables indépendantes, ici x et t. On a donc deux maillages distincts à définir, soir un pour la dérivée
temporelle au membre de gauche de l’éq. (9.23), et un maillage spatial pour la dérivée seconde en x au
membre de droite :

tm+1 = tm + ∆t , m = 0, 1, 2, ... , (9.25)

xk+1 = xk + ∆x , k = 0, 1, 2, ... . (9.26)

On associe alors à ces maillages la discrétisation,

Nkm ≡ N (xk , tm ) , (9.27)

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.3. DIFFUSION = MARCHE ALÉATOIRE 155

où l’indice temporel m est placé en exposant pour bien le distinguer de l’indice spatial. Il ne reste plus
qu’à introduire une différence finie avant pour la dérivée temporelle évaluées à xk , et une différence centrée
pour la dérivée spatiale évaluée au temps tm :
Nkm+1 − Nkm N m − 2Nkm + Nk−1
m
= D k+1 , (9.28)
∆t (∆x)2
ce qui conduit immédiatement à l’algorithme explicite :
 m
Nk+1 − 2Nkm + Nk−1
m 
Nkm+1 = Nkm + D∆t . (9.29)
(∆x)2
Cet algorithme est l’équivalent direct de la méthode d’Euler explicite considérée à la §7.2, dans le sens
que le membre de droite est évalué à tk , et est donc supposé “connu”, soit du pas de temps précédent soit
à partir de la condition initiale.
Considérons maintenant les conditions initiales et limites suivantes :
(
1 x≤0
N (x, t = 0) = (9.30)
0 x>0

∂N ∂N
= =0, (9.31)
∂x x=−100 ∂x x=+100
qui devraient encore éveiller en vous un certain sentiment de déjà vu... La Figure 9.9 montre une solution
numérique à ce problème, avec ∆x = 1, ∆t = 0.25, et D = 2. Comparez maintenant ceci à la Figure 9.6.
La solution a été tracée aux même temps équivalents, et avec le même code de couleur pour les différents
traits. L’accord est excellent ! Il est clair que l’éq. (9.23) est une excellente représentation de la marche
aléatoire en 1D, dans la limite d’un nombre de marcheurs tendant vers l’infini.
Il faut remarquer comment le coefficient de diffusion a été calculé ici ; dans l’éq. (9.24), le pas de temps
∆t correspond à un pas de la marche, qui définit en quelque sorte notre unité de temps ; et la quantité s
mesure effectivement notre unité de longueur. Donc, dans ces unités, le coefficient de diffusion doit valoir
D = 2. C’est donc la valeur utilisée pour le calcul de la solution de la Figure 9.9. Rendu au stade de la
discrétisation numérique de l’éq. (9.23), on doit choisir un pas spatial et temporel pour la discrétisation,
qui n’ont aucune raison particulière d’être identiques aux “unités naturelles” de la marche aléatoire. En
fait, du point de vue strictement numérique, dans le cas d’une équation aux dérivées partielles de type
diffusion, comme l’éq. (9.23), on peut montrer que le pas de discrétisation temporel doit satisfaire au
critère :
(∆x)2
∆t ≤ (∆t)C ≡ , (9.32)
D
afin de garantir la stabilité numérique de l’algorithme d’Euler explicite, pour un pas de discrétisation
spatiale ∆x. La dérivation de ce critère (appelé critère de Courant) est un superbe exercice en analyse
numérique, mais qui dépasse les bornes de ce cours, donc prenons simplement pour acquis qu’il doit être
satisfait. Ici, avec ∆x = 1 et D = 2 on a (∆t)C = 0.5, donc la solution de la Figure 9.9, avec ∆t = 0.25
satisfait le critère de Courant par un facteur deux. Prendre un pas de discrétisation spatiale ∆x plus grand
rend le critère moins contraignant sur la taille du pas de temps, mais on risque alors de perdreau niveau
de la précision à laquelle est discrétisée la dérivée seconde au membre de droite de l’éq. (9.23). Comme
diraient nos collègues anglophones, “there is no such thing as a free lunch”...
Le critère de Courant est un truc à prendre au sérieux. La Figure 9.10 montre ce qui se passe quand
on ne le fait pas. Il s’agit d’une simulation en tout point identique à celle de la Figure 9.9, sauf que cette
fois le pas de temps ∆t = 0.6 a été choisi légèrement plus grand que la grandeur limite (∆t)C = 0.5
dictée par le critère de Courant. Les profils de N (x, t) portés en graphique couvrent ici seulement les
premiers cinq pas de temps. On y note une oscillation noeud-à-noeud se développant rapidement autour
de la position de la discontinuité initiale à x = 0. Ces oscillations gagnent en amplitude avec le temps, et
se propagent dans les directions gauche et droite du domaine, à une “vitesse” d’un point de maille spatiale
par pas de temps. Donc, après seulement 100 pas de temps, la solution est complètement polluée par cette
instabilité numérique. On pourrait croire que le problème est causé par la discontinuité dans la condition
initiale utilisée ici, mais ce n’est pas le cas ; un profil raide mais lisse (comme la fonction arctangente,
par exemple) deviendra rapidement instable lui aussi. L’instabilité est directement associée au fait que le
membre de droite de l’éq. (9.23) est évalué de manière complètement explicite, soit au pas de temps m
(cf. l’algorithme (9.29)).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

156 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.9 – Solution numérique de l’équation de diffusion (9.23) avec les conditions initiale et limites
données par les équations (9.30)—(9.31), avec ∆x = 1 et ∆t = 0.25.

Figure 9.10 – Une solution au même problème de diffusion que ci-dessus, mais cette fois pour seulement
les cinq premiers pas de temps et en zoom sur la région [−10 ≤ x ≤ 10] chevauchant la discontinuité dans
le profil initial de N (x, t). Cette solution est en tout point identique à celle ci-dessus, sauf pour l’utilisation
d’un pas de temps ∆t = 0.6.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.4. MARCHE ALÉATOIRE SUR RÉSEAU 157

Figure 9.11 – Les dix-huit premiers pas d’une marche aléatoire sur réseau en deux dimensions spatiales
et débutant à (x, y) = (0, 0). Le dix-neuvième pas atterrira sur l’un des 4 sites indiqués par un cercle,
mais le site choisi l’est de manière complètement aléatoire et indépendante de la grandeur et orientation
du vecteur-déplacement au dix-huitième pas (voir texte). Comparez cette Figure à la Figure 9.4 pour la
marche aléatoire classique en 2D.

9.4 Marche aléatoire sur réseau

La marche aléatoire sur réseau (en anglais : lattice random walk) est une variation sur le thème
de la marche aléatoire qui permet d’incorporer une forme simple d’interaction entre marcheurs. L’idée de
base est illustrée à la Figure 9.11, pour une marche sur réseau bidimensionnel de type cartésien débutant
à (0, 0). Le marcheur ne peut qu’occuper les sites discrets (xi , yj ) (aux intersection des traits pointillés
sur la Fig. 9.11). Plutôt que de se déplacer dans des directions arbitraires comme dans le cas de la
marche aléatoire classique, le marcheur ne peut bouger qu’à un des sites se trouvant dans son voisinage
immédiat, haut-bas-droite-gauche, et celui des 4 sites voisins qui sera la cible du déplacement est choisi
aléatoirement. Ceci peut sembler une forme extrêmement contraignante de marche aléatoire, mais vous
aurez l’occasion de coder et expérimenter avec ce type de marche aléatoire sur réseau 2D au Labo 9, et
d’évaluer les similarités et différences avec la marche aléatoire classique en 2D discutée précédemment. En
particulier, vous constaterez (si tout va bien) qu’après un grand nombre de pas, l’orientation et la grandeur
du vecteur-déplacement Dn est distribuée de manière essentiellement identique à la marche aléatoire 2D
classique.
Tout l’attrait de la marche sur réseau réside en des situations où plusieurs marcheurs se déplacent
simultanément sur le réseau, tel qu’illustré sur la Figure 9.12. Typiquement, en tout temps, seule une
petite fraction des sites est occupée par les marcheurs (points noirs). Ces derniers ne peuvent encore que
bouger à un des sites se trouvant dans leur voisinage immédiat, haut-bas-droite-gauche (indiqués sur la
Figure par des cercles pour quelques marcheurs), avec le site-cible choisi aléatoirement, mais le pas n’est
effectué que si le site-cible est inoccupé, sinon le marcheur reste sur son site jusqu’à la prochaine itération
temporelle. Quelques exemples de pas permis sont indiqués par un trait vert sur la Figure 9.12.
Le fait qu’un marcheur ne puisse bouger à un site voisin occupé représente une forme très simplifiée de
“collision”, puisque, statistiquement, deux marcheurs voisins tentant de se croiser se verront stoppés, et
tendront même à être “réfléchis” dans des directions opposées. Bien que la restriction géométrique imposée

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

158 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.12 – Géométrie et règles de déplacement pour la marche aléatoire sur réseau, ici un réseau
cartésien régulier de dimensions 20×20 contenant 50 marcheurs distribués aléatoirement. Les déplacements
aux sites voisins (cercles, indiqués ici pour un sous-ensemble de 6 particules) ne sont permis (traits verts)
que si le site-cible est inoccupé.

aux déplacements puisse sembler nous éloigner de la “réalité”, les pseudo-collisions qu’elle incorpore au
processus de marche tend à nous en rapprocher. Lequel des deux types de marche aléatoire est à préférer
dépendra souvent du type de problème physique que vous désirez examiner, comme l’illustre l’exemple
discuté à la section qui suit.

9.5 Agrégation
La marche aléatoire sur réseau est particulièrement appropriée pour l’étude des phénomènes d’agré-
gation. On débute avec un grand nombre de particules distribuées de manière aléatoire mais statistique-
ment uniforme sur le réseau, et effectuant chacune leur petite marche aléatoire comme expliqué à la §9.4.
Quelque part dans le réseau, on introduit une ou plusieurs particules fixes spatialement et “collantes”, dans
le sens que les particules venant à occuper un site voisin stoppent leur mouvement, et deviennent collantes
à leur tour. Ceci conduira, au fil du temps, à une agrégation de particules se collant successivement aux
particules-germes. Ça, on s’en serait bien douté ; mais on n’aurait guère anticipé les formes des agrégats
résultant de ce processus dit d’agrégation limitée par la diffusion (“diffusion-limited aggregation” en
anglais, abbrévié DLA).
La Figure 9.13 montre un exemple spécifique, où l’agrégation débute à partir d’une seule particule-
germe, située ici au centre d’un réseau cartésien de taille 1024 × 1024. L’agrégation implique ici 2 ×
104 particules initialement distribuées aléatoirement sur le réseau. Les couleurs encodent l’ordre dans
lequel les particules ont été capturées par le germe ; examinez bien l’échelle de couleur, et constatez qu’à
n’importe quel stade de la croissance de la structure, cette croissance s’opère selon une série de captures
et branchements successifs se produisant presque toujours aux extrémités de branches déjà existantes.
La formation de structure de type dendritique s’explique par le fait que la moindre aspérité se formant
par hasard sur l’agrégat en croissance tend à “capturer” plus de particules que les surfaces planes. Ceci
est illustré sur la Figure 9.14. Sur un réseau (cartésien), il n’y qu’une manière de toucher une surface

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.5. AGRÉGATION 159

Figure 9.13 – Formation d’une structure dentritique à partir d’un germe central, par agrégation limitée
par la diffusion. Simulation basée sur la marche aléatoire de 20000 particules sur réseau 2D cartésien
(§9.4), ici de dimensions 1024 × 1024. Les couleurs indiquent l’ordre dans lequel les particules se sont
collées sur la structure : le rouge correspond aux premières 103 particules, l’orange aux 103 suivantes, et
ainsi de suite selon le code de couleur détaillé à droite du diagramme.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

160 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.14 – Agrégation (A) sur une “surface” plane, et (B) sur une aspérité. Les points rouges reliés
par un trait indiquent les particules fixes, et les cercles rouges les sites où pourraient potentiellement
se coller une particule mobile. Dans la situation en (A), chaque particule fixe ne contrôle qu’un site de
capture (pointillé rouge), qui n’est lui-même accessible que du site situé au dessus (flèche noire). En (B)
cependant, la particule située à l’extrémité de l’aspérité contrôle cinq sites de capture, qui collectivement
peuvent être atteints par 7 pas distincts. Notons également que les deux sites indiqués par des cercles
noirs sont devenus inaccessibles aux particules mobiles, qui se colleraient à la structure avant de pouvoir
y parvenir.

plane (un pas perpendiculaire à et dirigé vers la surface ; voir Figure 9.14A), tandis qu’une aspérité peut
être habituellement atteinte de plusieurs directions. (voir Figure 9.14B). De plus, une fois deux dendrites
plus ou moins parallèles formées, l’espace entre les deux sera difficile à remplir, puisque les particules
exécutant une marche aléatoire entre les dendrites auront une plus grande probabilité de se coller à une
des dendrites qu’à atteindre leur point de branchement. Dans certains cas, comme sur la Figure 9.14B,
les sites voisins du point de branchement peuvent même devenir carrément inaccessibles. Ces effets jouent
tous dans le même sens : croissance et branchements successifs des structures dendritiques, plutôt que
remplissage homogène du volume.

La structure dendritique résultant du processus d’agrégation est visuellement spectaculaire, et de plus,

comme on le verra plus loin, possède des caractéristiques géométriques assez particulières, notamment une
invariance d’échelle. D’un point de vue strictement visuel, sa forme peut rappeler l’arborescence des
dendrites neuronales, les racines de plantes, ou les branches d’un bassin hydrographique, mais il n’y a en fait
aucun lien physique puisque ces structures naturelles ne se forment pas par agrégation. D’autres systèmes
physiques, cependant, résultent de tels phénomènes. Les cristaux de givres se formant sur une surface
plane croissent souvent à partir d’une petite irrégularité sur laquelle des molécules de H2 O diffusant sur la
surface viennent s’agglutiner. De même, les grains de poussière interplanétaire et interstellaire se forment
par agrégation de plus petits grains entrant en collision ; leur forme révèle d’ailleurs assez clairement cette
origine (voir Fig. 9.15). Et dans un air saturé en vapeur d’eau et subissant un refroidissement, les cristaux
de neiges se forment habituellement par agrégation des molécules de H2 O sur un petit grain de poussière...
parfois d’origine interplanétaire ! (voir Fig. 9.16). Ici la structure moléculaire de H2 O limite l’agrégation
d’une molécule sur une autre à des angles très spécifiques, ce qui explique la remarquable régularité
géométrique du flocon (comparé à l’agrégat beaucoup plus irrégulier de la Figure 9.13, par exemple), mais
le principe est le même. En particulier, la moindre aspérité se formant le long d’une aiguille cristalline
devient un site de capture plus probable, et donc tend à croitre.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.6. L’INVARIANCE D’ÉCHELLE 161

Figure 9.15 – Photographies au microscope électronique d’un grain de poussière interplanétaire. Image
extraite de [Link]/[Link].

9.6 L’invariance d’échelle

Revenons à notre agrégat de la Figure 9.13. On a vu (cf. Fig. 9.14) que sa croissance dendritique est
favorisée par le fait que les aspérités ont une plus haute probabilité de capturer des particules libres, que
les particules fixes formant les troncs des structures dendritiques. Le même raisonnement peut s’appliquer
à un tronc dendritique dans son ensemble ; plus un tronc contient de branches et sous-branches, plus
il est efficace dans la capture de particules libres se déplaçant aléatoirement sur le réseau. Le taux de
croissance (et de branchement) d’une dendrite augmente donc avec sa taille, même si à l’échelle locale du
réseau, le processus de capture implique toujours une particule mobile pénétrant le voisinage immédiat
d’une particule fixe. Cette propriété conduit à une invariance d’échelle dans l’agrégat. Ceci est illustré à
la Figure 9.17, qui montre deux zooms successifs, chacun par un facteur 4, de l’agrégat. Examinez bien les
deux zooms. Les patrons de branchements (l’allure visuelle générale des dendrites, ou encore la probabilité
de branchement en se déplaçant le long d’un tronc, la distribution des longueurs de branches secondaires,
etc.) sont les mêmes aux trois échelles spatiales représentées ici. Cette invariance d’échelle, parfois aussi
appelée autosimilarité, est une conséquence directe de l’absence d’échelle caractéristique dans le processus
dynamique (ici l’agrégation) étant responsable de la formation de la structure.

9.7 Les fractales et leur mesure

Les formes géométriques présentant une invariance d’échelle sont souvent caractérisées comme étant des
fractales. Nous allons clore ce chapitre en examinant de plus près —et en formalisant mathématiquement—
ce concept.
Retournez lire la citation de Galilée servant d’ouverture au chapitre 1. Si vous êtes convaincu(e) par
son savant discours essayez ensuite d’aller me construire une coquille d’escargot en blocs Lego, et repensez-
y bien. Un moteur de voiture démonté peut se réduire à une collection de cylindres, plaques d’épaisseur
diverses, hexagones troués et autres “figures géométriques” simples ou combinés. Il en va ainsi de la plupart
des constructions technologiques. Mais, comme l’a si bien exprimé Benoit Mandelbrot,
“Les montagnes ne sont pas des cônes, les nuages ne sont pas des sphères, les arbres ne sont
pas des cylindres, et la foudre ne voyage pas en ligne droite”.

Accrochez vos tuques avec de la broche, vous vous apprêtez à franchir la ligne séparant l’idéalisation
physique de la réalité. La nature regorge de structures ayant des formes qui s’avèrent difficile à catégoriser
à l’aide de la géométrie Euclidienne si chère à Galilée (et bien d’autres avant et après lui). Comment
décrire mathématiquement de telles structures ? Notre réponse à cette question débutera par un exemple
géométriquement simple (à prime abord) mais mathématiquement plus que surprenant.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

162 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.16 – Photographies de flocons de neige s’étant formés sous des conditions d’humidité et
température différant légèrement. Notons ici que même si l’agrégation se produit dans l’espace à
trois dimensions spatiales, l’agrégat produit est une structure bi-dimensionnelle. Ces images sont ti-
rées de la magnifique collection de photographies de flocons de neige qui se trouve sur le site Web
[Link]/snow-crystals/English_index.html.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.7. LES FRACTALES ET LEUR MESURE 163

Figure 9.17 – Invariance d’échelle dans l’agrégat de la Figure 9.13. Les deux zooms successifs représentent
chacun un agrandissement par un facteur 4. Ce n’est ici qu’au second zoom que l’on peut commencer à dis-
tinguer que cette simulation est faite sur réseau, via le fait que les particules ne collent qu’horizontalement,
verticalement, ou à 45 degrés les unes des autres.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

164 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Considérons la construction géométrique itérative illustrée à la Figure 9.18. On débute avec un germe
ayant la forme d’un segment de droite de longueur unitaire (à n = 0 sur la Figure 9.18). On subdivise
maintenant ce segment en trois sections de longueur égales, et l’on élève un triangle équilatéral dans la
section centrale ; la courbe n = 1 montre le résultat de cette opération. Puis, on répète ce processus avec
chacun des quatre segments composant la figure n = 1, ce qui conduit à la figure n = 2 ; et ainsi de suite
pour n = 3, n = 4, etc, comme sur la Fig. 9.18 (qui ne se rend que jusqu’à n = 6). La courbe résultant
de ce processus dans la limite n → ∞ s’appelle la fractale de Koch. Avec un germe ayant la forme d’un
triangle équilatéral, on obtient quelque chose qui ressemble fort à un flocon de neige...
La fractale de Koch ne pourrait être qu’une jolie forme géométrique, mais cette courbe s’avère avoir des
propriétés mathématiques intrigantes, pour ne pas dire déroutantes. Le processus de génération implique
que le nombre de segments augmente d’un facteur 4 à chaque étape du processus. Par contre la longueur
de chacun de ces segments diminue d’un facteur 3. Donc, la longueur totale L(n) de la courbe à l’itération
n sera donnée par une expression du genre :
 n
n n 4
L(n) = 4 × (1/3) = . (9.33)
3
Puisque 4/3 > 1, on a clairement que la longueur de la courbe tend vers l’infini à mesure que n augmente :
lim L(n) → ∞ . (9.34)
n→∞

À examiner les longueurs des 6 premières itérations de la fractale de Koch sur la Figure 9.18, cette
augmentation peut paraitre lente, mais je vous laisse vérifier qu’à partir d’un germe de L = 3 centimètres,
déjà à n = 100 la fractale de Koch “dépliée” a une longueur suffisante pour faire le tour de la Terre 4000
fois environ.
Ce qui est remarquable ici est que du point de vue du plan de la feuille, la fractale de Koch, de longueur
infinie, a un début et une fin bien définis, soit les deux extrémités du segment de droite définissant le germe.
Comment une ligne de longueur infinie peut-elle avoir un début et une fin ? et de surcroit s’emboiter sans
problème à l’intérieur d’un périmètre de longueur finie, e.g., un rectangle. C’est déjà bizarre, mais il faut
de plus noter que cette courbe de longueur infinie ne “remplit” que très peu le rectangle. Quid ?
Helge von Koch (1870–1924) était un mathématicien diplômé et respecté, qui s’amusait dans ses temps
libres à découvrir ce qu’il appelait lui-même ses “monstres mathématiques”. La plupart de ses contempo-
rains ont jugé ses découvertes quelque part entre “amusantes” et “intéressantes”, mais disons qu’on en est
resté bien loin du prix Nobel... C’est le météorologue Lewis Fry Richardson (1881-1953) qui a le premier
montré, initialement par inadvertance et apparemment sans rien connaitre des monstres mathématiques
de Koch, que certaines structures naturelles avaient des propriétés semblables. Richardson s’intéressait
à la mesure de la longueur des côtes de sa mère-patrie l’Angleterre. Ayant judicieusement déduit qu’il
n’avait qu’à mesurer la longueur de la courbe de niveau d’altitude zéro sur une carte topographique, il
se lança dans ce processus pour arriver à un résultat en toute apparence raisonnable. Notoirement futé
et pionnier de l’approche “think different”, Richardson avait cependant très bien réalisé que son résultat
sous-estimait la longueur réelle des côtes, puisque à l’échelle de sa carte de toute l’Angleterre plusieurs
petites irrégularités, estuaires de petits cours d’eau, etc, n’étaient pas visibles. Il eu donc la géniale idée de
reprendre le processus sur une section des côtes à l’aide d’une carte à plus petite échelle, afin de calculer
un facteur de correction à appliquer à sa mesure. Ce facteur s’avérant substantiel, Richardson répéta le
processus avec une carte d’encore plus petite échelle, pour trouver un facteur de correction encore plus
grand, sans aucune indication de “convergence”. Tout comme la fractale de Koch, les côtes de l’Angle-
terre représentent une ligne ici de toute évidence fermée, mais néanmoins de longueur infinie et pouvant
s’emboiter dans un rectangle de taille finie (e.g., une carte topo de l’Europe).
Géométriquement parlant, la fractale de Koch et la courbe de niveau décrivant les côtes de l’Angleterre
sont “plus” qu’une ligne, mais “moins” qu’une surface ; autrement dit, ce sont des objets géométriques
auxquels on devrait assigner une dimension entre un et deux, soit une dimension fractionnaire (d’où
l’origine du terme “fractale”). Mais comment quantifier ceci ? La solution se trouve dans la mesure de
l’objet, et suit essentiellement la logique de Richardson.

9.8 La dimension fractale

L’idée sous-jacente à la mesure géométrique de la dimensionalité d’un objet s’illustre le plus facilement
en commençant par un exemple simple, soit les deux “objets” illustrés à la Figure 9.19. En anticipation

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.8. LA DIMENSION FRACTALE 165

Figure 9.18 – Les 6 premières étapes de la génération de la fractale de Koch. Le germe (n = 0) est un
segment de droite [0, 1], et à chaque étape le tier central est remplacé par un triangle équilatéral pointant
vers le coté “extérieur” de la structure. L’image du bas est un zoom par un facteur 27 de la petite région
délimitée par le tout petit cadre rouge, à peine visible, au sommet de la courbe de l’itération n = 6 ; notez
comment ce zoom est identique à la structure à l’itération n = 3. La longueur L à chaque itération est
également indiquée.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

166 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.19 – Deux objets géométriques simples, tous deux composés au niveau microscopique d’un
agrégat de “particules”. Le premier est une structure linéaire (i.e., à une dimension spatiale), tandis que
le second est une structure à deux dimensions spatiales, ici un carré. On définit ici une masse M (R), en
fonction du rayon R, comme étant le nombre de particules contenues à l’intérieur d’un cercle de rayon R
centré sur l’objet (voir texte).

à ce qui suivra, ces objets sont considérés comme étant formés d’un certain nombre de “particules” ou
composantes microscopiques (points rouges). Mais à une échelle spatiale beaucoup plus grande que la
taille de ces particules et que la distance-interparticules, l’objet en (A) est une ligne, tandis que celui en
(B) est un carré.
Pour identifier la position d’une particule composant l’objet en (A), on n’a besoin que d’une seule
coordonnée, par exemple la distance depuis un des bouts de la ligne ; et pour celui en (B), on aurait
besoin de deux coordonnées, par exemple mesurées dans les directions horizontale et verticale à partir du
coin inférieur gauche du carré. On dit donc que la ligne est un objet de dimension un, tandis que le carré
est un objet de dimension deux. Mais cette définition “paramétrique” de la dimensionalité est incomplète
à bien des points de vues ; par exemple, chaque particule composant l’agrégat de la Figure Fig. 9.13 peut
être localisée à l’aide de deux coordonnées (cartésiennes ou autres), donc on dirait aussi de cet objet
qu’il est de dimension deux. Du point de vue géométrique cependant, cet agrégat est fondamentalement
différent d’un carré, et cette différence se doit d’être quantifiée.
Considérons la procédure suivante : à partir du centre géométrique de chacun des deux objets, on trace
une série de cercles de rayons R croissants (voir Figure 9.19). Pour chacun de ces cercles, on calcule la
“masse” M (R), soit le nombre de particules contenues à l’intérieur de chaque cercle. Il est clair ici que
dans le cas de la ligne, ce nombre croitra linéairement avec R, tandis que dans le cas du carré on aura
M ∝ R2 , et ce tant que le diamètre du cercle demeure plus petit que la taille de chaque objet. C’est en effet
ce qu’on mesure, comme le montre la Figure 9.20. Ce graphique est tracé avec des axes logarithmiques,
donc une droite de pente D indique une relation mathématique entre M et R dite en Loi de puissance,
soit :

M ∝ RD , D≥0. (9.35)

Dans le cas de la ligne, on a D = 1, mais D = 2 pour le carré. On voit bien ici que pour des objets
géométriquement simples, D correspond à la dimension habituelle de l’objet.
Il est facile d’appliquer la même procédure de calcul à notre agrégat DLA de la Figure 9.13. La Figure
9.21 en montre le résultat. La masse M varie toujours avec R selon une loi de puissance (éq. (9.35)).
Comme auparavant cette loi de puissance ne tient que pour des échelle spatiales plus petites que la taille
de l’objet, mais passablement plus grande que la distance inter-particules. Mais cette fois-ci la pente
logarithmique est D = 1.66 ; bien que l’agrégat soit défini dans un plan 2D, sa structure a une dimension

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.8. LA DIMENSION FRACTALE 167

Figure 9.20 – Relation masse–rayon pour les deux objets géométriques simples de la Figure 9.19. Une
pente logarithmique de +1 correspond ici à une dimension D = 1 (objet à une dimension spatiale), tandis
qu’une pente de +2 indique D = 2 (objet bi-dimensionnel), comme on s’y serait attendu à voir la Figure
9.19. Dans les deux cas les mesures (points noirs) “décrochent” de la droite quand R devient comparable
à la grandeur de l’objet.

entre un et deux. L’agrégat est donc “plus” qu’une ligne, mais “moins” qu’une surface. C’est une structure
fractale. On doit remarquer que pour obtenir une valeur fiable de D, la structure doit être suffisamment
grande pour couvrir au moins un ordre de grandeur en rayon, de manière à ce que la pente logarithmique
puisse être déterminée avec une précision suffisante.
La relation masse-rayon devient difficile à appliquer à des objets de forme complexe, et la valeur de
D qui en résulte se retrouve à mesurer à la fois la forme globale de l’objet, ainsi que sa structure interne.
Une méthode plus robuste de la dimension fractale est basé sur le concept de la mesure. Revenons à
notre familier agrégat. Étant un objet défini dans un plan 2D, tout comme le désormais célèbre étang du
chapitre précédent, la mesure de sa “surface” peut se faire en le recouvrant de petit carrés contigus de
surface M ×M connue, et en comptant simplement le nombre N de carrés requis. Ceci s’appelle la méthode
du décompte des boites (traduction libre de “box-counting method”). Cette méthode est particulièrement
facile à utiliser pour des structures définies sur des réseaux, ou des images pixellisées.
La procédure est illustrée à la Figure 9.22, pour des carrés de coté égal à M =8, 16, 32 et 64. L’unité est
ici la distance entre deux noeuds voisins sur le réseau où se fait la marche aléatoire. Remarquez bien qu’il
n’importe pas ici qu’une boite ne recouvre qu’une seule particule ou plusieurs, dès qu’elle en couvre une
elle contribue “1” au décompte des boites. Encore une fois ici, l’utilisation de boites de taille comparable
à (ou plus petite que) la distance inter-particule n’a aucun sens physique et/ou géométrique. De plus,
comme l’agrégat a ici un diamètre d’environ 500 unités, tout décompte utilisant des boites plus grande
que cette taille produira N = 1 indépendamment de la taille de la boite.
Le résultat de cette procédure de décompte est illustré à la Figure 9.23. On y a porté en graphique
le décompte des boites en fonction de la résolution r (= 1/M ), définie ici comme l’inverse de l’échelle de
mesure M (i.e., haute résolution ≡ petite échelle de mesure), encore une fois selon des axes logarithmiques.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

168 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.21 – Relation masse–rayon pour l’agrégat de la Fig. 9.13. La pente logarithmique vaut main-
tenant 1.66, ce qui, géométriquement parlant, place l’objet quelque part entre la “ligne” et le “carré”, en
d’autres mots, entre le unidimensionnel et le bidimensionnel. La région en gris indique l’intervalle utilisé
pour calculer la pente (voir texte).

On y note de nouveau une loi de puissance de la forme

N (r) ∝ rD , D≥0. (9.36)
couvrant le domaine des échelles spatiales entre la taille de la structure (r petit) et la structure “mi-
croscopique” de l’agrégat (r très élevé). Comme auparavant la pente logarithmique donne directement
l’exposant D, qui correspond encore une fois à la dimension fractale, ici D = 1.59. La dimension fractale
ainsi calculée s’appelle la dimension de Hausdorff.
Le fait que les deux valeurs de la dimension fractale de notre agrégat, telles que calculées par la
relation masse-rayon et la méthode du décompte des boites, ne soient pas en parfait accord n’est pas
trop inquiétant en soi. Quelle que soit la méthode de calcul utilisée pour obtenir une valeur fiable de la
dimension fractale de notre agrégat DLA, il faudrait en fait l’appliquer à un grand nombre d’agrégats
distincts (i.e., produit selon des réalisations distinctes des marches aléatoires), et moyenner les valeurs de
D en résultant. Dans le cas d’agrégat de type DLA, on trouve bel et bien D ≃ 1.6 indépendamment de la
méthode utilisée
Qu’en est-il alors avec la fractale de Koch (Figure 9.18) ? Ici l’objet géométrique utilisé pour mesurer
la fractale est un segment de droite, plutôt qu’un carré. On a vu qu’à l’itération n, l’échelle M (longueur
de chaque segment) est donnée par (1/3)n , donc la résolution r = 1/M = 3n . Le nombre N de segment
requis pour couvrir la fractale, quand à lui, est donné par 4n . On a donc
log N log 4n n log 4 log 4
D= = = = = 1.26186 . (9.37)
log r log 3n n log 3 log 3
On notera en terminant que la fractale de Koch a une dimension substantiellement inférieure à celle
de l’agrégat DLA, ce qui est intuitivement satisfaisant puisque le second semble bel et bien plus “bi-
dimensionnel” que le premier.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.8. LA DIMENSION FRACTALE 169

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

170 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

Figure 9.22 – [Commence à la page précédente] Quatre itérations de la méthode de décompte des boites,
appliquée à l’agrégat de la Figure 9.13. Chaque itération double la dimension linéaire des carrés utilisés
pour couvrir l’objet, par rapport à l’itération précédente.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

9.8. LA DIMENSION FRACTALE 171

Figure 9.23 – Détermination de la dimension fractale de l’agrégat DLA de la Figure 9.13 à l’aide de
la méthode du décompte des boites. Comme auparavant, la dimension fractale correspond à la pente
logarithmique de N versus r, et est déterminée sur un intervalle de résolution (r = 1/M ) encadré par les
valeurs correspondant à la taille de la structure (r petit) et à la distance interparticule (r grand).

Exercices:

1. Démontrez que le résultat Dn2 = ns2 tient également pour une marche aléatoire en trois dimen-
sions spatiales.
2. Modifiez le code pour la marche aléatoire 1D afin d’introduire un biais systématique dans la marche,
dans le sens que le pas dans la direction positive de l’axe devient légèrement plus probable que le
pas dans la direction négative (i.e., introduisez des probabilité p(+) et p(−) telles que p(+) > p(−)
mais p(+) + p(−) = 1 !). Ensuite,
(a) Répétez l’expérience numérique décrite à la §9.2, et calculez l’équivalent des Figures 9.1 et 9.2
pour des valeurs de p(+) = 0.525, 0.55 et 0.6.
(b) À partir de vos résultats, estimez une “vitesse de dérive” vers la droite.
(c) Revenez maintenant à une simulation classique où les deux directions de pas sont équiprobables,
mais ajoutez une composante de vitesse non-aléatoire correspondant à la vitesse de dérive
estimée en (b) ; recalculez l’équivalent des Figures 9.1 et 9.2, et comparez à celles obtenues en
(a).
3. Utilisant la même procédure de discrétisation qu’à la §9.3, solutionnez numériquement l’équation
de diffusion (9.23) pour une condition initiale donnée par un profil gaussien :
 2
1 −x
N (x, t = 0) = √ exp ,
2πσ 2σ 2
avec σ = 0.5, sur l’intervalle spatial x ∈ [−10, 10]. Ensuite,

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

172 CHAPITRE 9. MARCHE ALÉATOIRE ET DIFFUSION

(a) Vérifiez que la forme gaussienne du profil initial est préservée au cours de l’évolution ;
(b) Examinez comment la déviation quadratique moyenne σ varie avec le temps.
4. Notre procédure de solution numérique de l’équation (9.23) évalue la dérivée seconde au membre
de droite au temps tm , tandis que la dérivée temporelle utilise une formule d’ordre O(h) impliquant
tm et tm+1 ; opérationnellement, ceci est donc équivalent à la méthode d’Euler explicite (§7.2). On
avait vu au chapitre 7 que la précision de la solution pouvait être améliorée en évaluant le membre
de droite comme une moyenne entre sa valeur à tm est une extrapolation linéaire au temps tm+1 ;
c’était la méthode de Heun.

(a) Appliquez cette technique à la solution numérique de (9.23) pour le problème de mélange
considéré à la §9.3 ;
(b) Calculez des solutions numériques pour diverses valeurs du pas de temps ∆t, et déterminez
si l’utilisation de la méthode de Heun change quelque chose à la stabilité de votre approche
numérique.

Bibliographie:

La marche aléatoire est traitée dans tous les ouvrages traitant de processus stochastiques. Le chapitre
12 de l’ouvrage Gould et Tobochnik cité en bibliographie du chapitre 1 offre une bonne discussion du
sujet.
De nos jours la diffusion est le plus souvent traitée dans certains ouvrages avancés de génie, dans
le contexte de la diffusion de la chaleur ou des effets dynamiques de la viscosité dans les fluides (deux
processus décrits par une équation effectivement identique à (9.23)). Dans la littérature plus physique,
j’aime bien la discussion au chapitre 2 de :
Guyon, É., Hulin, J.-P., et Petit, L., Hydrodynamique Physique, CNRS éditions (2001).
Pour une approche encore plus physique (mais à un niveau passablement avancé), je recommenderais :
Landau, L., et Lifschitz, E., Mécanique des Fluides, Éditions MIR (2e édition 1986).
La dérivation du critère de Courant se retrouve dans la plupart des ouvrages d’analyse numérique traitant
de la solution d’équations aux dérivées partielles. La présentation au chapitre 20 du Numerical Recipes
est tout à fait correcte et accessible.
Il existe une multitude d’ouvrages traitant de géométrie fractale. Le bouquin suivant, un des premiers
sur le sujet, vaut encore bien la peine d’être lu :
Mandelbrot, B., The fractal geometry of Nature, Freeman (1982).
J’ai appris beaucoup des deux ouvrages suivants, que je me permets donc de citer ici même si je doute
qu’ils soient les références optimales sur le sujet :
Prusinkiewicz, P., & Lindenmayer, A., The algorithmic beauty of plants, Springer (1990),
Flake, G.W., The computational beauty of Nature, MIT Press (1998).

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 173

Chapitre 10

Complexité

10.1 La complexité
La complexité est un concept qui a été et continue d’êtreapprêté à absolument toutes les sauces,
autant dans les milieux scientifiques “sérieux” quedans l’imaginaire populaire ; depuis une vingtaine d’an-
nées c’est un sujet très “in” chez les intellos de toute allégiances, tout comme le chaos l’a été durant les
années 1980. Malgré toute cette agitation intellectuelle, il demeure très difficile de cerner une définition
de la complexité qui fasse l’unanimité, au delà de sa triviale redéfinition :
complexe = pas simple
ce qui ramène évidemment le problème à définir ce qui est “simple”. Néanmoins, et tout comme moi, vous
avez probablement en tête une définition plus ou moins vague et intuitive de ce qui est complexe et de ce
qui ne l’est pas. Si l’on choisit de se limiter aux systèmes physiques et/ou naturels, on pourrait commencer
par dresser une liste de systèmes “simples” et “complexes”. Le tableau 10.1 en donne deux courtes listes,
et je compte sur vos suggestions pour qu’il s’allonge au fil des années (envoyez-moi ça par courriel).
Quelles seraient les caractéristiques de ces systèmes complexes en apparence si divers ? Si l’on reprend
les deux courtes listes du tableau 10.1, on peut en extraire certains points communs, tabulés au Tableau
10.2 ci-dessous. Un des plus évident est probablement le très grand nombre de degrés de liberté (ou
composantes en interaction), mais la plus fondamentale est plus subtile à détecter, et touche au compor-
tement dynamique des systèmes. Prenons un exemple simple. Si vous savez calculer la force nécessaire
pour faire tourner une poulie à laquelle est suspendu un poids, vous savez également comment calculer
la force nécessaire pour faire tourner un systèmes de 20 poulies démultipliées et/ou interconnectées pour
soulever le même poids ; ça pourrait bien être un calcul fastidieux, mais ce n’est vraiment qu’une question
de patience, de calme et de concentration. La dynamique du système de 20 poulies se réduit effectivement
à la dynamique d’une poulie. C’est une dynamique réductioniste. Par contre, tout connaitre sur la
molécule de H2 O ne vous permet pas d’anticiper que quelques zillions de molécules de H2 O produiront
de la turbulence, tout savoir sur l’électrochimie d’un neurone (ce qui serait déjà extraordinaire) ne vous
permet certainement pas d’anticiper qu’un assemblage de plusieurs neurones puisse pondre le Ich Will
de Rammstein ou l’Odyssée d’Homère, pas plus que le calcul du coefficient de friction entre deux grains
de sable vous permet de comprendre pourquoi un tas de sable (sec) formera toujours un cône présentant
une pente de ≃ 35 degrés. Dans ces derniers systèmes, la dynamique à l’échelle globale (fluide, cerveau,
tas de sable) est qualitativement différente de la dynamique à l’échelle locale (un H2 O, un neurone, un
grain de sable). De plus, cette dynamique globale (et souvent “complexe”) émerge des interactions locales
(et habituellement “simples”) entre un très grand nombre d’éléments composant le système. C’est là la
caractéristique sine qua non des systèmes complexes, tout comme la sensibilité aux conditions initiales
définit la nature chaotique d’un système.
Dans ce chapitre nous allons étudier trois modèles numériques simples de systèmes complexes, soit
le modèle dit “Tas-de-Sable” (§10.2 ; “sandpile model” dans la littérature anglophone), le modèle “Feux-
de-Forêt” (§10.4 ; “Forest Fire model”), et le modèle embouteillage (§10.6, “traffic jam model”). Ces
trois modèles nous servirons à illustrer divers types de comportements génériques associés aux systèmes
complexes, et nous feront aussi faire connaissance avec le concept de la criticalité auto-régulé (§10.3 ;
“Self-Organized Criticality”), sans nul doute une des grandes percées conceptuelles des dernières quelques
décennies en physique statistique ; le tout assaisonné d’un petit retour sur l’invariance d’échelle (§10.5).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

174 CHAPITRE 10. COMPLEXITÉ

Table 10.1 – Quelques exemples de systèmes simples et complexes

Systèmes “Simples” Systèmes “Complexes”

Le pendule La turbulence dans les fluides

Le thermomètre Le climat
L’atome d’Hydrogène Un flocon de neige
Le circuit RLC Le réseau d’Hydro-Québec
Les orbites planétaires Les écosystèmes
Une balance Un tas de sable (sec)

Table 10.2 – Quelques caractéristiques des systèmes simples et complexes

Systèmes “Simples” Systèmes “Complexes”

Relativement peu de degrés de liberté Énormément de degrés de liberté

Causalité unidirectionnelle Boucles de rétroaction
Une ou quelques échelles caractéristiques Multi-échelle ou invariance d’échelle
Prévisibles Imprévisibles
Dynamique réductioniste Dynamique émergente

10.2 Le modèle Tas-De-Sable

Le modèle Tas-de-Sable (ci-après TdS) est un modèle sur réseau évoluant selon des règles simples et
locales dans l’espace et le temps. On considère un réseau unidimensionnel de J noeuds sur lesquels on
définit une variable Sjn , où l’indice j numérote le noeud sur le réseau et n mesure l’itération temporelle.
Initialement (n = 0), on a
Sj0 = 0 , j = 1, ..., J . (10.1)
Cette variable nodale est est sujette à un mécanisme de forçage selon lequel une petite quantité de sable
est ajoutée sur le tas à un noeud choisi au hasard à chaque itération temporelle :
Srn+1 = Srn + ϵ , r ∈ [0, J] , ϵ ∈ [0, E] , (10.2)
où r et ϵ sont extraits de distribution aléatoires uniformes (discrète pour r et continue pour ϵ) dans les
intervalles correspondants, et l’incrément maximal E est un paramètre du modèle. L’analogie habituel-
lement introduite est celle du tas de sable, où Sjn correspond alors à la hauteur du tas à la position j
sur le réseau au “temps” n, et le mécanisme de forçage revient à laisser tomber des grains de sable au
hasard quelque part sur le tas. La conséquence en sera que la hauteur du tas va croitre inexorablement...
du moins au début.
Maintenant pour la dynamique du système ; à mesure que le tas croit en hauteur, à chaque itération
temporelle on calcule la pente associée à chaque paire de noeuds (j, j + 1) :
zjn = |Sj+1
n
− Sjn | , j = 1, ..., J − 1 . (10.3)
Si cette pente dépasse une valeur critique Zc prédéfinie, alors la paire de noeud (j, j + 1) est déclarée
instable, et un processus de redistribution entre en jeu pour ramener le système à une configuration stable
à l’itération suivante. Comme processus de redistribution, nous utiliserons ici la règle :
Sjn+1 = Sjn + (S̄ − Sjn )/2 , n+1
Sj+1 n
= Sj+1 n
+ (S̄ − Sj+1 )/2 , (10.4)
où
n
S̄ = (Sj+1 + Sjn )/2 . (10.5)
Je vous laisse vérifier que cette règle est conservative, dans le sens que
Sjn+1 + Sj+1
n+1
= Sjn + Sj+1
n
, (10.6)

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 10.2. LE MODÈLE TAS-DE-SABLE 175

et que la quantité δSjn de sable déplacée par cette procédure de redistribution est donnée par

zjn
δSjn = . (10.7)
4
Mais voilà, le fait d’avoir redistribué du sable entre les noeuds j et j + 1 change la pente associée aux
paires de noeuds (j − 1, j) et (j + 1, j + 2), et peut fort bien pousser l’une ou l’autre de ces pentes au
dessus du seuil critique Zc . Si c’est le cas, la règle de redistribution est appliquée à ces nouvelles paires
instables, et on doit conséquemment ensuite vérifier la stabilité —et appliquer la règle de redistribution le
cas échéant— des paires voisines, et ainsi de suite ; ce n’est que lorsque toutes les paires sont stables qu’on
active le mécanisme de forçage qui ajoute du sable au réseau. L’effet de tout ça est une avalanche de
redistributions, déplaçant le sable vers le bas du tas jusqu’à ce que la stabilité soit restaurée sur l’ensemble
du réseau. C’est ici que les conditions limites entrent en jeu. On impose au modèle :

S1n = SJn = 0 . (10.8)

Ceci est équivalent à laisser tomber le sable atteignant le bout du réseau, un peu comme si notre tas de
sable se trouvait sur une table de largeur égale à la base du tas. Les conditions limites jouent ici un rôle
clef dans la dynamique du système ; puisque la règle de redistribution est conservative, et vu l’addition
lente mais continuelle de sable sur le tas par le mécanisme de forçage, il est essentiel que du sable puisse
être évacué du système si on veut avoir une chance d’atteindre un état stationnaire.
Avant même de simuler quoique ce soit, si on songe un peu à l’effet de tout ça, on en déduirait qu’après
un certain temps, le tas prendra une forme triangulaire, avec le sommet au centre du réseau, les pentes
de chaque coté égales à la pente critique Zc , et pour un réseau de taille J on prédirait alors une hauteur
maximale égale à Zc × J/2. Voyons si ces attentes sont réalisées.
Le code Python ci-dessous offre une implémentation minimale du modèle TdS. Il s’agit ici d’une
implémentation minimale dans le sens qu’on a sacrifié la vitesse d’exécution pour avoir une meilleure
clarté du code. 1 Le tableau sable contient ici la quantité de sable à chacun des J noeuds du réseau.
Code Python pour modele Tas de Sable
1 import numpy as np
2

3 J=101 # taille du reseau

4 sable=[Link](J) # qte sable a chaque noeud, initialement zero
5 E=0.1 # qte maximm ajoutee a chaque iteration par forcage
6 penteCrit=5. # pente critique pour declenchement d'avalanche
7 nIter=150000
8

9 for iter in range(nIter): # iteration temporelle

10 move=[Link](J) # initialisation des transferts
11 dmasse=0. # init. masse totale transferee
12 for j in range(J-1): # boucle sur les noeuds
13 pente=abs(sable[j+1]-sable[j]) # pente associee a j,j+1
14 if pente>=penteCrit: # la paire j,j+1 est instable
15 av=(sable[j]+sable[j+1])/2.
16 move[j]+=(av-sable[j])/2. # qte a ajouter a j
17 move[j+1]+=(av-sable[j+1])/2. # idem a j+1
18 dmasse+=pente/4. # cumul de la masse deplacee
19

20 if dmasse>0: # il y a eu avalanche...
21 sable+=move # on fait les transferts
22 else: # il n'y a pas eu avalanche; on force
23 j=[Link].random_integers(0,J-1)
24 sable[j]+=[Link]()*E
25

26 sable[0]=0. # imposition des conditions limites

1. Nous verrons en classe comment modifier ce code pour qu’il s’exécute beaucoup plus rapidement, tout en effectuant
exactement la même chose.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 176 CHAPITRE 10. COMPLEXITÉ

Figure 10.1 – Croissance du tas de sable produit par le code montré ci-haut, ici avec J = 101, Zc = 5
et E = 0.1. Le trait pointillé indique la forme attendue d’un tas parfaitement triangulaire, avec les pentes
droites et gauche égales à ±Zc . Chaque courbe est séparée de la précédente par 50000 itérations.

27 sable[J-1]=0. # imposition des conditions limites

28 masse=[Link]()

Il y a deux choses très importantes à remarquer ici :

1. L’itération temporelle se fait en deux sous-étapes séquentielles : on teste d’abord la stabilité à

chaque paire de noeud, et on accumule dans un tableau (ici move) les quantités de sable qui doivent
être transférées pour rétablir la stabilité sans toucher au tableau sable à ce stade. Ce n’est qu’une
fois tous les noeuds testés qu’on ajuste le tableau sable en conséquence, en y ajoutant le contenu
de move. Cet ajustement synchrone de la variable nodale est essentiel afin de ne pas introduire de
biais directionnel dans le déclenchement ou la propagation des avalanches ;
2. L’ajout de sable ne se produit que si le système est stable partout à cette itération (“stop-and-
go sandpile”). Ceci vise à refléter le fait que le temps caractéristique associé au forçage se veut
beaucoup plus long que celui caractérisant la propagation des avalanches.
Allons-y pour une petite simulation. La Figure 10.1 illustre la croissance du tas durant les premières
5 × 105 itérations de l’algorithme ci-dessus, sur un réseau de taille J = 101 avec Zc = 5 et E = 0.1 En
raison des conditions limites imposées aux bouts du réseau, la forme conique (attendue !) du tas s’établit
d’abord près des bords. Cependant, dans sa configuration finale quasi stationnaire, les deux pentes du
tas atteignent une valeur inférieure à la pente critique (indiquée en pointillé), et le tas s’en retrouve
proportionnellement moins haut qu’anticipé. Ceci est une conséquence de la stochasticité du processus
de forçage, qui conduit à des redistributions pour certaines paires de noeuds avant que toutes les paires
aient atteint la pente critique ; le système stabilise donc à une valeur de pente moyenne plus petite que
Zc , s’approchant de Zc seulement dans la limite E → 0.
Il sera utile de se définir quelques quantités globales afin de caractériser l’évolution temporelle du
réseau. Commençons par la masse, soit la quantité totale de sable contenue dans le tas à l’itération n :
J
X
Mn = Sjn . (10.9)
j=1

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

10.3. LA CRITICALITÉ AUTO-RÉGULÉE 177

La Figure 10.2A montre l’évolution temporelle de cette quantité à partir du début de la simulation. La
masse croit initialement de manière linéaire, mais sature éventuellement à une valeur statistiquement
stationnaire, mais sujette à fluctuations. La forme que prennent ces fluctuations est particulière, comme
on peut le constater sur examen de l’encadré, montrant un zoom sur une petite partie de la séquence
dans le régime stationnaire. On y voit la masse croitre graduellement et approximativement linéairement,
mais cette croissance est épisodiquement interrompue par des baisses très rapides, manifestations d’une
avalanche ayant fait chuter une certaine quantité de sable du tas. Le pattern en dents-de-scie est une
réflexion du fait que le processus de chargement du tas opère d’une manière lente et graduelle, tandis
que le processus de vidage est lui rapide et très intermittent. La courbe décrivant la variation de M n est
auto-similaire, et on peut lui associer une dimension fractale plus grande que un, un peu comme on l’avait
fait pour la fractale de Koch (§9.7).
Une autre quantité d’intérêt est la masse déplacée à l’itération n lors d’une avalanche :
J−1
X
∆M n = δSjn , (10.10)
j=1

où δSjn est défini via l’éq. (10.7). Notez que cette dernière quantité n’est pas nécessairement égale à
M n+1 − M n , puisqu’une avalanche n’atteignant pas le bord du réseau ne changera pas la masse du tas,
bien qu’elle déplace du sable.
La Figure 10.2B montre la portion de la séquence temporelle de ∆M n correspondant à l’intervalle cou-
vert par l’encadré de la partie (A). Cette séquence est très intermittente, dans le sens que ∆M n = 0 sauf
durant de courts épisodes d’activité correspondant évidemment aux avalanches. Celles-ci se déclenchent de
manière irrégulière dans le temps, et ont des tailles pouvant varier grandement d’une avalanche à l’autre.
On remarque cependant que les plus grandes avalanches ont une amplitude maximale ∆M n ≃ 75, ce qui
correspond à une avalanche déplaçant vers le bas une quantité ∼ Zc /2 de sable à chaque noeud entre
le sommet du tas et une de ses extrémités basales. Vu la taille finie du réseau (J = 101 ici), il est tout
simplement impossible de développer une avalanche plus intense. On peut vérifier que les masses déplacées
par les avalanches sont distribuées en loi de puissance.

10.3 La criticalité auto-régulée

Ce qui est remarquable dans la dynamique globale du système TdS est qu’il accumule de “l’énergie”
(i.e., sable) de manière lente et graduelle, mais la libère de façon intense mais intermittente. Le fait que
plusieurs systèmes naturels se comportent ainsi a donc généré beaucoup d’intérêt pour le modèle TdS
(et ses variantes) comme une représentation idéalisée de ces systèmes. Le tas de sable (réel ou modélisé
numériquement, comme ci-dessus) est en fait devenu l’icône du concept de la criticalité auto-régulée
(traduction libre de “self-organized criticality”, souvent abbrévié à “SOC”), notion théorique qui fait
beaucoup de bruit en physique statistique depuis une vingtaine d’années.
Un système est dit critique quand une petite perturbation locale —e.g. l’ajout d’un site occupé quelque
part dans le réseau— se fait sentir globalement —e.g. un amas apparait qui traverse maintenant tout le
réseau, ce qui rend le matériau électriquement conducteur, ou perméable à l’écoulement d’un fluide, etc.
Généralement, ce phénomène n’est possible qu’à un seuil critique d’un certain paramètre, et la manifes-
tation de la criticalité ne peut se produire que si ce paramètre de contrôle est soumis à un ajustement
—habituellement extérieur— très fin.
Dans le cas du tas de sable, l’équivalent du seuil de criticaillé est l’angle critique de la pente. Si le tas
est sous l’angle critique, l’ajout d’un peu de sable ne fera probablement pas grand chose ; si la pente du
tas est au dessus de l’angle critique, elle avalanche déjà ; mais si on est très près de l’angle critique, l’ajout
d’un seul grain de sable quelque part sur le tas peut : (1) ne rien faire, (2) faire bouger un seul grain,
(3) déclencher une avalanche balayant toute la pente, ou (4) n’importe quoi entre (2) et (3). Cependant,
cet état critique est un attracteur de la dynamique du système, dans le sens qu’il résulte naturellement
de l’interaction entre un très grand nombre de grains de sable, sans ajustement fin d’un paramètre de
contrôle par un agent extérieur au système. C’est pourquoi on dit du tas de sable qu’il est dans un état
de criticalité auto-régulée.
Si on distille tout ça pour en extraire les conditions essentielles pour qu’un système puisse évoluer vers
un état critique auto-régulé, on en arrive à la courte liste suivante. Le système doit être :

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

178 CHAPITRE 10. COMPLEXITÉ

Figure 10.2 – Évolution temporelle du modèle TdS en une dimension spatiale, à partir d’une condition
initiale Sj0 = 0. Les paramètres de cette simulations sont J = 101, Zc = 5, et E = 0.1. La partie (A)
montre l’évolution de la masse M du tas, l’encadré offrant un zoom sur une petite portion de la séquence,
et montrant la forme self-similaire de la séquence temporelle. La partie (B) montre la séquence temporelle
de la masse déplacée ∆M , pour le même petit intervalle temporel que l’encadré de la partie (A).

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

10.4. LE MODÈLE FEU-DE-FORÊT 179

1. ouvert,
2. soumis à un forçage lent,
3. sujet à une instabilité locale...
4. ...dont l’activation requiert le dépassement d’un seuil d’amplitude finie,
5. et où la restabilisation s’effectue par redistribution locale de la variable dynamique.

Le nombre de système naturels pouvant satisfaire à ces conditions est substantiel : en plus des avalanches et
autres formes de glissement de terrain, on peut y inclure les sous-orages géomagnétiques, les tremblements
de terre, les éruptions solaires, et les feux de forêts, sujet de la section qui suit.

10.4 Le modèle Feu-de-Forêt

Le modèle “Feux-de-Forêt” (ci-après FdF) appartient à la classe dite des automates cellulaires. Le
n
modèle assigne à chaque noeud (i, j) d’un réseau cartésien 2D une variable d’état Sij pouvant avoir l’une
de trois valeurs : 0 pour un site vide, 1 pour un site occupé mais inerte, et 2 pour un site occupé et actif.
0
À partir d’une condition initiale où Sij = 0 sur tout le réseau, la variable nodale évolue dans le temps
n n+1
(Sij → Sij ) selon une série de règles discrètes dont certaines incorporent une composante stochastique :

1. Règle 1 : Si un site est inoccupé, il peut devenir occupé avec une probabilité pg ;
2. Règle 2 : Si un site est occupé mais inactif, il peut devenir actif spontanément avec une probabilité
pf
3. Règle 3 : Si un site est occupé et inactif, il devient actif si l’un de ses 8 voisins immédiats est actif.
4. Règle 4 : Si un site est occupé et actif, il devient vide à l’itération suivante.

L’inspiration initiale du modèle vient de l’écologie : un site occupé et inactif correspond à un arbre ; et un
site occupé et actif à un arbre en train de brûler ; la règle 1, c’est un arbre qui pousse ; la Règle 2, c’est
un arbre frappé par la foudre ; la Règle 3, c’est un arbre en feu enflammant les arbres voisins ; et la Règle
4 c’est la destruction d’un arbre par le feu.
Le fait qu’un arbre en feu puisse en enflammer un autre peut conduire à des effets d’avalanche sur
le réseau, dans le sens que l’activation d’un seul site peut conduire à une reconfiguration majeure du
système. Ceci est illustré à la Figure 10.3, qui montre une séquence d’instantanés chacun séparé par 10
itérations 2 , d’une simulation ayant pg = 10−3 et pf = 10−5 . Cette simulation roulait déjà depuis plusieurs
milliers d’itérations, et avait donc déjà atteint un état statistiquement stationnaire. Quelques itérations
avant le second instantané la foudre a frappé un peu en haut et à gauche du centre du réseau. L’activité se
propage de site en site, sous la forme d’un front de combustion approximativment circulaire initialement,
mais développant une forme de plus en plus convoluée à mesure qu’il se propage dans le réseau, en raison
du fait que la densité d’arbres dans la configuration pré-activité varie substantiellement à travers le réseau.
Cette hétérogénéité est elle-même une conséquence de feux ayant balayé le réseau dans un passé plus ou
moins rapproché (voir, e.g., le dernier instantané au bas de la Figure 10.3). Bien que le déclencheur soit
ici un processus stochastique (cf. Règle 2), l’activité passée affecte donc fortement l’activité présente.
La Figure 10.3 illustre bien la disparité des échelles temporelles implicite au modèle FdF. La plus
courte échelle de temps est l’échelle “dynamique” de la propagation de l’activité d’un site occupé à un
autre. L’échelle suivante est celle associée à l’occupation des sites vides. La dernière rangée d’instantanés
au bas de la Figure 10.3 montre bien la lenteur de ce processus ; il faut vraiment y regarder de près pour
réaliser que de nouveaux arbres sont apparus ici et là durant les 40 itérations couvertes par ces images. La
probabilité d’activation spontanée définit habituellement la plus longue échelle de temps dans le modèle,
l’intervalle moyen entre deux activations étant donnée par (p × N 2 × pf )−1 , où N est la grandeur du
réseau dans chaque dimension et p la probabilité moyenne d’occupation. Ici, avec N = 100, p ≃ 0.3 et
pf = 10−5 , on s’attend à une activation tous les 33 itérations en moyenne.
Le code ci-bas représente une implémentation minimale du modèle FdF, minimale encore une fois dans
le sens qu’on aurait pu écrire une version plus efficace du point de vue numérique, mais un peu moins
lisible.

2. Des animations en format mpeg de cette simulation, et d’autres pour différentes valeurs des paramètres pg et pf sont
disponible sur la page web du cours.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

180 CHAPITRE 10. COMPLEXITÉ

Figure 10.3 – Séquence d’instantanés de l’état du réseau pour le modèle FdF avec pg = 10−3 et pf = 10−5 ,
séparés chacun par 10 itérations. Les sites vides sont en blanc, les sites actifs en rouge, et les sites occupés
mais inactifs en vert. Au second instantané la foudre vient de frapper un arbre près du centre du réseau ;
un “front” de combustion balaye par la suite une grande partie du réseau. Simulation sur un réseau de
100 × 100.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 10.4. LE MODÈLE FEU-DE-FORÊT 181

Code Python pour modele Feux de Forêt

1 import numpy as np
2

3 N=100 # taille du reseau

4 pg=1.e-3 # probabilite de croissance
5 pf=1.e-5 # probabilite d'activation
6 nIter=5000
7

8 grille=[Link]([N+2,N+2],dtype='int') # initialisation du reseau, aucun arbre

9 #valeurs possibles de grille: 0-->vide, 1-->occupe, et 2-->enflamme
10 arbres=0 # variable compteur: nombre d'arbres sur le reseau
11

12 for k in range(nIter): # iteration temporelle

13 evol=[Link]([N+2,N+2],dtype='int') # tableau d'evolution (a ajouter a grille)
14 brules=0 # variable compteur: nombre d'arbres enflammes
15 # on balaye le reseau pour identifier quels arbres doivent s'enflammer,
16 # lesquels doivent disparaitre, et lesquels doivent pousser
17 for i in range(1,N+1):
18 for j in range(1,N+1):
19 if grille[i,j]==1: # le site est occuppe
20 if 2 in grille[i-1:i+2,j-1:j+2]: # s'enflamme par un voisin brulant deja
21 evol[i,j]=1
22 brules+=1
23 elif [Link]()<pf: # s'enflamme par la foudre
24 evol[i,j]=1
25 brules+=1
26

27 if grille[i,j]==2: # elimination des arbres deja enflammes

28 evol[i,j]=-2
29 arbres-=1
30

31 if grille[i,j]==0: # croissance des arbres aux sites vides

32 if [Link]()<=pg:
33 evol[i,j]=1
34 arbres+=1
35

36 # maintenant on mets a jour le reseau:

37 # on enflamme, elimine ou ajoute les arbres identifies prealablement
38 grille+=evol
39

40 print("iteration {}, arbres {}, en feu {}.".format(k,arbres,brules))

La structure globale du code est semblable à celle du modèle TdS (§10.2). Toute l’action est incluse
à l’intérieur d’une boucle inconditionnelle contrôlant l’itération temporelle. Remarquez encore une fois
qu’on identifie d’abord quels sites doivent s’enflammer, se vider ou se remplir, via le premier bloc de
doubles boucles for, et que la mise à jour du réseau se fait ensuite de manière synchrone, à la fin de
chaque itération temporelle. Les modifications au réseau sont accumulées dans un tableau (evol) de
taille identique à celle du réseau. Notez finalement que le tableau grille inclue un “tampon” de noeuds
fantômes sur sa périphérie, qui demeurent toujours vides mais permettent de ne pas avoir à traiter les bords
véritables du réseau de manière différente afin d’éviter les débordements de tableaux. C’est pourquoi, à
l’intérieur de l’itération temporelle, les boucles sur le réseau commencent à 1 et se terminent à N.
Les règles contrôlant l’évolution du modèle sont très simples, et la seule règle de couplage (la 3)
est purement locale, dans le sens qu’elle n’implique que les voisins immédiats sur le réseau. De plus, le
modèle ne compte que deux “paramètres” ajustables, soit la probabilité (à chaque itération temporelle) de
croissance d’un arbre (pg ), et la probabilité (pf ) d’être frappé par la foudre. Malgré tout, ce modèle peut
produire une vaste gamme de comportements qui sont fort difficiles à anticiper sur la base de ses règles

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

182 CHAPITRE 10. COMPLEXITÉ

d’opération. Ceci est illustré aux Figures 10.4 et 10.5, montrant l’évolution du nombre de sites occupés
inactifs (Na , trait noir) et actifs (Nf , traits rouge) pour différentes combinaisons de valeurs de pg et pf .
Si pf ∼ pg (Fig. 10.4, en haut, avec pg = pf = 10−4 ), les arbres sont frappés par la foudre à une
fréquence comparable à celle à laquelle ils poussent. Le nombre d’arbres sur le réseau demeure à peu près
constant, et de petits feux brûlent toujours quelquepart, sans jamais cependant prendre trop d’ampleur
car la densité d’arbres est trop faible, ce qui implique que très peu d’arbres ont un de leur 8 sites voisins
occupés par un autre arbre. Si on augmente pg à 10−2 (Fig. 10.4, en bas), la densité d’arbre est plus
élevée, et les arbres repoussent très rapidement ; si rapidement en fait qu’une fois un feu déclenché, il ne
s’éteint jamais, étant continuellement alimenté par le “reboisement” rapide s’effectuant derrière le front
de combustion. Ceci conduit à des oscillations passablement régulières dans le nombre de site actifs et
inactifs, les deux en antiphase, avec la période d’oscillation déterminée par le temps requis pour balayer
le réseau, ici de l’ordre de 100 itérations.
Si on laisse maintenant chuter la probabilité d’activation pf à une très faible valeur (pf = 10−6 pour les
deux solutions de la Figure 10.5), alors le réseau a la chance de se remplir beaucoup plus avant qu’un site
ne devienne actif. Mais quand celà se produit, presque chaque arbre a au moins un voisin, et on déclenche
alors un feu majeur qui brûle presque tout le réseau. Ceci se traduit en un cycle quasi-périodique dit de
“charge-décharge”, où à intervalles semi-régulier un feu de grande amplitude rase la plus grande partie de
la forêt. (Fig. 10.5, en haut). Avec une probabilité d’occupation ici de p ≃ 0.5 la quasi-totalité des arbres
ont un autre arbre à au moins un de leurs sites voisins, et donc le feu se propage rapidement. Le fait que le
nombre d’arbres ne tombe pas à zéro ici est en partie une conséquence des effets de bord, les arbres étant
situés sur les bords du réseau ayant moins de voisins se retrouvant plus difficile à enflammer. À bas pf , ce
cycle ne peut être brisé que si la croissance des arbres est elle-même suffisamment lente, de manière à ne
pas toujours remplir le réseau entre deux activations par la foudre. Ceci est illustré au bas de la Fig. 10.5,
pour une solution toujours avec pf = 10−6 mais où l’on a baissé à pg = 10−4 . Bien que des feux de grande
amplitude rasent une bonne partie du réseau de temps en temps, ceci se produit maintenant de manière
beaucoup plus irrégulière, et les tailles des feux couvrent maintenant un intervalle beaucoup plus large
en terme du nombre d’arbres détruits par feu. Notons la forme en dents-de-scie-fractale de la séquence
temporelle pour le nombre de sites occupés N , qui n’est pas sans rappeler la séquence temporelle de la
masse dans le modèle Tas-de-Sable (cf. Fig. 10.2A, encadré).
Ces différences deviennent frappantes si l’on calcule, à partir des résultats des simulations, les fonctions
de densité de probabilité de la taille des feux, en d’autre mots la fonction histogramme f (Nf ) mesurant
la probabilité d’occurrence d’un feu brûlant entre Nf et Nf + dNf arbres. Ces distributions sont portées
en graphique à la Figure 10.6, pour les deux simulations de la Figure 10.5. On y voit que dans le régime
pf ≪ 1, baisser de pg = 10−3 à pg = 10−4 produit une transition d’une distribution de type Gaussienne,
caractérisée par une valeur moyenne bien définie, à une distribution en loi de puissance de la forme :

f (N ) = f0 N −α , α>0, (10.11)

où f0 est une constante de normalization ; ici α = 1.07. Ce qui est remarquable est que dans le régime
pg ≪ 1, pf ≪ pg , la valeur de α est universelle, i.e., ne dépend essentiellement pas des valeurs exactes des
paramètres du modèle.
Quelle que soit la forme de la distribution f (N ), la quantité f (N )dN mesure la probabilité qu’un feu
détruise entre N et N + dN arbres. La quantité moyenne – ou la quantité attendue – d’arbres détruits
par un feu quelconque est alors donnée par l’intégrale :
Z Nmax
S= f (N )N dN, (10.12)
Nmin

où Nmin et Nmax représentent les quantités minimale et maximale d’arbres pouvant être détruits, res-
pectivement ici 1 et 104 , soit le nombre de sites occupables sur le réseau. Substituant l’éq. (10.11) dans
l’éq. (10.12), on obtient :

f0  2−α 2−α

S= Nmax − Nmin . (10.13)
2−α
Si Nmin ≪ Nmax (et ce sera habituellement le cas pour des systèmes impliquant un très grand nombre de
degrés de liberté), on se retrouve dans la situation suivante :

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

10.4. LE MODÈLE FEU-DE-FORÊT 183

Figure 10.4 – Évolution temporelle du nombre de sites occupés inactifs (traits noir) et actifs (traits rouge)
dans le modèle FdF avec diverses combinaisons de valeurs de pg et pf , dans le régime où la probabilité
d’activation est relativement élevée. Toutes les simulations sont effectuées sur un réseau de taille 100×100.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

184 CHAPITRE 10. COMPLEXITÉ

Figure 10.5 – Suite de la précédente, maintenant dans le régime où la probabilité d’activation pf est très
faible. Notez bien que les échelles horizontale et verticale des graphiques ne sont pas toujours les mêmes
d’un graphique à l’autre.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

10.4. LE MODÈLE FEU-DE-FORÊT 185

Figure 10.6 – Fonctions de densité de probabilité des tailles des feux balayant le réseau, pour les deux
simulations de la Figure 10.5. En (A), la distribution est tolérablement bien représentée par une gaussienne,
tandis qu’en (B) on observe une loi de puissance, ici avec pente logarithmique −1.07.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

186 CHAPITRE 10. COMPLEXITÉ

1. α < 2 ; l’exposant 2 − α est alors positif, et donc la quantité d’arbres détruits est dominée par les
rares grands feux, via la contribution de Nmax à l’évaluation de l’intégrale :
2−α
f0 Nmax
S≃ , [α < 2] . (10.14)
2−α

2. α > 2 ; l’exposant 2 − α est alors négatif, et donc la quantité d’arbres détruits est dominée par les
nombreux petits feux, via la contribution de Nmin à l’évaluation de l’intégrale :
f0
S≃ α−2 , [α > 2] . (10.15)
(α − 2)Nmin

Dans le cas du modèle FdF en régime pg ≪ 1, pf ≪ pg , on est dans la première de ces situations, et ce
sont donc les très rares plus grands feux qui dominent l’évolution de l’écosystème. On observe le même
comportement avec, par exemple, les tremblements de terre, où la relaxation des stress tectoniques est
dominée par les plus intenses séismes.
Il s’avère que dans la double limite

pf ≪ pg , pg ≪ 1 , (10.16)

le modèle FdF opère en régime critique auto-régulé ; la forçage, c’est la croissance des arbres ; l’instabilité,
c’est qu’il y ait une densité d’arbre suffisante pour que chaque arbre ait en moyenne un arbre voisin ; et
la redistribution, c’est la destruction des arbres par le feu.

10.5 Retour sur l’invariance d’échelle

On a vu que les deux systèmes complexe étudiés ci-dessus peuvent produire des “événéments” (ava-
lanches, feux) dont les tailles se distribuent selon une loi de puissance, dont on peut écrire la forme générale
comme :

f (x) = f0 x−α , α>0. (10.17)

Ceci s’avère caractéristique des systèmes en état d’autorégulation critique. Considérons ce qui arrive si l’on
décide soudainement de changer l’échelle de mesure de la variable x (par exemple, on décide de mesurer
la taille d’une avalanche de sable en tonnes plutôt qu’en kilos). Ceci revient à appliquer un changement
d’échelle à la variable x, dont on peut représenter le résultat par la définition d’une nouvelle variable y
telle que :

y = x/a , (10.18)

où a est une simple constante numérique (e.g., a = 103 si on décide de mesurer x en tonnes métriques
plutôt qu’en kilos). L’éq. (10.17) devient alors :

f (x) = f (ay) = f0 (ay)−α = (f0 a−α )y −α (10.19)

On voit que la distribution f (y) demeure une loi de puissance, avec la même valeur de l’exposant. Donc,
que la variable x soit mesurée en centimètres ou en années-lumière, sa distribution est toujours une loi
de puissance avec pente logarithmique égale à −α. On dit donc que la distribution est invariante par
rapport à un changement d’échelle. Contrastons ceci avec ce qui se passe, sous la même transformation
d’échelle, avec la distribution exponentielle :
 −1
−1 λ
f (x) = f (ay) = λ exp(−(ay)/λ) = a exp (−y)/(λ/a)) ; (10.20)
a

ici, la forme même de la distribution change, dans le sens que la valeur numérique du paramètre d’échelle λ
se retrouve effectivement divisée par un facteur a. La distribution exponentielle n’est donc pas invariante
par rapport à un changement d’échelle. Il en irait de même avec la distribution gaussienne, pour laquelle
et la valeur moyenne et la variance se retrouve à être affectées par un changement d’échelle.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 10.6. LE MODÈLE EMBOUTEILLAGE 187

L’invariance d’échelle caractérisant les systèmes en autorégulation critique vient du fait que la dy-
namique du système n’introduit aucune échelle caractéristique entre la distance internodale et la taille
globale du système. Une avalanche, qu’elle n’implique qu’un seul site ou toute la pente, opère toujours via
l’interaction d’un site avec ses voisins immédiats ; un feu, qu’il soit petit ou grand, se propage toujours
via l’allumage d’un arbre par un voisin déjà en feu. Une des conséquences les plus intriguantes de cette
invariance d’échelle apparait quand on examine les forme géométriques des avalanches dans le modèle
TdS, des fronts de combustion ou des clairières qu’ils forment dans le modèle FdF : ces structures sont
toutes des fractales !

10.6 Le modèle embouteillage

Des millions d’autos, “...des millions d’êtres humains qui s’battent pour un pouce d’autoroute, sans
trop se demander c’kyé au boutte..." ; pas évident à prime abord, mais le trafic automobile partage bon
nombre de similarités avec nos deux premier systèmes complexes : un grand nombre de composantes (les
autos) n’interagissant qu’avec les quelques composantes voisines (l’auto devant et celle derrière) selon des
règles simples (ralentir si l’auto d’en avant ralentit, accélérer si elle accèlère, etc.). Mais cette audacieuse
analogie tient-elle la route ? Nous examinerons ici cette question à l’aide du modèle embouteillage (ci-après
A15), qui offre une représentation très idéalisée du trafic définie par les règles suivantes :
1. Les voitures se déplacent sur une route à une seule voie, à sens unique ; donc, pas de dépassement.
2. Les positions et vitesse de la k-ième voiture au temps tn sont dénotée par xnk et vkn .
3. À chaque pas de temps (n), chaque chauffeur (k) ajuste sa vitesse en fonction de la distance le
séparant de l’auto le précédant :
δ = xnk+1 − xnk .
4. Si δ < 5, on ralentit : vkn → vkn − 3.
5. Si δ > 5, on accéllère : vkn → vkn + 1.
6. Vitesse minimale : zéro (on ne recule PAS dans un sens unique, n’en déplaise aux chauffeurs de
taxi...).
7. Vitesse maximale : 10 (sinon la SQ s’en mêle vite, avec son enthousiasme habituel pour la chose).
8. Les voitures se déplacent suivant la prescription habituelle reliant le déplacement à la vitesse (ici
considérée constante durant une itération temporelle) :

xn+1
k = xnk + vkn × ∆t .

Dans tout ce qui suit, on posera ∆t = 1 sans aucune perte de généralité. Le code ci-bas implémente
cet “algorithme” de déplacement du trafic, avec une importante addition discutée plus bas.
Code Python pour modele embouteillage
1 import numpy as np
2

3 N=300 # Nombre d'autos

4 pFrein=0.1 # Probabilite freinage aleatoire
5 nIter=1000 # Nombre de pas de temps
6

7 v=[Link](N) # Vitesses initiales nulles

8 x=[Link](N) # Positions initiales
9 x[0]=1 # premiere auto initialement a 1
10 for k in range(1,N): # repartitions initiale des autres autos
11 x[k]=x[k-1]+[Link](3.+14.*[Link]())
12

13 for iter in range(nIter): # boucle temporelle

14 for k in range(N-1): # boucle 1 sur voitures: vitesse
15 dx = x[k+1]-x[k] # calcul distance
16 if dx<5: # trop pres: on ralentit...
17 v[k]=max(0,v[k]-3)

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

 188 CHAPITRE 10. COMPLEXITÉ

18 if dx>5: # assez loin: on accelere...

19 v[k]=min(10,v[k]+1)
20

21 if x[-1]-x[-2]<=10: # cas special: la voiture de tete

22 v[-1]=min(10,v[-1]+1)
23

24 for k in range(1,N): # boucle 2 sur voitures: freinage

25 if [Link]()<=pFrein: # un bozo ralentit parfois pour rien
26 v[k]=max(0,v[k]-3)
27

28 for k in range(N-1): # boucle 3 sur voitures: on roule

29 x[k]=min(x[k]+v[k],x[k+1]-1) # deplacement (borne)
30

31 x[-1]=x[-1]+v[-1] # cas special: la voiture de tete

Notez bien, et comprenez, les aspects suivants :

1. La simulation est globalement structurée selon des boucles imbriquées, la boucle extérieure étant
l’itération temporelle et une séquence de trois boucles inconditionnelles intérieures sur les N voi-
tures ;
2. L’initialisation des positions se fait selon des incréments de taille aléatoire mais toujours positifs ;
ici 3 ≤ xk+1 − xk ≤ 17, pour un intervalle moyen de 10 unités ; cette façon de faire assure que
x1 < x2 < x3 < x4 < ... < xN ;
3. Le changements de la vitesse des voitures est tout d’abord calculé pour toutes les voitures, et
ensuite une seconde boucle modifie le tableau des positions de manière synchrone, en une étape
distincte du calcul des changements de vitesse.
4. On s’assure que la vitesse ne peut chuter sous zéro ou ne peut dépasser 10 ;
5. Un test assure que chaque voiture ne peut pas s’approcher à moins d’une unité de la voiture la
précédant ;
6. La voiture de tête, qui n’a pas de voiture la précédant, ajuste sa vitesse de manière particulière,
en fonction de la distance de la voiture la suivant ;
7. Et voici la clef de la simulation : occasionnellement, sans raison particulière autre que l’arrivée d’un
texto, le changement d’un CD, le cellulaire qui sonne, un écureuil traversant la chaussée, ou même
vraiment pour faire chier le peuple, un chauffeur aléatoire freine... Ici cet ajustement est effectué
après l’ajustement déterministe contrôlé par les distances inter-voitures.
Les Figures 10.7 et 10.8 illustrent différents aspects d’une simulation typique, ici pour un groupe de 300
voitures initialement réparties aléatoirement avec une distance inter-voiture moyenne de 10 ; il s’agit en
fait des valeurs de paramètres utilisées dans le code montré ci-haut. La figure 10.7 montre les trajectoires
de chacune des 300 voitures, i.e., 300 tracés de x versus t. Une déviation horizontale des tracés, impliquant
que x demeure constant quand t augmente, indique une vitesse zéro, soit un embouteillage ! La figure 10.8
pousse trois fois plus loin dans le temps, et se borne à indiquer les positions où les voitures sont au repos
ou presque (vitesse ≤ 1). Remarquons que même une fois la simulation poussée très loin dans le temps, des
embouteillages pouvant impliquer un nombre très variable de voitures se développent de manière en toute
apparence erratique. La plupart de ces embouteillages sont causés par le freinage aléatoire d’une voiture,
mais ce qui est remarquable est qu’un tel freinage individuel puisse produire (parfois) un embouteillage
impliquant une substantielle fraction du groupe de voitures en mouvement. L’encadré sur la Fig. 10.7
illustre la trajectoire d’une voiture particulière s’étant tout juste dépêtrée d’un embouteillage majeur
ayant affecté tout le système, et rejoignant, puis quittant, deux embouteillages secondaires en tentant
d’accélérer de nouveau. Plusieurs caractéristiques de cette simulation méritent d’être notées :
1. Le trafic se met en branle en deux phases plus ou moins distinctes : une phase initiale “solide” farcie
d’embouteillages majeurs, suivie d’une seconde phase “fluide” où toutes les voitures se déplacent
à une vitesse moyenne plus ou moins constante et légèrement inférieure à la vitesse maximale
permise. Ici la transition semble se produire à t ≃ 1300 (cf. Fig. 10.8), mais on verra plus loin que
le système atteint un état véritablement statistiquement stationnaire passablement plus tard, soit
vers t ≃ 2000.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

10.6. LE MODÈLE EMBOUTEILLAGE 189

Figure 10.7 – Évolution de la position des voitures (axe vertical) en fonction du temps (axe horizontal).
On note deux phases distinctes, la première durant laquelle la condition initiale relaxe, par une série
d’embouteillages majeurs, vers un état où la vitesse de toutes les voitures est approximativement constante,
mais où des embouteillages peuvent néanmoins se produire. Le trait orange indique la trajectoire d’une
voiture spécifique, située au trois quart du peloton. Les lignes pointillées indiquent la pente associée à
une voiture se déplaçant à la vitesse maximale v = 10. L’encadré montre un zoom sur un embouteillage ;
on y constate que les voitures ne se croisent jamais (comme il se doit puisque les dépassements sont
interdits !). Cette simulation, impliquant 300 voitures, a été effectuée avec la condition initiale et les
valeurs de paramètres tels que spécifiés dans le code de la Figure ??.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

190 CHAPITRE 10. COMPLEXITÉ

Figure 10.8 – La même simulation que sur la Figure 10.7, mais cette fois couvrant un plus grand intervalle
temporel et montrant la distribution spatiotemporelle des embouteillages. Chaque point bleu correspond
à une voiture au repos ou presque (v ≤ 1). Le carré inférieur gauche définit l’intervalle couvert sur la
Figure 10.7, et les lignes pointillées indiquent encore une fois la pente d’une trajectoire à vitesse maximale
v = 10. Les trajectoires des première et dernière voitures sont tracée en noir, et la voiture-test en orange.

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

10.6. LE MODÈLE EMBOUTEILLAGE 191

2. Même durant la seconde phase, de nombreux embouteillages se développent et disparaissent, pou-

vant n’impliquer que quelques voitures, ou une grande fraction du peloton (e.g., l’embouteillage
débutant à (x, t) ≃ (7000, 500) sur la Fig. 10.7).
3. Durant la seconde phase, une voiture quelconque tend soit à se déplacer presque à vitesse maximale,
soit à être coincée dans un embouteillage (voir trajectoire en orange).
4. L’étendue temporelle de l’embouteillage est substantiellement plus longue que le temps passé par
une voiture s’y empêtrant (trajectoire orange) ; les voitures à la tête de l’embouteillage peuvent
accélérer et s’en dépêtrer graduellement, une voiture à la fois, tandis que les voitures atteignant la
queue de l’embouteillage s’y empilent. C’est pourquoi l’embouteillage, une fois déclenché, “recule”
en x en fonction du temps (voie encadré sur Fig. 10.8).
Deux quantité intéressantes à suivre sont la vitesse moyenne des voitures :
N
1 X
⟨v⟩ = vk , (10.21)
N
k=1

et la distance moyenne entre voitures :

N −1
1 X xN − x1
⟨δ⟩ = (xk+1 − xk ) = (10.22)
N −1 N −1
k=1

(je vous laisse le soin de démontrer la seconde égalité dans cette dernière expression). La densité moyenne
de voitures (ρ ; nombre de voitures par unité de distance) est simplement l’inverse de cette expression :
N −1
ρ= (10.23)
xN − x1
Connaissant ces deux quantités, le flux (Φ) de voitures, soit le nombre moyen de voiture traversant une
position x∗ quelconque par unité de temps, se calcule facilement :

Φ = ρ × ⟨v⟩ ; (10.24)

La Figure 10.9 montre l’évolution temporelle de ⟨v⟩, ρ et Φ, pour la simulation de la Figure 10.7. On y
remarque que les valeurs numériques de ces deux quantités varient rapidement jusqu’à t ∼ 1300, ce qui
correspond au changement marqué dans la structure des embouteillages visibles sur la Fig. 10.7, cependant
la densité de voitures —et donc aussi le flux— ne se stabilise vraiment que vers t ≃ 2000.
La série d’embouteillages monstres caractérisant la phase “solide” en début de simulation suggère que
la condition initiale choisie ici n’est peut-être pas la meilleure, du point de vue de la fluidité du trafic.
Jusqu’à quel point cette condition initiale influence-t-elle l’évolution de la simulation ? Est-elle “oubliée”
rapidement ou lentement ? En fait, concoctez la condition initiale que vous voulez, ou changez le nombre
de voitures (tant que N demeure grand), le système stabilisera toujours aux valeurs statistiquement
stationnaires de ⟨v⟩, ρ et Φ de la Figure 10.9 ! Cette forme de trafic, avec ses embouteillages intermittent,
s’avère être un attracteur de la dynamique du système.
L’évolution vers une vitesse moyenne “robuste” pourrait laisser croire que toutes les voitures se dé-
placent à une vitesse ne différant pas trop de cette valeur moyenne, e.g. la distribution des vitesses a l’air
d’une gaussienne centrée sur ⟨v⟩. Ce n’est en fait pas du tout le cas, comme on peut le constater sur
examen de la Figure 10.10. La fonction de densité de probabilité est ici calculée par échantillonnage des
vitesses de toutes les voitures à tous les pas de temps dans la phase fluide (t > 3500). La distribution n’est
en rien symmétrique par rapport à la vitesse moyenne (tiret vertical à v ≃ 8.6), mais couvre l’intervalle
complet [0, 10] avec un maximum à v = 10, un pic secondaire à v = 0 correspondant aux embouteillages,
et un autre à v = 7. Ce second pic secondaire est une conséquence directe de la procédure de freinage
aléatoire, qui réduit la vitesse de 3 unités, agissant sur le pic de la distribution à v = 10. On constate
également que les voitures passent un peu plus de 60% du temps à rouler à la vitesse maximale v = 10
et environ 4% du temps coincées dans un embouteillage quelconque, ce qui n’est pas si mal finalement
(même si le niveau de stress généré serait évidemment hors de proportion par rapport à cette réalité). On
voit qu’ici la vitesse moyenne n’est pas une quantité particulièrement utile pour caractériser les vitesses
des voitures, même si elle a un sens mathématique incontestable au niveau du flux global de l’ensemble
des voitures.

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

192 CHAPITRE 10. COMPLEXITÉ

Figure 10.9 – Variation temporelle de la vitesse moyenne ⟨v⟩, de la densité de voitures ρ, et du flux Φ,
pour la simulation des Figures 10.7 et 10.8, maintenant poussée jusqu’à 5000 pas de temps.

Vous aurez probablement déjà saisi que la formation d’un embouteillage représente une forme d’ava-
lanche de freinages successifs. Si l’analogie tient, on pourrait s’attendre à ce que ces “avalanches” soient
caractérisées par une invariance d’échelle. La taille d’un embouteillage devrait normalement être définie
comme le nombre de voitures bloquée (vkn ≤ 1) sommé sur la durée d’arrêt de chaque voiture impliquée.
Autrement dit, le nombre de points bleus dans chaque “amas” distinct sur la Figure 10.8. Une alternative
plus facile consiste à choisir quelques voitures-test (genre, une dizaine) suffisamment séparées l’une de
l’autre, et de comptabiliser les durées des phases où chaque voiture est arrêtée ou presque (dans le sens
vkn ≤ 1). On sait déjà (voir Figures 10.7 et 10.8) que ces phases sont plus courtes que la durée de l’embou-
teillage dans son ensemble, mais elles devraient tout de même montrer les même distributions statistiques.
Dans les deux cas, on obtient, devinez quoi, une loi de puissance, indiquant une invariance d’échelle au
niveau des embouteillages.
Globalement, ce qui compte au niveau du déplacement efficace du traffic, c’est de maximiser le flux de
voitures, soit le produit de la densité moyenne de la vitesse moyenne. On pourrait imaginer imposer un
grand espacement entre chaque voiture, de manière telle à ce qu’un freineur aléatoire ait assez de temps
pour ré-accélérer à la vitesse maximale avant de forcer la voiture le suivant à ralentir. Cependant, une telle
configuration serait caractérisée par une densité moyenne de voiture très faible, donc un flux très faible
même si toutes les voitures roulent à vitesse maximale. Inversement, forcer toutes les voitures à rouler
très près les unes des autres, de manière à avoir une très haute densité et donc un très haut flux, garantit
que le moindre freinage aléatoire causera un embouteillage monstre qui forcera l’arrêt complet d’un très
grand nombre de voitures, diminuant ainsi drastiquement le flux. Mais voici le truc vraiment subtil :
l’état bordellique du trafic simulé ici, avec ses embouteillages spatiotemporellement intermittents et de
toutes tailles, représente l’état qui maximise le flux de voitures, en présence de freineurs aléatoires. Et cet
état est auto-régulé, dans le sens qu’il émerge naturellement des interactions locales entre chaque voiture
et ses deux voisines. On pourrait même déclarer que le système est dans un état critique, dans les sens
qu’une petite perturbation spatialement localisée —un freinage aléatoire quelquepart— a une probabilitée

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

10.7. COMPLEXITÉ ̸= STOCHASTICITÉ ̸= CHAOS 193

Figure 10.10 – Fonction de distribution de probabilité des vitesses, construite à partir des mesures de
vitesses de toutes les voitures à chaque pas de temps pour la simulation des Figs. 10.7, 10.8, et 10.9, dans
la phase “fluide” t > 3500. Le trait vertical noir indique la vitesse moyenne, et le pic secondaire à v = 7
est produit par le freinage aléatoire (v → v − 3) de voitures se déplaçant à vitesse maximale (voit texte).

définitivement non-nulle de causer un changement global dans tout le système —un embouteillage stoppant
la quasi-totalité des voitures. On pourrait donc dire qu’on a encore ici affaire à un système en état
d’autorégulation critique.

10.7 Complexité ̸= Stochasticité ̸= chaos

Les trois systèmes considérés ici ont été déclarés complexes a priori (en commençant avec le titre du
chapitre !). Cependant, les chapitres 8 et 9, nous ont également mis face à divers systèmes se comportant de
manière “complexe”, du moins dans le sens vernaculaire du terme. On peut donc légitimement s’interroger
sur la présence ou absence de différences fondamentales permettant de distinguer et/ou catégoriser les
sytèmes stochastiques, chaotiques et complexes (maintenant dans le sens mathématico-physique du terme).
Si on se limite aux système dont l’extrant peut être quantifié mathématiquement, alors l’évolution du
système peut habituellement se décrire comme une séquence de nombres ou de symboles plus abstraits.
Il s’avère que dans de tels cas, il existe une mesure de la complexité qui peut se définir rigoureusement :
c’est la complexité algorithmique.
Considérons les six mystérieuses séquences de 20 entiers tabulées dans chaque colonne du Tableau 10.3.
Comme chaque entier est composé ici de 5 chiffres (base 10), chaque colonne contient donc à strictement
parler 100 caractères, qui occuperait conséquemment 100 octets de mémoire sur votre ordinateur ; et si
les colonnes avaient 2 × 106 nombres plutôt que 20, ceci demanderait 10 MégaOctet (MO) de mémoire.
La quantité de mémoire requise augmente tout simplement linéairement avec la longueur de la séquence,
et est donc la même pour chacune des séquences du Tableau 10.3.
Mais examinons de plus près la première colonne (séquence s1 ) ; il s’agit ici d’une alternance régulière
de 00000 et 00001. Donc, plutôt que d’emmagasiner en mémoire 5MO de 00000 et 5MO de 00001, il

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

194 CHAPITRE 10. COMPLEXITÉ

Table 10.3 – Six séquences numériques plus ou moins mystérieuses...

s1 s2 s3 s4 s5 s6
00000 00002 00001 00001 06464 11009
00001 00003 00002 00004 23945 31788
00000 00004 00003 00005 72118 85928
00001 00005 00005 00008 79626 59284
00000 00006 00008 00009 64242 22379
00001 00007 00013 00014 90967 39022
00000 00008 00021 00003 32538 47769
00001 00009 00034 00020 86925 22116
00000 00010 00055 00025 45004 52061
00001 00011 00089 00007 98011 34803
00000 00012 00144 00003 07716 16195
00001 00013 00233 00024 28198 97786
00000 00014 00377 00025 80178 39746
00001 00015 00610 00004 62934 09349
00000 00016 00987 00017 92374 09128
00001 00017 01597 00046 27894 29219
00000 00018 02584 00021 79649 03260
00001 00019 04181 00025 64187 26513
00000 00020 06765 00049 91028 37855
00001 00021 10946 00023 32339 87804

pourrait être judicieux d’emmagasiner un programme générant 00000 et 00001 en alternance, 20 millions
de fois. De même, la seconde séquence pourrait être emmagasinée dans un programme qui débute à 00001,
et ajoute 1 à ceci, 2 millions de fois. La séquence s3 est plus difficile à déchiffrer ; elle croit de manière
monotone mais définitivement pas linéaire ou quadratique, mais il semble avoir un pattern ici également.
La quatrième séquence semble encore plus irrégulière, dans le sens que globalement elle semble croitre
comme s2 et s3 , mais avec des baisses occasionnelles. Les séquences s5 et s6 , quant à elles, ne présentent
rien qui ressemble à un pattern pouvant s’encoder dans une instruction simple. “À l’oeil”, on pourrait
donc être tenté de classer les six séquence par ordre de complexité croissante, de la manière suivante
(schématiquement) :
[s1 ] < [s2 ] < [s3 ] < [s4 ] < [s5 ] ≃ [s6 ] .
Donc, même si toutes les séquences sont définies par le même nombre total d’entiers, on serait tenté de
dire que les deux premières sont les plus “simples” et les deux dernières sont les plus “complexes”, parce
que les premières peuvent clairement être “compressées” en quelques instruction de production, mais
(apparemment) pas les autres.
Cette idée est formalisée sous l’appellation de complexité algorithmique, qui est définie comme la
longueur (mesurée en octets, par exemple) du programme le plus court pouvant produire une séquence
donnée. Si il n’y a vraiment pas de pattern dans la séquence (comme apparamment ici avec s5 et s6 ), un
tel programme ne pourra qu’énumérer les membres de la séquences, dans lequel cas le programme aura
essentiellement la même longueur que la séquence même. Mais parfois, comme dans le cas des séquences
s1 er s2 , le programme sera beaucoup plus court que la séquence.
En fait, les six séquences du Tableau 10.3 ont été produite par le petit bout de code montré ci-dessous.
Les séquences s1 , s2 , s3 (séquence de Fibonnacci) et s5 (séquence chaotique produite par carte logistique)
s’avèrent à avoir une complexité algorithmique comparable, dans le sens qu’elles sont toutes produites par
une instruction séquentiellement répétée, soit la ligne de code à l’intérieur de la boucle. Ici ces instructions
n’impliquent que des opérations arithmétiques simples, comme l’addition ou la multiplication. La séquence
s4 est également produite par une seule ligne de code, mais utilise l’opérateur “%”, qui calcule le reste
de la division du chiffre le précédant par celui le suivant ; opération à prime abord plus compliquée que
l’addition ou la multiplication, mais qui du point de vue de la manière dont elle est calculée par l’ordi,
ne l’est pas vraiment. La séquence s6 , quant à elle, résulte d’une manipulation simple d’une séquence de
nombres pseudo-aléatoires, de complexité algorithmique plus élevée parce qu’il y a pas mal d’instructions
cachées dans la fonction [Link](). Les trois systèmes complexes étudiés dans ce chapitre

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

 10.8. COMPLEXITÉ ET ÉMERGENCE 195

peuvent tous être définis par un code long d’une page et qui utilise [Link](), donc on devra
assigner à leur extrant (e.g., séquence temporelle de sable déplacé ; d’arbres brulés ; vitesse d’une voiture)
une complexité algorithmique encore plus élevée.
Code Python pour calculer les six séquences du Tableau 10.3.
1 #Calcul six sequences plus ou moins complexes de nombres
2 import numpy as np
3 NN=21
4

5 x1=[Link](NN)
6 x2=[Link](NN)
7 x3=[Link](NN)
8 x4=[Link](NN)
9 x5=[Link](NN)
10 x6=[Link](NN)
11

12 # Sequence 1: bitflip
13 for k in range(NN): x1[k]=(k+1)%2
14

15 # Sequence 2: entiers positifs

16 x2[0]=1.0
17 for k in range(1,NN): x2[k]=x2[k-1]+1
18

19 # Sequence 3: Fibonnacci
20 x3[0]=1.0
21 x3[1]=1.
22 for k in range(2,NN): x3[k]=x3[k-1]+x3[k-2]
23

24 # Sequence 4: a mod k
25 for k in range(NN): x4[k]=12345%(3*k+1)
26

27 # Sequence 5: Carte logistique, regime chaotique

28 r=0.99
29 x5[0]=0.983399
30 for k in range(1,NN): x5[k]=4.*r*x5[k-1]*(1.-x5[k-1])
31 x5=[Link](1.e5*x5)
32

33 # Sequence 6: Aleatoires uniforme dans [0,1]

34 for k in range(NN): x6[k]=[Link]()
35 x6=[Link](1.e5*x6)
36

37 # Sortie
38 for n in zip(x1[1:],x2[1:],x3[1:],x4[1:],x5[1:],x6[1:]):
39 print(("{:05n} "*6).format(*n))

Donc, du point de vue de la complexité algorithmique, on devrait donc reclasser nos six séquences,
ainsi que les trois systèmes étudiés dans ce chapitre, de la manière suivante (toujours schématiquement) :
[s1 ] ≃ [s2 ] ≃ [s3 ] ≃ [s5 ] ≃ [s4 ] < [s6 ] < [TdS] ≃ [FdF] ≃ [A15] .
À moins d’avoir l’esprit vraiment tordu, ceci n’est définitivement pas conforme à l’impression “intuiti-
ve” produite par un premier examen du tableau 10.3, telle que reflétée dans notre premier classement
préliminaire.

10.8 Complexité et émergence

On a vu que les processus stochastiques classiques n’ont aucune mémoire ; il est donc impossible, par
exemple, de prédire la trajectoire d’un marcheur aléatoire. Donc, vu la nature stochastique du mécanisme

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal

196 CHAPITRE 10. COMPLEXITÉ

déclencheur dans les modèles TdS, FdF, et A15, on s’attendrait à juste titre qu’il soit impossible de
prédire leur comportement dans le détail (e.g., étant donné l’état du système à l’itération n, où et quand
se déclenchera la prochaine avalanche ou le prochain feu). Cependant il ne faut surtout pas en conclure que
ces systèmes se comportent de manière véritablement stochastique, puisque l’état du système à l’itération
n a une très forte influence sur l’état du système à l’itération n + 1. Il est certainement vrai que les
systèmes stochastiques et complexes impliquent habituellement un grand nombre de degrés de liberté.
Mais, même si la trajectoire d’un seul marcheur aléatoire peut paraitre très “complexe”, comme on l’a vu
l’évolution de la distribution d’un très grand nombre de marcheurs est, elle, très simple, et exprimable
sous la forme d’une équation différentielle pouvant même parfois être solutionnée analytiquement. Ce
n’est certainement pas le cas des systèmes complexes en état d’autorégulation critique, qui ne se portent
absolument pas à ce genre de réduction statistique. À mesure que l’on augmente le nombre de degrés de
liberté dans le système, la possibilité de produire une grande “fluctuation” par rapport à l’état moyen (i.e.,
une avalanche de taille comparable à l’échelle globale du système) reste la même ! Tout le contraire de la
convergence statistique des systèmes stochastiques, où dans la limite N → ∞ les fluctuations diminuent
comme N −1/2 .
La relation avec les systèmes chaotiques est encore plus difficile à établir. Ces derniers impliquent
habituellement un nombre relativement bas de degrés de liberté, et leur évolution est (habituellement)
régie par des règles complètement déterministes qui font que l’état du système au temps t + ∆t est
complètement fixé par l’état du système au temps t. L’antithèse même des processus stochastiques, mais
il peut sembler y avoir un lien ici avec les systèmes complexes, puisque ceux-ci évoluent également de
manière purement déterministe, sauf pour le déclenchement des avalanches. Pourrait-on imaginer un
système complexe comme un système chaotique ayant un grand nombre de degrés de liberté, et sujet à un
faible forçage stochastique ? La réponse s’avère être non, et, ultimement, est associée à la manière dont
les décorrélations s’effectuent dans ces systèmes. Dans les systèmes chaotiques, la décorrélation de deux
solutions différant très peu se produit lors de l’approche de points critiques dans l’espace de phase du
système (retournez voir la Fig. 8.11). Ces points critiques peuvent être identifiés ab initio si la dynamique
de chaque degré de liberté est connue. Dans un système complexe en régime SOC, deux noeuds du réseau
décorrèlent au passage d’une avalanche, dont les caractéristiques ne peuvent absolument pas être anticipée
sur la base des règles d’évolution locales.
L’émergence d’une dynamique globale qualitativement distincte de la dynamique locale semble donc
être la condition sine qua non requise pour déclarer qu’un système est complexe.

Exercices:

1. Vérifiez que l’éq. (10.7) résulte bien de l’application de la règle de redistribution définie par
l’éq. (10.4).
2. Élaborez et codez une version 2D du modèle TdS de la §10.2. Mesurez les tailles et durée des
avalanches une fois le système dans son état SOC, et montrez que ces deux quantités se distribuent
comme des lois de puissance.
3. Modifiez le code C pour le modèle FdF (Fig. ??) de manière à opérer en mode “stop-and-go”,
c’est-à dire qu’aucun arbre ne peut pousser tant qu’un feu brûle quelquepart sur le réseau. Dans
quel(s) régions(s) de l’espace des paramètres celà change-t-il le comportement du modèle ?
4. Modifiez le code C pour le modèle FdF (Fig. ??) de manière à ce que seul les quatres voisins
haut+bas+gauche+droite puissent enflammer un arbre. Celà change-t-il le comportement global
du modèle ?
5. L’équation (10.13) se comporte de manière pathologique (→ ∞) pour une loi de puissance ayant
α = 2. Comment vous y prendriez vous pour calculer le nombre d’arbres détruits par l’ensemble
des feux dans cette situation ?

Bibliographie:

Plusieurs bouquins traitant de complexité à saveur grand public ont été écrits, et sont devenus des
“best-sellers”. Il pourrait être instructif d’en lire au moins un. Je doit bien être la seule personne que je
connaisse ( !) à ne pas avoir été particulièrement épaté à la lecture du best-seller The Quark and the Jaguar,

PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal 24 août 2022

10.8. COMPLEXITÉ ET ÉMERGENCE 197

par Murray Gell-Mann (Prix Nobel de Physique 1969 !), mais c’est définitivement un incontournable sur
le sujet, dans la catégorie non-technique. Plusieurs ouvrages passablement plus techniques sont également
disponibles. Ils font cependant souvent dans la superficialité, en partie en raison de la vaste gamme
d’applications du sujet, et aussi en raison du fait qu’il n’existe pas à l’heure actuelle de théorie de la
complexité. Dans cette catégorie, ma préférence (en date de la mi-novembre 2009) va à
Érdi, P., Complexity Explained, Springer (2008).
Une exception notable à cette tendance à la superficialité est ce qui est rapidement devenu le Manifeste
du (maintenant défunt) Santa Fe Institute, soit l’ouvrage :
Kauffman, S.A., The Origin of Order, Oxford University Press (1993),
mais l’emphase y est nettement mise sur les systèmes biochimiques. Je suggérerais également l’éclectique
bouquin
Hofstadter, D.R., Gödel, Escher, Bach, Basic Books (1979),
qui, bien que datant de maintenant 30 ans, demeure une lecture des plus stimulantes intellectuellement.
Les chapitres 15 à 19 de l’ouvrage de Flake cité au chapitre 7 représentent également une intéressante
introduction au sujet. Tout ce que vous voudriez savoir sur les automates cellulaires se trouve fort proba-
blement dans la plus récente brique de Stephen Wolfram (l’inventeur du logiciel Mathematica) :
Wolfram, S., A new kind of science, Wolfram Media Inc. (2002).
Cependant, préparez vous psychologiquement à devoir endurer l’égo cosmologique de l’auteur, suintant
abondamment de chaque page souvent au point de rendre la lecture irritante. Sur la criticalité auto-régulée,
commencez par
Bak, P., Quand la nature s’organise (trad. How Nature Works), Flammarion (1999),
et passez ensuite à la vision plus cartésienne du sujet telle que développée dans :
Jensen, H.J., Self-organized Criticality, Cambridge (1998).

24 août 2022 PHY1234, Paul Charbonneau/David Lafrenière, Université de Montréal