Embed Size (px)
Citation preview
MathematicaUn langage pour l'ingénieur
Thierry Verdel (2009)
La représentation graphique de couverture a été obtenue au moyen de la commande suivante :
ContourPlot3D[x^4 + y^4 + z^4 - (x^2 + y^2 + z^2)^2 + 3 (x^2 + y^2 +
z^2) == 3, {x, -2, 2}, {y, -2, 2}, {z, -2, 2}, Mesh Ø None,
ContourStyle Ø Directive[Orange, Opacity[0.8], Specularity[White,
30]]]
Ce document a été entièrement réalisé avec Mathematica’, marque déposée de Wolfram Research, Inc.
Table des matières
ii Table des matières
Table des matières
Chapitre 1 ...........................................................................................................................................................1
1 Introduction ...................................................................................................................................................31.1 Qu'est ce que Mathematica ? ....................................................................................................................3
1.2 Comment Mathematica fonctionne-t-il ? ..............................................................................................3
1.3 A propos de ce document .......................................................................................................................4
Chapitre 2 ...........................................................................................................................................................7
2 Aperçu des fonctionnalités de Mathematica ...................................................................................9
2.1 Calculs numériques ..................................................................................................................................9
2.2 Algèbre et calcul symbolique .................................................................................................................10
2.3 Résolutions d'équations ...........................................................................................................................12
2.4 Calcul matriciel ..........................................................................................................................................13
2.5 Manipulation de listes ..............................................................................................................................14
2.6 Représentations graphiques ...................................................................................................................17
2.7 Les 1000 premières décimales de p .....................................................................................................21
Chapitre 3 .............................................................................................................................................................23
3 Prise en main de Mathematica ................................................................................................................25
3.1 Premier calcul .............................................................................................................................................25
3.2 Mise en page, utilisation des styles et des feuilles de style .............................................................26
3.3 Image écran et contenu de la mémoire ..............................................................................................27
3.4 Les expressions et leur évaluation ........................................................................................................31
3.4.1 Tout est expression .................................................................................................................................31
3.4.2 L'évaluation des expressions ...................................................................................................................33
3.5 Règles de syntaxe ......................................................................................................................................34
3.5.1 Nommage des fonctions .........................................................................................................................34
3.5.2 Parenthèses, crochets, accolades .............................................................................................................36
3.5.3 Représentations d'une expression ...........................................................................................................36
3.5.4 Notations ................................................................................................................................................37
3.6. Aides .............................................................................................................................................................38
3.6.1 Aide interactive .......................................................................................................................................38
3.6.2 Aide en ligne ...........................................................................................................................................39
3.7 Exercices ......................................................................................................................................................42
3.7.1 Recherche d'une fonction .......................................................................................................................42
3.7.2 Calcul numérique ...................................................................................................................................42
3.7.3 Problème .................................................................................................................................................43
Chapitre 4 .............................................................................................................................................................45
4 Définir une fonction ..................................................................................................................................47
4.1 Affectation instantanée et affectation différée ..................................................................................47
4.2 Ma première fonction ..............................................................................................................................49
Table des matières iii
4.3 Fonction typée ............................................................................................................................................52
4.3.1 Typage formel ........................................................................................................................................52
4.3.2 Typage conditionnel ...............................................................................................................................54
4.4 Fonction polymorphe ...............................................................................................................................56
4.5 Fonction à plusieurs arguments ............................................................................................................57
4.6 Arguments par défaut ..............................................................................................................................58
4.7 Fonction récursive et fonction à mémoire .........................................................................................58
4.8 Exercices ......................................................................................................................................................61
4.8.1 Définir une fonction ...............................................................................................................................61
4.8.2 Définir une fonction paramétrique .........................................................................................................61
4.8.3 Orthogonalisez des vecteurs ...................................................................................................................62
Chapitre 5 .............................................................................................................................................................63
5 Programmation par motifs ....................................................................................................................65
5.1 Rappel ..........................................................................................................................................................65
5.2 Fonction effectuant des opérations symboliques ..............................................................................66
5.3 Utilisation des attributs ............................................................................................................................67
5.4 Programmation par motifs .....................................................................................................................69
5.5 Répétition de motifs .................................................................................................................................71
5.6 Fonctions internes exploitant les motifs ..............................................................................................71
5.7 Exercices ......................................................................................................................................................73
5.7.1 L'opérateur logarithme ...........................................................................................................................73
5.7.2 Argument "liste de couples" ...................................................................................................................73
5.7.3 Nettoyer une liste ....................................................................................................................................73
5.7.4 Recherche de maxima dans une liste .....................................................................................................73
5.7.5 Extraction des arguments dans une expression ......................................................................................74
Chapitre 6 .............................................................................................................................................................75
6 Fonctions pures ............................................................................................................................................77
6.1 Fonctions pures ..........................................................................................................................................77
6.2 Outils pour la programmation fonctionnelle ....................................................................................78
6.2.1 Fonction Map .........................................................................................................................................78
6.2.2 Fonction Apply .....................................................................................................................................78
6.2.3 Fonction Nest (et NestList) .............................................................................................................78
6.2.4 Fonction FixedPoint (et FixedPointList) ................................................................................82
6.2.5 Fonction Fold (et FoldList) .............................................................................................................83
6.2.6 Combinaisons .........................................................................................................................................83
6.3 Exercices ......................................................................................................................................................84
6.3.1 Programmation fonctionnelle .................................................................................................................84
6.3.2 Programmation fonctionnelle .................................................................................................................84
6.3.3 Programmation fonctionnelle .................................................................................................................84
6.3.4 Programmation fonctionnelle .................................................................................................................84
Chapitre 7 .............................................................................................................................................................87
7 Modules ............................................................................................................................................................89
7.1 Nécessité d'un dispositif de protection des symboles ......................................................................89
7.2 Utilisation de Module ............................................................................................................................89
7.3 Utilisation de Block ...............................................................................................................................93
7.4 Différence entre Module et Block ..................................................................................................95
iv Table des matières
7.4 Différence entre Module et Block ..................................................................................................95
7.5 Dialogue avec l'utilisateur .......................................................................................................................96
7.6 Exercices ......................................................................................................................................................96
7.6.1 Cercle passant par trois points ................................................................................................................96
7.6.2 Cercles de Mohr .....................................................................................................................................97
7.6.3 Boîtes à moustaches ................................................................................................................................97
Chapitre 8 .............................................................................................................................................................99
8 Substitutions ...................................................................................................................................................101
8.1 Substitution instantanée ..........................................................................................................................101
8.2 Substitution différée ..................................................................................................................................104
8.3 Substitutions multiples .............................................................................................................................107
8.4 Programmation par règles et motifs ....................................................................................................108
8.5 Les options des fonctions .........................................................................................................................109
8.6 Exercices ......................................................................................................................................................112
8.6.1 Solution d'une équation de degré 3 ........................................................................................................112
8.6.2 Cercles de Mohr (bis) ..............................................................................................................................112
8.6.3 Transformation graphique .....................................................................................................................112
8.6.4 Transformation graphique .....................................................................................................................112
8.6.5 Transformation d'expression ..................................................................................................................113
8.6.6 Transformation simple ...........................................................................................................................113
Chapitre 9 .............................................................................................................................................................115
9 Graphiques .....................................................................................................................................................117
9.1 Commandes graphiques préprogrammées ........................................................................................117
9.1.1 Représenter des fonctions .......................................................................................................................117
9.1.2 Visualiser des données ............................................................................................................................120
9.1.3 Options courantes ..................................................................................................................................122
9.1.4 Combinaison de représentations graphiques .........................................................................................128
9.1.5 Animations et représentations graphiques interactives ..........................................................................130
9.2 Programmation des graphiques ............................................................................................................133
9.2.1 Primitives graphiques 2D .......................................................................................................................133
9.2.2 Primitives graphiques 3D .......................................................................................................................138
9.2.3 Directives graphiques ............................................................................................................................139
9.3 Exercices ......................................................................................................................................................141
9.3.1 Fréquences et histogrammes ..................................................................................................................141
9.3.2 Etoiles .....................................................................................................................................................141
9.3.3 Fractales ..................................................................................................................................................142
Chapitre 10 ..........................................................................................................................................................145
10 Programmation objet .............................................................................................................................147
10.1 Exemple introductif ................................................................................................................................147
10.2 UpValues ...............................................................................................................................................148
10.3 Programmation objet .............................................................................................................................150
10.4 Exercices ....................................................................................................................................................153
10.4.1 L'objet Triangle ....................................................................................................................................153
10.4.2 Comptabilité .........................................................................................................................................153
Table des matières v
Chapitre 11 ..........................................................................................................................................................155
11 Packages .........................................................................................................................................................157
11.1 Les packages ou Add-ons existants (standard) ................................................................................157
11.2 La notion de contexte ............................................................................................................................158
11.3 Programmation d'un package .............................................................................................................161
11.4 Exercices ....................................................................................................................................................165
11.4.1 NormalPlot ...........................................................................................................................................165
11.4.2 NormalPlot avec des options ................................................................................................................165
11.4.3 Package .................................................................................................................................................166
Chapitre 12 ..........................................................................................................................................................167
12 Interactivité ..................................................................................................................................................169
12.1 Vues multiples ..........................................................................................................................................169
12.2 Interactivité avec les expressions : la fonction Manipulate ........................................................170
12.3 Boutons ......................................................................................................................................................173
12.4 Dialogues ...................................................................................................................................................174
12.5 Variables dynamiques ...........................................................................................................................177
12.6 Les projets de démonstration ..............................................................................................................184
12.7 Exercice .....................................................................................................................................................184
Chapitre 13 ..........................................................................................................................................................185
13 Le langage des notebooks ....................................................................................................................187
13.1 Objets, commandes et manipulations de base ...............................................................................187
13.2 Mainpulation de fichiers .......................................................................................................................190
13.3 Autres outils ..............................................................................................................................................191
13.3.1 Tableaux visuelss ..................................................................................................................................191
13.3.2 Fabrication de palettes ..........................................................................................................................192
13.3.3 Caractères spéciaux ..............................................................................................................................193
13.4 Exercices ....................................................................................................................................................193
13.4.1 Notebooks automatiques ......................................................................................................................193
13.4.2 Palette ...................................................................................................................................................193
vi Table des matières
Chapitre 1
Introduction
2 1. Introduction
1 Introduction
1.1 Qu'est ce que Mathematica ?
Mathematica est un logiciel général pour le calcul scientifique et technique dont les applications portent sur tous les
domaines de la science et de la technologie. Doté de près de 5000 fonctions intégrées (version 7 packages inclus), d'une
interface riche et astucieuse faisant office de traitement de texte avancé, d'une documentation exhaustive et interactive
ainsi que d'un langage polymorphe très puissant, il constitue probablement l'un des meilleurs outils de calcul général
pour l'ingénieur, le chercheur, l'enseignant ou l'étudiant.
Il a été conçu à l'origine par Stephen Wolfram, un scientifique britannique surdoué qui obtient en effet un PhD en
physique théorique à Caltech en 1979, à l'âge de 20 ans. Il y travaille notamment sur la Physique des Hautes Energies, la
Théorie Quantique des Champs et la Cosmologie. En 1982, il s'intéresse à la compréhension des mécanismes à l'origine
des comportements complexes dans un grand nombre de systèmes naturels et artificiels. Il est notamment l'un des
premiers à utiliser des modèles de calcul appelés automates cellulaires pour étudier les origines de la complexité dans des
systèmes dont les composantes sont simples. En 1984, il invente un procédé de cryptographie utilisant les automates
cellulaires, et en 1985, il co-invente une nouvelle approche de calcul en Dynamique des Fluides. Après avoir été
Professeur pendant 2 ans à Caltech à partir de 1979 puis travaillé à l'Institut des Etudes Avancées de Princeton pendant
4 ans, il part pour l'Université d'Illinois où, jusqu'en 1990, il est simultanément directeur du centre de recherche sur les
systèmes complexes et Professeur de Physique, de Mathématiques et d'Informatique. Depuis 1987, il est le président
fondateur de Wolfram Reserch Inc., la société qui a développé et qui commercialise Mathematica.
La conception de Mathematica a commencé en 1986. La première version de Mathematica a été livrée en Juin 1988, la
version 2 en Juin 1991, la version 3 en Décembre 1996, la version 4 en Septembre 1999, la version 5 en 2003 et la
version 7 en 2009.
Mathematica traite les calculs de manière unifiée, qu'ils soient numériques, symboliques ou graphiques. Pour cela, il utilise des
expressions symboliques permettant de donner une représentation la plus générale possible des mathématiques et d'autres
structures. La généralité des expressions symboliques permet à Mathematica de couvrir un vaste champ d'applications avec
un nombre réduit de méthodes mathématiques et informatiques comme nous le verrons dans ce livre. Doué pour la mise
en page, il permet de calculer tout en composant des documents joliment présentés. Les feuilles de calcul deviennent
ainsi des articles scientifiques, des polycopiés ou même des livres comme celui-ci. Il reconnaît de très nombreux formats
tant pour l'importation et l'exportation de données que pour le partage des documents. De même il existe en version web
(webMathematica’) et en version grille de calcul (gridMathematica’).
L'utilisation la plus courante de Mathematica est celle d'un solveur : vous posez une question sous forme de commandes et
Mathematica renvoie la solution. Vous disposez alors de plusieurs milliers de fonctions prédéfinies vous permettant
d'apporter des réponses directes à vos calculs.
Mais l'étendue des calculs possibles avec Mathematica est toutefois bien plus importante qu'avec un calculateur
traditionnel ou un langage de programmation classique tel que Fortran, Pascal, C ou Java. Ainsi, alors qu'un système
traditionnel peut supporter une trentaine d'opérations mathématiques, Mathematica possède près de 5000 fonctions
(packages standard inclus) auxquelles peuvent s'ajouter des milliers de fonctions disponibles gratuitement sur Internet ou
sous forme de package payants. Mais, comme nous le verrons, il n'est pas nécessaire de connaître le nom de toutes ces
fonctions pour faire un usage intelligent de Mathematica ou exploiter pleinement ses possibilités.
Mathematica est le système (de calcul formel) le plus répandu dans le monde à ce jour. Sa documentation est exemplaire.
Son langage est intellectuellement séduisant et sémantiquement très riche. Le système est robuste. On retiendra
notamment que là où la résolution d'un problème nécessite 20 lignes de code en Fortran, Pascal, C ou Java, une seule
ligne en moyenne suffit en Mathematica. C'est beaucoup de temps gagné et beaucoup d'élégance en plus.
1.2 Comment Mathematica fonctionne-t-il ?
Le système Mathematica est composé de deux logiciels distincts : le noyau, qui effectue en réalité les calculs et l'éditeur
qui traite les interactions avec l'utilisateur.
Le noyau (kernel en anglais) fonctionne de la même façon sur tous les ordinateurs qui exécutent Mathematica. Par contre,
l'éditeur est optimisé pour des ordinateurs et des interfaces utilisateurs particuliers.
1. Introduction 3
Le noyau (kernel en anglais) fonctionne de la même façon sur tous les ordinateurs qui exécutent Mathematica. Par contre,
l'éditeur est optimisé pour des ordinateurs et des interfaces utilisateurs particuliers.
L'éditeur (front-end) manipule des documents appelés cahiers (notebooks). Ce sont des documents interactifs permettant
une organisation hiérarchique de textes, d'expressions Mathematica et de représentations graphiques produites par
Mathematica, à la manière d'un traitement de texte scientifique. J'utiliserai plus souvent les mots anglais de Front-End, Kernel
et de Notebooks dans la suite, pour des raisons de commodité et de similitude avec le nom de certaines commandes de
Mathematica que nous explorerons.
Le noyau traduit (ou interprète) toutes les expressions envoyées par le Front-End, effectue les calculs et renvoie la
solution dans le Front-End.
Mathematica est par ailleurs l'un des logiciels les plus complexes jamais développés. Son code source est une
combinaison de C et de Mathematica et comporte plusieurs dizaines de milliers de pages. A titre d'exemple, la fonction
Integrate a demandé 500 pages de code Mathematica et 600 pages de code C.
1.3 A propos de ce document
Ce document est entièrement écrit avec le Front End de Mathematica (version 7) et imprimé directement depuis
Mathematica.
Tout en s'appuyant en partie sur «!L'essentiel de Mathematica!» (Global Design, 1999), mon premier ouvrage, il propose
un apprentissage à Mathematica beaucoup plus appronfondi, mieux structuré, plus rationnel et plus progressif. Il peut
notamment constituer le support écrit d'un cours consacré à l'apprentissage de Mathematica comme c'est le cas à l'Ecole
des Mines de Nancy.
Il puise assez librement dans différents ouvrages et en particulier dans les différentes versions du MathematicaBook (la
documentation officielle) mais je me suis parfois appuyé sur d'autres ouvrages dont le plus ancien, en français, est :
«!Mathematica, une nouvelle approche du calcul scientifique!» de Abdallah Sfeir (Global Design, 1993), autrefois professeur à
l'Ecole des Mines de Nancy et qui m'a fait découvrir Mathematica. D'autres, rédigés en anglais m'ont également aidé et
permis de découvrir différentes facettes du logiciel. Il s'agit principalement de «!Programming in Mathematica!» de Roman
Maeder (Addison-Wesley,1989), indispensable pour qui veut exploiter au mieux les possibilités de programmation avec
Mathematica, de «!Mathematica for the Sciences!» de Richard E. Crandall (Addison-Wesley, 1991) que j'apprécie pour la
qualité de ses exemples, de «!Exploring Mathematics with Mathematica!», l'ouvrage de Theodore W.!Gray (Addison-Wesley,
1991) remarquable pour sa qualité pédagogique, de «!Mastering Mathematica!» de John W. Gray (Academic Press, 1991)
pour sa complétude et ses exercices, de «!Mathematica Graphics » de Tom Wickham-Jones (Telos, 1994) pour son exposé de
toutes les possibilités graphiques du logiciel.
En français, je recommande l'excellent «!Mathematica, calcul formel et programmation symbolique pour l'informatique scientifique!»
de Rémi Barrère (Vuibert, 2002), celle de «!Mathematica 3 par la pratique!» de Yves Pointevineau (Eyrolle, 2000) ou encore
celle utile de «!Faire des maths avec Mathematica!» de Norbert Verdier (Ellipses, 2000).
On trouvera également des ateliers spécifiques développés dans «!Ateliers Mathematica!» coordonné par Robert Erra
(Vuibert, 2003) auquel j'ai eu le plaisir de participer. Et je n'oublie pas des ouvrages plus anciens comme «!Introduction à
Mathematica!» de Jean-Christophe Culioli (1991) ou «!Mathematica pour classes préparatoires et DEUG scientifiques!» de
Jacqueline Zizi (1997).
Ce document a été réalisé avec la version MacOS X’ de Mathematica!7.
Les exemples exposés dans le document se présenteront toujours ainsi : les entrées en courier gras et les sorties
en courier standard sur le modèle suivant :
IntegrateB1
1 + x3, xF
ArcTanB -1+2 x
3F
3
+1
3Log@1 + xD -
1
6LogA1 - x + x2E
4 1. Introduction
Pour obtenir le nombre de variables et fonctions intégrées au noyau de Mathematica, on peut utiliser la commande
suivante où le caractère "*" désigne n'importe quel caractère ou chaîne de caractères connus du logiciel :
Length@Names@"*"DD3480
1. Introduction 5
6 1. Introduction
Chapitre 2
Aperçu
8 2. Aperçu
2 Aperçu des fonctionnalités de Mathematica
L'objet de ce chapitre est de donner un aperçu des opérations qu'il est possible d'envisager avec Mathematica. Sa lecture
est rapide et permet de repérer des fonctions essentielles, d'usage fréquent. Il peut servir de support à une présentation de
Mathematica devant un auditoire.
2.1 Calculs numériques
Avec Mathematica, il est possible d'effectuer des calculs aussi simplement qu'avec une calculette. Il suffit d'entrer une
opération et Mathematica donne le résultat (on peut utiliser la palette BasicInput pour taper 32, taper directement 3^2 ou
utiliser un raccourci clavier en tapant 3!‚!^!2) :
5 + 32
14
Contrairement à une calculatrice numérique, Mathematica donne des résultats exacts quelle que soit la taille des
nombres calculés. Ainsi 12 à la puissance 35 donne le résultat suivant!:
1235
59 066 822 915 424 320 448 445 358 917 464 096 768
Une approximation numérique de ce nombre peut néanmoins être demandée au moyen de la commande N. Le
caractère % désigne le résultat précédent :
N@%D
5.90668 µ 1037
En fait, il n'y a pas de limite, hormis celle de la mémoire de l'ordinateur utilisé, au nombre de chiffres significatifs qui
peuvent être utilisés dans une opération. Ainsi, le nombre ‰ connu par Mathematica avec une précision infinie, peut être
affiché à l'écran avec autant de chiffres derrière la virgule que l'on veut. En voici 200 :
N@E, 200D
2.71828182845904523536028747135266249775724709369995957496696762772407663-
035354759457138217852516642742746639193200305992181741359662904357290033-
42952605956307381323286279434907632338298807531952510190
Mathematica est également en mesure de manipuler des nombres complexes. Voici 8 - 3 Â à la puissance 23. Sous
Mathematica, Â!qu'on écrit généralement I correspond à la racine carrée de -1.
H8 - 3 IL^23
-1 038 255 848 226 092 915 704 - 2 471 236 212 905 806 463 349 Â
La plupart des fonctions mathématiques standard sont implantées dans Mathematica. On peut ainsi obtenir
instantanément la valeur de la fonction Zeta en 0.9, en 1 et en 1.1 :
[email protected], 1, 1.1<D
8-9.43011, ComplexInfinity, 10.5844<
Mathematica permet de rechercher numériquement les racines d'une fonction. Cherchons par exemple la racine de la
fonction x7 - 12 x3 + ex en démarrant la recherche en x = 0.5 (algorithme de Newton) :
2. Aperçu 9
FindRootAx7 - 12 x3 + 2 + Ex, 8x, 0.5<E
8x Ø 0.698654<
De même, il est possible de calculer numériquement des intégrales, par exemple, l'intégrale de la fonction précédente
entre 0 et 1 :
NIntegrateAx7 - 12 x3 + 2 + Ex, 8x, 0, 1<E
0.843282
Par ailleurs, Mathematica possède de nombreuses fonctions permettant des manipulations d'entiers. Voici par exemple
les facteurs premiers d'un entier :
factors = FactorInteger@70 612 139 395 722 186D
882, 1<, 83, 2<, 843, 5<, 826 684 839, 1<<
On peut en effet vérifier ce résultat en effectuant le produit de ces facteurs élevés à leur puissance respective :
2 * 32 * 435 * 26 684 839
70 612 139 395 722 186
Ou, plus directement, de la façon suivante :
Apply@Times, Apply@Power, factors, 2DD
70 612 139 395 722 186
De même, on peut obtenir le milliardième plus grand nombre premier positif avec la commande suivante :
PrimeA109E
22 801 763 489
2.2 Algèbre et calcul symbolique
Mathematica effectue non seulement des calculs numériques mais aussi du calcul symbolique. Soit une expression
algébrique :
H2 + xL H3 x + 5 yL Hx + yL2
H2 + xL Hx + yL2 H3 x + 5 yL
Elle peut être portée à la puissance 3 et développée, ce qui donne :
ExpandA%3E
216 x9 + 324 x10 + 162 x11 + 27 x12 + 2376 x8 y + 3564 x9 y + 1782 x10 y +
297 x11 y + 11 520 x7 y2 + 17 280 x8 y2 + 8640 x9 y2 + 1440 x10 y2 +
32 320 x6 y3 + 48 480 x7 y3 + 24 240 x8 y3 + 4040 x9 y3 + 57 840 x5 y4 +
86 760 x6 y4 + 43 380 x7 y4 + 7230 x8 y4 + 68 496 x4 y5 + 102 744 x5 y5 +
51 372 x6 y5 + 8562 x7 y5 + 53 696 x3 y6 + 80 544 x4 y6 + 40 272 x5 y6 +
6712 x6 y6 + 26 880 x2 y7 + 40 320 x3 y7 + 20 160 x4 y7 + 3360 x5 y7 + 7800 x y8 +
11 700 x2 y8 + 5850 x3 y8 + 975 x4 y8 + 1000 y9 + 1500 x y9 + 750 x2 y9 + 125 x3 y9
C'est une opération relativement simple à effectuer à la main mais l'on n'est pas à l'abri des erreurs de calcul. Par
contre l'opération inverse qui consiste à factoriser l'expression précédente est beaucoup plus difficile à effectuer à la main.
Avec Mathematica, c'est très simple :
10 2. Aperçu
Factor@%D
H2 + xL3 Hx + yL6 H3 x + 5 yL3
On retrouve bien l'expression de départ élevée à la puissance 3.
Comme nous l'avons vu précédemment, Mathematica peut intégrer des expressions. Après l'intégration numérique,
voyons maintenant le calcul de primitive (expression entrée à l'aide de la palette Basic Math Input) :
‡ Ix7 - 12 x3 + 2 + ExM „x
‰x+ 2 x - 3 x4 +
x8
8
Ou, avec un exemple un peu plus compliqué :
‡1
1 + x3„x
ArcTanB-1+2 x
3F
3
+1
3Log@1 + xD -
1
6LogA1 - x + x2E
En dérivant cette expression, on trouve :
D@%, xD
1
3 H1 + xL-
-1 + 2 x
6 I1 - x + x2M+
2
3 I1 +1
3H-1 + 2 xL2M
Expression qu'il suffit de simplifier pour retomber sur l'expression de départ :
Simplify@%D
1
1 + x3
Mathematica peut également effectuer des développements en séries entières, par exemple, le développement de sinHxL
x au
voisinage de 0, à l'ordre 8 :
SeriesBSin@xD
x, 8x, 0, 8<F
1 -x2
6+
x4
120-
x6
5040+
x8
362 880+ O@xD9
Dans ce dernier cas, si l'on désire se débarasser du dernier terme pour conduire un autre calcul, on utilisera la fonction
Normal :
Normal@%D
1 -x2
6+
x4
120-
x6
5040+
x8
362 880
La fonction Series de Mathematica permet également de traiter des fonctions purement symboliques telles que f :
2. Aperçu 11
Series@f@xD, 8x, 0, 4<D
f@0D + f£@0D x +1
2f££@0D x2 +
1
6fH3L@0D x3 +
1
24fH4L@0D x4 + O@xD5
2.3 Résolutions d'équations
Définissons une équation sous Mathematica :
x3 + 3 x2 - a x == 0
-a x + 3 x2 + x3 ã 0
Cherchons maintenant une solution de l'équation précédente en fonction de a :
Solve@%, xD
:8x Ø 0<, :x Ø1
2J-3 - 9 + 4 a N>, :x Ø
1
2J-3 + 9 + 4 a N>>
Voici maintenant la solution d'un système de deux équations à deux inconnues :
Solve@8a x + b y == 0, x + y == c<, 8x, y<D
::x Ø -b c
a - b, y Ø
a c
a - b>>
La résolution d'une équation algébrique n'est possible formellement que jusqu'à l'ordre 4 (sauf à passer par des
décompositions assez complexes pour l'ordre 5). La fonction NSolve permet de trouver des solutions numériques à des
équations algébriques d'ordre quelconque :
NSolveAx5 + x2 + 1 == 0, xE
88x Ø -1.19386<, 8x Ø -0.15459 - 0.828074 Â<, 8x Ø -0.15459 + 0.828074 Â<,
8x Ø 0.751519 - 0.784616 Â<, 8x Ø 0.751519 + 0.784616 Â<<
La fonction FindRoot permet, quant à elle, de résoudre par des méthodes numériques tout type d'équations
algébriques ou non. Voici la solution d'un système de 2 équations en démarrant la recherche en x = 1 et y = 0 :
FindRoot@8Sin@xD == x - y, Cos@yD == x + y<, 8x, 1<, 8y, 0<D
8x Ø 0.883401, y Ø 0.1105<
Mathematica est également en mesure de résoudre des équations différentielles. Ainsi, la solution générale de
y '' HxL - k yHxL = 1 est!:
DSolve@y''@xD - k y@xD == 1, y@xD, xD
::y@xD Ø -1
k+ ‰
k x C@1D + ‰- k x C@2D>>
La fonction NDSolve permet de trouver des solutions numériques à des équations différentielles. La solution est en
général une fonction interpolée :
NDSolveA
9y''@xD + Sin@xD2 y£@xD + y@xD == Cos@xD2, y@0D == 1, y£@0D == 0=, y, 8x, 0, 20<E
88y Ø InterpolatingFunction@880., 20.<<, <>D<<
Que l'on peut ensuite représenter :
12 2. Aperçu
Plot@Evaluate@y@xD ê. %D, 8x, 0, 20<D
5 10 15 20
0.4
0.6
0.8
1.0
2.4 Calcul matriciel
Définissons une matrice dont l'élément Hi, jL est défini par 1
i+ j+1. Mathematica représente les matrices sous forme d'une
liste de listes.
m = TableB1
i + j + 1, 8i, 1, 3<, 8j, 1, 3<F
::1
3,1
4,1
5>, :
1
4,1
5,1
6>, :
1
5,1
6,1
7>>
Expression que l'on peut afficher sous la forme habituelle des matrices (les parenthèses ne sont affichées que depuis la
version 3 de Mathematica) :
MatrixForm@%D
1
3
1
4
1
5
1
4
1
5
1
6
1
5
1
6
1
7
Calculons maintenant l'inverse de la matrice m :
Inverse@mD
88300, -900, 630<, 8-900, 2880, -2100<, 8630, -2100, 1575<<
L'inverse de m multiplié par m doit nous donner la matrice identité :
%.m
881, 0, 0<, 80, 1, 0<, 80, 0, 1<<
Transformons maintenant la matrice m en modifiant sa diagonale principale :
m - x IdentityMatrix@3D
::1
3- x,
1
4,1
5>, :
1
4,1
5- x,
1
6>, :
1
5,1
6,1
7- x>>
On peut alors calculer le déterminant de cette nouvelle matrice que l'on appelle le polynôme caractéristique de la
matrice m :
Det@%D
1
378 000-
317 x
25 200+71 x2
105- x3
On peut aussi calculer les valeurs propres et vecteurs propres de la matrice m. Il s'agit ici d'un calcul numérique
puisque nous avons utilisé la commande N :
2. Aperçu 13
On peut aussi calculer les valeurs propres et vecteurs propres de la matrice m. Il s'agit ici d'un calcul numérique
puisque nous avons utilisé la commande N :
Eigenvalues@N@mDD
80.657051, 0.0189263, 0.000212737<
Eigenvectors@N@mDD
88-0.703153, -0.549268, -0.451532<,
8-0.668535, 0.29444, 0.68291<, 80.242151, -0.782055, 0.574241<<
Mathematica peut également manipuler des matrices symboliques et calculer de façon symbolique les valeurs propres
d'une matrice :
Eigenvalues@88a, b<, 8-b, 2 a<<D
:1
23 a - a2 - 4 b2 ,
1
23 a + a2 - 4 b2 >
Le produit des valeurs propres doit être égal au déterminant de la matrice. On peut le vérifier en calculant d'abord ce
produit, ici effectué en multipliant le premier élément du résultat précédent par le deuxième élément du résultat
précédent. Le produit est ensuite simplifié grâce à l'utilisation de la commande Simplify.
Simplify@ Apply@Times, %D D
2 a2 + b2
On vérifie, en effet, que cela est bien égal au déterminant de la matrice :
Det@88a, b<, 8-b, 2 a<<D
2 a2 + b2
2.5 Manipulation de listes
Mathematica manipule des listes de façon très naturelle et très pratique. Ainsi, comme nous venons de le voir, une
matrice est en fait une liste de listes. Il n'y a pas de limite au niveau d'imbrication des listes qu'on peut donner.
Voici une liste contenant les 15 premières factorielles!:
Table@n!, 8n, 1, 15<D
81, 2, 6, 24, 120, 720, 5040, 40 320, 362 880, 3 628 800,
39 916 800, 479 001 600, 6 227 020 800, 87 178 291 200, 1 307 674 368 000<
Prenons maintenant le logarithme népérien de chaque élément de la liste ci-dessous. La fonction Log ayant l'attribut
Listable, l'appliquer à une liste correspond à l'appliquer à chaque élément de la liste (je donne le nom liste au
résultat)!:
liste = N@Log@%DD
80., 0.693147, 1.79176, 3.17805, 4.78749, 6.57925, 8.52516, 10.6046,
12.8018, 15.1044, 17.5023, 19.9872, 22.5522, 25.1912, 27.8993<
Je peux extraire n'importe quel élément d'une liste en donnant son numéro d'apparition dans la liste. J'utilise pour cela
la notation à double crochet [[n°]] (raccourci de la fonction Part)!:
liste@@3DD
1.79176
14 2. Aperçu
Si nous rappelons la matrice m précédente, on peut extraire, par exemple, le 3ième élément de la 2ième liste qui
compose cette matrice :
m
::1
3,1
4,1
5>, :
1
4,1
5,1
6>, :
1
5,1
6,1
7>>
m@@2, 3DD
1
6
Traçons maintenant l'ensemble des points de la liste, fabriquée ci dessus, des logarithmes des 15 premières factorielles
(je donne le nom des1 au graphique) :
des1 = ListPlot@listeD
2 4 6 8 10 12 14
5
10
15
20
25
La commande Fit permet de recherche un ajustement fonctionnel à une liste de points en utilisant la méthode des
moindres carrés!:
equa = FitAliste, 91, x, x2=, xE
-1.48508 + 0.963131 x + 0.06766 x2
des2 = Plot@equa, 8x, 0, 15<D
2 4 6 8 10 12 14
5
10
15
20
25
En superposant les deux dessins (commande Show), je constate que l'ajustement est assez bon!:
Show@8des1, des2<D
2 4 6 8 10 12 14
5
10
15
20
25
Il existe d'innombrables commandes et fonctions permettant de créer et de manipuler des listes, comme nous le
verrons plus loin. En voici quelques unes.
2. Aperçu 15
Il existe d'innombrables commandes et fonctions permettant de créer et de manipuler des listes, comme nous le
verrons plus loin. En voici quelques unes.
La fonction Permutations donne toutes les permutations possibles des éléments d'une liste :
Permutations@8a, b, c<D
88a, b, c<, 8a, c, b<, 8b, a, c<, 8b, c, a<, 8c, a, b<, 8c, b, a<<
La fonction Flatten supprime les accolades internes figurant dans une liste :
Flatten@%D
8a, b, c, a, c, b, b, a, c, b, c, a, c, a, b, c, b, a<
Voici maintenant les positions occupées par l'élément b dans cette dernière liste :
Position@%, bD
882<, 86<, 87<, 810<, 815<, 817<<
On peut ensuite, par exemple, faire le produit cumulatif des positions :
FoldList@Times, 81<, %D
881<, 82<, 812<, 884<, 8840<, 812 600<, 8214 200<<
L'opérateur NestList est très pratique pour calculer une fonction de fonction de fonction ... de quelque chose et
mettre chaque niveau d'imbrication de la fonction sur elle-même dans une liste (on parle de composition)!:
NestList@Cos, x, 3D
8x, Cos@xD, Cos@Cos@xDD, Cos@Cos@Cos@xDDD<
L'opérateur Map permet d'appliquer une fonction à chaque élément d'une liste :
Map@f, 8a, b, c, d<D
8f@aD, f@bD, f@cD, f@dD<
ou plus généralement à tout élément d'une expression :
Map@f, a + b + c + dD
f@aD + f@bD + f@cD + f@dD
Tandis que l'opérateur Apply permet notamment d'appliquer une fonction sur l'ensemble des éléments d'une liste (à
condition que la fonction accepte n'importe quel nombre d'arguments) :
Apply@f, 8a, b, c, d<D
f@a, b, c, dD
Apply@Plus, 8a, b, c, d<D
a + b + c + d
Mais cette fonction opère également sur toute expression comme dans l'exemple suivant dans lequel on remplace une
somme par un produit :
Apply@Times, a + b + c + dD
a b c d
16 2. Aperçu
2.6 Représentations graphiques
Comme nous venons de le voir à travers quelques exemples, Mathematica permet de tracer des représentations
graphiques variées. Voici par exemple le tracé de la fonction cos2HexL pour x compris entre 0 et p.
PlotBCosA‰xE2, 8x, 0, p<F
0.5 1.0 1.5 2.0 2.5 3.0
0.2
0.4
0.6
0.8
1.0
Mathematica fournit à l'utilisateur de nombreuses possibilités pour améliorer la présentation de ses graphiques :
Show@%, Frame Ø True, FrameLabel Ø 8"Temps", "Signal"<,
GridLines Ø Automatic, BaseStyle Ø 8FontFamily -> "Arial", FontSize Ø 7<D
0.0 0.5 1.0 1.5 2.0 2.5 3.0
0.0
0.2
0.4
0.6
0.8
1.0
Temps
Signal
Voici maintenant une représentation en courbes de niveaux et une représentation en densité, de la fonction
sinHx + sinH yLL. Les zones les plus claires correspondent aux sommets (en fait, avant que ne soit fabriqué ce tableau de
graphiques, Mathematica fabrique par défaut chaque graphique séparément. Ces derniers ont été ici manuellement
supprimés)!:
GraphicsGrid@88
ContourPlot@Sin@x + Sin@yDD, 8x, -2, 2<, 8y, -2, 2<D,
DensityPlot@Sin@x + Sin@yDD, 8x, -2, 2<, 8y, -2, 2<D
<<D
A partir d'une liste de points, plusieurs représentations graphiques sont possibles. La commande ListPlot (déjà vue
plus haut) permet ainsi de représenter des points donnés par leurs coordonnées dans une liste!:
2. Aperçu 17
ListPlot@880, 0<, 80.2, 1<, 80.5, 0.5<, 81.5, 2<, 82, 1<<,
PlotStyle Ø PointSize@LargeDD
0.5 1.0 1.5 2.0
0.5
1.0
1.5
2.0
Equivalentes aux commandes ContourPlot et DensityPlot, les commandes ListContourPlot et
ListDensityPlot produisent respectivement un tracé de courbes de niveau et un tracé de densité à partir d'une
matrice de valeurs d'altitude. Ainsi, la commande suivante génère un tableau à deux dimensions dans lequel l'élément
Hi, jL est égal à 1 si i et j sont premiers entre eux, 0 sinon (le point virgule permet de ne pas afficher les éléments du
tableau)!:
tab1 = Table@If@GCD@i, jD == 1, 1, 0D, 8i, 40<, 8j, 40<D;
ListDensityPlot@tab1D
tab2 = Table@Sin@i + Cos@2 jDD, 8i, -3, 3, 0.2<, 8j, -3, 3, 0.2<D;
ListContourPlot@tab2, Contours Ø 6, ContourLines Ø FalseD
5 10 15 20 25 30
5
10
15
20
25
30
18 2. Aperçu
Passons maintenant à des représentations en 3 dimensions :
Plot3D@Sin@x + Cos@yDD, 8x, -3, 3<, 8y, -3, 3<D
Avec Mathematica, on peut aussi calculer et dessiner en 3D des fonctions définies paramétriquement. Les coordonnées
sont alors exprimées en fonction de 2 paramètres (1 seul en 2D)!:
ParametricPlot3DB:u Sin@tD, u Cos@tD,t
3>,
8t, -3, 3<, 8u, -3, 3<, Ticks Ø NoneF
On peut ensuite superposer les deux représentations précédentes (notez le traitement automatique de l'intersection des
deux représentations) :
Show@%, %%D
2. Aperçu 19
Voici une autre représentation paramétrique tridimensionnelle :
ParametricPlot3DB8Sin@tD Cos@uD, Sin@tD Sin@uD, Cos@tD<,
8t, 0, p<, :u, 0,3 p
2>, Ticks Ø NoneF
L'équivalent tridimensionnel de la commande ListPlot est ListPlot3D qui produit le tracé d'une surface
représentée par une matrice de valeurs d'altitude. Cette commande permet donc de représenter en 3D ce que
ListContourPlot ou ListDensityPlot représentent en 2D. Ainsi, avec les données du tableau tab2 défini plus
haut, on obtient la représentation suivante :
ListPlot3D@tab2, Ticks Ø NoneD
Mathematica peut également être utilisé comme langage graphique. Il est alors possible d'assembler des objets
graphiques à partir d'éléments déjà définis. L'exemple suivant est ainsi construit à partir de cubes unitaires (les cubes sont
fabriqués dans une liste avec une couleur choisie aléatoirement pour chacun) :
20 2. Aperçu
Graphics3D@Table@With@8p = 8i, j, k< ê 5<, 8Hue@RandomReal@DD,
[email protected], Cuboid@p, p + .15D<D, 8i, 5<, 8j, 5<, 8k, 5<DD
2.7 Les 1000 premières décimales de p
Rien de plus facile et rapide avec Mathematica que de calculer les décimales de p (autant que l'on en souhaite) ou de
toute autre grandeur, grâce à un algorithme performant :
N@Pi, 1000D
3.14159265358979323846264338327950288419716939937510582097494459230781640-
628620899862803482534211706798214808651328230664709384460955058223172535-
940812848111745028410270193852110555964462294895493038196442881097566593-
344612847564823378678316527120190914564856692346034861045432664821339360-
726024914127372458700660631558817488152092096282925409171536436789259036-
001133053054882046652138414695194151160943305727036575959195309218611738-
193261179310511854807446237996274956735188575272489122793818301194912983-
367336244065664308602139494639522473719070217986094370277053921717629317-
675238467481846766940513200056812714526356082778577134275778960917363717-
872146844090122495343014654958537105079227968925892354201995611212902196-
086403441815981362977477130996051870721134999999837297804995105973173281-
609631859502445945534690830264252230825334468503526193118817101000313783-
875288658753320838142061717766914730359825349042875546873115956286388235-
3787593751957781857780532171226806613001927876611195909216420199
2. Aperçu 21
22 2. Aperçu
Chapitre 3
Prise en main
24 3. Prise en main
3 Prise en main de Mathematica
3.1 Premier calcul
Au lancement de Mathematica, un nouveau notebook s'affiche à l'écran. Il s'appelle Untitled-1. A l'image d'une
feuille de papier, il invite à l'écriture.
Pour commencer il suffit donc de cliquer sur la feuille et de taper une instruction à l'aide du clavier ou en cliquant sur
les boutons d'une palette (voir menu Palettes pour les ouvrir si elles ne sont pas déjà affichées à l'écran), par exemple :
Cela crée ce qu'on appelle une cellule, délimitée à droite par un crochet de couleur bleue (par défaut). Pour lancer ce
calcul, il faut placer le curseur d'insertion (que pilote la souris) n'importe où dans la cellule et taper la combinaison de
touches : ˜ - Á (majuscule - entrée) ou la touche Á (entrée) du pavé numérique.
Cette opération provoque tout d'abord le lancement du noyau de Mathematica (sauf si le noyau est déjà chargé), le titre
de la fenêtre arbore alors un "Running..." et le crochet de la cellule évaluée change de forme (il apparaît en double-
épaisseur). Enfin s'affiche le résultat sous la forme suivante :
Le résultat s'inscrit dans une nouvelle cellule (un autre crochet bleu avec une symbolique légèrement différente) et l'on
remarque qu'un crochet regroupant la cellule d'entrée et la cellule de sortie s'est constitué. On obtient ce qu'on appelle
un groupe de cellules.
3. Prise en main 25
On comprendra à l'usage l'importance de ce système de regroupement (que l'on peut désactiver manuellement). Il
s'agit d'un regroupement hiérarchique. La cellule de sortie (appelée Output Cell) est de niveau hiérarchique inférieur à
celui de la cellule d'entrée (appelée Input Cell), un regroupement de cellules s'exerce donc automatiquement. Un double-
clic sur le crochet du groupe va masquer toutes les cellules qu'il contient sauf la première, faisant apparaître un triangle
noir qui permet de repérer l'existence d'un groupe de cellules qu'on dira fermé.
Un nouveau double-clic sur le crochet du groupe permet de déployer les cellules qu'il contient. On parlera de groupe
de cellules ouvert.
3.2 Mise en page, utilisation des styles et des feuilles de style
A chaque cellule est attaché un style (de mise en forme), le style d'une cellule d'entrée s'appelle Input, celui d'une
cellule de sortie Output. En ouvrant le menu Format!/!Style, on notera l'existence de nombreux autres styles qui
permettent la mise en page d'un document complexe comportant titres et sous-titres, sections et sous-sections, textes, etc.
On pourra aussi accéder plus rapidement aux styles en activant la commande menu : Window!/!Show ToolBar (image ci-
dessous).
Il faut retenir à ce stade que seules les cellules de style Input peuvent être évaluées. Les autres cellules ne servent
qu'aux résultats des calculs (graphiques ou numériques) ou à la mise en forme d'un document comportant du texte ou des
images.
Ces styles sont hiérarchisés, c'est à dire que le style Title est de niveau hiérarchique supérieur à tous les autres tandis
que le style Section est de niveau supérieur à Subsection lui même supérieur à Subsubsection, puis à tous les
autres entre lesquels il n'y a plus de supériorité hiérarchique sauf Input supérieur à Output comme signalé
précédemment.
Grâce à ce système, dès qu'un document aura été formaté à souhait, il sera aisé de ne visualiser que les sections et sous-
sections, d'afficher un plan d'ensemble, de cacher (pour l'impression) les résultats d'une question dans un polycopié, etc.
On pourra noter que par défaut, on dispose d'une dizaine de styles prédéfinis qui appartiennent à une feuille de styles
appelée Default. D'autres feuilles de styles sont proposées dans Mathematica. On peut les choisir à travers la commande
menu : Format!/!Stylesheet. L'activation de la feuille de style PastelColor par exemple transforme la présentation de
notre nouveau document qui devient :
26 3. Prise en main
Mais revenons à la feuille de style Default et introduisons un titre de section en tête du document. Pour cela, il faut
placer le pointeur au-dessus de la première cellule jusqu'à ce qu'il prenne une direction horizontale. Dès lors, un clic
insère une ligne indiquant l'endroit choisi pour l'insertion d'une nouvelle cellule. Il reste à taper au clavier la chaîne de
caractères souhaitée, puis, en sélectionnant le crochet de cette nouvelle cellule, à lui appliquer le style Section pour
obtenir finalement le résultat suivant :
3.3 Image écran et contenu de la mémoire
Nous allons maintenant insérer une nouvelle cellule de calcul avant la cellule de calcul déjà présente dans le document.
Pour cela, on déplace le curseur d'insertion à l'endroit souhaité, entre deux cellules existantes. Il prend alors une position
horizontale. C'est à ce moment que l'on clique pour faire apparaître une ligne d'insertion comme dans l'exemple suivant :
Il suffit alors de taper directement au clavier la chaîne de caractères souhaitée pour créer une nouvelle cellule (par
défaut dans le style Input) :
3. Prise en main 27
Evaluons maintenant la cellule nouvelle (˜-Á), cela donne :
Arrêtons nous un instant ici pour dresser un premier bilan de ce que nous avons réalisé : nous avons créé un document
(qui n'est pas encore enregistré, d'où la présence d'un point noir dans la boule rouge de fermeture de la fenêtre, en haut à
gauche, sous Mac OS X) comportant un groupe de cellules commençant par une cellule de style Section ("Mon
premier calcul") et contenant quatre autres cellules, deux cellules d'entrée (style Input) et deux cellules de sortie (style
Ouput). La hiérarchie inhérente aux styles a produit une cascade de crochets sur lesquels on peut cliquer pour masquer
à souhait tout ou partie des cellules affichées.
Mais il est une chose importante que nous n'avons pas encore signalée : les cellules d'entrée et de sortie sont numérotées et la
numérotation indiquée (en bleu et à gauche de chaque cellule, par défaut) correspond à l'ordre d'évaluation des cellules
et non pas à l'ordre d'apparition dans le document.
Mais poursuivons notre exemple. Nous allons tout d'abord modifier la première instruction (en remplaçant
l'intégration de 0 à 10 par l'intégration de 0 à 100) puis nous évaluons à nouveau la cellule d'entrée correspondante (ce
qui est nécessaire pour produire le nouveau résultat). Cela donne :
28 3. Prise en main
Nous constatons que le numéro de la cellule a changé. Il s'agit maintenant de la cellule n°3, en fait, la cellule ayant été
évaluée en 3ième position. Nous avons donc deux cellules d'entrée, à l'écran, la première numérotée 3 et la seconde
numérotée 1. Il manque l'instruction n°2 qui a été remplacée par la n°3.
Nous avons dit en introduction que Mathematica était composé de 2 programmes : le Front-End et le Kernel (noyau de
calcul). A l'écran, nous voyons le contenu du Front-End, le noyau restant en arrière-plan, sans fenêtre d'édition (par défaut
mais on peut aussi éditer directement dans le noyau dans certaines configurations). Le contenu de chaque cellule validée
(˜-Á) dans le Front-End est en réalité envoyé dans le noyau pour exécution. Puis ce dernier renvoie le résultat, dans le
Front-End, dans une cellule de style Output, placée juste en dessous (par défaut) de la cellule d'entrée. Les numéros
des cellules correspondent donc à l'ordre dans lequel elles ont été exécutées dans le noyau, ce dernier
gardant la trace et la mémoire de toutes les instructions réalisées (jusqu'à ce que l'on quitte Mathematica ou
simplement son noyau).
En effet, nous pouvons rappeler, à tout moment, le résultat d'un calcul antérieur, que l'instruction l'ayant produit soit
ou ne soit pas affichée à l'écran. Il suffit pour cela d'évaluer l'instruction Out[n°] ou %n° comme le montre l'exemple
suivant :
En outre, l'évaluation de % seul permet de rappeler le dernier résultat exécuté (mais pas forcément celui placé juste au
dessus dans le Front-End, car cela dépend de l'endroit où cette évalution a été faite) :
3. Prise en main 29
Il est aussi possible, comme dans un traitement de texte, d'effacer tout ou partie de ce qui apparaît à l'écran. Cet
effacement n'altère pas le contenu de la mémoire du noyau et il est toujours possible de rappeler un résultat préalable en
appelant la fonction Out ou en utilisant % comme le montre l'exemple suivant :
Enfin, dans Mathematica, il est possible de valider une instruction sans afficher son résultat. Pour cela, il suffit de placer
un point-virgule après l'expression entrée, ce qui n'empêche pas d'afficher ultérieurement le résultat (ou de l'utiliser dans
un calcul ultérieur) comme le montre l'exemple suivant!:
A partir de maintenant, les exemples seront directement intégrés au document et nous ne montrerons plus, sauf exception, les fenêtres de calcul.
Par ailleurs, pour des raisons esthétiques, les numéros des entrées et sorties ne seront pas affichées.
30 3. Prise en main
3.4 Les expressions et leur évaluation
3.4.1 Tout est expression
Dans Mathematica, tout est expression, qu'il s'agisse d'une instruction classique, d'une cellule, d'un graphique, d'un
notebook, etc.
Chaque expression est composée de ce qu'on appelle une tête (ce qui vient en premier dans l'écriture fonctionnelle de
l'expression) suivi éventuellement d'arguments, placés entre crochets ([,]) et séparés par des virgules, chaque argument
pouvant lui-même être une expression comportant une tête et des arguments. Dans l'exemple suivant, Integrate est
la tête, 1/(1+x) est le premier argument et x est le second :
Integrate@1 ê H1 + xL, xD
Log@1 + xD
Voici d'autres exemples montrant la généralité de ce principe :
CellPrint@Cell@"Une chaîne en style Output", "Output"DD
Une chaîne en style Output
Graphics@8Circle@80, 0<, 1D, [email protected], 0<, 2D<,
AspectRatio Ø Automatic, Axes Ø TrueD
-1 1 2
-2
-1
1
2
Set@a, 5D H* équivalent de a=5 *L
5
La fonction Head permet d'extraire la tête de n'importe quelle expression :
Head@5D
Integer
Head@5 ê 2D
Rational
Head@2 + 3 ID
Complex
3. Prise en main 31
Head@Graphics@8Circle@80, 0<, 1D, [email protected], 0<, 2D<DD
Graphics
Head@mafonction@x, y, zDD
mafonction
On peut, de même, extraire chaque argument d'une expression. On utilise pour cela la fonction Part ou son
raccourci [[!]] :
sol = Integrate@1 ê H1 + x^3L, xD
ArcTanB-1+2 x
3F
3
+1
3Log@1 + xD -
1
6LogA1 - x + x2E
Head@solD
Plus
Part@sol, 1D
ArcTanB-1+2 x
3F
3
Part@sol, 2D
1
3Log@1 + xD
sol@@3DD H* ou Part@sol,3D *L
-1
6LogA1 - x + x2E
Ce principe peut être étendu pour extraire un élément dans l'expression, situé à un niveau inférieur. On écrira par
exemple :
sol@@1, 2DD
ArcTanB-1 + 2 x
3
F
pour afficher le 2ième argument du 1er argument de sol qu'on pourra aussi écrire :
Part@sol, 1, 2D
ArcTanB-1 + 2 x
3
F
Pour visualiser une expression sous sa forme fonctionnelle (standard) on peut utiliser :
InputForm@solD
ArcTan[(-1 + 2*x)/Sqrt[3]]/Sqrt[3] + Log[1 + x]/3 -
Log[1 - x + x^2]/6
32 3. Prise en main
ou :
FullForm@solD
Plus@Times@Power@3, Rational@-1, 2DD,
ArcTan@Times@Power@3, Rational@-1, 2DD, Plus@-1, Times@2, xDDDDD,
Times@Rational@1, 3D, Log@Plus@1, xDDD,
Times@Rational@-1, 6D, Log@Plus@1, Times@-1, xD, Power@x, 2DDDDD
De même, on peut visualiser l'arborescence de l'expression au moyen de la fonction TreeForm mais le résultat,
quoique parfois utile, n'est pas toujours très facile à exploiter (on n'en voit ici qu'une partie) :
TreeForm@solD
Plus
Times
Power
3 Rational
-1 2
ArcTan
Times
Power
3 Rational
-1 2
Plus
-1 Times
2 x
Times
Rational
1 3
Log
Plus
1 x
Times
Rational
-1 6
Log
Plus
1 Times
-1 x
Power
x 2
3.4.2 L'évaluation des expressions
L'évaluation des expressions suit un ordre standard (sauf exceptions) qu'il est important de bien connaître. Quand on
soumet le calcul d'une expression à Mathematica, ce dernier commence (en général) à se la représenter sous la forme d'un
arbre (TreeForm par exemple) comportant une tête (le tronc) et des arguments (les branches), chaque branche étant
éventuellement elle-même composée d'une tige et de feuilles (ou d'autres branches, etc.). L'évaluation commence alors
par le bas (ou le haut selon l'image que l'on se fait de l'arbre) : les feuilles d'abord puis les branches, puis le tronc, etc. On
commence donc par évaluer les arguments d'une expression avant d'évaluer l'expression elle-même.
Cela permet des constructions de ce genre!:
Integrate@a = H1 + x^5L, xD
x +x6
6
Les arguments de Integrate ayant été évalués au préalable, on peut, par la suite, utiliser le symbole a défini dans
l'expression précédente :
a
1 + x5
Nous avons à faire ici à un mécanisme très général, commun à tous les calculs réalisés dans Mathematica sauf dans
certains cas particuliers comme par exemple dans la fonction Plot :
3. Prise en main 33
Nous avons à faire ici à un mécanisme très général, commun à tous les calculs réalisés dans Mathematica sauf dans
certains cas particuliers comme par exemple dans la fonction Plot :
Plot@a = Sin@xD + Sin@2 xD, 8x, 0, 10<D
2 4 6 8 10
-1.5
-1.0
-0.5
0.5
1.0
1.5
a
0.368984
Si le mécanisme d'évaluation avait été le même que précédement, nous aurions obtenu, à l'appel de a, l'expression
symbolique représentée graphiquement. En fait, Mathematica ne nous renvoie que la dernière valeur numérique prise par
l'expression Sin[x]+Sin[2x] lors de la construction du graphique.
Sans entrer dans le détail du mécanisme en jeu, nous retiendrons simplement ici que la fonction Plot ne suit pas le
mode d'évaluation standard. On peut s'en convaincre en regardant les attributs de cette fonction :
Attributes@PlotD
8HoldAll, Protected<
L'attribut HoldAll (qui signifie retenir tout), indique à Mathematica qu'il ne faut pas évaluer au préalable les arguments
mais les utiliser tels quels. La fonction Integrate ne possède pas cet attribut!:
Attributes@IntegrateD
8Protected, ReadProtected<
Nous reviendrons à plusieurs reprises sur ce mécanisme d'évaluation, mais il est important, dès maintenant d'en
prendre bien conscience.
3.5 Règles de syntaxe
3.5.1 Nommage des fonctions
Mathematica adopte quelques règles de syntaxe qui permettent d'offrir à l'utilisateur une notation très consistante. En
voici les principales :
Toutes les commandes et fonctions internes de Mathematica commencent par une majuscule.
Il n'y aucune exception à cette règle et elle permet d'éviter toute confusion entre les symboles existants et les symboles
créés par l'utilisateur à condition que ces derniers ne commencent que par des minuscules.
Pour toutes les fonctions ou commandes dont le nom est constitué de deux termes, chaque terme comporte une
majuscule.
34 3. Prise en main
Vous pouvez constatez l'application de ces deux règles sur la liste non-exhaustive suivante :
Append InverseWeierstrassP
BernoulliB Jacobian
ChebyshevT LegendreP
Numerator MaxIterations
EulerGamma NSum
FactorSquareFreeList OddQ
GammaRegularized PrecisionGoal
HermiteH RiemannSiegelTheta
Quelques fonctions ou variables internes à Mathematica.
A quelques exceptions près, les noms des fonctions internes sont explicites (noms complets).
Quasiment aucune abréviation, à moins qu'elle ne soit unanimement utilisée en mathématiques, n'est employée. Cela
permet d'éviter des confusions du genre que celle qu'entraînerait, par exemple, l'utilisation d'une fonction appelée "int"
(dans Maple par exemple). S'agit-il d'une fonction pour intégrer, ou de la partie entière (integer part), etc... Dans
Mathematica, il y a la fonction Integrate et la fonction IntegerPart.
Par ailleurs, le plus souvent, il suffit de deviner le mot anglais correspondant à une opération quelconque pour, à coup
presque sûr, trouver le nom de la fonction recherchée. Par exemple, pour simplifier une expression, il faut penser à
Simplify ou FullSimplify, pour fabriquer une matrice identité, penser à la fonction IdentityMatrix, etc. La
liste suivante rassemble la plupart des abréviations utilisées par Mathematica. Il existe aussi d'autres abréviations dérivées
de celles-ci telles que Cosh (Cosinus Hyperbolique), etc.
Abs Valeur Absolue
C Constantes dans une intégration différentielle
Cos Fonction Cosinus
Cot Fonction Cotangente
Csc Fonction Cosecante égale à H1êSinL
D Opérateur dérivée partielle
Dt Opérateur dérivée totale
Det Déterminant d'une matrice
Exp Fonction exponentielle
GCD Plus grand commun diviseur
Im Partie imaginaire d'un nombre complexe
LCM Plus petit commun multiple
Log Fonction logarithme
Max Plus grande valeur dans une liste
Min Plus petite valeur dans une liste
Mod Reste de la division
N Approximation numérique
O Termes omis dans un développement en séries
Re Partie réelle d'un nombre complexe
Sec Fonction Secante égale à H1êCosL
Sin Fonction Sinus
Sqrt Racine*carrée
Tan Fonction Tangente
Trig Désigne l'utilisation de fonctions trigonométriques
Xor Ou exclusif
Principales fonctions internes désignées par des abréviations.
3.5.2 Parenthèses, crochets, accolades
3. Prise en main 35
3.5.2 Parenthèses, crochets, accolades
Pour offrir une notation la plus consistante possible (c'est à dire qui évite les confusions), Mathematica propose
l'utilisation de 5 systèmes d'encadrement : les parenthèses, les crochets, les accolades, les double-crochets et les
parenthèses-étoiles.
Les parenthèses "(...)" servent simplement à regrouper des termes :
4 H5 + 3L H2^2 + 3L
224
Les crochets "[...]" servent à entourer les arguments d'une fonction :
GCD@21, 63, 16 807D
7
Les accolades "{...}" désignent des listes d'objets :
Intersection@81, 2, 3, z, c, x, truc<, 8truc, 5, 3, x<D
83, truc, x<
Les double-crochets "[[...]]" permettent de désigner et d'extraire des éléments dans une liste ou, plus généralement,
d'extraire des parties dans une expression (raccourci pour la fonction Part) :
liste = 8a, b, c, d, e, f<;
liste@@4DD
d
Les parenthèses associées à des étoiles "(*...*)" servent à encadrer des commentaires qui sont ignorés au moment de
l'évaluation :
D@x^3 H* polynôme de degré 3 *L, xD
3 x2
3.5.3 Représentations d'une expression
Mathematica propose 3 représentations possibles d'une même expression : la représentation dite InputForm, la
représentation dite StandardForm et la représentation dite TraditionalForm.
La représentation InputForm est une représentation dans laquelle ne sont utilisés que des caractères ASCII
(accessibles directement au clavier), par exemple :
ArcTan@H2 x - 1L ê Sqrt@3DD ê Sqrt@3D + H1 ê 3L * Log@1 + xD
ArcTanB-1+2 x
3F
3
+1
3Log@1 + xD
La représentation standard (StandardForm) est une représentation proche de la notation mathématique mais qui
n'en suit pas toutes les règles. C'est le mode de représentation utilisé par défaut dans les résultats de calculs ou dans les
palettes. En notation standard, l'expression précédente devient :
ArcTanB2 x-1
3F
3
+1
3Log@1 + xD
36 3. Prise en main
En écriture mathématique (TraditionalForm), on n'utilise pas les crochets, ni les majuscules et la fonction
ArcTan s'écrit tan-1. Ce mode permet l'écriture traditionnelle du langage mathématique (selon les conventions
américaines néanmoins). Dans ce mode, l'expression précédente devient :
1
3logHx + 1L +
tan-1K2 x-1
3O
3
On retiendra que l'on peut passer d'un mode à l'autre en activant un article du menu Cell / Convert!To après avoir
sélectionné le crochet de la cellule concernée et on notera la symbolique que prend le crochet en fonction du mode choisi.
On retiendra enfin que par défaut, les cellules créées sont dans le mode StandardForm et qu'il faut éviter d'évaluer une
cellule dans le mode TraditionalForm car la notation traditionnelle est parfois ambiguë (tan-1 est-il la fonction inverse ou
1/tan ?).
On pourra remarquer également que l'on peut écrire une formule mathématique au sein d'une cellule de texte. Dans
ce cas, après avoir copié la formule précédente dans sa représentation standard comme ci-contre :
ArcTanB 2 x-13
F
3
+1
3Log@1 + xD, on peut ensuite la sélectionner et la convertir en notation traditionnelle comme ici :
tan-12 x-1
3
3
+1
3logHx + 1L. On pourra noter la qualité de la typographie ainsi utilisée.
3.5.4 Notations
Mathematica propose 4 façons différentes d'écrire une expression : la notation standard, la notation prefix, la notation
postfix et la notation infix.
La notation standard est la notation interne de Mathematica. Elle consiste à écrire une expression sous la forme d'une tête
et d'arguments placés entre crochets et séparés par des virgules. Toute expression écrite dans Mathematica peut s'écrire
sous cette forme, y compris les graphiques. On peut traduire toute expression dans cette forme grâce à la commande
FullForm (ou sous une forme parfois légèrement réduite avec InputForm) :
FullForm@b + c^dD
Plus@b, Power@c, dDD
Avec la notation prefix, le nom de la fonction s'écrit devant l'argument. Cette notation n'est utilisable qu'avec les
fonctions n'exigeant l'entrée que d'un seul argument (les autres arguments s'il y en a devant être facultatifs) par exemple!:
Sin ü 5.2
-0.883455
Avec la notation postfix, et avec la même réserve que précédemment concernant la fonction utilisée, le nom de la
fonction s'écrit derrière l'argument.
5.2 êê Sin
-0.883455
Cette notation sera souvent utilisée pour compléter une instruction déjà écrite, par exemple pour demander une
approximation numérique quand on a oublié de le faire au préalable :
Sin@5 ê 2D
SinB5
2F
Sin@5 ê 2D êê N
0.598472
La notation infix peut être utilisée pour des fonctions à plusieurs arguments. C'est notamment la notation utilisée pour
les opérations mathématiques standard comme la somme, le produit, etc. Avec cette notation, le nom de la fonction est
placé entre les arguments :
3. Prise en main 37
La notation infix peut être utilisée pour des fonctions à plusieurs arguments. C'est notamment la notation utilisée pour
les opérations mathématiques standard comme la somme, le produit, etc. Avec cette notation, le nom de la fonction est
placé entre les arguments :
5 + 7
12
5~Plus~7
12
b~Power~H-cL~Plus~d
b-c+ d
5~f~7
f@5, 7D
3.6. Aides
3.6.1 Aide interactive
Pour rechercher une fonction ou avoir des explications sur son utilisation, il est possible de faire appel à l'aide
interactive de Mathematica disponible sous le menu Help / Documentation Center. C'est une aide indexée très bien conçue qui
permet en plus, d'avoir accès aux fonctions contenues dans les packages disponibles (programmes externes écrits en
langage Mathematica). Depuis la version 6 de Mathematica, l'aide interactive a ajouté à son ancienne structure par thèmes,
un mode de recherche par mots-clefs très efficace et très semblable à une recherche sur internet. D'une manière générale,
les documents d'aide sont constitués de cahiers (notebooks) dans lequel on trouve généralement des exemples qu'il est
possible d'exécuter comme dans un cahier standard. Ces documents sont souvent reliés à d'autres documents par des
hyperliens pour permettre une navigation interactive simplifiée à travers l'aide. Par ailleurs, elle contient l'intégralité du
manuel de référence soit environ 1500 pages dactylographiées, sous la forme de cahiers Mathematica. L'image suivante la
montre pour la version 7 de Mathematica.
38 3. Prise en main
3.6.2 Aide en ligne
Une autre forme d'aide, souvent pratique, est l'aide en ligne accessible dans une session de travail en tapant un point
d'interrogation suivi du nom de la fonction recherchée comme le montre l'exemple suivant (l'hyperlien ">>" à la fin de la
dernière ligne renvoie à l'aide interactive) :
? Select
Select@list, critD picks out all elements ei of list for which crit@eiD is True.
Select@list, crit, nD picks out the first n elements for which crit@eiD is True. !à
L'utilisation d'un double point d'interrogation vous renseigne sur les attributs de la fonction recherchée (et parfois sur
ses options) :
?? Select
Select@list, critD picks out all elements ei of list for which crit@eiD is True.
Select@list, crit, nD picks out the first n elements for which crit@eiD is True. !à
Attributes@SelectD = 8Protected<
Pour accéder aux options d'une fonction on préférera utiliser la fonction Options[] :
3. Prise en main 39
Options@PlotD
:AlignmentPoint Ø Center, AspectRatio Ø1
GoldenRatio,
Axes Ø True, AxesLabel Ø None, AxesOrigin Ø Automatic,
AxesStyle Ø 8<, Background Ø None, BaselinePosition Ø Automatic,
BaseStyle Ø 8<, ClippingStyle Ø None, ColorFunction Ø Automatic,
ColorFunctionScaling Ø True, ColorOutput Ø Automatic,
ContentSelectable Ø Automatic, CoordinatesToolOptions Ø Automatic,
DisplayFunction ß $DisplayFunction, Epilog Ø 8<, Evaluated Ø Automatic,
EvaluationMonitor Ø None, Exclusions Ø Automatic,
ExclusionsStyle Ø None, Filling Ø None, FillingStyle Ø Automatic,
FormatType ß TraditionalForm, Frame Ø False, FrameLabel Ø None,
FrameStyle Ø 8<, FrameTicks Ø Automatic, FrameTicksStyle Ø 8<,
GridLines Ø None, GridLinesStyle Ø 8<, ImageMargins Ø 0.,
ImagePadding Ø All, ImageSize Ø Automatic, ImageSizeRaw Ø Automatic,
LabelStyle Ø 8<, MaxRecursion Ø Automatic, Mesh Ø None,
MeshFunctions Ø 8Ò1 &<, MeshShading Ø None, MeshStyle Ø Automatic,
Method Ø Automatic, PerformanceGoal ß $PerformanceGoal,
PlotLabel Ø None, PlotPoints Ø Automatic,
PlotRange Ø 8Full, Automatic<, PlotRangeClipping Ø True,
PlotRangePadding Ø Automatic, PlotRegion Ø Automatic,
PlotStyle Ø Automatic, PreserveImageOptions Ø Automatic, Prolog Ø 8<,
RegionFunction Ø HTrue &L, RotateLabel Ø True, Ticks Ø Automatic,
TicksStyle Ø 8<, WorkingPrecision Ø MachinePrecision>
De plus, il est possible de rechercher tous les symboles ou fonctions comprenant un ou des caractères spécifiés, en
utilisant le caractère * qui signifie "rien ou n'importe quel caractère ou chaîne de caractères". Dans l'exemple suivant, on
recherche toutes les fonctions commençant par L (la présentation en hyperliens qui renvoient vers l'aide interactive
n'existe que depuis Ÿ 4.1) :
40 3. Prise en main
? Lin*
System`
Line LinkClose
Line3DBox LinkConnect
LinearFilter LinkConnectedQ
LinearFractionalTransform LinkCreate
LinearModelFit LinkError
LinearOffsetFunction LinkFlush
LinearProgramming LinkFunction
LinearRecurrence LinkHost
LinearSolve LinkInterrupt
LinearSolveFunction LinkLaunch
LineBox LinkMode
LineBreak LinkObject
LinebreakAdjustments LinkOpen
LineBreakWithin LinkOptions
LineForm LinkPatterns
LineIndent LinkProtocol
LineIndentMaxFraction LinkRead
LineIntegralConvolutionPlot LinkReadHeld
LineIntegralConvolutionScale LinkReadyQ
LineSpacing Links
LineWrapParts LinkWrite
LinkActivate LinkWriteHeld
Puis on recherche toutes les fonctions commençant par Linear :
? Linear*
System`
LinearFilter LinearProgramming
LinearFractionalTransform LinearRecurrence
LinearModelFit LinearSolve
LinearOffsetFunction LinearSolveFunction
3. Prise en main 41
Dans l'exemple suivant, on recherche toutes les fonctions terminant par String :
? *String
System`
DateString IntegerString
DisplayString NumberString
DMSString RepeatedString
EndOfString SpokenString
ExportString StartOfString
FrontEndResourceString String
ImportString ToString
InputString WriteString
InString
Enfin, on peut rechercher toutes les fonctions commençant par exemple par C et terminant par ing :
? C*ing
System`
Ceiling ColorFunctionScaling
CellGrouping ContourShading
CellHorizontalScrolling ContourSmoothing
CellLabelPositioning ControllerLinking
CharacterEncoding ControlsRendering
Closing CounterStyleMenuListing
3.7 Exercices
3.7.1 Recherche d'une fonction
a) Quels sont les entiers diviseurs de 100.
b) Quel est le plus petit commun multiple des 10 premiers entiers ?
c) Quels sont les facteurs premiers de 2350792 ?
d) 1299709 est-il un nombre premier ?
e) Quel est le quotient (entier) et le reste de la division de 25364 par 354.
f) Fabriquez un nombre aléatoire entier compris entre 50 et 100. Puis, en utilisant Table, fabriquer une liste de 10
nombres aléatoires entiers compris entre 50 et 100.
3.7.2 Calcul numérique
a) Déterminez de combien ‰p 163 est proche d'un entier.
b) Utilisez NumberForm pour afficher les chiffres de 123456789 par blocs de 3 chiffres.
c) Vérifier que ⁄i=1100 i =
100µ 101
2.
42 3. Prise en main
c) Vérifier que ⁄i=1100 i = 100µ 101
2.
d) Calculer la somme : 1 + 11!+ 12!+ 13!+ ... + 1
10!. Que vaut ⁄i=0
¶ 1i!
?
e) Calculer l'inverse de la matrice 3 µ 3 de Hilbert dont l'élément Hi, jL est défini par 1Hi+ j-1L
f) Calculer une approximation de p en réalisant une intégration numérique de la fonction 4
1+ x2 entre 0 et 1.
3.7.3 Problème
On veut fabriquer un canal d'adduction d'eau à partir d'éléments de tôle ayant une largeur unité. La section du canalest trapézoïdale avec une base de largeur x et les côtés de dimensions y inclinés d'un angle a par rapport à la verticale(voir schéma).
y y
x
a
x+2y=1
a) Définir l'expression de la surface de la section de l'aqueduc en fonction de y et de a
b) Trouvez des valeurs approchées de x, y et a qui maximisent la section en examinant un tracé tridimensionnel de lasection puis une représentation en courbes de niveaux.
c) Trouvez les valeurs de x, y et a qui maximisent la section (on utilisera au moins FindRoot)
3. Prise en main 43
44 3. Prise en main
Chapitre 4
Définir une fonction
46 4. Définir une fonction
4 Définir une fonction
Avant de montrer comment l'on définit une fonction, nous allons présenter les notions fondamentales d'affectation
instantanée et d'affectation différée. Nous verrons notamment qu'une fonction est généralement définie au moyen d'une
affectation différée mais que dans certains cas il peut être préférable, notamment pour économiser du temps de calcul, de
les définir au moyen d'une affectation instantanée.
4.1 Affectation instantanée et affectation différée
L'affectation est un lien entre un symbole et une entité qui ont des existences séparées (en informatique, on parle de
pointeur).
Dans une affectation instantanée, le symbole est lié à une entité au moment de sa création, grâce au caractère "=". On
notera au passage, dans l'exemple suivant, qu'il est possible d'écrire plusieurs instructions dans une même cellule. Seule la
dernière qui n'est pas suivie d'un point virgule affiche un résultat :
a = 5; x = a; 8a, x<
85, 5<
a = 10; 8a, x<
810, 5<
Si on interroge le système au sujet de x, on constate bien que x a pris la valeur de a au moment de sa création :
? x
Global`x
x = 5
Dans une affectation différée, le symbole n'est lié à l'entité qu'au moment de son utilisation grâce à une affectation au
moyen de la chaîne de caractères ":=". Ainsi, dans l'exemple suivant, y ne prend la valeur de a qu'au moment où y est
utilisé. Si la valeur de a change à un moment, celle de y changera également.
a = 5; y := a; 8a, y<
85, 5<
a = 10; 8a, y<
810, 10<
Si on interroge le système au sujet de y, on constate bien que y n'est pas égal à une valeur donnée, mais à une
expression (ici a) et on comprend pourquoi sa valeur change si l'expression a changé :
? y
Global`y
y := a
Pour supprimer l'affectation effectuée, on peut employer la commande suivante :
a =.
4. Définir une fonction 47
a
a
Il est néanmoins souvent plus prudent d'utiliser les commandes Clear, ClearAll ou Remove. Clear supprime
les valeurs et les définitions des symboles mentionnés, ClearAll supprime les affectations, les attributs, les messages et
valeurs par défaut associés aux symboles tandis que Remove supprime l'existence même des symboles :
Clear@xD; Remove@yD;
? x
Global`x
? y
Information::notfound : Symbol y not found. à
Pour supprimer toutes les affectations faites au moment d'une session de travail, c'est-à-dire depuis le lancement du
noyau, on pourra utiliser l'une ou l'autre des commandes suivantes qui s'appliquent à tous les symboles créés par
l'utilisateur au cours d'une session :
ClearAll@"Global`*"D;
ou
Remove@"Global`*"D;
Remarque
En notation fonctionnelle, l'affectation instantanée s'écrit Set et l'affectation différée s'écrit SetDelayed :
Set@a, 3 + 5D;
SetDelayed@b, 3 + 5D;
? a
Global`a
a = 8
? b
Global`b
b := 3 + 5
On pourra mieux comprendre la différence entre ces deux types d'affectation en observant que la seconde a l'attribut
HoldAll lui demandant de ne pas évaluer au préalable les arguments de la fonction :
Attributes@SetDelayedD
8HoldAll, Protected, SequenceHold<
Tandis que la première n'a que l'attribut HoldFirst, lui demandant de ne pas évaluer au préalable le premier
argument uniquement (c'est à dire ici le nom du symbole) :
48 4. Définir une fonction
Attributes@SetD
8HoldFirst, Protected, SequenceHold<
4.2 Ma première fonction
Mathematica est un langage extensible. C'est à dire que l'on peut définir des fonctions, des commandes ou des
opérateurs qui se comportent comme les fonctions, commandes et opérateurs internes.
La manière la plus élémentaire de définir une fonction est illustrée par l'exemple suivant :
f@x_D := 5 Sqrt@xD - 1 ê 10 x^2 + Sin@Exp@Sqrt@xDDD;
f est le nom donné à la fonction, la notation x_ signifie un et un seul argument appelé x pour les besoins de
la définition mais à ceci près quelconque. Si le _ est omis, la fonction n'est définie que pour le symbole x. La
partie droite de l'affectation (en général différée pour une fonction) ne comporte jamais de _. Dès que la fonction est
définie, on peut l'utiliser comme une fonction interne : en faire une représentation graphique, la dériver, l'intégrer, etc.
Plot@f@xD, 8x, 0, 10<D
2 4 6 8 10
4
6
8
D@f@xD, xD
5
2 x-x
5+
‰ x CosB‰ x F
2 x
NIntegrate@f@xD, 8x, 0, 10<D
72.2172
En pratique, il peut être plus efficace de définir f au moyen d'une affectation instantanée, avec =, plutôt que par une
affectation différée avec := comme nous venons de le faire.
Voici, pour l'illustrer, l'exemple de deux fonctions g et h, identiques à ceci près que g est définie par une affectation
différée et h par une affectation instantanée :
g@x_D := Integrate@1 ê H1 + u^2L, 8u, 0, x<D;
h@x_D = Integrate@1 ê H1 + u^2L, 8u, 0, x<D;
Ces deux fonctions donnent bien le même résultat général :
8g@zD, h@zD<
8ArcTan@zD, ArcTan@zD<
4. Définir une fonction 49
Mais Mathematica ne les stocke pas en mémoire de la même façon :
? g
Global`g
g@x_D := Ÿ0
x 1
1+u2„u
? h
Global`h
h@x_D = ArcTan@xD
On voit bien que l'affectation est différée dans le premier cas (le calcul n'est pas fait, il ne le sera qu'à l'appel de
l'expression g[x]) tandis que le calcul est instantané dans le deuxième cas (il a été fait au moment de valider les
affectations).
Regardons maintenant le temps que Mathematica met pour représenter ces fonctions dans l'intervalle [0, 10]!:
Timing@Plot@g@xD, 8x, 0, 10<DD
:4.74911,
2 4 6 8 10
0.8
1.0
1.2
1.4
>
Timing@Plot@h@xD, 8x, 0, 10<DD
:0.002068,
2 4 6 8 10
0.8
1.0
1.2
1.4
>
La différence vient du fait que, dans le premier cas, en chaque point utilisé pour tracer la courbe (25 par défaut mais
souvent davantage), Mathematica recalcule l'intégrale car en chaque point il fait appel à la fonction g qui n'est évaluée
qu'au moment de son utilisation. Par contre, dans le deuxième cas, la fonction h est déjà évaluée au moment de l'utiliser
dans la commande Plot. Il ne reste plus à Mathematica qu'à substituer à x des valeurs numériques pour dessiner la
courbe.
Cette subtilité entre affectation instantanée et affectation différée est à l'origine de fréquents problèmes d'exécution. Il
suffit parfois de faire une affectation instantanée plutôt qu'une affectation différée pour faire passer le temps d'exécution
de 1 heure à quelques minutes ou secondes.
Néanmoins, pour éviter des erreurs il est conseillé de toujours utiliser une affectation différée au moment
de définir une fonction.
Une autre façon de contourner ce problème sans passer par une affectation instantanée consistera à forcer l'évaluation
au moyen de la commande Evaluate comme le montre l'exemple suivant :
50 4. Définir une fonction
Timing@Plot@Evaluate@g@xDD, 8x, 0, 10<DD
:1.33641,
2 4 6 8 10
0.8
1.0
1.2
1.4
>
Enfin, dans la mesure où une fonction pourra être redéfinie plusieurs fois, soit à cause d'erreurs de frappe, soit
simplement parce qu'on le souhaite, il est conseillé d'associer à la définition, la commande Clear ou ClearAll, dans
la même cellule que celle dans laquelle est définie la fonction. L'exemple suivant illustre l'intérêt de Clear.
Considérons la fonction k suivante :
k@xD := x * Sin@xD
On peut constater que le caractère _ a été (ici volontairement) omis. Cette fonction n'opère donc que pour le symbole
x :
8k@xD, k@uD, k@5D<
8x Sin@xD, k@uD, k@5D<
Je décide donc de modifier ma définition en introduisant le caractère _ et en modifiant également la partie droite de la
définition (supposons par exemple que j'ai oublié une puissance de x) :
k@x_D := x^2 Sin@xD;
Si maintenant j'appelle ma fonction avec les mêmes arguments que précédemment, je constate que Mathematica a
gardé la mémoire de ma première définition (celle où je la définis pour le symbole x) :
8k@xD, k@uD, k@5D<
9x Sin@xD, u2 Sin@uD, 25 Sin@5D=
Regardons comment Mathematica stocke la définition de k dans sa mémoire!:
? k
Global`k
k@xD := x Sin@xD
k@x_D := x2 Sin@xD
On constate que Mathematica connaît maintenant 2 définitions pour k : l'une pour le symbole x et l'autre pour
n'importe quel argument. Ainsi, si l'on demande l'intégrale de la fonction, on obtient un résultat nettement différent selon
que l'on utilise x ou un autre argument symbolique :
Integrate@k@xD, xD
-x Cos@xD + Sin@xD
Integrate@k@uD, uD
-I-2 + u2M Cos@uD + 2 u Sin@uD
4. Définir une fonction 51
On verra ultérieurement l'usage que l'on peut faire de cette propriété. La pratique nous enseignera donc, suite aux
remarques précédentes, qu'il est souhaitable d'effacer de la mémoire les définitions préalables d'une fonction avant de la
définir à nouveau ou même pour la première fois, en écrivant par exemple :
Clear@kD;
k@x_D := x^2 Sin@xD;
Ainsi, aucune ancienne définition ne viendra interférer avec la fonction que l'on souhaite définir à présent :
? k
Global`k
k@x_D := x2 Sin@xD
Nous venons de voir comment définir une fonction simple, générale, acceptant n'importe quel type d'argument. Nous
allons voir maintenant comment typer notre fonction.
4.3 Fonction typée
Le typage d'une fonction consiste à faire comprendre à Mathematica que cette fonction ne doit s'appliquer que pour
certains types d'arguments ou renvoyer des résultats qui dépendent de ce type. Ce typage portera par exemple sur la
nature de l'argument ou encore sur sa valeur. On retiendra surtout ici qu'il est aisé de définir une fonction polymorphe,
réagissant différemment selon la nature ou la valeur de l'argument donné.
4.3.1 Typage formel
Le typage formel consiste à indiquer pour quel type d'argument la fonction définie s'applique. Par exemple, on pourra
définir une fonction qui ne s'applique qu'aux entiers de la façon suivante!:
Clear@fD;
f@x_IntegerD := Sin@x^2D;
Et nous constatons en effet que la fonction répond pour l'argument 5 mais ne répond pas (ou plutôt renvoie
l'expression entrée non évaluée) pour l'argument 5.2 :
8f@5D, [email protected]<
8Sin@25D, [email protected]<
Nous venons donc de restreindre ici l'ensemble de départ de la fonction à l'ensemble des entiers relatifs !.
La chaîne de caractères x_Integer s'appelle un motif (pattern en anglais) et le principe mis en œuvre ici s'appelle la
reconnaissance de formes ou la programmation par motifs.
Nombreuses sont les fonctions internes de Mathematica qui n'acceptent qu'un type d'argument donné. Ainsi, si on
donne à la fonction Prime un argument non entier positif, Mathematica renvoie un message d'erreur et retourne l'entrée
non évaluée :
Prime::intpp : Positive integer argument expected in [email protected]. à
D'autres motifs peuvent être utilisés et la liste suivante en donne quelques-uns des plus couramment utilisés.
x_Integer un entier
x_Real un nombre numérique Hcomportant un point décimalL
x_Complex un nombre complexe Hcomportant une partie imaginaire non nulleL
52 4. Définir une fonction
x_Complex un nombre complexe Hcomportant une partie imaginaire non nulleL
x_List une liste
x_Symbol un symbole
x_String une chaîne de caractères
Motifs couramment utilisés dans Mathematica.
Le principe du typage formel est simple!: à l'appel de la fonction, Mathematica détermine la tête de l'argument. Si la tête
obtenue est la même que celle indiquée dans le motif, alors l'expression est évaluée!; sinon Mathematica renvoie
l'expression initiale non évaluée. D'une manière générale, on pourra donc définir le motif utilisé en utilisant n'importe
quelle tête possible. En voici un exemple :
Clear@f, a, bD;
f@x_PlusD := x^2;
8f@a + bD, f@5D, f@a * bD<
9Ha + bL2, f@5D, f@a bD=
Mathematica a en effet déterminé au préalable quelle était la tête de l'argument :
Head@a + bD
Plus
Comme il y a correspondance avec le motif, le calcul de f[a+b] est effectué.
Remarque
Profitons de cet exemple pour discuter à nouveau du mécanisme d'évaluation. Soit le calcul suivant!:
f@3 + 5D
f@8D
On constate que bien que l'argument soit une somme, Mathematica refuse d'évaluer cette expression. Nous sommes en
effet dans le cadre du mécanisme d'évaluation standard selon lequel les arguments sont évalués au préalable. 3 + 5 = 8, 8
est un entier donc l'expression n'est pas évaluée. Pour que cela fonctionne comme souhaité, il faudrait quitter le mode
d'évaluation standard. On peut le faire en donnant l'attribut HoldAll à la fonction f. On notera dans ce cas l'utilisation
de ClearAll (qui supprime aussi les attributs) à la place de Clear (qui ne supprime pas ces derniers) :
ClearAll@fD;
Attributes@fD = 8HoldAll<;
f@x_PlusD := x^2;
f@3 + 5D
64
Fin de remarque
Ainsi, toute tête possible peut servir au typage formel d'une fonction. On pourra donc définir par exemple la fonction
suivante qui consiste à élever au carré l'argument du sinus donné en argument de f!:
ClearAll@fD;
f@x_SinD := x@@1DD^2
8f@Sin@5DD, f@Cos@5DD<
825, f@Cos@5DD<
Ou par exemple une fonction dont l'argument doit être de la forme (ou du type) g[...]!:
4. Définir une fonction 53
Ou par exemple une fonction dont l'argument doit être de la forme (ou du type) g[...]!:
ClearAll@f, g, hD;
f@x_gD := x@@1DD^2
8f@g@aDD, f@h@aDD, f@Sin@aDD<
9a2, f@h@aDD, f@Sin@aDD=
4.3.2 Typage conditionnel
En plus d'indiquer un motif, on peut soumettre l'argument à des contraintes définies par des conditions. Pour écrire
une condition on utilise le plus souvent la syntaxe suivante : expr /; condition (/; peut se lire "à condition
que")!:
Clear@fD;
f@x_Integer ê; x^2 ¥ 10D := x^2;
8f@1D, f@2D, f@3D, f@4D<
8f@1D, f@2D, f@3D, 16<
Pour écrire la condition, n'importe quel test, aussi complexe soit-il, peut être utilisé. Il suffit pour cela que la fonction-
test renvoie True quand le test donne vrai. Vous pouvez donc écrire vous-même une fonction-test comme le montre
l'exemple suivant :
test@x_D := If@And@x > 0, x < 5D, True, False, FalseD;
8test@-2D, test@2D, test@5D<
8False, True, False<
Il suffit ensuite d'utiliser ce test dans une fonction :
Clear@fD;
f@x_Integer ê; test@xDD := x^3;
8f@-2D, f@0D, f@1D, f@2D, f@5D, f@6D<
8f@-2D, f@0D, 1, 8, f@5D, f@6D<
Mathematica fournit un certain nombre de fonctions pour tester les propriétés des expressions. Deux types de tests
existent : les tests symboliques qui se présentent toujours sous la forme d'une fonction se terminant par Q indiquant
qu'elle pose une question et les tests de comparaison de valeurs.
NumberQ@exprD nombre
IntegerQ@exprD entier
EvenQ@exprD nombre pair
OddQ@exprD nombre impair
PrimeQ@exprD nombre premier
PolynomialQ@expr, 8x1, x2, ...<D polynôme en x1, x2, ...
VectorQ@exprD liste représentant un vecteur
MatrixQ@exprD liste représentant une matrice
VectorQ@expr, NumberQD vecteur de nombres
MatrixQ@expr, IntegerQD matrice d'entiers
Certaines fonctions pour tester les propriétés d'expressions
54 4. Définir une fonction
Voici par exemple une fonction qui teste si l'argument est un nombre :
Clear@fD;
f@x_ ê; NumericQ@xDD := "nombre";
8f@2D, [email protected], f@2 ê 3D, f@1 + ID, f@pD, f@totoD<
8nombre, nombre, nombre, nombre, nombre, f@totoD<
Mathematica offre également une autre notation pour imposer des contraintes à un argument : motif?test en lieu et
place de motif /; test. Elle est parfois plus courte :
Clear@gD;
g@x_?NumericQD := "oui";
8g@2D, [email protected], g@2 ê 3D, g@1 + ID, g@pD, g@totoD<
8oui, oui, oui, oui, oui, g@totoD<
Dans ce cas, le test s'applique automatiquement à l'argument sans qu'il soit nécessaire de le préciser.
Equal@x, yD ou x ã y x et y ont la même valeur numérique
Unequal@x, yD ou x != y x et y n'ont pas la même valeur numérique
Less@x, yD ou x < y x est strictement inférieur à y
Greater@x, yD ou x > y x est strictement supérieur à y
LessEqual@x, yD ou x <= y x est inférieur ou égal à y
GreaterEqual@x, yD ou x >= y x est supérieur ou égal à y
Positive@xD x est strictement positif
Negative@xD x est strictement négatif
NonNegative@xD x n' est pas strictement négatif Hx est positif ou nulL
Autres fonctions pour comparer des valeurs
Les tests symboliques et les tests de comparaison de valeurs diffèrent dans le fait que les tests symboliques renvoient
True ou False tandis que les tests de comparaison de valeurs renvoient True si c'est vrai, False si c'est faux et
renvoient l'expression entrée inchangée quand on ne sait pas!:
8Equal@a, bD, SameQ@a, bD<
8a ã b, False<
De même :
[email protected], 3 ê 2D, [email protected], 3 ê 2D<
8True, False<
En effet, 1.5 a la même valeur numérique que 3/2 mais ces deux nombres ne sont pas identiques car 1.5 est de
type réel tandis que 3/2 est de type rationnel.
Enfin, plusieurs tests peuvent être utilisés simultanément comme le montre l'exemple suivant :
Clear@hD;
h@x_ ê; Or@EvenQ@xD, PrimeQ@xDDD := x^2;
8h@4D, h@7D, h@9D, h@2 ê 3D, [email protected]<
:16, 49, h@9D, hB2
3F, [email protected]>
4. Définir une fonction 55
Et plusieurs motifs peuvent également être proposés (on utilise caractère | (pipe) qui signifie ici : motif 1 ou motif!2) :
Clear@kD;
k@x_Integer x_RationalD := x^2;
[email protected], k@2D, k@2 ê 3D, k@1 + ID<
:[email protected], 4,4
9, k@1 + ÂD>
4.4 Fonction polymorphe
En étendant les considérations précédentes, il devient aisé de construire une fonction prenant des valeurs différentes
selon le type d'argument entré ou selon la valeur de cet argument. Pour cela, il suffit de proposer plusieurs définitions de
la fonction comme cela a été rapidemment évoqué dans le chapitre 4.2. Définissons par exemple une fonction qui
effectue des opérations différentes selon le type d'argument. Il suffit d'écrire :
Clear@fD;
f@x_D := 0;
f@x_IntegerD := x
f@x_RationalD := x^2;
f@x_RealD := x^3;
f@x_ComplexD := Re@xD^4;
f@0D = 1;
Regardons comment Mathematica conserve cette fonction en mémoire :
? f
Global`f
f@0D = 1
f@x_IntegerD := x
f@x_RationalD := x2
f@x_RealD := x3
f@x_ComplexD := Re@xD4
f@x_D := 0
Comme on peut le constater, Mathematica a trié les définitions dans un ordre différent de celui avec lequel nous avons
défini la fonction f. Mathematica traite les règles données selon leur niveau de particularité. Une règle est dite générale
quand elle ne comporte rien derrière le _ (c'est le cas ici de la règle f[x_]=0). Elle est dite particulière quand elle ne
comporte pas de _ (f[0]=1). Enfin elle est considérée comme de niveau intermédiaire quand elle comporte quelque chose
derrière le _ (comme dans les autres cas). Ainsi, dans sa mémoire, Mathematica va placer en tête les règles particulières
puis les règles intermédiaires puis les règles générales. Dans chaque catégorie, l'ordre des règles restera néanmoins celui
donné par l'utilisateur et c'est dans cas qu'il faudra veiller à bien ordonner les définitions de sorte que l'une d'elle n'en
cache par une autre. Au moment de l'évaluation, Mathematica parcourt alors les règles dans l'ordre qu'il a adopté et utilise
la première rencontrée qui s'applique. Testons maintenant cette fonction :
56 4. Définir une fonction
8f@0D, f@2D, f@2 ê 3D, [email protected], f@1 + ID, f@totoD<
:1, 2,4
9, 9.261, 1, 0>
A titre d'exemple supplémentaire, construisons maintenant une fonction à plusieurs intervalles de définition :
Clear@fD;
f@x_ ê; x <= 0D := x;
f@x_ ê; x <= 5D := 2 x;
f@x_ ê; x <= 10D := 3 x - 5;
f@x_D := 250 ê x;
Et donnons sa représentation graphique dans l'intervalle [-10, 20]!:
Plot@f@xD, 8x, -10, 20<D
-10 -5 5 10 15 20
-10
-5
5
10
15
20
25
4.5 Fonction à plusieurs arguments
La construction d'une fonction à plusieurs arguments est très simple. Elle repose sur le même principe que la
construction de fonctions à un seul argument, avec les mêmes possibilités de restriction sur les arguments au moyen des
motifs. Voici l'exemple d'une fonction à deux arguments qui donne la liste des puissances d'un nombre (le premier
argument) jusqu'à l'ordre (entier) donné par le deuxième argument :
Clear@fD;
f@x_, y_IntegerD := Table@x^i, 8i, 1, y<D;
f@2, 5D
82, 4, 8, 16, 32<
On peut ajouter un troisième argument à cette fonction pour choisir de quel ordre à quel autre on veut afficher les
puissances entières d'un nombre :
Clear@gD;
g@x_, y_Integer, z_IntegerD := Table@x^i, 8i, y, z<D;
g@2, 3, 8D
88, 16, 32, 64, 128, 256<
Si l'on a besoin de faire porter une condition sur les deux arguments, on prendra soin de sortir la condition du crochet
de la fonction car cette dernière ne peut être attachée exclusivement ni au premier ni au second argument :
Clear@hD;
h@x_, y_D ê; y > x := y - x;
h@x_, y_D := x - y
4. Définir une fonction 57
8h@2, 5D, h@5, 3D<
83, 2<
Dans ce dernier cas, la première règle est testée au préalable. Si elle ne s'applique pas, c'est la deuxième, plus générale,
qui s'applique.
Sur le même principe, on pourra définir des fonctions à 3, 4 ou plus arguments. Nous verrons dans le chapitre suivant
comment idéalement programmer une fonction possédant de nombreux arguments ou quand ces derniers sont en
nombre indéterminé.
4.6 Arguments par défaut
Quand on définit des fonctions à plusieurs variables, il est parfois pratique de proposer des valeurs par défaut pour
certaines d'entre elles, surtout si le nombre d'arguments exigés est important et que certains de ces arguments prennent
presque toujours la même valeur. Pour cela il suffit de rajouter au motif le caractère : suivi de la valeur par défaut
souhaitée comme le montre l'exemple suivant :
Clear@fD;
f@x_, y_: 2D := x^y;
8f@3D, f@3, 2D, f@3, 3D<
89, 9, 27<
Ou encore ici une fonction qui sert à appliquer une fonction sur un argument :
Clear@appliquerD;
appliquer@f_: Sin, x_D := f@xD;
8appliquer@Pi ê 2D, appliquer@Cos, PiD<
81, -1<
4.7 Fonction récursive et fonction à mémoire
La définition d'une fonction peut être récursive, c'est à dire faire appel à elle-même. Dans ce cas, au moment de
l'exécution, Mathematica effectue un calcul en boucle. Il est alors toujours nécessaire de disposer d'une valeur de départ.
La syntaxe employée est toujours la même. Définissons par exemple la fonction factorielle de manière récursive!:
Clear@facD;
fac@n_IntegerD := n fac@n - 1D;
fac@0D = 1;
8fac@25D, 25!<
815 511 210 043 330 985 984 000 000, 15 511 210 043 330 985 984 000 000<
Notre fonction donne bien la même valeur que la fonction factorielle interne. Néanmoins, quand le nombre de calculs
en boucle est trop grand, Mathematica affiche un message :
fac@300D
58 4. Définir une fonction
$RecursionLimit::reclim : Recursion depth of 256 exceeded. à
2 558 533 941 286 829 342 717 924 560 147 560 222 845 676 472 147 959 265 021 817 701 -
191 436 383 061 943 938 370 721 009 046 437 271 000 661 788 849 955 570 665 001 631 -
824 663 847 151 540 742 310 268 417 084 526 033 390 537 648 900 101 952 558 925 443 -
936 882 670 282 730 041 888 846 219 339 082 291 128 119 320 830 732 088 341 919 162 -
621 416 203 259 998 329 584 615 889 138 366 742 749 843 704 700 061 387 083 225 067 -
301 759 546 540 838 962 303 040 052 445 991 551 359 053 966 225 310 066 550 509 334 -
015 423 901 823 371 360 755 721 206 337 385 511 179 268 597 746 027 780 376 498 056 -
709 576 991 617 160 737 692 204 568 776 011 756 316 861 381 172 264 960 000 000 000 -
000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000
Hold@fac@46 - 1DD
En effet, pour éviter que le calcul ne boucle indéfiniment à la suite à une erreur d'écriture par exemple, Mathematica
limite le nombre de boucles à la valeur de la variable globale $RecursionLimit qui est de 256 par défaut.
Néanmoins, l'utilisateur peut changer cette valeur par défaut :
$RecursionLimit = 500;
fac@300D
306 057 512 216 440 636 035 370 461 297 268 629 388 588 804 173 576 999 416 776 741 259 -
476 533 176 716 867 465 515 291 422 477 573 349 939 147 888 701 726 368 864 263 907 -
759 003 154 226 842 927 906 974 559 841 225 476 930 271 954 604 008 012 215 776 252 -
176 854 255 965 356 903 506 788 725 264 321 896 264 299 365 204 576 448 830 388 909 -
753 943 489 625 436 053 225 980 776 521 270 822 437 639 449 120 128 678 675 368 305 -
712 293 681 943 649 956 460 498 166 450 227 716 500 185 176 546 469 340 112 226 034 -
729 724 066 333 258 583 506 870 150 169 794 168 850 353 752 137 554 910 289 126 407 -
157 154 830 282 284 937 952 636 580 145 235 233 156 936 482 233 436 799 254 594 095 -
276 820 608 062 232 812 387 383 880 817 049 600 000 000 000 000 000 000 000 000 000 -
000 000 000 000 000 000 000 000 000 000 000 000 000 000 000
Cette syntaxe permet donc de construire aisément des suites. Néanmoins, le temps de calcul peut rapidement se
révéler un problème dans la mesure où, chaque fois qu'une valeur est demandée, Mathematica recalcule tous les termes de
la suite pour déterminer le terme recherché. Il existe un moyen de conserver en mémoire toutes les valeurs
intermédiaires déjà calculées de façon à ne pas avoir à les recalculer. Considérons pour cela deux nouvelles fonctions
récursives f et g assez complexes. f est définie de façon standard, comme la fonction fac et g est définie de manière à
conserver en mémoire toutes ses évaluations intermédiaires :
Clear@fD;
f@n_D := NBCos@f@n - 1DD2
LogAf@n - 1D2E
12
F;
f@0D = 2;
Clear@gD;
g@n_D := g@nD = NBCos@g@n - 1DD2
LogAg@n - 1D2E
12
F;
g@0D = 2;
Cette façon de définir la fonction g permet, au moyen d'une affectation instantanée dans la partie droite de la
définition, de stocker (en mémoire) toutes les valeurs intermédiaires. On parle alors de fonction à mémoire ou de mémo-
fonction.
4. Définir une fonction 59
Calculons la valeur de f et de g pour n=10 :
8f@10D, g@10D<
92.16963 µ 10-25, 2.16963 µ 10-25=
On constate bien que les deux fonctions exécutent les mêmes calculs. Regardons maintenant le temps mis par
Mathematica pour effectuer ces calculs :
8Timing@f@10D;D, Timing@g@10D;D<
980.010654, Null<, 97. µ 10-6, Null==
Le calcul avec la fonction g est maintenant instantané tandis qu'avec la fonction f, il est relativement long (cela
dépend aussi, bien entendu, de l'ordinateur utilisé). En effet, Mathematica ne stocke pas les définitions des deux fonctions fet g de la même façon!:
? f
Global`f
f@0D = 2
f@n_D := NBKCos@f@n-1DD2
LogAf@n-1D2EO12
F
?g
Global`g
g@0D = 2
g@1D = 1.44428 µ 10-11
g@2D = 4.17382 µ 10-21
g@3D = 2.1416 µ 10-24
g@4D = 3.55496 µ 10-25
g@5D = 2.40926 µ 10-25
g@6D = 2.21817 µ 10-25
g@7D = 2.17973 µ 10-25
g@8D = 2.17169 µ 10-25
g@9D = 2.16999 µ 10-25
g@10D = 2.16963 µ 10-25
g@n_D := g@nD = NBKCos@g@n-1DD2
LogAg@n-1D2EO12
F
En plus de stocker la définition générale, Mathematica conserve en mémoire toutes les valeurs intermédiaires
déterminées par g pour calculer g[10]. Ces valeurs intermédiaires ont été stockées en mémoire au moment où nous
avons appelé g[10], la première fois. Il ne reste plus à Mathematica qu'à relire la valeur déjà calculée au moment où l'on
redemande g[10], alors que les calculs intermédiaires sont de nouveau effectués pour la fonction f. Ce mécanisme
provient des propriétés des fonctions SetDelayed (:=) et Set (=). Chaque fois qu'une valeur est calculée, la fonction
Set (=) permet le stockage de cette valeur dans la mémoire du noyau.
Si cette construction permet d'offrir un gain significatif en terme de vitesses d'exécution, elle consomme davantage de
mémoire. Il convient donc d'être prudent quant à son utilisation.
60 4. Définir une fonction
En plus de stocker la définition générale, Mathematica conserve en mémoire toutes les valeurs intermédiaires
déterminées par g pour calculer g[10]. Ces valeurs intermédiaires ont été stockées en mémoire au moment où nous
avons appelé g[10], la première fois. Il ne reste plus à Mathematica qu'à relire la valeur déjà calculée au moment où l'on
redemande g[10], alors que les calculs intermédiaires sont de nouveau effectués pour la fonction f. Ce mécanisme
provient des propriétés des fonctions SetDelayed (:=) et Set (=). Chaque fois qu'une valeur est calculée, la fonction
Set (=) permet le stockage de cette valeur dans la mémoire du noyau.
Si cette construction permet d'offrir un gain significatif en terme de vitesses d'exécution, elle consomme davantage de
mémoire. Il convient donc d'être prudent quant à son utilisation.
4.8 Exercices
4.8.1 Définir une fonction
a) Ecrire une fonction f[x] qui produit le tracé suivant (la partie entre -1 et 1 est une parabole):
-3 -2 -1 0 1 2 3
0.20.40.60.81.0
b) Calculer Ÿ-33
f HxL „ x
c) Définir une fonction pascal[n] qui représente la rangée n du triangle de Pascal (penser à utiliser la fonction
Binomial[m,n]). Afficher un triangle de Pascal avec la commande TableForm.
4.8.2 Définir une fonction paramétrique
a) Définir la fonction à une variable qui renvoie une liste de deux coordonnées telles que leur tracé paramétrique
donne la représentation graphique suivante :
-1.5-1.0-0.5 0.5 1.0 1.5 2.0
-2
-1
1
2
4. Définir une fonction 61
b) Même question pour le tracé suivant obtenu par une petite modification du précédent.
-2 -1 1 2
-2
-1
1
2
c) Même question pour le tracé suivant (fonction à deux variables)
4.8.3 Orthogonalisez des vecteurs
a) Définir une fonction projection[u,v] qui réalise la projection du vecteur u sur le vecteur v.
b) La procédure d'orthogonalisation de Gram-Schmidt consiste à transformer une liste v de 3 vecteurs 8v1, v2, v3< en la
liste u des trois vecteurs 8u1, u2, u3< tels que :
u1 = v1;
u2 = v2 - projection@v2, u1D;
u3 = v3 - projection@v3, u1D - projection@v3, u2D;
Définir une fonction ortho[vecteurs] qui transforme une liste v en une liste u selon la procédure décrite.
c) Orthogonaliser les vecteurs suivants : 881, 2, 3<, 82, -3, -4<, 8-1, 5, 2<<. Vérifier le résultat en projetant chaque
vecteur sur les deux autres.
d) Ecrire maintenant une fonction normalisation[vecteur] qui permet de normaliser les vecteurs
orthogonaux obtenus par la fonction définie précédemment. Faire la vérification.
62 4. Définir une fonction
Chapitre 5
Programmation par motifs
64 5. Programmation par motifs
5 Programmation par motifs
5.1 Rappel
Rappelons que pour définir une fonction à un argument (par exemple), on doit respecter la syntaxe proposée dans
l'exemple suivant :
Clear@fD;
f@x_D := Sin@x^2D
8f@5D, f@totoD<
9Sin@25D, SinAtoto2E=
Nous avons vu que _ signifie un et un seul argument à ceci près quelconque. La fonction précédente est donc
une fonction très générale car elle peut-être utilisée, a priori, avec n'importe quel argument.
Néanmoins, il est généralement conseillé de restreindre l'ensemble de départ de la fonction aux seuls arguments
possibles, faute de quoi Mathematica renverrai un message d'erreur après une tentative de calcul, parfois longue. Par
exemple, si par erreur je tente d'appliquer f sur un graphique cela donne :
des = Plot@Sin@xD ê x, 8x, 0, 10<D
2 4 6 8 10-0.2
0.2
0.4
0.6
0.8
1.0
f@desD
SinB
2 4 6 8 10
0.40.60.81.0
2
F
Evidemment ce résultat n'a pas de sens. Il est donc souhaitable de typer notre fonction, par exemple de la façon
suivante :
Clear@fD;
f@x_?NumericQD := Sin@x^2D
8f@xD, f@5D, f@5 ê 2D, f@totoD, f@desD<
:f@xD, Sin@25D, SinB25
4F, f@totoD, fB
2 4 6 8 10
0.40.60.81.0
F>
Par ailleurs, nous avons vu au chapitre précédent que l'on pouvait construire des fonctions polymorphes en donnant
plusieurs définitions à f, distinctes l'une de l'autre par le motif utilisé, comme dans l'exemple suivant :
5. Programmation par motifs 65
Clear@fD;
f@x_IntegerD := Sin@x^2D;
f@x_RationalD := Cos@x^2D;
f@x_RealD := Tan@xD;
f@x_ListD := Length@xD;
8f@5D, f@5 ê 2D, [email protected], f@81, 2, 5<D, f@totoD<
:Sin@25D, CosB25
4F, -1.88564, 3, f@totoD>
5.2 Fonction effectuant des opérations symboliques
Dans plusieurs des exemples du chapitre précédent, nous avons vu qu'il était possible d'entrer des arguments
symboliques à condition que la définition de la fonction ne restreigne pas son usage à des types d'arguments particuliers
non symboliques (Real, Integer,...).
On peut également définir des fonctions effectuant des manipulations symboliques qui peuvent dépendre de la façon
dont les arguments sont entrés.
Par exemple, on peut définir ce qu'une fonction doit faire quand l'argument donné est une somme, un produit, une
puissance, permettant par exemple de décomposer un polynôme en ses termes. On utilisera les syntaxes suivantes très
explicites :
Clear@fD;
f@x_ + y_D := 8x, y<;
f@x_ * y_D := 8x, y<;
f@x_^n_D := 8x, n<;
Ce qui donne par exemple :
f@2 x^2 + 5 yD
92 x2, 5 y=
Si nous voulons généraliser de telle sorte que la fonction soit récursive (qu'elle continue à explorer les termes du
polynôme), nous pouvons le faire de la façon suivante (mais il existe d'autres moyens plus élégants) :
Clear@fD;
f@x_ + y_D := 8f@xD, f@yD<;
f@x_ * y_D := 8f@xD, f@yD<;
f@x_^n_D := 8f@xD, f@nD<;
f@x_D := x;
Ce qui donne à l'usage :
f@2 x^2 + 5 yD
882, 8x, 2<<, 85, y<<
f@2 x^2 + 5 y + z^Hx + yLD
882, 8x, 2<<, 885, y<, 8z, 8x, y<<<<
De cette façon, nous pourrions aussi reprogrammer les règles de la dérivation dont voici quelques unes, suivies d'un
exemple d'application :
66 5. Programmation par motifs
Clear@derive, a, bD;
derive@u_ + v_, x_D := derive@u, xD + derive@v, xD;
derive@u_ * v_, x_D := u * derive@v, xD + v * derive@u, xD;
derive@u_^c_, x_D := c * u^Hc - 1L * derive@u, xD;
derive@x_, x_D := 1;
derive@c_?NumericQ, x_D := 0;
derive@3 x^4 + 3 y^5, xD
12 x3 + 15 y4 derive@y, xD
C'est d'ailleurs sur ce principe que sont programmées les règles de l'opérateur D dans le noyau de Mathematica et il
suffit d'une page de code pour couvrir l'essentiel des besoins.
5.3 Utilisation des attributs
Les attributs servent à attacher à des symboles des propriétés particulières préprogrammées. Nous avons par exemple
déjà rencontré l'attribut HoldAll qui indique à une fonction de ne pas évaluer au préalable les arguments qu'on lui
soumet. Voici un exemple pour s'en rappeler. Celui d'une fonction qui transforme une somme en puissance :
Clear@fD;
f@x_ + y_D := x^y;
f@a + bD
ab
Mais la fonction ne donne le résultat escompté que pour des arguments en partie symbolique comme le montre
l'exemple suivant :
f@3 + aD
3a
f@3 + 5D
f@8D
Dans ce dernier cas en effet, conformément au mécanisme général d'évaluation, l'argument est évalué au préalable ce
qui donne : 3 + 5 = 8. La fonction n'ayant pas de définition pour autre chose qu'une somme de 2 termes, elle n'est pas
évaluée. On peut corriger ce problème en donnant l'attribut HoldAll à la fonction f :
Attributes@fD = 8HoldAll<;
A partir de maintenant, nous avons le comportement attendu :
f@3 + 5D
243
Il existe d'autres attributs utiles. Voici par exemple ceux de l'opérateur Plus :
Attributes@PlusD
8Flat, Listable, NumericFunction, OneIdentity, Orderless, Protected<
L'attribut Flat signifie associatif. L'attribut Listable veut dire que la fonction opère automatiquement sur les
éléments d'une liste à tous les niveaux d'imbrication et que le résultat se présente avec la même arborescence que l'entrée.
L'attribut Orderless signifie commutatif.
5. Programmation par motifs 67
Voyons par exemple l'utilisation de l'attribut Listable. Sans cet attribut, la fonction précédente n'opère pas sur une
liste :
f@83 + 5, a + b, 88c + d, a + 5<, 2 + 3<<D
f@83 + 5, a + b, 88c + d, a + 5<, 2 + 3<<D
Avec l'attribut Listable, le fonctionnement de f change :
Attributes@fD = 8HoldAll, Listable<;
f@83 + 5, a + b, 88c + d, a + 5<, 2 + 3<<D
9243, ab, 99cd, a5=, 8==
L'exemple de Orderless est plus subtil. Pour l'illustrer, considérons la fonction suivante :
ClearAll@gD;
g@x_, y_D := x^y
Et comparons les deux résultats suivants :
8g@a, bD, g@b, aD<
9ab, ba=
Les résultats obtenus sont bien les résultats attendus. Supposons néanmoins que nous devions imposer à g la règle de
la commutativité. Il suffit pour ce faire d'écrire :
Attributes@gD = 8Orderless<;
Ce qui nous donne maintenant, à l'appel de g :
8g@a, bD, g@b, aD<
9ab, ab=
On obtient maintenant le même résultat dans les deux cas car la fonction est commutative. La règle de calcul étant la
suivante : puisque le symbole g a l'attribut Orderless, Mathematica change automatiquement l'ordre des arguments et
les place dans l'ordre canonique : croissant pour les nombres, alphabétique pour les symboles et nombres avant
symboles!:
8g@5, aD, g@a, 5D<
95a, 5a=
Il y a bien évidemment d'autres attributs possibles et on pourra les connaître en consultant l'aide interactive ou l'aide
en ligne comme dans l'exemple suivant :
? OneIdentity
OneIdentity is an attribute that can be
assigned to a symbol f to indicate that f @xD, f @ f @xDD, etc. are
all equivalent to x for the purpose of pattern matching. !à
On prendra soin, pour la suite, de supprimer les attributs affectés aux symboles créés :
ClearAll@"Global`*"D;
68 5. Programmation par motifs
5.4 Programmation par motifs
Il existe dans Mathematica des fonctions qu'on peut utiliser avec autant d'arguments que l'on veut. Par exemple, les
opérateurs internes Plus et Times fonctionnent de cette façon comme le montre l'instruction suivante :
8Plus@D, Plus@1D, Plus@1, 2D, Plus@1, 2, 3, 4, 5, 6D<
80, 1, 3, 21<
Pour définir un tel comportement il suffit de multiplier le nombre de _ dans la définition de l'argument de la fonction :
__ (2 soulignés) pour dire un ou plusieurs arguments ou ___ (3 soulignés) qui signifie 0, un ou plusieurs
arguments. Cela offre de très intéressantes possibilités dans la mesure ou un seul symbole permet de désigner ce qu'on
appelle alors une séquence d'arguments (fonction Sequence[...]). Voyons un premier exemple simple, celui d'une
fonction qui calcule la différence entre le dernier et le premier argument donnés (qu'on doit placer dans une liste pour les
extraire) :
Clear@fD;
f@x__D := 8x<@@-1DD - 8x<@@1DD
f@3, 5, 2, 7D
4
Voyons maintenant un exemple beaucoup plus subtil dans lequel x désigne toujours le premier argument donné à f et
y désigne tous les autres :
Clear@fD;
f@x_, y__D := x + 2 f@yD;
f@x_D := x;
Deux définitions ont été programmées. La première correspond au programme principal. Pour qu'elle fonctionne, il
faut utiliser au moins 2 arguments (un pour x et au moins un pour y). La seconde indique ce qu'il faut faire quand f ne
reçoit qu'un seul argument. Il s'agit par ailleurs d'une fonction récursive. Voyons sur un exemple :
f@1, 2, 3D
17
On peut décomposer le calcul en les étapes suivantes :
f@1, 2, 3D;
1 + 2 * f@2, 3D;
1 + 2 * H2 + 2 * f@3DL;
1 + 2 * H2 + 2 * 3L
17
Décomposition que Mathematica va réaliser automatiquement comme on peut le voir grâce à l'affichage des étapes de
calculs (fonction On[] à utiliser avec parcimonie et à faire suivre de la fonction Off[] pour désactiver son action) :
On@D;
On::trace : On@D --> Null. à
CompoundExpression::trace : On@D; --> Null. à
f@1, 2, 3D
f::trace : f@1, 2, 3D --> 1+2 f@2, 3D. à
f::trace : f@2, 3D --> 2+2 f@3D. à
5. Programmation par motifs 69
f::trace : f@3D --> 3. à
Times::trace : 2 f@3D --> 2 µ 3. à
Times::trace : 2 µ 3 --> 6. à
Plus::trace : 2+2 f@3D --> 2+6. à
Plus::trace : 2+6 --> 8. à
Times::trace : 2 f@2, 3D --> 2 µ 8. à
Times::trace : 2 µ 8 --> 16. à
Plus::trace : 1+2 f@2, 3D --> 1+16. à
Plus::trace : 1+16 --> 17. à
17
Off@D;
On comprendra vite l'intérêt de cette façon de faire : elle évite le décompte des arguments car ces derniers peuvent
être désignés collectivement par l'utilisation d'un seul symbole. Par exemple, programmer la fonction moyenne devient un
jeu d'enfant et ne nécessite aucune boucle. Comme le montre l'exemple suivant, le programme consiste à effectuer la
somme de tous les arguments et à la diviser par la longueur de la liste dans laquelle on les place. On ajoute par ailleurs
une règle dans le cas où aucun argument n'est donné :
Clear@moyD;
moy@x__D := Plus@xD ê Length@8x<D;
moy@ D := Print@"aucun argument"D;
moy@2, 3, 2D
7
3
De cette manière, on peut écrire des programmes très sophistiqués et, avec l'habitude, faciles à relire. Voici par
exemple un programme permettant de trier dans l'ordre croissant des nombres placés dans une liste sans utiliser la
fonction Sort. Le programme consiste à balayer les éléments de la liste et à inverser deux éléments consécutifs quand le
deuxième est plus petit que le premier. Le voici!:
Clear@triD;
tri@8x___, y_, z_, w___< ê; z < yD := tri@8x, z, y, w<D;
tri@x_D := x;
Et on peut vérifier que le programme fonctionne correctement :
tri@87, 3, 8, 4, 5, 6, 2, 4, 2, 1, 7<D
81, 2, 2, 3, 4, 4, 5, 6, 7, 7, 8<
Le principe du programme est le suivant : la première règle sert à trier une liste qui n'est pas triée. Quand la première
règle ne s'applique plus, c'est la deuxième qui s'applique. Cette dernière sert donc à renvoyer une liste quand elle a déjà
été triée (grâce à la première règle). La première règle est récursive. En effet, le programme consiste à permuter deux
éléments consécutifs qui ne sont pas dans l'ordre. Chaque fois qu'une telle opération a été réalisée, il faut rappeler la règle
pour rechercher deux autres éléments consécutifs non triés jusqu'à ce qu'il n'en existe plus (c'est alors la deuxième règle
qui prend le relai). Dans le programme, les deux éléments qui sont comparés sont notés y et z. Ils ne sont suivis que d'un
seul _ et désignent donc chacun un seul élément qui pourront faire l'objet d'une comparaison (test placé en fin de liste :
/;z<y). Devant y nous trouvons x___. x désigne donc 0, un ou plusieurs termes, ceux qui précèdent y. Derrière z
nous trouvons w___. w désigne donc tous les éléments qui suivent z dans la liste. x et w nous permettront de récupérer
les éléments qui précèdent et les éléments qui suivent, dans la liste, les deux éléments qui seront permutés. Ensuite, le
mécanisme de permutations successives s'enclenche automatiquement grâce à la récursivité.
70 5. Programmation par motifs
Le principe du programme est le suivant : la première règle sert à trier une liste qui n'est pas triée. Quand la première
règle ne s'applique plus, c'est la deuxième qui s'applique. Cette dernière sert donc à renvoyer une liste quand elle a déjà
été triée (grâce à la première règle). La première règle est récursive. En effet, le programme consiste à permuter deux
éléments consécutifs qui ne sont pas dans l'ordre. Chaque fois qu'une telle opération a été réalisée, il faut rappeler la règle
pour rechercher deux autres éléments consécutifs non triés jusqu'à ce qu'il n'en existe plus (c'est alors la deuxième règle
qui prend le relai). Dans le programme, les deux éléments qui sont comparés sont notés y et z. Ils ne sont suivis que d'un
seul _ et désignent donc chacun un seul élément qui pourront faire l'objet d'une comparaison (test placé en fin de liste :
/;z<y). Devant y nous trouvons x___. x désigne donc 0, un ou plusieurs termes, ceux qui précèdent y. Derrière z
nous trouvons w___. w désigne donc tous les éléments qui suivent z dans la liste. x et w nous permettront de récupérer
les éléments qui précèdent et les éléments qui suivent, dans la liste, les deux éléments qui seront permutés. Ensuite, le
mécanisme de permutations successives s'enclenche automatiquement grâce à la récursivité.
En résumé, quand on soumet une liste à la fonction tri, chaque fois que la première règle peut s'appliquer (i.e. il
existe deux éléments consécutifs non ordonnés), elle s'applique. Quand tous les éléments sont ordonnés, la première règle
ne s'applique plus et la deuxième permet de retourner la liste ordonnée.
De nombreuses opérations peuvent être programmées de cette façon. Néanmoins, si ce type de programme est
particulièrement élégant (et puissant), il manque souvent d'efficacité en terme de rapidité de calcul.
5.5 Répétition de motifs
Cette façon de programmer trouve une autre forme similaire dans la répétition de motifs. Si nous souhaitons par exemple
indiquer à une fonction qu'elle ne doit opérer que sur des listes de couples dont le deuxième élément est un même entier
nous pourrons écrire :
Clear@fD;
f@data : 88_, n_Integer< ..<D := Transpose@dataD@@1DD;
Dans cet exemple, data est le nom donné à l'argument de f et désigne donc tout ce qui suit dans la description de
l'argument. Cet argument est donc une liste (les accolades extérieures) qui contient un couple {n'importe quoi,
un entier appelé n} qu'on peut trouver en un ou plusieurs exemplaires (..). Nous aurions pu aussi utiliser (...)
qui veut dire : répété 0, une ou plusieurs fois. Cela donne à l'usage :
f@88a, 3<, 8b, 3<, 8c, 3<, 8d, 3<<D
8a, b, c, d<
Mais dans le cas suivant, la fonction n'est pas évaluée car l'écriture de l'argument impose implicitement que tous les
éléments placés en deuxième position dans les couples soient identiques (le symbole n placé à la fin de chaque couple ne
peut désigner qu'une seule et même valeur pour tous les couples puisqu'il y a répétition du motif) :
f@88a, 1<, 8b, 3<, 8c, 3<, 8d, 3<<D
f@88a, 1<, 8b, 3<, 8c, 3<, 8d, 3<<D
Pour généraliser à des listes de couples dont le deuxième élément est n'importe quel entier, on écrira!:
Clear@fD;
f@data : 88_, _Integer< ..<D := Transpose@dataD@@1DD;
Ce qui permettra de calculer :
f@88a, 1<, 8b, 2<, 8c, 3<, 8d, 4<<D
8a, b, c, d<
5.6 Fonctions internes exploitant les motifs
Un certain nombre de fonctions internes exploitent le mécanisme offert par les motifs. Nous citerons les fonctions
Cases, Position et Count.
La fonction Cases permet d'extraire d'une liste ou plus généralement d'une expression, tous les éléments ayant une
forme donnée (correspondant à un motif qui constitue le deuxième argument de la fonction Cases). Par exemple ici
nous demandons l'extraction des nombres inférieurs à 5 :
Cases@81, 3, 3 ê 2, 82, 3<, toto, 9, 10, 8a + b, a^b<<, x_ ê; x < 5D
:1, 3,3
2>
Puis l'extraction des entiers inférieurs à 5 :
5. Programmation par motifs 71
Cases@81, 3, 3 ê 2, 82, 3<, toto, 9, 10, 8a + b, a^b<<, x_Integer ê; x < 5D
81, 3<
Puis l'extraction de tous les entiers (inutile dans ce cas de nommer le motif puisqu'il n'y a pas de test explicite
nécessitant de faire référence à ce nom) :
Cases@81, 3, 3 ê 2, 82, 3<, toto, 9, 10, 8a + b, a^b<<, _IntegerD
81, 3, 9, 10<
Voici l'extraction de tous les couples quelconques :
Cases@81, 3, 3 ê 2, 82, 3<, toto, 9, 10, 8a + b, a^b<<, 8_, _<D
982, 3<, 9a + b, ab==
Et l'extraction des couples d'entiers :
Cases@81, 3, 3 ê 2, 82, 3<, toto, 9, 10, 8a + b, a^b<<, 8_Integer, _Integer<D
882, 3<<
Par ailleurs, grâce à un troisième argument optionnel, on pourra exécuter la recherche des formes à différents niveaux
dans l'arborescence de l'expression comme dans l'exemple suivant!:
Cases@81, 3, 3 ê 2, 82, 3<, toto, 9, 10, 8a + b, a^b<<, _PlusD
8<
Aucune somme au premier niveau, mais si l'on fait la recherche jusqu'au deuxième niveau :
Cases@81, 3, 3 ê 2, 82, 3<, toto, 9, 10, 8a + b, a^b<<, _Plus, 2D
8a + b<
On peut aussi limiter la recherche à un niveau particulier, par exemple au premier niveau seulement!:
Cases@81, 3, 82, 3<, 89, 10<, 884, 5<, 86, 7<<<, _IntegerD
81, 3<
Au deuxième niveau seulement :
Cases@81, 3, 82, 3<, 89, 10<, 884, 5<, 86, 7<<<, _Integer, 82<D
82, 3, 9, 10<
Au troisième niveau seulement :
Cases@81, 3, 82, 3<, 89, 10<, 884, 5<, 86, 7<<<, _Integer, 83<D
84, 5, 6, 7<
Jusqu'au niveau 2 :
Cases@81, 3, 82, 3<, 89, 10<, 884, 5<, 86, 7<<<, _Integer, 2D
81, 3, 2, 3, 9, 10<
A tous les niveaux :
Cases@81, 3, 82, 3<, 89, 10<, 884, 5<, 86, 7<<<, _Integer, InfinityD
81, 3, 2, 3, 9, 10, 4, 5, 6, 7<
Les fonctions Position et Count s'utilisent exactement de la même manière que Cases mais servent à déterminer
la position des éléments ayant une forme donnée (Position) ou à compter leur nombre (Count). Elles s'utilisent avec
des listes mais plus généralement avec n'importe quelle expression comme dans l'exemple suivant :
72 5. Programmation par motifs
Les fonctions Position et Count s'utilisent exactement de la même manière que Cases mais servent à déterminer
la position des éléments ayant une forme donnée (Position) ou à compter leur nombre (Count). Elles s'utilisent avec
des listes mais plus généralement avec n'importe quelle expression comme dans l'exemple suivant :
Position@2 x^3 + 5 y^2 + 10 z^4, x_Integer ê; x < 5, InfinityD
881, 1<, 81, 2, 2<, 82, 2, 2<, 83, 2, 2<<
La position {1,1} signifie le premier élément du premier élément de l'expression, etc.
expr = 2 x^3 + 5 y^2 + 10 z^4;
8expr@@1DD, expr@@1, 1DD<
92 x3, 2=
5.7 Exercices
5.7.1 L'opérateur logarithme
Reprogrammer un opérateur ln (pour logarithme népérien) permettant d'obtenir les résultats suivants :
ln@x^3D
3 ln@xD
ln@5 x^3D
ln@5D + 3 ln@xD
ln@5 * 8^3D
ln@5D + 3 ln@8D
5.7.2 Argument "liste de couples"
Ecrire une fonction dont l'argument ne peut être qu'une liste de couples 8x, y< et qui renvoie une liste comprenant la
liste des x2 et la liste des y2.
5.7.3 Nettoyer une liste
Ecrire une fonction arrange[liste] qui réarrange une liste entrée en lui retirant tous ses éléments multiples sans
changer l'ordre des éléments comme dans l'exemple suivant :
arrange@81, 2, 4, a, b, 3, a, 2, 5, b, a, 3, 1<D
81, 2, 4, a, b, 3, 5<
On notera que la fonction Union supprime les doublons mais change l'ordre des éléments.
5.7.4 Recherche de maxima dans une liste
Ecrire une fonction maxima[liste] qui ne conserve d'une liste de nombres que les éléments qui sont plus grands
que tous ceux qui les précédent dans la liste (on pourra fabriquer une liste d'entiers aléatoires avec la fonction
RandomInteger).
5. Programmation par motifs 73
5.7.5 Extraction des arguments dans une expression
Définir une fonction versliste qui transforme une expression quelconque de façon à extraire tous les arguments
qui s'y trouvent en conservant la structure arborescente de l'expression de départ (en d'autres termes, je supprime toutes
les têtes et ne conserve que les arguments atomiques, en préservant sous forme de listes, le niveau auquel chaque
argument atomique apparaît). Par exemple verliste[2x^2-1] doit donner {-1,{2,{x,2}}}.
Etendre ensuite la fonction de telle sorte qu'elle renvoie également le nom des opérations qui sont faites. Avec
l'exemple précédent il s'agit d'obtenir :
{Plus,{-1,{Times,{2,{Power,{x,2}}}}}}:
74 5. Programmation par motifs
Chapitre 6
Fonctions pures
76 6. Fonctions pures
6 Fonctions pures
Nous allons montrer dans ce chapitre comment l'on définit ce qu'on appelle des fonctions pures, à quoi elles servent et
comment on peut les utiliser. Nous montrerons également un certain nombre de fonctions internes permettant de les
exploiter pour écrire des programmes courts et efficaces.
6.1 Fonctions pures
En mathématiques, une fonction est une transformation d'un ensemble de départ vers un ensemble d'arrivée. Peu
importe le nom donné à cette fonction, l'important est la transformation qu'elle opère. Il est souvent très utile,
notamment quand une fonction n'est utilisée qu'une seule fois dans un long programme ou dans une longue session de
travail, de pouvoir effectuer des transformations sans avoir à définir une fonction particulière. Mathematica utilise le
concept de !-fonctions ou de fonctions pures pour traiter ce genre de problème. La branche des mathématiques qui
étudie les caractéristiques formelles des fonctions pures est appelée !-calcul. Elle a été développée par Church dans les
années 30.
La manière standard d'utiliser une fonction pure avec Mathematica est illustrée par l'exemple suivant dans le lequel on
définit une fonction (commande Function) qui transforme son argument appelé x en x2 logH1 + sinHxLL et qu'on
applique à l'entier 6!:
Function@x, x^2 Log@1 + Sin@xDDD@6D
36 Log@1 + Sin@6DD
On peut ensuite obtenir une valeur numérique de cette expression, en écrivant par exemple!:
% êê N
-11.7969
Une manière plus élégante et plus condensée d'écrire la même chose est la suivante :
HÒ^2 Log@1 + Sin@ÒDDL & @6D
36 Log@1 + Sin@6DD
Sous cette forme, le caractère &, toujours placé à la fin, désigne la commande Function (c'est une notation postfix) et
l'unique argument est désigné par le caractère #. Ces deux caractères sont réservés à cette utilisation.
Pour des fonctions à plusieurs arguments, il suffit de numéroter les # : #1, #2, etc... L'exemple suivant montre une
fonction pure à deux arguments qui effectue le produit du premier par le carré du deuxième :
HÒ1 Ò2^2L & @4, 5D
100
Mathematica étant un langage fonctionnel, il utilise abondamment la notion de fonctions pures. Comme tout langage
fonctionnel, Mathematica traite les fonctions comme des objets dits de première classe (first class objects). Cela veut dire
que l'on peut travailler avec les fonctions comme avec n'importe quel objet (entiers, réels, etc...). En particulier, on peut
utiliser les fonctions comme arguments d'autres fonctions, créer des fonctions pendant l'exécution d'un programme,
retourner une fonction comme résultat et inclure des fonctions comme éléments de structure de données tels que listes et
tableaux.
6. Fonctions pures 77
6.2 Outils pour la programmation fonctionnelle
6.2.1 Fonction Map
La fonction Map est une des plus utiles en Mathematica. Voyons sa définition officielle :
? Map
Map@ f , exprD or f êü expr applies f to each element on the first level in expr.
Map@ f , expr, levelspecD applies f to parts of expr specified by levelspec. !à
Il s'agit donc d'une fonction dont le premier argument doit être une fonction, par exemple une fonction pure, et qui a
pour objet d'appliquer la fonction donnée en premier argument à chaque élément situé au premier niveau (par défaut) de
l'expression donnée en deuxième argument. Voici un premier exemple dans lequel nous demandons d'appliquer la
fonction Sqrt à chaque élément d'une liste (Range[10] renvoie la liste des entiers de 1 à 10) :
Map@Sqrt, Range@10DD
:1, 2 , 3 , 2, 5 , 6 , 7 , 2 2 , 3, 10 >
Dans cette exemple, la fonction Map est équivalente à l'attribut Listable. Or, Sqrt ayant l'attribut Listable, il
n'est pas utile d'utiliser la fonction Map pour obtenir le même résultat :
Sqrt@Range@10DD
:1, 2 , 3 , 2, 5 , 6 , 7 , 2 2 , 3, 10 >
Mais de nombreuses fonctions n'ont pas l'attribut Listable, par exemple la fonction Solve. On peut ainsi
imaginer le calcul suivant qui donne les solutions de l'équation n x + 5 = 0 pour n allant de 1 à 10 :
Map@Solve@Ò x + 5 ã 0, xD &, Range@10DD
:88x Ø -5<<, ::x Ø -5
2>>, ::x Ø -
5
3>>, ::x Ø -
5
4>>, 88x Ø -1<<,
::x Ø -5
6>>, ::x Ø -
5
7>>, ::x Ø -
5
8>>, ::x Ø -
5
9>>, ::x Ø -
1
2>>>
Par ailleurs, on peut, avec la fonction Map, limiter l'action de la fonction donnée en argument, à un niveau particulier
dans l'arborescence de l'expression comme dans les exemples suivants.
Ici, au premier niveau (par défaut) :
Map@Ò^2 &, a + b^c + dD
a2 + b2 c + d2
Ici, jusqu'au deuxième niveau :
Map@Ò^2 &, a + b^c + d, 2D
a2 + Ib2M2 c2
+ d2
Ici, aux termes situés au 2e niveau seulement :
Map@Ò^2 &, a + b^c + d, 82<D
a + Ib2Mc2
+ d
Il existe de nombreuses variantes à la fonction Map que l'on pourra découvrir dans l'aide de Mathematica.
78 6. Fonctions pures
Il existe de nombreuses variantes à la fonction Map que l'on pourra découvrir dans l'aide de Mathematica.
? Map*
System`
Map MapAll MapAt
MapIndex-
ed MapPlot MapThread
6.2.2 Fonction Apply
La fonction Apply permet de faire un type particulier de substitution. Nous verrons dans le chapitre 8 la notion de
substitution sous toutes ses formes. Sa définition est la suivante :
? Apply
Apply@ f , exprD or f üü expr replaces the head of expr by f .
Apply@ f , expr, levelspecD
replaces heads in parts of expr specified by levelspec. !à
Plutôt que d'appliquer une fonction à chaque élément (argument) d'une expression, la fonction Apply permet la
substitution de la tête d'une expression par une autre. Par exemple, on peut aisément transformer une somme en un
produit :
Apply@Times, a + b + c + dD
a b c d
On utilisera souvent cette fonction pour supprimer les accolades extérieures d'une liste, c'est à dire pour remplacer la
tête d'une liste (le mot List) par autre chose.
Head@Range@10DD
List
C'est ainsi qu'on calcule la somme des 10 premiers entiers. On retiendra notamment ici que cette opération est très
rapide et ne nécessite pas l'écriture d'une boucle.
Apply@Plus, Range@10DD
55
Si donc on souhaite programmer une fonction qui calcule la moyenne des éléments d'une liste on écrira ainsi :
Clear@moyD;
moy@x_ListD := Apply@Plus, xD ê Length@xD;
moy@81, 2, 3<D
2
6.2.3 Fonction Nest (et NestList)
La fonction Nest (mot anglais qui veut dire nid) permet la composition d'une fonction sur une expression. Voyons sa
définition officielle :
6. Fonctions pures 79
? Nest
Nest@ f , expr, nD gives an expression with f applied n times to expr. !à
Sur un exemple formel, on comprend bien son fonctionnement :
Nest@k, x, 5D
k@k@k@k@k@xDDDDD
De même la fonction NestList donne, dans une liste, le résultat de chaque itération successive!:
NestList@k, x, 5D
8x, k@xD, k@k@xDD, k@k@k@xDDD, k@k@k@k@xDDDD, k@k@k@k@k@xDDDDD<
C'est ainsi qu'avec Nest on construira des fractions continues :
NestB1
1 + Ò&, x, 10F
1
1 +1
1+1
1+1
1+1
1+1
1+1
1+1
1+1
1+1
1+x
Nous avons là des fonctions très utiles pour programmer des algorithmes récursifs, par exemple l'algorithme de
Newton de recherche des racines d'une fonction. Soit par exemple le polynôme 2 x3 - 20 x - 3 dont nous souhaitons
rechercher les racines. Le dessin de cette expression permet de localiser ses racines approximativement.
Plot@2 x^3 - 20 x - 3, 8x, -5, 5<D
-4 -2 2 4
-100
-50
50
La méthode de Newton consiste, à partir d'un point quelconque de l'axe des absisses (par exemple 84, 0<), à dresser
une verticale qui rencontre alors la courbe en 84, f @4D<, puis à tirer la tangente à la courbe en ce point qui va rencontrer
l'axe des abscisses en un nouveau point que je vais appeler 8g@4D, 0< à partir duquel on prendra le point 8g@4D, f @g@4DD< et
ainsi de suite. L'opération converge (sauf cas particuliers) vers l'une des racines de la fonction. Il suffit ensuite de changer
le point de départ pour converger (éventuellement) vers une autre racine.
Si donc j'appelle f, la fonction dont on recherche les racines :
Clear@fD;
f@x_D := 2 x^3 - 20 x - 3
Si j'appelle g la fonction qui me donnent l'abcisse du point d'intersection d'une tangente avec l'axe des x en fonction de
la valeur précédente dans l'algorithme :
80 6. Fonctions pures
Clear@gD;
g@x_D := NBx -f@xD
f'@xDF
Je peux aisément trouver une première racine en validant l'instruction suivante :
Nest@g, 6, 5D
3.23477
On peut également voir toutes les valeurs successives fournies par l'algorithme :
NestList@g, 6, 5D
86, 4.42347, 3.5853, 3.27953, 3.23565, 3.23477<
Et visualiser les étapes graphiquement au moyen des instructions suivantes!:
pts = Map@88Ò, 0<, 8Ò, f@ÒD<< &, NestList@g, 6, 5DD;
pts = Flatten@pts, 1D
886, 0<, 86, 309<, 84.42347, 0<, 84.42347, 81.6394<, 83.5853, 0<,83.5853, 17.4678<, 83.27953, 0<, 83.27953, 1.95414<, 83.23565, 0<,83.23565, 0.0377216<, 83.23477, 0<, 83.23477, 0.0000150672<<
Plot@f@xD, 8x, 3, 6<, Epilog Ø Line@ptsDD
3.5 4.0 4.5 5.0 5.5 6.0
50
100
150
200
250
300
Les autres racines peuvent être obtenues par :
Nest@g, 0, 5D
-0.15034
Nest@g, -2, 5D
-3.10258
Et on peut vérifier ce résultat au moyen de la fonction Solve ou FindRoot cette dernière employant, entre autres
méthodes possibles, une version améliorée de l'algorithme de Newton-Raphson!:
Solve@2 x^3 - 20 x - 3 ã 0, xD êê N êê Chop
88x Ø 3.23477<, 8x Ø -0.15034<, 8x Ø -3.08443<<
FindRoot@2 x^3 - 20 x - 3 ã 0, 8x, 4<D
8x Ø 3.23477<
FindRoot@2 x^3 - 20 x - 3 ã 0, 8x, 0<D
8x Ø -0.15034<
6. Fonctions pures 81
FindRoot@2 x^3 - 20 x - 3 ã 0, 8x, -2<D
8x Ø -3.08443<
On notera ainsi qu'il faut un nombre d'itérations supérieur à 5 pour obtenir une meilleure précision sur la dernière
racine (la plus à gauche) :
Nest@g, -2, 10D
-3.08443
6.2.4 Fonction FixedPoint (et FixedPointList)
La fonction FixedPoint est une extension de la fonction Nest. Elle permet d'itérer sans être obliger de fixer à
l'avance le nombre d'itération.
? FixedPoint
FixedPoint@ f , exprD starts with expr, then
applies f repeatedly until the result no longer changes. !à
Pour fonctionner, l'opération itérée doit donc être convergente, comme dans le cas de l'algorithme de Newton. Ainsi,
on pourra obtenir plus directement les racines recherchées précédemment en tapant!:
FixedPoint@g, 84, 0, -2<D
83.23477, -0.15034, -3.08443<
De même qu'avec NestList vis à vis de Nest, FixedPointList permet d'accéder à toutes les étapes calculées :
FixedPointList@g, 4D
84, 3.40789, 3.24689, 3.23483, 3.23477, 3.23477, 3.23477<
Par défaut, les itérations s'arrêtent quand deux valeurs successives diffèrent de moins de 10-10. Mais l'on peut changer
ce seuil d'indifférence en utilisant l'option SameTest de FixedPoint!:
Options@FixedPointD
8SameTest Ø Automatic<
Le test doit être donné sous la forme d'une fonction pure à deux arguments (deux valeurs successives calculées) qui
renvoie True ou False. On pourra ainsi écrire :
FixedPointListAg, 4, SameTest Ø IAbs@Ò1 - Ò2D < 10-2 &ME
84, 3.40789, 3.24689, 3.23483, 3.23477<
Mais si l'on manie encore difficilement les fonctions pures on pourra écrire une fonction-test séparément :
Clear@ftD;
ft@x_, y_D ê; Abs@x - yD < 10-2 := True;
FixedPointList@g, 4, SameTest Ø ftD
84, 3.40789, 3.24689, 3.23483, 3.23477<
Sur un principe équivalent, on a vu apparaître avec la version 4 de Mathematica les fonctions NestWhile et
NestWhileList qu'on pourra consulter dans l'aide intégrée.
82 6. Fonctions pures
6.2.5 Fonction Fold (et FoldList)
La fonction Fold est une extension de la fonction Nest pour la composition de fonctions à deux arguments.
Néanmoins, comme la composition de telles fonctions n'a pas de sens, Fold propose de composer avec le premier
argument en modifiant, à chaque itération, la valeur du deuxième argument choisi de façon itérative dans une liste. Voici
l'explication officielle de cette fonction :
? Fold
Fold@ f , x, listD gives the last element of FoldList@ f , x, listD. !à
? FoldList
FoldList@ f , x, 8a, b,…<D gives 8x, f @x, aD, f @ f @x, aD, bD,…<. !à
On pourra par exemple écrire :
FoldB1
Ò1 + Ò2&, x, Range@10DF
1
10 +1
9+1
8+1
7+1
6+1
5+1
4+1
3+1
2+1
1+x
Ou, pour mieux comprendre :
FoldListB1
Ò1 + Ò2&, x, 81, 2, 3, 4, 5<F
:x,1
1 + x,
1
2 +1
1+x
,1
3 +1
2+1
1+x
,1
4 +1
3+1
2+1
1+x
,1
5 +1
4+1
3+1
2+1
1+x
>
C'est avec FoldList que l'on pourra, par exemple, effectuer des sommes progressives :
FoldList@Plus, 0, 8a, b, c, d, e, f<D80, a, a + b, a + b + c, a + b + c + d, a + b + c + d + e, a + b + c + d + e + f<
6.2.6 Combinaisons
La combinaison de plusieurs de ces fonctions permet d'écrire des programmes très courts et en même temps très
puissants. On pourra par exemple facilement calculer la somme des inverses des dix premiers entiers de la façon
suivante!:
ApplyBPlus, MapB1
Ò&, Range@10DFF
7381
2520
Qu'on pourrait d'ailleurs écrire plus simplement (car la division est une opération Listable)!:
6. Fonctions pures 83
Qu'on pourrait d'ailleurs écrire plus simplement (car la division est une opération Listable)!:
ApplyBPlus,1
Range@10DF
7381
2520
Ou calculer la somme des sommes successives des éléments d'une liste (voir fin du chapitre!6.2.5) :
Apply@Plus, FoldList@Plus, 0, 8a, b, c, d, e, f<DD
6 a + 5 b + 4 c + 3 d + 2 e + f
Et, par exemple, remplacer chaque terme de cette dernière expression par son logarithme :
Map@Log, Apply@Plus, FoldList@Plus, 0, 8a, b, c, d, e, f<DDD
Log@6 aD + Log@5 bD + Log@4 cD + Log@3 dD + Log@2 eD + Log@fD
6.3 Exercices
6.3.1 Programmation fonctionnelle
a) Construire la fraction suivante. On pourra définir des fonctions intermédiaires pour faciliter la résolution du
problème. En langage fonctionnel (que l'on peut mettre en oeuvre) une ligne suffit.
1 +1
2 +1
3+1
4+1
5+1
6+1
7+1
8+1
9+1
10+x
b) Quelle est la valeur (approchée) de cette fraction pour x = 0, 1, 2, ... , 10 ?
6.3.2 Programmation fonctionnelle
Une école d'ingénieur de 200 élèves par promo envisage d'augmenter son recrutement à raison de 5% par an. En une
seule commande, déterminer (de deux manières différentes) en combien d'années elle aura doublé son effectif ?
6.3.3 Programmation fonctionnelle
Soit une liste de 100 entiers choisis aléatoirement compris entre 1 et 10. Programmez une fonction fréquence qui
donne son résultat sous la forme de couples : {{n1, occurences de n1}, {n2, occurences de n2}, ...}.
6.3.4 Programmation fonctionnelle
a) Soit la fonction f définie par f HxL = a x H1 - xL pour x compris entre 0 et 1. Programmer une fonction g qui dessine
deux segments de droite (fonction Line) compris entre la courbe de f et la bissectrice de façon à obtenir la
représentation suivante grâce à Epilog pour a = 2.9 :
84 6. Fonctions pures
Plot@8x, f@xD<, 8x, 0, 1<, Epilog -> [email protected]
0.2 0.4 0.6 0.8 1.0
0.2
0.4
0.6
0.8
1.0
b) Développer le programme pour dessiner automatiquement plusieurs itérations successives comme ci-dessous pour
a = !2.9.
0.2 0.4 0.6 0.8 1.0
0.2
0.4
0.6
0.8
1.0
c) Rechercher la valeur de a qui conduit à une situation chaotique (pas de cycles apparents).
6. Fonctions pures 85
86 6. Fonctions pures
Chapitre 7
Modules
88 7. Modules
7 Modules
Dans un programme complexe, il est généralement nécessaire d'effectuer des calculs intermédiaires, mémorisés dans
des variables qu'on appellera locales de façon à simplifier l'écriture et la relecture du programme. Il est dans ce cas
généralement nécessaire de protéger les symboles servant à enregistrer ces calculs intermédiaires pour éviter les effets de
bords (propagation des valeurs en dehors du programme, interférence avec d'autres programmes, etc...). C'est l'objet du
présent chapitre que de montrer comment cela se fait dans Mathematica.
7.1 Nécessité d'un dispositif de protection des symboles
Soit le programme suivant :
Clear@fD;
f@x_D := Table@x^i, 8i, 1, 5<D;
Si j'appelle ma fonction avec les arguments suivants 81, 2, x, y, z<, je n'ai aucun problème :
Map@f, 81, 2, x, y, z<D
981, 1, 1, 1, 1<, 82, 4, 8, 16, 32<,
9x, x2, x3, x4, x5=, 9y, y2, y3, y4, y5=, 9z, z2, z3, z4, z5==
Si j'appelle f[i], je m'attends à obtenir : 9i, i2, i3, i4, i5= or j'obtiens :
f@iD
81, 4, 27, 256, 3125<
Apparaît en effet une confusion entre le i qui sert à l'itération dans la fonction Table et le i, argument de la
fonction. Il me faut donc considérer le i dans Table comme variable locale au programme, différencié d'un i qu'on
dira global, utilisé comme argument de f. On utilise pour cela la fonction Module ou la fonction Block.
7.2 Utilisation de Module
Revenons à l'exemple précédent. Il nous faut différencier un i global d'un i local. Pour cela on peut utiliser la syntaxe
suivante :
Clear@fD;
f@x_D := Module@8i<, Table@x^i, 8i, 1, 5<DD;
Cela résoud en effet notre problème :
f@xD
9x, x2, x3, x4, x5=
f@iD
9i, i2, i3, i4, i5=
Pour montrer comment cela marche, en plus de renvoyer la liste souhaitée, je demande au programme d'afficher la
valeur du i local. La commande Module me permet en effet d'exécuter plusieurs instructions successives, séparées par
des points virgules et placées en 2e position dans la liste des arguments de Module (le premier argument étant la liste des
variables locales). Par ailleurs, la fonction Print utilisée ici fait fi du point virgule placé derrière elle. Son utilité réside
d'ailleurs dans cette propriété qui permet, dans un programme, d'afficher des résultats intermédiaires qui serviront par
exemple à la vérification de son bon déroulement :
7. Modules 89
Pour montrer comment cela marche, en plus de renvoyer la liste souhaitée, je demande au programme d'afficher la
valeur du i local. La commande Module me permet en effet d'exécuter plusieurs instructions successives, séparées par
des points virgules et placées en 2e position dans la liste des arguments de Module (le premier argument étant la liste des
variables locales). Par ailleurs, la fonction Print utilisée ici fait fi du point virgule placé derrière elle. Son utilité réside
d'ailleurs dans cette propriété qui permet, dans un programme, d'afficher des résultats intermédiaires qui serviront par
exemple à la vérification de son bon déroulement :
Clear@fD;
f@x_D := Module@8i<, Print@iD; Table@x^i, 8i, 1, 5<DD;
Si maintenant j'appelle ma fonction plusieurs fois de suite :
f@iD
i$13417
9i, i2, i3, i4, i5=
f@iD
i$13418
9i, i2, i3, i4, i5=
f@iD
i$13419
9i, i2, i3, i4, i5=
Je constate que le i local change de nom. Il s'appele en réalité i$n°. C'est la fonction Module qui opère ce
changement pour différencier le i placé en argument de f du i local. Par ailleurs, à chaque exécution de la fonction, le
nom du i local change (le numéro change) et dès que le calcul est terminé, Mathematica se débarrasse de la variable
utilisée. Il s'agit d'une variable dite temporaire, qui n'existe que le temps de l'exécution du programme. Comme on le voit
ci-dessous, la variable i$ a l'attribut Temporary.
? i$
Global`i$
Attributes@i$D = 8Temporary<
Si donc nous cherchons à rappeler la dernière variable locale utilisée (ici i$733), nous obtenons le message suivant :
? i$733
Information::notfound : Symbol i$733 not found. à
Plus généralement, dès lors qu'un programme occupera plusieurs lignes, il sera souhaitable de le décomposer en
plusieurs calculs intermédiaires dont on mémorisera les résultats dans des variables locales. Cela permettra notamment
l'utilisation, en dehors du programme, des symboles utilisés pour cela.
Voici par exemple un programme offrant une forme de représentation des fonctions quand elles agissent sur des
nombres complexes. Le principe est le suivant : nous partons du dessin d'une grille régulière couvrant le plan complexe
allant pour x et pour y, de -1 à 1, de 0.1 en 0.1. Chaque noeud de la grille représente donc un nombre complexe de la
forme x + Â y. L'application d'une fonction f sur ce nombre conduit à un autre nombre complexe f @x + Â yD = x ' + Â y '
qu'on peut représenter sur le plan complexe. Ainsi chaque noeud de la grille régulière devient un noeud d'une nouvelle
grille que nous nous proposons de dessiner. Voici donc le programme proposé donc l'argument est une fonction
quelconque appelée f dont on cherche à représenter l'image :
90 7. Modules
Clear@imageD;
image@f_D := Module@8pts, x, y, lv, lh<,
pts = Table@8Re@f@x + I * yDD, Im@f@x + I * yDD<,
8x, -1, 1, 0.1<, 8y, -1, 1, 0.1<D;
lv = Map@Line, ptsD;
lh = Map@Line, Transpose@ptsDD;
Graphics@8lv, lh<, AspectRatio Ø AutomaticDD;
Voici par exemple l'image de la fonction Identité (nous retrouvons bien la grille régulière de départ)!:
image@Ò &D
L'image de la fonction Sinus :
image@SinD
7. Modules 91
L'image de la fonction Cube :
image@Ò^3 &D
Ou l'image de la fonction Exponentielle :
image@ExpD
L'intérêt d'avoir utilisé Module réside dans le fait que les symboles utilisés pour mémoriser des résultats intermédiaires
(x, y, lv, pts) perdent leur valeur en dehors du programme et ne risquent pas ainsi de contaminer d'autres
programmes extérieurs. En effet, si j'appelle x, y, lv ou pts, ces symboles n'ont, en dehors du programme, aucune
valeur affectée :
92 7. Modules
8x, y, lv, pts<
8x, y, lv, 886, 0<, 86, 309<, 84.42347, 0<, 84.42347, 81.6394<, 83.5853, 0<,83.5853, 17.4678<, 83.27953, 0<, 83.27953, 1.95414<, 83.23565, 0<,83.23565, 0.0377216<, 83.23477, 0<, 83.23477, 0.0000150672<<<
Je peux donc continuer à les utiliser dans d'autres programmes, sans risque d'interférence.
7.3 Utilisation de Block
Une autre fonction permet la protection des symboles de manière similaire à Module. Il s'agit de la fonction Block,
qui utilise la même syntaxe que Module comme le montre l'exemple suivant :
Clear@gD;
g@x_D := Block@8i<, Table@x^i, 8i, 1, 5<DD;
g@xD
9x, x2, x3, x4, x5=
g@yD
9y, y2, y3, y4, y5=
Néanmoins, Block ne permet pas la correction de l'erreur mentionnée précédemment, c'est à dire la confusion entre
symbole local et symbole global :
g@iD
81, 4, 27, 256, 3125<
La différence provient notamment du fait que le i local est en réalité le même symbole que le i global comme le
montre l'exemple suivant :
Clear@gD;
g@x_D := Block@8i<, Print@iD; Table@x^i, 8i, 1, 5<DD;
g@xD
i
9x, x2, x3, x4, x5=
Il n'y a pas changement de nom (en i$n°). Par contre, l'intérêt de Block est de pouvoir donner une valeur locale à i
différente de sa valeur globale comme le montre l'exemple suivant :
Clear@gD;
g@x_D := Block@8i<, i = 100; 2 x + iD
i = 1000;
g@xD
100 + 2 x
Nous avons vu que le i local est le même symbole (il a strictement le même nom) que le i global. Ici, nous avons
donné une valeur locale à ce i (100) différente de sa valeur globale (1000) sans d'ailleurs affecter cette valeur globale :
i
1000
On dira que, dans Block, on peut changer la valeur locale d'un symbole global sans modifier sa valeur globale
alors que dans Module, on créé un symbole local complètement différencié du symbole global portant
(apparemment) le même nom.
7. Modules 93
On dira que, dans Block, on peut changer la valeur locale d'un symbole global sans modifier sa valeur globale
alors que dans Module, on créé un symbole local complètement différencié du symbole global portant
(apparemment) le même nom.
L'intérêt de Block n'est pas évident a priori, on peut néanmoins en montrer un exemple très concrêt. Soit la fonction
factorielle reprogrammée par récursivité :
Clear@facD;
fac@n_IntegerD := n * fac@n - 1D;
fac@0D = 1;
Nous avons vu dans un chapitre précédent que le calcul avec cette fonction est limité par une variable (système) de
sécurité appelée $RecursionLimit!:
fac@10D
3 628 800
fac@300D
306 057 512 216 440 636 035 370 461 297 268 629 388 588 804 173 576 999 416 776 741 259 -
476 533 176 716 867 465 515 291 422 477 573 349 939 147 888 701 726 368 864 263 907 -
759 003 154 226 842 927 906 974 559 841 225 476 930 271 954 604 008 012 215 776 252 -
176 854 255 965 356 903 506 788 725 264 321 896 264 299 365 204 576 448 830 388 909 -
753 943 489 625 436 053 225 980 776 521 270 822 437 639 449 120 128 678 675 368 305 -
712 293 681 943 649 956 460 498 166 450 227 716 500 185 176 546 469 340 112 226 034 -
729 724 066 333 258 583 506 870 150 169 794 168 850 353 752 137 554 910 289 126 407 -
157 154 830 282 284 937 952 636 580 145 235 233 156 936 482 233 436 799 254 594 095 -
276 820 608 062 232 812 387 383 880 817 049 600 000 000 000 000 000 000 000 000 000 -
000 000 000 000 000 000 000 000 000 000 000 000 000 000 000
Nous avions alors choisi de modifier la valeur de la variable système $RecursionLimit pour permettre un tel
calcul. Cela pose néanmoins un problème car cette variable est utilisée pour limiter le nombre d'itérations récursives dans
d'autres constructions. Ainsi, si nous passons à 1000 la valeur de cette variable, tous les algorithmes récursifs vont
dorénavant boucler 1000 fois avant de nous avertir d'un éventuel problème de convergence. C'est du temps et de la
mémoire consommée pour rien. Grâce à Block, il va être possible de modifier localement la valeur de cette variable
sans modifier sa valeur globale, donc sans perturber d'autres programmes qui l'utilisent. Voici comment on écrira alors la
fonction factorielle :
Clear@fac2D;
fac2@n_D := Block@8$RecursionLimit<, $RecursionLimit = 1000; fac@nDD;
J'utilise donc toujours la fonction fac, mais je modifie temporairement la valeur de $RecursionLimit avant
d'utiliser cette fonction. Cela donne :
fac2@300D
306 057 512 216 440 636 035 370 461 297 268 629 388 588 804 173 576 999 416 776 741 259 -
476 533 176 716 867 465 515 291 422 477 573 349 939 147 888 701 726 368 864 263 907 -
759 003 154 226 842 927 906 974 559 841 225 476 930 271 954 604 008 012 215 776 252 -
176 854 255 965 356 903 506 788 725 264 321 896 264 299 365 204 576 448 830 388 909 -
753 943 489 625 436 053 225 980 776 521 270 822 437 639 449 120 128 678 675 368 305 -
712 293 681 943 649 956 460 498 166 450 227 716 500 185 176 546 469 340 112 226 034 -
729 724 066 333 258 583 506 870 150 169 794 168 850 353 752 137 554 910 289 126 407 -
157 154 830 282 284 937 952 636 580 145 235 233 156 936 482 233 436 799 254 594 095 -
276 820 608 062 232 812 387 383 880 817 049 600 000 000 000 000 000 000 000 000 000 -
000 000 000 000 000 000 000 000 000 000 000 000 000 000 000
94 7. Modules
fac2@500D
1 220 136 825 991 110 068 701 238 785 423 046 926 253 574 342 803 192 842 192 413 588 -
385 845 373 153 881 997 605 496 447 502 203 281 863 013 616 477 148 203 584 163 378 -
722 078 177 200 480 785 205 159 329 285 477 907 571 939 330 603 772 960 859 086 270 -
429 174 547 882 424 912 726 344 305 670 173 270 769 461 062 802 310 452 644 218 878 -
789 465 754 777 149 863 494 367 781 037 644 274 033 827 365 397 471 386 477 878 495 -
438 489 595 537 537 990 423 241 061 271 326 984 327 745 715 546 309 977 202 781 014 -
561 081 188 373 709 531 016 356 324 432 987 029 563 896 628 911 658 974 769 572 087 -
926 928 871 281 780 070 265 174 507 768 410 719 624 390 394 322 536 422 605 234 945 -
850 129 918 571 501 248 706 961 568 141 625 359 056 693 423 813 008 856 249 246 891 -
564 126 775 654 481 886 506 593 847 951 775 360 894 005 745 238 940 335 798 476 363 -
944 905 313 062 323 749 066 445 048 824 665 075 946 735 862 074 637 925 184 200 459 -
369 692 981 022 263 971 952 597 190 945 217 823 331 756 934 581 508 552 332 820 762 -
820 023 402 626 907 898 342 451 712 006 207 714 640 979 456 116 127 629 145 951 237 -
229 913 340 169 552 363 850 942 885 592 018 727 433 795 173 014 586 357 570 828 355 -
780 158 735 432 768 888 680 120 399 882 384 702 151 467 605 445 407 663 535 984 174 -
430 480 128 938 313 896 881 639 487 469 658 817 504 506 926 365 338 175 055 478 128 -
640 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 -
000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000 000
Bien que les calculs aient été possibles, la valeur globale de $RecursionLimit n'a pas été modifiée :
$RecursionLimit
500
On trouve dans cet exemple, toute l'utilité de Block comparée à Module. Mais on retiendra que généralement et
sauf exception, c'est avec Module que l'on construira des programmes compliqués nécessitant des calculs intermédiaires.
7.4 Différence entre Module et Block
Nous venons de voir la différence entre Module et Block. Nous avons notamment souligné le fait que dans
Module, on définit des symboles locaux ayant des valeurs locales alors que dans Block, on utilise des symboles globaux
ayant temporairement une valeur locale différente de leur valeur globale. On peut exprimer autrement cette différence à
partir de l'exemple suivant :
Clear@m, i, aD;
m = i^2;
Module@8i = a<, i + mD
a + i2
i n'a pas été affecté globalement :
i
i
Clear@m, i, aD;
m = i^2;
Block@8i = a<, i + mD
a + a2
7. Modules 95
i n'a pas été affecté globalement non plus :
i
i
Comme on peut le constater, nous avons un symbole i global (dans m=i^2) et i est déclaré en variable locale dans
Module et dans Block. On peut interpréter les résultats obtenus en disant que dans Module, seul les variables locales
qui apparaissent explicitement dans le programme (i+m) sont affectées d'une valeur locale (i=a). Dans Block, les
variables locales sont affectées, même celles qui apparaissent implicitement (le i dans m=i^2). Ainsi, avec Block, le
programme peut se lire : i+i^2, i valant a alors qu'avec Module, le programme se lit i+m, i valant a et m valant i^2
(i ne valant plus a à ce moment).
7.5 Dialogue avec l'utilisateur
Pour clore ce chapitre avec lequel nous avons appris à concevoir des programmes plus ambitieux, je voudrais signaler
l'existence de la fonction Input permettant d'afficher une boîte de dialogue qui invite l'utilisateur à répondre à une
question. En voici un exemple de fonctionnement :
sol = Input@"Entrer un nombre"D;
A l'exécution de cette instruction, Mathematica lance l'affichage d'une fenêtre invitant l'utilisateur à saisir un nombre.
Dès l'information saisie et validée, on peut récupérer l'information saisie en appelant ici le symbole sol :
sol^2
144
Il s'agit d'une possibilité d'interfaçage avec l'utilisateur qui est rudimentaire mais qui pourra parfois rendre service.
D'autres possibilités d'interfaçage plus satisfaisantes mais aussi plus complexes à mettre en oeuvre sont présentées au
chapitre 12.
7.6 Exercices
Il est suggéré ici d'écrire des programmes modulaires s'appuyant sur des calculs intermédiaires. On verra par la suite
que d'autres formes de programmation permettront d'utiliser des algorithmes beaucoup plus courts et efficaces pour la
résolution de ces exercices.
7.6.1 Cercle passant par trois points
a) Ecrire deux fonctions rayon et centre agissant sur une liste de 3 couples de coordonnées (3 points), qui
retournent respectivement le rayon et le centre du cercle passant par 3 points. Tester avec les trois points suivants :
880, 3<, 84, 4<, 84, 0<<.
b) Ecrire maintenant un programme qui, étant donné trois points, dessine ces trois points, le cercle passant par ces
trois points et le centre de ce cercle. On utilisera les fonctions Point et Circle dans une instruction globale du type :
Graphics[{Circle[...], Point[...]}, options].
7.6.2 Cercles de Mohr
96 7. Modules
7.6.2 Cercles de Mohr
a) Ecrire une fonction f[data:{{_,_}..}] qui transforme une liste de couples en la représentation graphique
que montre l'exemple suivant.
f@881, 2<, 83, 5<, 8-1, 3<<D
-1 1 2 3 4 5
0.5
1.0
1.5
2.0
b) Tester le programme avec la liste fournie par la commande suivante :
Table@8RandomReal@8-5, 5<D, RandomReal@8-5, 5<D<, 8100<D
7.6.3 Boîtes à moustaches
Ecrire un programme qui fabrique des "boîtes à moustaches" qui permettent de représenter la répartition d'une série
de valeurs en indiquant de façon symbolique la position de la médiane, des quartiles et des valeurs extrêmales, comme
dans l'exemple suivant dont on s'inspirera.
L'exemple suivant montre des données fabriquées à partir d'une loi du c2, l'histogramme de ces données et leur boîte
à moustaches.
Mathematica propose également la fonction BoxWhiskerPlot dans le package StatisticalPlots` qui fait la
même chose.
data = RandomReal@ChiSquareDistribution@6D, 8500<D;
Histogram@dataD
moustaches@dataD
5 10 15
7. Modules 97
98 7. Modules
Chapitre 8
Substitutions
100 8. Substitutions
8 Substitutions
La substitution consiste à remplacer, dans une expression, tout ou partie de cette expression par une autre, sans
affecter l'expression de départ. C'est un mécanisme très général et très utilisé dans Mathematica puisque même les
affectations sont en réalité des substitutions. Nous allons voir les différentes formes de substitution possibles ainsi que les
programmes ou algorithmes qu'on peut mettre en oeuvre avec elles.
8.1 Substitution instantanée
Le mode de substitution le plus simple consiste, dans une expression, à remplacer tout ou partie de cette expression
par une autre expression (qui sera évaluée au préalable conformément au mécanisme d'évaluation standard). La syntaxe
utilisée est la suivante :
expr = a x^2 + b x + c;
expr ê. a Ø 10
c + b x + 10 x2
Qui se lit : expr, expression dans laquelle a est remplacé par 10. En notation standard /. est un raccourci de la fonction
ReplaceAll tandis que Ø (qu'on écrit en 2 caractères ->) est une abbréviation de la fonction Rule. Si bien que la
même instruction peut s'écrire :
ReplaceAll@expr, Rule@a, 10DD
c + b x + 10 x2
Il s'agit bien de substitution, l'expression de départ n'ayant pas été affectée ni modifiée :
expr
c + b x + a x2
Nous avons déjà rencontré les règles de subtitution : dans les résultats des fonctions Solve et FindRoot par
exemple, mais aussi en utilisant les options des fonctions comme dans les exemples suivants :
Solve@2 x^2 + 3 x - 5 ã 0, xD
::x Ø -5
2>, 8x Ø 1<>
Plot@Sin@xD ê x, 8x, 0, 10<, Frame Ø TrueD
0 2 4 6 8 10-0.2
0.0
0.2
0.4
0.6
0.8
1.0
Dans le cas de Solve (ou de FindRoot), les solutions sont données sous forme de règles de substitution. x ne
pouvant être égal à deux choses en même temps, cette présentation apparaît logique. Elle va surtout pouvoir être
astucieusement exploitée dans des programmes. Dans le deuxième cas, la règle constitue un argument de la fonction
Plot et nous apprendrons un peu plus loin à programmer des options (qui fonctionnent toutes selon ce principe).
Dans le cas de Solve, on va ainsi pouvoir extraire directement toutes les solutions trouvées en écrivant par exemple :
8. Substitutions 101
Dans le cas de Solve, on va ainsi pouvoir extraire directement toutes les solutions trouvées en écrivant par exemple :
x ê. Solve@2 x^2 + 3 x - 5 ã 0, xD
:-5
2, 1>
Mieux encore, plutôt que de remplacer x par les solutions de l'équation, on pourra rechercher toutes les valeurs
possibles d'une expression dans laquelle x a été remplacé par les solutions de l'équation. Par exemple, le problème à
résoudre peut se formuler ainsi : calculer les valeurs numériques de la dérivée de sinHxL
xquand x est solution de l'équation
2 x2 + 3 x - 5. On écrira directement :
D@Sin@xD ê x, xD ê. Solve@2 x^2 + 3 x - 5 ã 0, xD êê N
80.416213, -0.301169<
Mais la substitution est un mécanisme très général dans Mathematica qui s'applique à toutes les expressions, qu'elles
soient numériques, formelles ou graphiques. On pourra par exemple remplacer la tête d'une expression par une autre :
Range@100D ê. List Ø Plus
5050
Dans cet exemple, nous avons effectué exactement la même opération qu'avec Apply dans un chapitre précédent!:
Apply@Plus, Range@100DD
5050
En effet Range[100] renvoie la liste des entiers de 1 à 100, cette liste (List[1,2,...,100]) est une expression
dans laquelle nous avons remplacé le symbole List par le symbole Plus (pour obtenir Plus[1,2,...,100]) et
ainsi calculer la somme des 100 premiers entiers. C'est par ailleurs une opération très rapide, beaucoup plus qu'avec une
boucle.
Dans un graphique nous pourrons modifier à loisir une représentation comme dans l'exemple suivant dans lequel nous
avons remplacé la ligne brisée (Line) qui constitue la courbe, par un polygone!:
des = Plot@Sin@xD, 8x, 0, 10<D
2 4 6 8 10
-1.0
-0.5
0.5
1.0
Show@des ê. Line Ø PolygonD
2 4 6 8 10
-1.0
-0.5
0.5
1.0
102 8. Substitutions
Le mécanisme de substitution est encore plus général quand on le combine avec la reconnaissance de forme. En effet,
le premier argument d'une règle pourra être un motif comportant un ou plusieurs _ comme le montre l'exemple suivant
dans lequel tous les entiers de la liste sont remplacés par leur inverse :
liste = 85, 3, 4 ê 3, 5 + 3 I, 8a, b<, 3.2, 8c, d<<;
liste ê. x_Integer Ø 1 ê x
:1
5,1
3,4
3, 5 + 3 Â, 8a, b<, 3.2, 8c, d<>
Sur le même principe, on peut remplacer tous les couples par autre chose :
liste ê. 8x_, y_< Ø y - x
:5, 3,4
3, 5 + 3 Â, -a + b, 3.2, -c + d>
Attention néanmoins, ce type de substitution se conduit en commençant par le niveau le plus haut dans l'arborescence
de l'expression (le niveau de la tête). Observons l'exemple suivant :
888a, b<, 8c, d<<, 881, 2<, 83, 4<<< ê. 8_, _< Ø 0
0
En effet l'expression de départ est déjà constituée d'un couple (dont le premier élément est {{a,b},{c,d}}). Si on
modifie légèrement le motif, le comportement sera différent :
888a, b<, 8c, d<<, 881, 2<, 83, 4<<< ê. 8_Integer, _< Ø 0
888a, b<, 8c, d<<, 80, 0<<
Ici, nous voyons bien que le couple {1,2} est de la forme indiquée donc il est remplacé par 0. Il en est de même pour
le couple {3,4}. On pourrait aussi pu envisager d'écrire :
888a, b<, 8c, d<<, 881, 2<, 83, 4<<< ê. 88_Integer, _<, _< Ø 0
888a, b<, 8c, d<<, 0<
Qui conduit à une substitution portant sur un niveau intermédiaire de l'expression.
Si l'on souhaite remplacer chaque couple présent dans l'expression de départ par 0 comme on aurait souhaité le faire
précédemment, on aurait pu employer la fonction Replace (qui n'a pas de raccourci) en précisant à quel niveau (dans
l'arborescence de l'expression) on souhaite agir (ici au niveau 2 uniquement) :
Replace@888a, b<, 8c, d<<, 881, 2<, 83, 4<<<, 8_, _< Ø 0, 82<D
880, 0<, 80, 0<<
Tous les couples quelconques situés au niveau 2 dans l'expression sont bien remplacés par 0.
De même on pourra aisément manipuler des expressions formelles comme dans l'exemple suivant!:
8. Substitutions 103
expr = ‡1
1 + x5„x
1
20-2 10 - 2 5 ArcTanB
1 + 5 - 4 x
10 - 2 5
F +
2 2 J5 + 5 N ArcTanB-1 + 5 + 4 x
2 J5 + 5 N
F + 4 Log@1 + xD +
J-1 + 5 N LogB1 +1
2J-1 + 5 N x + x2F - J1 + 5 N LogB1 -
1
2J1 + 5 N x + x2F
On explore la valeur de l'expression quand x est remplacé par 0 :
expr ê. x Ø 0 êê N
-0.102077
Ou on s'intéresse aux parties de l'expression ne comportant pas de termes en log :
expr ê. Log@_D Ø 0
1
20-2 10 - 2 5 ArcTanB
1 + 5 - 4 x
10 - 2 5
F + 2 2 J5 + 5 N ArcTanB-1 + 5 + 4 x
2 J5 + 5 N
F
8.2 Substitution différée
Nous avons rencontré les affectations instantanées et les affectations différées. Sur le même principe, on distingue les
substitutions instantanées des substitutions différées. Prenons l'exemple de la substitution suivante :
ClearAll@"Global`*"D
f@H1 + xL^2D + g@H1 + yL^3D + h@H1 + zL^4D ê. f@x_D Ø Expand@xD
H1 + xL2 + gAH1 + yL3E + hAH1 + zL4E
Notre substitution consiste à remplacer toute partie d'expression de la forme f[quelque chose] par le
développement (Expand) de quelque chose. Or si la substitution s'est bien faite, le développement de l'argument de
f n'a pas été réalisé.
Pour comprendre ce qui se passe, rappelons que nous avons à faire aux fonctions ReplaceAll (/.) et Rule (Ø). Or
ces deux fonctions n'ont pas l'attribut HoldAll :
Attributes@ReplaceAllD
8Protected<
104 8. Substitutions
Attributes@RuleD
8Protected, SequenceHold<
Cela veut dire que leurs arguments sont évalués avant qu'elles opèrent. Par exemple avant d'appliquer la règle, le
deuxième argument de cette règle (Expand[x]) va être évalué ce qui donne!:
Expand@xD
x
La substitution consiste donc, en fait, à remplacer f[x_] par x :
f@x_D Ø Expand@xD
f@x_D Ø x
Pour empêcher l'évaluation préalable de la règle, on utilisera la syntaxe ß (ou :>), raccourci de la fonction
RuleDelayed qui donne :
f@x_D :> Expand@xD
f@x_D ß Expand@xD
D'où la substitution :
f@H1 + xL^2D + g@H1 + yL^3D + h@H1 + zL^4D ê. f@x_D :> Expand@xD
1 + 2 x + x2 + gAH1 + yL3E + hAH1 + zL4E
Ou encore, en généralisant :
f@H1 + xL^2D + g@H1 + yL^3D + h@H1 + zL^4D ê. _@x_D :> Expand@xD
3 + 2 x + x2 + 3 y + 3 y2 + y3 + 4 z + 6 z2 + 4 z3 + z4
La fonction RuleDelayed possède en effet l'attribut HoldRest qui sert à empêcher l'évaluation de tous les
arguments sauf le premier.
Attributes@RuleDelayedD
8HoldRest, Protected, SequenceHold<
Comme pour les affectations, il sera souvent préférable d'utiliser une substitution différée plutôt qu'une substitution
instantanée. L'exemple suivant montre en effet que c'est souvent nécessaire. Supposons en effet que nous disposions d'une
liste de couples de valeurs numériques (par exemple des données issues d'une expérimentation). Nous proposons de
remplacer chaque couple de valeur par un disque de couleur aléatoire, de rayon 0.1, centré sur la valeur de chaque
couple. Cela donne, avec une substitution instantanée :
8. Substitutions 105
data = Table@8Random@D, Random@D<, 8100<D;
Show@Graphics@data ê. 8x_, y_< Ø 8Hue@Random@DD, Disk@8x, y<, 0.1D<DD
Nous observons que la substitution a été effectuée mais avec une seule couleur. En effet, la règle ayant été évaluée au
préalable, Hue[Random[]] a été évalué avant la substitution qui n'est donc menée qu'avec une seule couleur, la même
pour tous les disques. Pour remédier à ce problème il faudra utiliser une substitution différée, de sorte que l'évaluation de
Random[], qui fixera la couleur, ne soit faite qu'après substitution, autant de fois qu'il y a de couples au départ :
Show@Graphics@data ê. 8x_, y_< :> 8Hue@Random@DD, Disk@8x, y<, 0.1D<DD
On peut s'en convaincre en comparant numériquement les résultats de deux substitutions suivantes, la première
instantanée, la seconde différée :
data = Table@8Random@D, Random@D<, 810<D;
data ê. 8x_, y_< -> 8x, y, Hue@Random@DD<
880.352474, 0.757591, [email protected]<,
80.761015, 0.838255, [email protected]<, 80.0777199, 0.462315, [email protected]<,
80.416158, 0.0603288, [email protected]<,
80.733226, 0.545144, [email protected]<, 80.29295, 0.13301, [email protected]<,
80.233273, 0.0751288, [email protected]<, 80.294341, 0.969092, [email protected]<,
80.369719, 0.46394, [email protected]<, 80.462007, 0.271409, [email protected]<<
106 8. Substitutions
data ê. 8x_, y_< ß 8x, y, Hue@Random@DD<
880.352474, 0.757591, [email protected]<,
80.761015, 0.838255, [email protected]<, 80.0777199, 0.462315, [email protected]<,
80.416158, 0.0603288, [email protected]<,
80.733226, 0.545144, [email protected]<, 80.29295, 0.13301, [email protected]<,
80.233273, 0.0751288, [email protected]<, 80.294341, 0.969092, [email protected]<,
80.369719, 0.46394, [email protected]<, 80.462007, 0.271409, [email protected]<<
Enfin, nous disions au début de ce chapitre que même les affectations étaient des substitutions, voici quelques
instructions qui le montrent :
Remove@fD;
f@x_D := x^2
DownValues@fD
9HoldPattern@f@x_DD ß x2=
Les DownValues sont les définitions d'un symbole qui, lors d'un appel au symbole sont testées en dernier (définitions
aval). Cela permet par exemple d'ajouter à un opérateur (comme Plus) ou à une fonction existante des définitions
supplémentaires qui seront testées en dernier. Il existe aussi les UpValues qui sont testées en premier (cf. chapitre 10,
définitions amont).
8.3 Substitutions multiples
Plusieurs substitutions peuvent être réalisées successivement ou simultanément. De même une règle de substitution
peut être appelée récursivement sur une expression.
Bien évidemment, on peut enchaîner les substitutions qui s'appliquent dans l'ordre dans lequel on les a écrites (de
gauche à droite) :
x + y + z ê. x Ø y ê. y Ø 5
10 + z
Mais on peut aussi réunir dans une liste toutes les substitutions que l'on souhaite mener sur une expression, cela donne
par exemple :
x + y + z ê. 8x Ø y, y Ø 5<
5 + y + z
On retiendra ici que les règles de substitution s'appliquent une seule fois sur l'expression de départ et qu'en
aucun cas, dans notre exemple, la deuxième règle (yØ5) ne s'applique après la première (xØy).
Si l'on place chaque règle de substitution dans une sous-liste, on obtient la liste des résultats obtenus par l'application
de chacune des règles sur l'expression de départ :
x + y + z ê. 88x Ø y<, 8y Ø 5<<
82 y + z, 5 + x + z<
C'est d'ailleurs sous cette forme que Solve, par exemple, renvoie ses solutions, qu'on peut ainsi exploiter
simultanément :
sol = Solve@2 x^2 - 5 x + 1 ã 0, xD
::x Ø1
4J5 - 17 N>, :x Ø
1
4J5 + 17 N>>
8. Substitutions 107
x + y + z ê. sol
:1
4J5 - 17 N + y + z,
1
4J5 + 17 N + y + z>
Ce schéma rend ainsi évitable l'utilisation de Map :
Map@x + y + z ê. Ò &, 8x Ø y, y Ø 5<D
82 y + z, 5 + x + z<
Enfin, on peut appliquer plusieurs fois de suite la ou les mêmes règles, de manière récursive en utilisant la commande
ReplaceRepeated, abbrégée en //. :
ClearAll@"Global`*"D
x + y + z êê. 8x Ø y, y Ø 5<
10 + z
L'arrêt de la récursivité se produisant quand deux itérations successives renvoient le même résultat. On peut d'ailleurs
visualiser les substitutions successives de la manière suivante :
On@D
On::trace : On@D --> Null. à
x + y + z êê. 8x Ø y, y Ø 5<
Plus::trace : y+5+ z --> 5+ y+ z. à
Plus::trace : 5+5+ z --> 10+ z. à
ReplaceRepeated::trace : x+ y+ z êê. 8x Ø y, y Ø 5< --> 10+ z. à
10 + z
Off@D
La première trace montre que dans l'expression de départ x a été remplacé par y et y par 5 puis que l'expression a été
réordonnée (à cause de la commutativité de Plus). Puis la deuxième trace montre montre que le y restant a, dans un
deuxième temps, lui aussi été remplacé par 5.
8.4 Programmation par règles et motifs
En combinant substitutions récursives et motifs, il sera possible d'écrire des programmes très élégants. Reprenons le tri,
programmé au chapitre 5. Nous avions écrit :
Clear@triD;
tri@8x___, y_, z_, w___< ê; z < yD := tri@8x, z, y, w<D;
tri@x_D := x;
tri@83, 2, 9, 6, 7, 7, 8, 1<D
81, 2, 3, 6, 7, 7, 8, 9<
Le programme consistait à repérer dans la liste donnée deux éléments consécutifs, le deuxième étant plus petit que le
premier ; à les intervertir puis à rappeler la fonction de façon à rechercher à nouveau deux éléments consécutifs
respectant la condition. Quand la liste était triée, la première règle (ou définition) ne s'appliquant plus, la deuxième
permettait de renvoyer la liste (triée à ce moment).
108 8. Substitutions
Il est possible d'écrire exactement le même programme sans définir de fonction mais en utilisant directement une
substitution récursive de la manière suivante :
liste = 83, 2, 9, 6, 7, 7, 8, 1<;
liste êê. 8x___, y_, z_, w___< ê; z < y :> 8x, z, y, w<
81, 2, 3, 6, 7, 7, 8, 9<
On constatera sur cet exemple que le motif utilisé dans la règle (à gauche de la règle) est exactement le même que celui
utilisé dans la définition de tri, le //. (ReplaceRepeated) assurant l'appel récursif à la règle tout comme tri
faisait appel à tri. Pour mieux comprendre le fonctionnement de ce programme, on pourra visualiser les étapes
intermédiaires en écrivant par exemple :
liste = 83, 2, 9, 6, 7, 7, 8, 1<;
liste êê. 8x___, y_, z_, w___< ê; z < y :> HPrint@8x, z, y, w<D; 8x, z, y, w<L
82, 3, 9, 6, 7, 7, 8, 1<
82, 3, 6, 9, 7, 7, 8, 1<
82, 3, 6, 7, 9, 7, 8, 1<
82, 3, 6, 7, 7, 9, 8, 1<
82, 3, 6, 7, 7, 8, 9, 1<
82, 3, 6, 7, 7, 8, 1, 9<
82, 3, 6, 7, 7, 1, 8, 9<
82, 3, 6, 7, 1, 7, 8, 9<
82, 3, 6, 1, 7, 7, 8, 9<
82, 3, 1, 6, 7, 7, 8, 9<
82, 1, 3, 6, 7, 7, 8, 9<
81, 2, 3, 6, 7, 7, 8, 9<
81, 2, 3, 6, 7, 7, 8, 9<
8.5 Les options des fonctions
Voyons maintenant, et pour clore ce chapitre, comme programmer des options dans des fonctions nouvelles. Nous
avons constaté que les options des fonctions internes se présentent sous la forme de règles de substitution comme dans la
fonction Plot :
Plot@Sin@xD ê x, 8x, 0, 10<, Frame Ø True, AspectRatio Ø 1D
0 2 4 6 8 10
-0.2
0.0
0.2
0.4
0.6
0.8
1.0
8. Substitutions 109
Les options des fonctions sont des arguments de ces fonctions qui ont l'avantage de pouvoir être utilisés dans n'importe
quel ordre. Dans l'exemple précédent, je peux en effet utiliser les mêmes options mais dans un ordre différent :
Plot@Sin@xD ê x, 8x, 0, 10<, AspectRatio Ø 1, Frame Ø TrueD
0 2 4 6 8 10
-0.2
0.0
0.2
0.4
0.6
0.8
1.0
On dira que Plot (comme beaucoup d'autres fonctions internes) est une fonction munie de deux arguments
positionnels : le premier étant l'expression à représenter et le second étant l'intervalle de variation de la variable, ainsi que
d'arguments nominaux (qui portent un nom) qu'on peut dès lors (parce qu'on leur a donné un nom) utiliser dans
n'importe quelle position. Plot possède 30 arguments de ce genre :
Options@PlotD
:AlignmentPoint Ø Center, AspectRatio Ø1
GoldenRatio,
Axes Ø True, AxesLabel Ø None, AxesOrigin Ø Automatic,
AxesStyle Ø 8<, Background Ø None, BaselinePosition Ø Automatic,
BaseStyle Ø 8<, ClippingStyle Ø None, ColorFunction Ø Automatic,
ColorFunctionScaling Ø True, ColorOutput Ø Automatic,
ContentSelectable Ø Automatic, CoordinatesToolOptions Ø Automatic,
DisplayFunction ß $DisplayFunction, Epilog Ø 8<, Evaluated Ø Automatic,
EvaluationMonitor Ø None, Exclusions Ø Automatic,
ExclusionsStyle Ø None, Filling Ø None, FillingStyle Ø Automatic,
FormatType ß TraditionalForm, Frame Ø False, FrameLabel Ø None,
FrameStyle Ø 8<, FrameTicks Ø Automatic, FrameTicksStyle Ø 8<,
GridLines Ø None, GridLinesStyle Ø 8<, ImageMargins Ø 0.,
ImagePadding Ø All, ImageSize Ø Automatic, ImageSizeRaw Ø Automatic,
LabelStyle Ø 8<, MaxRecursion Ø Automatic, Mesh Ø None,
MeshFunctions Ø 8Ò1 &<, MeshShading Ø None, MeshStyle Ø Automatic,
Method Ø Automatic, PerformanceGoal ß $PerformanceGoal,
PlotLabel Ø None, PlotPoints Ø Automatic,
PlotRange Ø 8Full, Automatic<, PlotRangeClipping Ø True,
PlotRangePadding Ø Automatic, PlotRegion Ø Automatic,
PlotStyle Ø Automatic, PreserveImageOptions Ø Automatic, Prolog Ø 8<,
RegionFunction Ø HTrue &L, RotateLabel Ø True, Ticks Ø Automatic,
TicksStyle Ø 8<, WorkingPrecision Ø MachinePrecision>
Length@%D
57
Pour programmer une telle fonction, on définit tout d'abord les options de la fonction avec leur valeur par défaut, puis
on respecte la syntaxe donnée dans l'exemple suivant :
110 8. Substitutions
Clear@fD;
Options@fD = 8facteur Ø 1, exposant Ø 1<;
f@x_, opts___D := Module@8fac, exp<,
fac = facteur ê. 8opts< ê. Options@fD;
exp = exposant ê. 8opts< ê. Options@fD;
fac * x^expD
Cette fonction a un argument positionnel que j'appelle x et zéro, un ou plusieurs autres arguments que j'appelle
collectivement opts (j'aurai pu choisir tout autre nom). Dans le module, les deux premières instructions vont servir à lire
les valeurs choisies par l'utilisateur pour les deux options ici programmées qui s'appellent facteur et exposant.
Voyons tout d'abord quelques exemples d'utilisation. Si je n'indique aucune option, ma fonction utilise les valeurs par
défaut attribuées aux options (fac = 1 et exp = 1).
f@uD
u
En effet, dans ce cas {opts}={}, les deux règles de substitution s'écrivent ainsi :
fac = facteur ê. 8< ê. 8facteur Ø 1, exposant Ø 1<
1
exp = exposant ê. 8< ê. 8facteur Ø 1, exposant Ø 1<
1
Je peux maintenant utiliser l'une des options :
f@u, exposant Ø 20D
u20
Dans ce cas en effet, puisque que {opts}={exposantØ20}, fac et exp valent :
fac = facteur ê. 8exposant Ø 20< ê. 8facteur Ø 1, exposant Ø 1<
1
exp = exposant ê. 8exposant Ø 20< ê. 8facteur Ø 1, exposant Ø 1<
20
Enfin avec deux options :
f@u, exposant Ø 20, facteur Ø 100D
100 u20
Nous avons {opts}={exposantØ20,facteurØ100}, ce qui donne :
fac = facteur ê. 8exposant Ø 20, facteur Ø 100< ê. 8facteur Ø 1, exposant Ø 1<
100
exp = exposant ê. 8exposant Ø 20, facteur Ø 100< ê. 8facteur Ø 1, exposant Ø 1<
20
Pour en être convaincu, on notera que quand la première règle s'applique, la deuxième ne s'applique plus puisque le
symbole (par exemple facteur) a été remplacé par une valeur numérique (par exemple 100). Il n'y a donc plus de
substitution possible du symbole facteur.
8.6 Exercices
8. Substitutions 111
8.6 Exercices
8.6.1 Solution d'une équation de degré 3
a) Résoudre l'équation : -x3 + 2 x2 + a x + b = 0 et réunir les 3 solutions dans une liste.
b) Résoudre maintenant l'équation : -x3 + 2 x2 + x - 2 = 0 et réunir les 3 solutions dans une liste.
c) Dans la question a), les solutions comportent des nombres complexes. Dans la question b), les solutions sont réelles.
A partir de la solution générale obtenue en a), utiliser une règle de substitution pour remplacer a par 1 et b par -2. Puis
comparer les valeurs obtenues avec les solutions de la question b). Conclusion.
8.6.2 Cercles de Mohr (bis)
a) Ecrire une fonction f[data:{{_,_}..}] qui transforme une liste de couples en la représentation graphique
que montre l'exemple suivant au moyen d' une règle de substitution.
f@881, 2<, 83, 5<, 8-1, 3<<D
-1 1 2 3 4 5
0.5
1.0
1.5
2.0
b) Tester la règle avec la liste fournie par la commande suivante :
RandomReal@8-5, 5<, 820, 2<D
8.6.3 Transformation graphique
Utiliser une règle de substitution pour visualiser, sous forme de lignes verticales joignant la courbe à l'axe des abscisses,
les points utilisés dans le dessin de la fonction sinHxL
x pour x allant de 0 à 10.
8.6.4 Transformation graphique
Trouver une règle de substitution qui permet de transformer la représentation graphique ci-dessous à gauche en la
représentation graphique ci-dessous à droite. Proposer ensuite d'autres transformations conduisant à des représentations
originales...
La grille de départ pourra être obtenue par l'instruction suivante :
des = Graphics@8Table@Line@88-1, i<, 81, i<<D, 8i, -1, 1, 0.1<D,
Table@Line@88i, -1<, 8i, 1<<D, 8i, -1, 1, 0.1<D<, AspectRatio -> 1D;
112 8. Substitutions
8.6.5 Transformation d'expression
Que devient d'expression formelle de Ÿ1
1-x5„ x quand on supprime les termes en ?
8.6.6 Transformation simple
Soit une liste de 100 couples 8x, y< de valeurs aléatoires comprises en 0 et 1. Transformer cette liste de couples en liste
de triplets 8x, y, z<, z étant le reste de la division de x par y. Représenter ensuite les couples 8x, y<, puis les couples 8x, z<,puis les couples 8 y, z<.
8. Substitutions 113
114 8. Substitutions
Chapitre 9
Graphiques
116 9. Graphiques
9 Graphiques
Le langage graphique de Mathematica est constitué de commandes préprogrammées pour les utilisations les plus
courantes, en particulier pour représenter des fonctions ou visualiser des données, ainsi que de primitives et directives
graphiques élémentaires à partir desquelles on pourra programmer toutes les représentations graphiques souhaitées. Les
versions successives de Mathematica ont apporté de nombreuses et régulières innovations dans la production des
représentations graphiques que l'on pourra étudier en consultant l'aide interactive de Mathematica. De même, les réglages
les plus subtils à travers les options de ces commandes sont largement documentés dans l'aide et le traitement d'images est
devenu très sophistiqué. Aussi, dans ce chapitre, nous ne présenterons que les fonctions les plus courantes et quelques
exemples montrant comment l'on peut exploiter la richesse du langage de Mathematica pour produire les représentations
graphiques espérées.
9.1 Commandes graphiques préprogrammées
9.1.1 Représenter des fonctions
Pour représenter une fonction mathématique, Mathematica propose un certain nombre de commandes
préprogrammées qui couvrent les besoins les plus courants. L'encadré suivant en donne une liste presque exhaustive :
Plot représentation d' une fonction à une variable
LogPlot représentation logarithmique en y
LogLinearPlot représentation logarithmique en x
LogLogPlot représentation logarithmique en x et en y
DiscretePlot représentation d' une fonction discrète
Plot3D représentation d' une fonction à 2 variables
ParametricPlot représentation paramétrique d ' une courbe plane
ParametricPlot3D représentation paramétrique d ' une surface tridimensionnelle
ContourPlot représentation 2 D en courbes de niveaux d' une fonction à deux variables
ContourPlot3D représentation 3 D en surfaces de niveaux d' une fonction à 3 variables
DensityPlot représentation en densité d ' une fonction à 2 variables
PolarPlot représentation polaire où la fonction donne le rayon en fonction de l ' angle
RevolutionPlot3D représentation en symétrie de révolution d' une fonction à une variable
SphericalPlot3D représentation surfacique d ' une fonction deux variables donnant le rayon
RegionPlot représentant du domaine de validité d ' une condition bidimensionnelle
RegionPlot3D représentant du domaine de validité d ' une condition tridimensionnelle
StreamPlot représentation bidimensionnelle des lignes de flux d ' un champ vectoriel
StreamDensityPlot représentation bidimensionnelle de lignes de flux
d ' un champ vectoriel à laquelle est superposée à une
représentation en densité de la magnitude ou tout autre grandeur
VectorPlot représentation des vecteurs d ' un champ vectoriel en 2 dimensions
VectorPlot3D représentation des vecteurs d ' un champ vectoriel en 3 dimensions
Principales commandes graphiques préprogrammées
9. Graphiques 117
La syntaxe est similaire pour l'ensemble des commandes graphiques. La fonction Plot par exemple, dont la syntaxe
ressemble à celle de la fonction Table, permet de représenter une ou plusieurs fonctions simultanément comme ci-
dessous :
PlotBSin@xD
x, 8x, -10, 10<F
-10 -5 5 10-0.2
0.2
0.4
0.6
0.8
1.0
PlotB:Sin@xD,1
x,Sin@xD
x>, 8x, -10, 10<F
-10 -5 5 10
-1
1
2
Pour des fonctions à deux variables on utilisera la fonction Plot3D :
Plot3D@Sin@xD Sin@yD, 8x, -p, p<, 8y, -p, p<D
La fonction ParametricPlot, comme son nom l'indique, sert à représenter des fonctions paramétriques comme
dans l'exemple ci-dessous :
118 9. Graphiques
ParametricPlotB:Sin@2 tD, CosB5 t
2F>, 8t, -p, p<F
-1.0 -0.5 0.5 1.0
-1.0
-0.5
0.5
1.0
Et pour deux variables paramétriques, on utilise la fonction ParametricPlot3D :
ParametricPlot3DA9Sin@tD, Cos@uD, Cos@uD2 + Sin@tD2=, 8t, -p, p<, 8u, -p, p<E
Les fonctions ContourPlot et DensityPlot offrent deux autres types de représentation des fonctions à 2 variables dans
lesquelles les zones sombres correspondent aux faibles valeurs de la fonction et les zones claires aux plus fortes valeurs :
des1 = ContourPlot@Sin@xD Sin@yD, 8x, -p, p<, 8y, -p, p<D;
des2 = DensityPlot@Sin@xD Sin@yD, 8x, -p, p<, 8y, -p, p<D;
GraphicsGrid@88des1, des2<<D
Les instructions suivantes illustrent d'autres commandes graphiques pouvant être utiles.
9. Graphiques 119
des1 = StreamPlot@8-1 - x + y, 1 + x - y^2<, 8x, -3, 3<, 8y, -3, 3<D;des2 = VectorPlot@8-1 - x + y, 1 + x - y^2<, 8x, -3, 3<, 8y, -3, 3<D;des3 = RegionPlot@MatchQ@Sqrt@x - y^3D, _RealD, 8x, -2, 2<, 8y, -2, 2<D;GraphicsGrid@88des1, des2, des3<<D
9.1.2 Visualiser des données
Pour visualiser des données, c'est à dire des listes de points, dans le plan ou dans l'espace, Mathematica propose des
commandes préprogrammées dont les plus classiques sont celles de l'encadré suivant :
ListPlot visualisation de points définis par leurs coordonnées dans un plan
ListPlot3D visualisation d'une surface décrite par un
tableau à 2 dimensions décrivant la hauteur en fonction des
deux autres coordonnées données par les indices du tableau
ListContourPlot visualisation d'une surface décrite par un tableau à 2 dimensions
donnant la hauteur en fonction des deux autres coordonnées fournies
par les indices du tableau, sous la forme de courbes de niveaux
ListDensityPlot visualisation d'une surface décrite par un tableau à 2 dimensions
donnant la hauteur en fonction des deux autres coordonnées fournies
par les indices du tableau, sous la forme d'une image en densité
Commandes préprogrammées permettant la visualisation de données
Pour dessiner des couples de valeurs placés dans une liste on utilisera :
ListPlotBTableB:x,Sin@xD
x>, 8x, 0.1, 10, 0.1<FF
2 4 6 8 10-0.2
0.2
0.4
0.6
0.8
1.0
120 9. Graphiques
Si la première coordonnée est omise, Mathematica utilise par défaut la liste des premiers entiers :
ListPlotBTableBSin@xD
x, 8x, 0.1, 10, 0.1<FF
20 40 60 80 100-0.2
0.2
0.4
0.6
0.8
1.0
La commande suivante permet de tracer des points dont les deux premières coordonnées sont données par les indices
d'un tableau dont les valeurs correspondent à la troisième (la hauteur) :
pts = Table@Sin@xD Sin@yD, 8x, -3, 3, 0.2<, 8y, -3, 3, 0.2<D;
ListPlot3D@ptsD
Ces données peuvent également être représentées en courbes de niveaux et en densité :
GraphicsGrid@88ListContourPlot@ptsD, ListDensityPlot@ptsD<<D
9. Graphiques 121
D'autres commandes graphiques servent à représenter des ensembles de données comme celles indiquées dans
l'encadré suivant. On se reportera à l'aide interactive pour les voir en action.
ListLinePlot représentation de points joints par une ligne
ListLogPlot ... représentation de points dans une ou plusieurs échelles logarithmiques
ListPolarPlot représentation de points définis par des couples 8angle, rayon<
ListPlot3D représentation d' une surface définie par un tableau de hauteurs
ListPointPlot3D représentation de points définis par leurs 3 coordonnées
ListContourPlot3D représentation des surfaces de niveaux à partir
d ' un volume décrit par une matrice 3 D de “hauteurs”
ListCurvePathPlot représentation d' une ligne passant au mieux par les points donnés
ListSurfacePlot3D représentation d' une surface 3 D s ' ajustant aux points 3 D fournis
ArrayPlot représentation colorée d ' un tableau de valeurs
ReliefPlot représentation colorée
Hà l ' image d' une image en relief L d' un tableau de valeurs
MatrixPlot représentation colorée d ' un tableau de valeurs
DateListPlot ... représentation de données attachées à une date
Histogram histogramme de données
Histogram3D histogramme 3 D de données
ListStreamPlot ... représentation bidimensionnelle des lignes de flux
d ' un champ vectoriel à partir d ' un tableau de vecteurs
ListVectorPlot ... représentation bidimensionnelle des vecteurs d '
un champ vectoriel à partir d ' un tableau de vecteurs
GraphPlot représentation d' un graphe par ses sommets et arêtes
LayeredGraphPlot représentation d' un graphe hiérarchique par ses sommets et arêtes
TreePlot représentation d' une arbre
BarChart & BarChart3D représentation en bâtons
PieChart représentation en secteurs
BubbleChart représentation en bulles
Autres commandes permettant la visualisation de données
9.1.3 Options courantes
De nombreuses options permettent de modifier l'apparence des représentations graphiques. Pour chaque fonction
préprogrammée, ces options sont accessibles en demandant les options de la fonction comme dans l'exemple suivant :
122 9. Graphiques
Options@PlotD
:AlignmentPoint Ø Center, AspectRatio Ø1
GoldenRatio,
Axes Ø True, AxesLabel Ø None, AxesOrigin Ø Automatic,
AxesStyle Ø 8<, Background Ø None, BaselinePosition Ø Automatic,
BaseStyle Ø 8<, ClippingStyle Ø None, ColorFunction Ø Automatic,
ColorFunctionScaling Ø True, ColorOutput Ø Automatic,
ContentSelectable Ø Automatic, CoordinatesToolOptions Ø Automatic,
DisplayFunction ß $DisplayFunction, Epilog Ø 8<, Evaluated Ø Automatic,
EvaluationMonitor Ø None, Exclusions Ø Automatic,
ExclusionsStyle Ø None, Filling Ø None, FillingStyle Ø Automatic,
FormatType ß TraditionalForm, Frame Ø False, FrameLabel Ø None,
FrameStyle Ø 8<, FrameTicks Ø Automatic, FrameTicksStyle Ø 8<,
GridLines Ø None, GridLinesStyle Ø 8<, ImageMargins Ø 0.,
ImagePadding Ø All, ImageSize Ø Automatic, ImageSizeRaw Ø Automatic,
LabelStyle Ø 8<, MaxRecursion Ø Automatic, Mesh Ø None,
MeshFunctions Ø 8Ò1 &<, MeshShading Ø None, MeshStyle Ø Automatic,
Method Ø Automatic, PerformanceGoal ß $PerformanceGoal,
PlotLabel Ø None, PlotPoints Ø Automatic,
PlotRange Ø 8Full, Automatic<, PlotRangeClipping Ø True,
PlotRangePadding Ø Automatic, PlotRegion Ø Automatic,
PlotStyle Ø Automatic, PreserveImageOptions Ø Automatic, Prolog Ø 8<,
RegionFunction Ø HTrue &L, RotateLabel Ø True, Ticks Ø Automatic,
TicksStyle Ø 8<, WorkingPrecision Ø MachinePrecision>
Une explication de chaque option est aussi accessible par l'aide interactive ou en ligne comme dans l'exemple suivant :
? Frame
Frame is an option for Graphics, Grid and other
constructs that specifies whether to include a frame. !à
Chaque fonction graphique a ses options propres qu'il convient d'interroger, mais beaucoup d'options sont communes
et l'encadré suivant en rassemble quelques unes parmi les plus couramment employées.
AspectRatio Ø 1 ê GoldenRatio permet d ' ajuster les proportions du graphique
Axes Ø True permet d ' afficher ou non les axes
AxesLabel Ø None permet de donner un nom aux axes
AxesOrigin Ø Automatic permet de modifier l ' origine des axes
AxesStyle Ø 8< permet de modifier le style des axes
Background Ø None permet de changer la couleur du fond
BaseStyle Ø 8< permet de modifier des réglages de base HPolice, Taille, CouleurL
ColorOutput Ø Automatic permet de choisir le code de couleur à utiliser pour les tracés
Epilog Ø 8< permet d ' ajouter des objets
graphiques au dessus du graphique principal
Filling Ø None permet d ' ajouter des objets
graphiques au dessus du graphique principal
Frame Ø False permet d ' encadrer le graphique Hgraduations sur le cadreL
FrameTicks Ø Automatic permet d ' ajuster les graduations du cadre Hquand c ' est utiliséL
GridLines Ø None permet d ' ajouter une grille à définir
ImageSize Ø Automatic permet de fixer la taille du graphique dans la page en points
9. Graphiques 123
permet de fixer la taille du graphique dans la page en points
PlotLabel Ø None permet de définir et d ' afficher un titre au graphique
PlotPoints Ø Automatic permet de définir la taille de la grille de base
à utiliser pour produire les représentations 3 D.
PlotRange Ø Automatic permet de définir la plage de variation des variables
Prolog Ø 8< permet d ' ajouter des objets
graphiques en dessous du graphique principal
Ticks Ø Automatic permet de spécifier les graduations des axes
Options communes à toutes les commandes graphiques préprogrammées
La plupart d'entre elles sont explicites. Voyons simplement quelques exemples.
Par exemple, en plus d'ajouter un titre au graphique et un nom aux axes, on peut modifier leur style comme ci-après :
Plot@Cos@xD * Exp@-x ê 5D, 8x, 0, 10<,
AxesLabel -> 8"x", "y"<,
PlotLabel -> StyleForm@"Oscillations amorties",
FontFamily -> "Times", FontSize -> 10, FontSlant -> "Italic"D,
PlotStyle Ø 8Orange, Dashed, Thick<,
BaseStyle Ø 8FontFamily -> "Arial", FontSize Ø 8<D
2 4 6 8 10x
-0.5
0.5
1.0
yOscillations amorties
L'option PlotRange permet de spécifier pour quelles plages de variation de chacune des coordonnées le graphique
doit être affiché. Par défaut, Mathematica choisi des plages de variation qui permettent la meilleure lecture possible du
graphe. Ainsi, dans l'exemple suivant (à gauche), pour pouvoir observer les oscillations de la courbe dans les régions où
x est grand, Mathematica choisi de tronquer la partie centrale du graphique, mais on peut forcer l'affichage de toutes les
valeurs (à droite) :
des1 = Plot@Sin@xD ê x, 8x, -20, 20<D;
des2 = Plot@Sin@xD ê x, 8x, -20, 20<, PlotRange -> AllD;
GraphicsGrid@88des1, des2<<D
-20 -10 10 20
-0.2
-0.1
0.1
0.2
0.3
0.4
-20 -10 10 20-0.2
0.2
0.4
0.6
0.8
1.0
Pour les représentations bidimensionnelles, Mathematica affiche ses graphiques dans un cadre dont le rapport entre la
largeur et la hauteur vaut généralement le nombre d'or (GoldenRatio). Ainsi, les représentations graphiques n'ont pas,
en général, la même échelle dans la direction verticale et dans la direction horizontale. Pour mettre un graphique à la
même échelle dans les deux directions, il suffit d'opter pour le réglage Automatic comme le montre le double exemple
suivant, sinon on fixera le rapport hauteur/largeur à la valeur souhaitée :
124 9. Graphiques
des1 = Plot@Sin@xD, 8x, 0, 2 p<D;
des2 = Plot@Sin@xD, 8x, 0, 2 p<, AspectRatio Ø AutomaticD;
GraphicsGrid@88des1, des2<<D
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
1 2 3 4 5 6
-1.0-0.5
0.51.0
L'option Frame sert à spécifier un encadrement des graphiques bidimensionnels. Lui sont associées les options
FrameLabel (pour donner des noms aux côtés du cadre) et FrameStyle (pour changer le style du cadre) :
Plot@x Sin@xD, 8x, 0, 50<, Frame -> True,
FrameLabel -> 8"x", "y"<, FrameStyle Ø Orange, Axes -> FalseD
0 10 20 30 40 50
-40
-20
0
20
40
x
y
Les options Ticks ou FrameTicks servent à spécifier les marques de graduation reportées sur les axes ou sur le
cadre :
des1 = Plot@x Sin@xD^2, 8x, 0, 50<,
Ticks -> 8Automatic, 8810, "a"<, 820, "b"<, 830, "c"<, 840, "d"<<<D;
des2 = Plot3D@Sin@xD Sin@yD, 8x, 0, 10<, 8y, 0, 1<,
Ticks -> 8Range@10D, None, None<D;
GraphicsGrid@88des1, des2<<D
D'autres réglages sont possibles pour les marques de graduation tels que la longueur des marques elles-mêmes, leur
style, etc...
On peut également ajouter une grille de repères sur un graphique. Sur le graphique lui-même en 2D et sur les côtés
d'un graphique en 3D grâce aux options GridLines et FaceGrids :
9. Graphiques 125
des1 = ParametricPlot@8Sqrt@tD Sin@tD, Sqrt@tD Cos@tD<,
8t, 0, 50<, GridLines -> Automatic, BaseStyle Ø 8FontSize Ø 8<D;
des2 = ParametricPlot@8Sqrt@tD Sin@tD, Sqrt@tD Cos@tD<, 8t, 0, 50<,
GridLines -> 882, 6<, 83, 4, 5<<, BaseStyle Ø 8FontSize Ø 8<D;
des3 = Plot3D@2 Exp@-x^2 - y^2D, 8x, -2, 2<, 8y, -2, 2<,
FaceGrids -> 880, 1, 0<, 8-1, 0, 0<<, BaseStyle Ø 8FontSize Ø 8<D;
GraphicsGrid@88des1, des2, des3<<D
L'aspect des courbes dans les représentations graphiques bidimensionnelles peut être choisi par l'utilisateur grâce à
l'option PlotStyle. Cette option permet en particulier de fixer l'épaisseur des courbes, leur couleur, de choisir des
courbes pointillées, etc. Si plusieurs courbes sont affichées dans un même graphique, chacune peut être représentée dans
un style propre. Les exemples suivants montrent quelques variations possibles.
des1 = Plot@8Sin@xD, Cos@xD<, 8x, 0, 4 Pi<,
PlotStyle -> 88Dashed, Thick, Orange<, 8Thick, Blue<<D;
des2 = Plot@8Sin@xD, Cos@xD<, 8x, 0, 4 Pi<,
PlotStyle -> 8GrayLevel@0D, [email protected], [email protected]<<D;
GraphicsGrid@88des1, des2<<D
2 4 6 8 10 12
-1.0
-0.5
0.5
1.0
2 4 6 8 10 12
-1.0
-0.5
0.5
1.0
L'option PlotStyle permet également de changer le style des points dans un tracé de données avec la commande
ListPlot soit par l'utilisation des noms en spécificant directement les valeurs
pts = Table@8x, x^3<, 8x, 0, 10, 0.5<D;
des1 = ListPlot@pts, PlotStyle Ø 8Blue, PointSize@LargeD<D;
des2 = ListPlot@pts, PlotStyle Ø 8RGBColor@0, 0, 1D, [email protected]<D;
GraphicsGrid@88des1, des2<<D
2 4 6 8 10
200
400
600
800
1000
2 4 6 8 10
200
400
600
800
1000
126 9. Graphiques
Une autre option parfois utile est l'option PlotPoints. Elle permet de spécifier la discrétisation souhaitée pour un
tracé en densité ou en courbes de niveaux comme dans l'exemple suivant :
des1 = DensityPlot@Exp@-x^2 y^2D, 8x, -2, 2<, 8y, -2, 2<, PlotPoints Ø 3D;
des2 = DensityPlot@Exp@-x^2 y^2D, 8x, -2, 2<, 8y, -2, 2<, PlotPoints -> 30D;
GraphicsGrid@88des1, des2<<D
Dans la plupart des cas, le réglage automatique par défaut conviendra, grâce à l'utilisation des B-splines. L'exemple
suivant le montre clairement :
des1 = Plot3D@Exp@-x^2 y^2D, 8x, -2, 2<, 8y, -2, 2<D;
des2 = Plot3D@Exp@-x^2 y^2D, 8x, -2, 2<, 8y, -2, 2<, PlotPoints Ø 3D;
GraphicsGrid@88des1, des2<<D
Enfin, l'option ColorFunction permet de spécifier la fonction de couleur à utiliser les représentations graphiques.
On peut par exemple utiliser la fonction de couleur Hue ( "Teinte") qui prend comme argument la valeur z, la fonction
GrayLevel ou indiquer un pré-réglage comme "Rainbow" :
9. Graphiques 127
des1 = Plot3D@Sin@xD Sin@yD, 8x, 0, 2 Pi<,
8y, 0, 2 Pi<, ColorFunction -> Hue, Axes Ø FalseD;
des2 = Plot3D@Sin@xD Sin@yD, 8x, 0, 2 Pi<, 8y, 0, 2 Pi<,
ColorFunction -> GrayLevel, Axes Ø FalseD;
des3 = Plot3D@Sin@xD Sin@yD, 8x, 0, 2 Pi<, 8y, 0, 2 Pi<,
ColorFunction Ø "Rainbow", Axes Ø FalseD;
GraphicsGrid@88des1, des2, des3<<D
Les options Epilog et Prolog communes à toutes les fonctions graphiques permettent de piloter l'affichage de
certaines primitives graphiques (voir plus loin) en dessous (Prolog) ou au dessus (Epilog) du graphique principal.
Prolog -> 8< permet l ' affichage de primitives graphiques avant Hen dessousL le tracé du
graphique principal
Epilog -> 8< permet l ' affichage de primitives graphiques après Hau dessusL le tracé du
graphique principal
Options des commandes graphiques permettant l'affichage de primitives graphiques.
Dans l'exemple suivant, l'option Epilog permet d'afficher les pts au dessus la courbe alors qu'avec l'option Prolog,
les représente en dessous la courbe.
data = Table@8i, RandomReal@iD<, 8i, 10<D;
des1 =
ListLinePlot@data, Epilog Ø 8PointSize@LargeD, Orange, Point@dataD<,
InterpolationOrder Ø 2D;
des2 = ListLinePlot@data, Prolog Ø 8PointSize@LargeD, Orange, Point@dataD<,
InterpolationOrder Ø 2D;
GraphicsGrid@88des1, des2<<D
2 4 6 8 10
2
4
6
8
2 4 6 8 10
2
4
6
8
9.1.4 Combinaison de représentations graphiques
Tous les types de graphiques produits par Mathematica peuvent être combinés grâce à l'utilisation de la commande
Show. Cette commande permet par ailleurs de réafficher un graphique en changeant ses options d'affichage. Voici
quelques exemples!:
128 9. Graphiques
des1 = [email protected] + Sin@xD Sin@yD, 8x, 0, Pi<, 8y, 0, Pi<D;
des2 = [email protected] - Sin@xD Sin@yD, 8x, 0, Pi<, 8y, 0, Pi<D;
Show@8des1, des2<D
Parmi les combinaisons possibles intéressantes, il y a celle qui consiste à insérer une représentation graphique dans une
autre à un endroit bien déterminé. Plusieurs moyens existent pour faire cela, comme ci-dessous avec la fonction
Rectangle. Dans l'exemple suivant, on cherche à insérer un zoom d'une portion du graphique à l'intérieur de ce
même graphique.
On fabrique tout d'abord le graphique principal!:
des1 = ListPlot@Table@8x, Exp@-x^2D + 0.1 RandomReal@D<, 8x, -1, 4, 0.02<D,
PlotJoined -> True, AxesOrigin -> 8-1, 0<D
0 1 2 3 4
0.2
0.4
0.6
0.8
1.0
Puis le zoom :
des2 = Show@des1, PlotRange -> 882, 3<, 80, 0.1<<, Axes Ø False,
Frame Ø True, BaseStyle -> 8FontFamily -> "Arial", FontSize Ø 6<D
2.0 2.2 2.4 2.6 2.8 3.0
0.00
0.02
0.04
0.06
0.08
0.10
La combinaison est ensuite effectuée en précisant sur quelle fraction de la surface finale d'affichage (dans quel
rectangle) chaque graphique est placé (la surface totale est un rectangle de côtés 1, le coin inférieur gauche ayant les
coordonnées 80, 0<) :
9. Graphiques 129
Graphics@8Rectangle@80, 0<, 81, 1<, des1D,
[email protected], 0.5<, 81, 1<, des2D<, AspectRatio Ø 1 ê GoldenRatioD
0 1 2 3 4
0.2
0.4
0.6
0.8
1.0
2.0 2.2 2.4 2.6 2.8 3.0
0.00
0.02
0.04
0.06
0.08
0.10
La fonction Inset permet également ce genre de manipulation.
Une autre façon de combiner des représentations graphiques consistent à les placer dans un tableau de graphiques
avec la commande GraphicsGrid comme certaines des illustrations précédentes ainsi que dans l'exemple suivant :
tab = Table@Plot3D@Cos@i x ê 2D + Cos@i y ê 2D, 8x, -Pi, Pi<,
8y, -Pi, Pi<, Axes -> FalseD, 8j, 0, 6, 3<, 8i, j, j + 2, 1<D;
GraphicsGrid@tab, Spacings Ø [email protected], Frame Ø AllD
9.1.5 Animations et représentations graphiques interactives
Fabriquer une animation avec Mathematica est un jeu d'enfants. La commande de base est la commande Animate qui
sert à animer une représentation en faisant varier un ou plusieurs paramètres dans la fonction représentée comme dans
l'exemple ci-dessous!:
130 9. Graphiques
Animate@Plot@t Sin@xD ê x, 8x, -10, 10<, PlotRange Ø 8All, 8-0.2, 1<<D,
8t, 0, 0.8, 0.1<D
t
-10 -5 5 10
-0.2
0.2
0.4
0.6
0.8
1.0
De la même manière, on peut animer une liste de graphiques préalablement fabriqués, avec la commande
ListAnimate.
tabs = Table@Plot@Sin@n xD, 8x, 0, 10<D, 8n, 5<D;
ListAnimate@tabsD
2 4 6 8 10
-1.0
-0.5
0.5
1.0
Dans les deux cas, la fenêtre d'animation contient différents curseurs qui permettent d'interagir avec l'animation.
La fonction Manipulate, qui s'utilise de la même manière, permet de manipuler une représentation graphique en
faisant varier manuellement un ou plusieurs paramètres comme ci-dessous.
9. Graphiques 131
Manipulate@Plot@Sin@a x + bD, 8x, 0, 6<D,
88a, 2, "Multiplicateur"<, 1, 4<, 88b, 0, "Phase"<, 0, 10<D
Multiplicateur
Phase
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Les fonctions TabView, SlideView, FlipView peuvent également être utilisées pour présenter de différentes
manières des tableaux interactifs de graphiques. Tout comme les fonctions Animate et Manipulate, ces fonctions ne
sont pas réservées aux graphiques et peuvent être utilisées pour tout type d'expression paramétrée.
tabs = Table@Plot@Sin@n xD, 8x, 0, 10<D, 8n, 5<D;
TabView@tabsD
2 4 6 8 10
-1.0
-0.5
0.5
1.0
1 2 3 4 5
132 9. Graphiques
9.2 Programmation des graphiques
Au delà des commandes préprogrammées, Mathematica est doté d'un langage graphique reposant sur des primitives
graphiques qui permettent de définir des objets graphiques élémentaires (points, traits, ellipses,...) et des directives
graphiques pour modifier leur aspect (épaisseur, couleur, pointillé, etc...). Les primitives et directives graphiques sont
des fonctions Mathematica comme les autres et toutes les possibilités de programmation vues jusqu'à maintenant leur sont
applicables. Comme nous allons le voir, la richesse syntaxique du langage Mathematica va permettre la construction de
représentations graphiques sophistiquées par l'utilisation d'un nombre très restreint d'instructions.
9.2.1 Primitives graphiques 2D
La liste des primitives graphiques bidimensionnelles est donnée dans l'encadré suivant. Elles définissent les objets
graphiques élémentaires à partir desquels on peut imaginer des constructions graphiques plus complexes.
Point@8x, y<D point placé en 8x, y<
Line@8pt1, pt2, pt3, ...<D ligne brisée passant successivement par les points pt1,
pt2, pt3, ...
Arrow@8pt1, pt2<D flèche
BezierCurve@8pt1, pt2, ...<D courbe de Bézier
BSplineCurve@8pt1, pt2, ...<D B - spline
Polygon@8pt1, pt2, pt3, ...<D polygone défini par ses sommets
Circle@pt, rD cercle centré au point pt et de rayon r
Circle@pt, 8r1, r2<D ellipse centrée en pt et de diamètres principaux r1 et r2
Circle@pt, r, 8q, f<D arc de cercle centré en pt, de rayon r et allant
de l ' angle q à l ' angle f avec l ' axe des abscisses
Disk@pt, rD ou variantes disque plein centré au point pt et de rayon r
Rectangle@pt1, pt2D rectangle plein défini par les points
de sa première diagonale
Raster@88a11, a12, ...<, ...<D matrice rectangulaire de cellules grises ou colorées
Text@expr, pt, position relativeD chaîne de caractères positionnée en
pt selon des directives de positionnement
Inset@objetD permet d ' insérer un objet dans un graphique
Primitives graphiques bidimensionnelles
Les commandes graphiques préprogrammées utilisent en fait ces primitives pour fournir les représentations graphiques
de courbes ou de données les plus fréquemment utilisées. On peut s'en convaincre en regardant la forme interne d'une
représentation graphique obtenue avec la commande Plot par exemple. Pour cela, on utilise la commande
InputForm (dans l'exemple suivant, nous avons supprimé une partie du résultat pour une meilleure lisibilité) :
Plot@Sin@xD, 8x, 0, p<D
0.5 1.0 1.5 2.0 2.5 3.0
0.2
0.4
0.6
0.8
1.0
9. Graphiques 133
InputForm@%D
Graphics[{{{}, {}, {Hue[0.67, 0.6, 0.6], Line[{{6.411413578754679*^-8,
6.411413578754675*^-8}, {0.0009635827659544611,
0.0009635826168413605}, {0.0019271014177731347,
0.0021565371692775508}, {3.1405143521123096,
0.0010783012685207124}, {3.1415925894756573,
6.411413590069065*^-8}}]}}}, {AspectRatio -> GoldenRatio^(-1),
Axes -> True, AxesOrigin -> {0, 0},
PlotRange -> {{0, Pi}, {0., 0.9999999707682925}},
PlotRangeClipping -> True, PlotRangePadding ->
{Scaled[0.02], Scaled[0.02]}}]
On peut ainsi voir que la courbe est définie par une succession de segments de droite qui constituent une ligne brisée
(commande Line).
En retiendra ici que les primitives graphiques définissent des objets graphiques élémentaires. Mises en arguments de la
fonction Graphics, elles permettent de constituer un objet graphique que l'on peut ensuite afficher avec la fonction
Show.
La richesse fonctionnelle de Mathematica et de son langage de programmation permet donc, en utilisant les primitives
graphiques, de construire des représentations graphiques complexes avec un minimum d'instructions.
Ainsi il pourra être intéressant et économique de programmer une fonction graphique quand on en a besoin
régulièrement. L'exemple ci-dessous montre, par exemple, la construction d'un polygone régulier dont le nombre de
côtés est donné par l'utilisateur :
polygone@n_IntegerD :=
Graphics@Line@Table@8Cos@2 i Pi ê nD, Sin@2 i Pi ê nD<, 8i, 1, n + 1<DDD;
GraphicsGrid@Table@polygone@iD, 8j, 3, 11, 4<, 8i, j, j + 3, 1<DD
L'utilisation de règles de substitution peut aussi être très pratique pour des constructions graphiques. Les instructions
suivantes montrent par exemple comment remplacer une liste de points par des cercles de rayon 0.1 centrés en ces
points, ou, dans un deuxième temps, par des polygones pleins!:
134 9. Graphiques
pts = RandomReal@80, 1<, 810, 2<D;
des1 = Graphics@pts ê. 8x_, y_< :> Circle@8x, y<, 0.1D, Frame -> TrueD;
des2 = Graphics@pts ê. 8x_, y_< ß
8Hue@xD, Polygon@88x - 0.1, y - 0.1<, 8x - 0.1, y + 0.1<, 8x + 0.1, y + 0.1<,
8x + 0.1, y - 0.1<, 8x - 0.1, y - 0.1<<D<, Frame -> TrueD;
GraphicsGrid@88des1, des2<<D
0.0 0.2 0.4 0.6 0.8
0.0
0.2
0.4
0.6
0.8
1.0
0.0 0.2 0.4 0.6 0.8
0.0
0.2
0.4
0.6
0.8
1.0
Des constructions graphiques basées sur des fonctions itératives sont aussi faciles à mettre en oeuvre. Dans l'exemple
suivant, on dessine des carrés imbriqués de manière itérative. Pour cela, on écrit d'abord une fonction qui détermine les
sommets d'un carré en fonction des sommets du carré de niveau supérieur :
pts = 880, 0<, 80, 1<, 81, 1<, 81, 0<<;
f@pts_, d_, i_D := NestList@Ò + HRotateRight@ÒD - ÒL ê d &, pts, iD ê.
8x : 8_, _<, y__< -> 8x, y, x<;
des1 = Graphics@Map@Line, f@pts, 2, 10DDD;
des2 = Graphics@Map@Line, f@pts, 4, 10DDD;
GraphicsGrid@88des1, des2<<D
La primitive Text permet quant à elle de placer une expression dans un graphique. On peut en particulier spécifier la
position exacte de l'expression entrée par rapport aux coordonnées d'un point.
9. Graphiques 135
points = RandomReal@80, 1<, 810, 2<D;
cercles = Map@Circle@Ò, 0.1D &, pointsD;
textes = Table@Text@i, points@@iDDD, 8i, 1, 10<D;
Graphics@8cercles, textes<, Frame -> TrueD
1
2
3
4
5
6
7
8
9
10
0.0 0.2 0.4 0.6 0.8 1.0
0.0
0.2
0.4
0.6
0.8
Text@expr, 8x, y<, pos, dirD texte de l ' expression!placée au point de
coordonnées 8x, y<, !avec des options de position
HposL et!dans une direction donnée par dir.
réglages possibles pour pos
80, 0< texte centré en 8x, y<
8-1, 0< texte aligné à gauche en 8x, y<
81, 0< texte aligné à droite en 8x, y<
80, -1< texte centré au dessus de 8x, y<
80, 1< texte centré en dessous de 8x, y<
réglages possibles pour dir
81, 0< texte horizontal ordinaire
80, 1< texte vertical de bas en haut
80, -1< texte vertical de haut en bas
8-1, 0< texte horizontal de droite à gauche
Primitive Text
La primitive Raster est la primitive permettant de représenter des images bitmap représentée par une matrice
bidimensionnelle de valeurs ou de couleurs. Par défaut, comme ci-dessous à gauche, les images sont constituées de pixels
gris dont l'intensité dépend de la valeur dans la matrice. Pour travailler en couleur, il faut fournir une matrice de triplets
dont chaque élément donne le niveau de rouge, de vert et de bleu (ci-dessous à droite, on remplace ainsi chaque élément
de la matrice précédente par un triplet de valeur construit avec la valeur initiale).
136 9. Graphiques
tab = NüTable@Sin@x yD, 8x, 0, 2 Pi, 2 Pi ê 100<, 8y, 0, 2 Pi, 2 Pi ê 100<D;
des1 = Graphics@Raster@tab, 880, 0<, 82 Pi, 2 Pi<<DD;
des2 = Graphics@Raster@tab ê. x_?NumberQ :> 8x, x^2, x^3<DD;
GraphicsGrid@88des1, des2<<D
L'opacité peut également être ajoutée à chaque triplet pour produire des images translucides
Graphics@88Orange, Disk@850, 50<, 50D<,
Raster@tab ê. x_?NumberQ :> 8x, x^2, x^3, 0.4<D<D
Quant aux courbes de Bezier, elles permettent de construire des figures complexes avec un minimum de points :
Graphics@
Table@8Hue@RandomReal@DD, BezierCurve@RandomReal@1, 84, 2<DD<, 820<DD
9. Graphiques 137
9.2.2 Primitives graphiques 3D
Pour fabriquer des objets graphiques tridimensionnels, des primitives graphiques supplémentaires sont nécessaires.
L'encadré suivant donne donc la liste des primitives graphiques tridimensionnelles.
Point@8x, y, z<D point placé en 8x, y, z<
Line@8pt1, pt2, pt3, ...<D ligne brisée passant successivement par les points pt1,
pt2, pt3, ...
Arrow@8pt1, pt2<D flèche
BezierCurve@8pt1, pt2, ...<D courbe de Bézier
BSplineCurve@8pt1, pt2, ...<D B - spline
Polygon@8pt1, pt2, pt3, ...<D polygone défini par ses sommets
Cuboid@ptD cube de côtés 1 dont le sommet
inférieur gauche arrière est placé en pt
Cuboid@pt1, pt2D cube dont le sommet inférieur gauche arrière est placé en
pt1 et le sommet supérieur droit avant est placé en pt2
Sphere@pt, rD sphère centrée en pt de rayon r
Cylinder@8pt1, pt2<, rD cylindre de rayon r autour de la ligne allant de pt1 à pt2
Cone@8pt1, pt2<, rD cylindre de base de rayon r centrée en pt1 et de sommet pt2
Tube@8pt1, pt2, ...<, rD tube de rayon r passant par les points
BSplineSurface@tableauD surface spline dont les points de
contrôle sont donnés dans le tableau
Text@expr, pt, pos, dirD texte d ' une expression placé au point de coordonnées
pt selon les spécifications données par pos et dir
Primitives graphiques tridimensionnelles
Et voici une promenade aléatoire (noter l'élégance du programme), en ligne ou en tubes (ou t désigne la séquence de
couples aléatoires) :
des1 = Graphics3D@8Thickness@LargeD, Blue,
Line@FoldList@Plus, 80, 0, 0<, t = RandomReal@8-1, 1<, 840, 3<DDD<D;
des2 = Graphics3D@8Thickness@LargeD, Green,
Tube@FoldList@Plus, 80, 0, 0<, tD, 0.5D<D;
des3 = Graphics3D@Cuboid êü FoldList@Plus, 80, 0, 0<, tDD;
GraphicsGrid@88des1, des2, des3<<D
Ou encore ce bel exemple tiré de l'aide de Mathematica :
138 9. Graphiques
With@8f = 8Cos@xD + Sin@xD, Sin@xD<<, Graphics@
Table@8Hue@t ê H2 PiL, 1, .8D, Arrow@8f, Normalize@D@f, xDD + f<D< ê. x Ø t,
8t, 0, 2 Pi, .1<DDD
Les autres primitives graphiques tridimensionnelles sont similaires à leur équivalent respectif en 2D.
9.2.3 Directives graphiques
Les directives graphiques sont des fonctions graphiques qui permettent de changer l'aspect des objets graphiques créés,
qu'ils soient bi ou tri-dimensionnels. Les encadrés suivants en donnent la liste!:
Dashing@8d1, d2, ...<D pointillé
AbsoluteDashing@8d1, ...<D pointillé en unités absolues
Thickness@tD épaisseur d ' un trait
AbsoluteThickness@tD épaisseur d ' un trait en unités absolues
PointSize@sD taille d ' un point
AbsolutePointSize@sD taille d ' un point en unités absolues
GrayLevel@gD niveau de gris
RGBColor@r, g, bD couleur Hrouge, vert, bleuL
Hue@hD teinte
Hue@h, s, bD teinte Hteinte, saturation, luminositéL
CMYKColor@c, m, y, kD couleur Hcyan, magenta, jaune, noirL
Blend@8col1, col2<, xD dégradé linéaire de couleur entre la
couleur col1 et la couleur col2 en fonction de x
Opacity@aD opacité H0 pour transparentL
Arrowheads@specD style des têtes de flèches
JoinForm@typeD forme des sommets dans les lignes brisées
CapForm@typeD forme des extrémités des segments
Directives graphiques bidimensionelles
FaceForm@styleD style de la face d ' un polygone
EdgeForm@styleD style de l ' arête d ' un polygone
Opacity@aD opacité d ' une surface H0 pour transparentL
Glow@colD couleur de l ' éclat d ' un objet
Specularity@sD spécularité d ' un objet
Directives graphiques supplémentaires pour les objets tridimensionels
9. Graphiques 139
Les directives qui invitent à indiquer des valeurs en unités relatives permettent de donner des spécifications en
proportion de la taille finale de la surface d'affichage (Dashing, Thickness, PointSize). Avec leur homologue en
spécification absolue, on donne la taille en points d'impression (1 point º 0.35 mm).
Le principe à retenir est que ces directives s'emploient d'une façon identique à celle des primitives graphiques et
qu'elles s'appliquent à tous les objets graphiques qui suivent (dans la même liste) jusqu'à ce que d'autres spécifications
soient données.
lignes =
Flatten@Table@[email protected] * i<D, Line@880, i<, 81, i<<D<, 8i, 0, 9<DD;
Graphics@lignes, Frame -> True, AspectRatio Ø 1 ê GoldenRatio,
FrameTicks -> NoneD
Les directives graphiques qui permettent de spécifier la couleur des objets graphiques peuvent être utilisées par
exemple pour figurer l'évolution de la variable dans un tracé paramétrique. Les exemples suivant deux utilisations
distinctes donnant le même résultat (Hue[0] º Bleu ; Hue[0.7] º Rouge) :
pts1 = Table@
[email protected] * H1 - x ê H2 PiLLD, Point@8x, Sin@xD<D<, 8x, 0, 2 Pi, 2 Pi ê 40<D;
des1 = Graphics@[email protected], pts1<, Axes Ø TrueD;
pts2 = Table@8Blend@[email protected], Hue@0D<, x ê H2 PiLD, Point@8x, Sin@xD<D<,
8x, 0, 2 Pi, 2 Pi ê 40<D;
des2 = Graphics@8PointSize@LargeD, pts2<, Axes Ø TrueD;
GraphicsGrid@88des1, des2<<D
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Enfin, voici un exemple de surface B-spline :
cpts = Table@8i, j, RandomReal@8-1, 1<D<, 8i, 5<, 8j, 5<D;
Graphics3D@8FaceForm@8Green, [email protected]<D, BSplineSurface@cptsD<D
9.3 Exercices
140 9. Graphiques
9.3 Exercices
9.3.1 Fréquences et histogrammes
a) Nous avons déjà programmé une fonction fréquence permettant de compter le nombre d'occurence de chaque
élément présent dans une liste. Réécrire cette fonction dont le résultat doit être exprimée sous la forme donnée par
l'exemple suivant :
frequence@8a, b, c, a, d, e, a, e, b, a<D
88a, 4<, 8b, 2<, 8c, 1<, 8d, 1<, 8e, 2<<
b) Considérer maintenant une liste de 100 entiers compris entre 1 et 10. Calculer les fréquences de chaque entier puis
dessiner les fréquences obtenues avec la commande ListPlot. Ecrire ensuite un programme qui dessine un véritable
histogramme comme ci-dessous à partir de la représentation donnée par ListPlot et en utilisant une règle de
substitution.
2 4 6 8 10
5
10
15
9.3.2 Etoiles
a) Ecrire une fonction etoile[n] qui dessine une étoile à n branches (la longueur des branches valant la moitié du
rayon maximal de l'étoile)
GraphicsGrid@88Etoile@7D, Etoile@20D<<D
b) Modifier la fonction etoile de telle sorte qu'elle soit munie de trois 3 arguments (le nombre de branches, le rayon
et l'angle des branches) pour obtenir, par exemple, la représentation suivante à gauche et rechercher les arguments
permettant d'obtenir celle de droite :
Etoile@10, 3, 0.4D H* pour l'image de gauche *L
9.3.3 Fractales
9. Graphiques 141
9.3.3 Fractales
a) Définir une fonction rota[vec,q] qui fait subir une rotation d'un angle q à un vecteur. On définira la
transformation par le biais du produit vectoriel d'une matrice de rotation et du vecteur (l'illustration ci-dessous montre la
rotation du vecteur 81, 1< d'un angle de + p/6).
0.2 0.4 0.6 0.8 1.0
0.2
0.4
0.6
0.8
1.0
1.2
b) Définir maintenant une fonction qui à partir d'un segment de droite donne naissance à 2 nouveaux segments de
longueur égale à 0.8 fois (option par défaut) celle du segment initial et faisant un angle de ± 30° (option par défaut) avec
le segment initial comme le montre l'exemple suivant bâti à partir du segment {{0,0},{1,1}}. Faire la représentation
graphique.
0.5 1.0 1.5 2.0
0.5
1.0
1.5
2.0
c) Exploiter maintenant ces fonctions pour construire, de façon récursive, un arbre comme le suivant (initialisé avec le
segment {{0,0},{0,1}}) :
d) Ecrire maintenant un programme complet permettant de dessiner des arbres de formes variables selon l'angle de
rotation choisi et la longueur des branches. Voici quelques exemples possibles.
142 9. Graphiques
des1 =
fractale@880, 0<, 80, 1<<, Recursions -> 8, Angle -> 30 , Echelle -> 0.8D;
des2 = fractale@880, 0<, 80, 1<<, Recursions -> 8,
Angle -> 45 , Echelle -> 0.7D;
des3 = fractale@880, 0<, 80, 1<<, Recursions -> 8,
Angle -> 90 , Echelle -> 0.7D;
GraphicsGrid@88des1, des2, des3<<D
e) Modifier maintenant le programme en y introduisant des aléas dans les angles ou les longueurs. Cela permettra des
représentations graphiques comme les suivantes.
des1 = fractale@880, 0<, 80, 1<<, Recursions -> 8, Alea -> 0.3D;
des2 = fractale@880, 0<, 80, 1<<,
Recursions -> 8, Angle -> 20, Echelle -> 0.7 , Alea -> 0.4D;
GraphicsGrid@88des1, des2<<D
9. Graphiques 143
144 9. Graphiques
Chapitre 10
Programmation Objet
146 10. Programmation Objet
10 Programmation Objet
Nous allons présenter quelques principes de la programmation objet dans Mathematica. On trouvera sur Internet des
packages gratuits permettant d'étendre les possibilités de Mathematica dans ce domaine. En particulier, les notions de
classes et d'héritage ne sont pas implémentés par défaut dans le noyau de Mathematica.
10.1 Exemple introductif
Imaginons que nous souhaitons programmer la somme des décibels. Par définition, on voudra écrire par exemple :
Clear@dBD;
dB@x_D + dB@y_D := dBA10 LogA10, 10xê10 + 10yê10EE
SetDelayed::write : Tag Plus in dB@x_D+dB@y_D is Protected. à
$Failed
Malheureusement, comme le montre le message donné par Mathematica, ce n'est pas possible de procéder ainsi car la
somme (l'opérateur Plus) est protégé.
Nous allons donc considérer les décibels (dB) comme une classe d'objets et nous écrirons alors :
Clear@dBD;
dB ê: dB@x_D + dB@y_D := dBA10 LogA10, 10xê10 + 10yê10EE
Maintenant, nous pouvons utiliser la classe dB et notamment faire la somme de décibels :
dB@5D + dB@5D êê N
En fait, grâce à la commande /: (voir TagSet ou TagSetDelayed), nous avons assigné la définition (on dira la
propriété) au symbole dB plutôt que de l'assigner à l'opérateur Plus.
? TagSet
f ê: lhs = rhs assigns rhs to be the value of
lhs, and associates the assignment with the symbol f . !à
? TagSetDelayed
f ê: lhs := rhs assigns rhs to be the delayed value
of lhs, and associates the assignment with the symbol f . !à
? TagUnset
f ê: lhs=. removes any rules defined for lhs, associated with the symbol f . !à
Nous aurions pu aussi écrire :
10. Programmation Objet 147
Clear@dBD;
dB@x_D + dB@y_D ^:= dBA10 LogA10, 10xê10 + 10yê10EE
Ce qui donne le même résultat (c'est quasiment la même chose) :
dB@5D + dB@5D êê N
Expression dans laquelle ^:= correspond à UpSetDelayed :
? UpSetDelayed
lhs ^:= rhs assigns rhs to be the delayed value of lhs, and associates
the assignment with symbols that occur at level one in lhs. !à
? UpSet
lhs ^= rhs assigns rhs to be the value of lhs, and associates
the assignment with symbols that occur at level one in lhs. !à
10.2 UpValues
Les instructions précédentes nous ont permis d'attacher les définitions au symbole choisi (dB). Ces définitions
constituent ce qu'on appelle les UpValues du symbole (définition amont) :
UpValues@dBD
9HoldPattern@dB@x_D + dB@y_DD ß dBA10 LogA10, 10xê10 + 10yê10EE=
Mais choisissons un autre exemple pour comparer les choses. Soit la définition suivante :
Clear@f, gD;
f@g@x_DD := Sin@xD;
fAgA2 x2 + 3EE
SinA3 + 2 x2E
La définition est assignée à f, elle constitue une valeur aval de f :
? f
Global`f
f@g@x_DD := Sin@xD
? g
Global`g
DownValues@fD
8HoldPattern@f@g@x_DDD ß Sin@xD<
148 10. Programmation Objet
UpValues@fD
8<
Si maintenant nous écrivons :
Clear@f, gD;
g ê: f@g@x_DD := Sin@xD;
Nous avons une assignation complètement différente. Le système ne connaît aucune définition pour f :
? f
Global`f
En effet, la définition a été assignée à g :
? g
Global`g
f@g@x_DD ^:= Sin@xD
Elle constitue ce qu'on appelle une valeur amont de g :
DownValues@gD
8<
UpValues@gD
8HoldPattern@f@g@x_DDD ß Sin@xD<
Reprenons l'exemple des décibels. Plutôt que de définir la somme comme nous l'avons fait (en assignant la définition
au symbole dB), et contrairement à ce que nous avons laissé entendre, nous aurions pu l'assigner à l'opérateur Plus.
Mais pour cela nous devons retirer la protection de cet opérateur (ce qui est toujours dangereux). Ainsi nous aurions pu
aussi écrire!:
Clear@dBD;
Unprotect@PlusD;
Plus@dB@x_D, dB@y_DD := dBA10 LogA10, 10xê10 + 10yê10EE;
Protect@PlusD;
dB@5D + dB@5D êê N
DownValues@PlusD
9HoldPattern@dB@x_D + dB@y_DD ß dBA10 LogA10, 10xê10 + 10yê10EE=
L'intérêt des UpValues réside dans le fait qu'elles sont testées en premier à l'appel du symbole concerné.
Dans l'exemple ci-dessus, quand nous demandons de calculer la somme de décibels, nous utilisons l'opérateur Plus
auquel nous avons ajouté une règle (une définition aval). Mais avant de faire le calcul avec la définition donnée,
Mathematica va d'abord tester si le symbole dB a des UpValues (et il n'en a pas dans ce cas) puis tester toutes les
définitions (toutes les règles) internes à l'opérateur Plus pour faire des sommes (la somme d'entiers, la somme de
complexes, la somme de listes, etc...), puis enfin rechercher parmi les définitions aval disponibles (notre définition) pour
exécuter le calcul. Notre définition est donc testée en dernier et ce mécanisme peut, dans certains cas, prendre beaucoup
de temps.
Dans la méthode exposée plus haut (avec /:), puisque la définition est une définition amont (UpValues) du symbole
dB, elle est testée en premier et donc directement appliquée. Le mécanisme d'évaluation est donc beaucoup plus rapide.
10. Programmation Objet 149
Dans la méthode exposée plus haut (avec /:), puisque la définition est une définition amont (UpValues) du symbole
dB, elle est testée en premier et donc directement appliquée. Le mécanisme d'évaluation est donc beaucoup plus rapide.
Voici un autre exemple très simple. Soit le calcul suivant :
Sin@aD Cos@bD
Cos@bD Sin@aD
Il ne se passe pas grand chose, hormis le fait que la commutativité du produit change l'ordre des expressions.
Moyennant l'enlèvement de la protection de la fonction Sin, on peut attacher à ce symbole (à Sin) une règle de
décomposition dans le cas d'un produit avec un cosinus :
Unprotect@SinD;
Sin ê: Sin@x_D Cos@y_D := Sin@x + yD ê 2 + Sin@x - yD ê 2;
Protect@SinD;
UpValues@SinD
:HoldPattern@Cos@y_D Sin@x_DD ß1
2Sin@x + yD +
1
2Sin@x - yD>
Sin@aD Cos@bD
1
2Sin@a - bD +
1
2Sin@a + bD
Sin@5D Cos@3D
Sin@2D
2+Sin@8D
2
En associant cette définition à Sin plutôt qu'à Times (on aurait pu le faire de la même façon), on évite de ralentir
l'exécution de Times chaque fois qu'on l'utilise pour d'autres opérations, car, s'agissant d'une valeur amont (UpValues)
de Sin, la règle est immédiatement utilisée avant d'explorer les valeurs (ou définitions) aval (DownValues) de Times.
On veillera le cas échéant, à restaurer la fonction Sin originale en validant les instructions suivantes, le Clear
n'affectant pas les définitions internes :
Unprotect@SinD;
Clear@SinD;
Protect@SinD;
UpValues@SinD
8<
Sin@5D Cos@3D
Cos@3D Sin@5D
10.3 Programmation objet
C'est avec ces principes que nous allons programmer des objets dans Mathematica.
Prenons l'exemple des lois de probabilités continues. Pour la plupart d'entre elles, et pour pouvoir les utiliser, on doit
définir leur moyenne, leur écart-type, leur densité de probabilité, leur fonction de répartition, etc...
On pourrait alors décider de programmer la fonction moyenne, la fonction écart-type, la fonction densité et la
fonction de répartition de la façon suivante :
150 10. Programmation Objet
Clear@Moyenne, EcartType, LoiNormale, LoiStudent, LoiChiDeuxD;
Moyenne@LoiNormale@m_, s_DD := m;
Moyenne@LoiStudent@n_DD := 0;
Moyenne@LoiChiDeux@n_DD := n;
H* etc ...*L
EcartType@LoiNormale@m_, s_DD := s;
EcartType@LoiStudent@n_DD := Sqrt@n ê Hn - 2LD;
EcartType@LoiChiDeux@n_DD := Sqrt@2 nD;
H* etc ...*L
Moyenne@LoiNormale@10, 5DD
10
EcartType@LoiStudent@10DD
5
2
Il faudra notamment prévoir aussi la moyenne des éléments dans une liste, leur écart-type, etc.
Conformément au mécanisme d'évaluation, quand on veut calculer la moyenne d'une loi du c2, Mathematica passe en
revue les définitions de la moyenne et, à la troisième (dans le cas présent), trouve une définition qu'il applique.
? Moyenne
Global`Moyenne
Moyenne@LoiNormale@m_, s_DD := m
Moyenne@LoiStudent@n_DD := 0
Moyenne@LoiChiDeux@n_DD := n
Hormis le temps d'évaluation qui peut être allongé si nous introduisons plusieurs dizaines de lois de probabilité,
l'inconvénient principal réside ici dans la structure du programme que nous sommes entrain d'écrire. Nous avons d'abord
les définitions de la moyenne, puis les définitions de l'écart-type, puis la densité de probabilité, puis la fonction de
répartition, etc... Si à un moment donné nous devons ajouter une nouvelle loi de probabilité, il faudra passer en revue
tout le programme et ajouter des définitions deci-delà, ce qui ne manquera pas de poser des problèmes dans un
programme de plusieurs milliers de lignes de code.
Une bien meilleure méthode de travail consiste à rassembler, pour chaque loi de probabilité, toutes les définitions qui
lui sont attachées et à traiter ces définitions comme des propriétés de la loi qu'on considérera alors comme un objet. Ainsi
nous écrirons plutôt :
Clear@Moyenne, EcartType, LoiNormale, LoiStudent, LoiChiDeuxD;
H* propriétés de la loi normale *L
LoiNormale ê: Moyenne@LoiNormale@m_, s_DD := m;
LoiNormale ê: EcartType@LoiNormale@m_, s_DD := s;
H* propriétés de la loi de Student *L
LoiStudent ê: Moyenne@LoiStudent@n_DD := 0;
LoiStudent ê: EcartType@LoiStudent@n_DD := Sqrt@n ê Hn - 2LD;
H* propriétés de la loi du chi2 *L
LoiChiDeux ê: Moyenne@LoiChiDeux@n_DD := n;
LoiChiDeux ê: EcartType@LoiChiDeux@n_DD := Sqrt@2 nD;
10. Programmation Objet 151
? Moyenne
Global`Moyenne
? LoiNormale
Global`LoiNormale
Moyenne@LoiNormale@m_, s_DD ^:= m
EcartType@LoiNormale@m_, s_DD ^:= s
Les lois étant rassemblées par chapitre, l'ajout d'une nouvelle loi consiste à ajouter, en bout de programme, un
nouveau chapitre dans lequel nous écrirons toutes les propriétés connues de l'objet. C'est plus simple, mieux structuré,
plus facile à faire évoluer. Par ailleurs, l'évaluation est plus rapide puisque Mathematica regarde d'abord s'il peut utiliser des
définitions amont avant de rechercher des définitions aval.
On pourra continuer à considérer la moyenne d'une liste comme une définition aval du symbole Moyenne tandis que
la moyenne d'une loi de probabilité sera considérée comme une définition amont de la loi de probabilité.
C'est cette méthode de programmation qui est employée dans Mathematica pour programmer les lois de distribution
statistiques.
Enfin, nous pourrons également surcharger des symboles existants en leur attribuant des propriétés nouvelles, à
condition toutefois de retirer au préalable leur protection comme dans l'exemple suivant avec la fonction (l'objet) interne
Circle :
Clear@Surface, Circonference, Diametre, Rayon, CentreD;
Unprotect@CircleD;
Circle ê: Surface@Circle@8_, _<, r_DD := 4 * Pi * r2;
Circle ê: Circonference@Circle@8_, _<, r_DD := 2 * Pi * r;
Circle ê: Diametre@Circle@8_, _<, r_DD := 2 r;
Circle ê: Rayon@Circle@8_, _<, r_DD := r;
Circle ê: Centre@Circle@c : 8_, _<, r_DD := c;
Protect@CircleD;
Nous pouvons ainsi utiliser Circle, non seulement pour dessiner, mais aussi pour faire des calculs :
Show@Graphics@Circle@82, 3<, 4D, AspectRatio Ø Automatic, Axes Ø TrueDD
-2 2 4 6
2
4
6
152 10. Programmation Objet
Surface@Circle@82, 3<, 4DD
64 p
Diametre@Circle@82, 3<, 4DD
8
Centre@Circle@82, 3<, 4DD
82, 3<
10.4 Exercices
10.4.1 L'objet Triangle
Programmer l'objet Triangle (sur le modèle de Circle) en définissant quelques unes de ses propriétés, en
particulier sa représentation graphique, sa surface et son centre de gravité de sorte qu'on puisse les obtenir en validant les
instructions suivantes
Graphics[Triangle[{...}]]
Surface[Triangle[{...}]]
Centre[Triangle[{...}]]
10.4.2 Comptabilité
Nous proposons dans cet exercice de créer un ensemble de méthodes permettant de gérer un compte bancaire. On
commencera par créer une fonction de création de compte dont le résultat sera un objet auquel on pourra attacher des
méthodes pour le dépôt d'une somme d'argent sur ce compte (depot) et le retrait d'argent sur ce compte (retrait). On
définira les méthodes créées de manière à obtenir les réponses suivantes aux instructions données :
creer@compte@"Dupont"DD
8Nom Ø Dupont, Solde Ø 0<
depot@compte@"Dupont"D, 40D
8Nom Ø Dupont, Solde Ø 40<
depot@compte@"Dupont"D, 70D
8Nom Ø Dupont, Solde Ø 110<
retrait@compte@"Dupont"D, 50D
8Nom Ø Dupont, Solde Ø 60<
creer@compte@"Durand"DD
8Nom Ø Durand, Solde Ø 0<
depot@compte@"Durand"D, 1000D
8Nom Ø Durand, Solde Ø 1000<
retrait@compte@"Durand"D, 300D
8Nom Ø Durand, Solde Ø 700<
10. Programmation Objet 153
compte@"Dupont"D
8Nom Ø Dupont, Solde Ø 60<
compte@"Durand"D
8Nom Ø Durand, Solde Ø 700<
154 10. Programmation Objet
Chapitre 11
Packages
156 11. Packages
11 Packages
Une des caractéristiques les plus importantes de Mathematica est son extensibilité car il est en effet possible de lui ajouter
des fonctionnalités nouvelles rassemblées dans un document séparé, appelé package, que l'on pourra charger en mémoire
à la demande de manière très simple, sans l'ouvrir explicitement. Pour la plupart des calculs courants, les fonctionnalités
contenues dans le noyau de Mathematica sont généralement suffisantes. Mais dès qu'on s'intéresse à un domaine assez
particulier, on peut avoir besoin de fonctions nouvelles. Dans ce cas, on pourra trouver ces fonctions manquantes dans
des packages disponibles, gratuits ou payants ou l'on pourra programmer soit même un ensemble de fonctions que l'on
pourra distribuer ou réutiliser soi-même quand on en a besoin.
Ces packages (on dit aussi Add-ons) sont des notebooks contenant des définitions de variables et fonctions qu'on peut
charger dans le noyau sans ouvrir explicitement ces notebooks. Pour charger les définitions qu'ils contiennent, on
emploie la commande Get dont le raccourci est << (ou éventuellement Needs), suivie du nom du package.
11.1 Les packages ou Add-ons existants (standard)
On trouvera dans l'aide interactive, toute la documentation relative aux packages disponibles sur votre installation qui,
par défaut, comprend des packages standard appelés "Standard Extra Packages". La figure suivante montre par exemple
la page d'accueil du package Hypothesis Testing qui contient des définitions pour réaliser des tests statistiques
d'hypothèses.
Pour charger en mémoire le contenu de ce package, on validera l'instruction suivante :
<< HypothesisTesting`
Cela donne accès à des fonctions nouvelles comme les suivantes :
11. Packages 157
? MeanTest
MeanTest A list , m0E performs a test with null hypothesis m = m
0.!à
? MeanCI
MeanCI @ list D gives a confidenceinterval for the population mean estimated from list .!à
Que l'on peut désormais utiliser comme si elles faisaient partie du noyau de calcul :
Mathematica 7 est livré avec 50 packages standard dont l'encadré suivant donne la liste. Ces packages représentent près
de 2000 fonctions supplémentaires que l'on a pas voulu intégrer au noyau pour ne pas le surcharger. Les utilisateurs qui
utilisent ou viennent d'une version de Mathematica inférieure à la version 7 noteront que de nombreuses fonctions
autrefois disponibles dans un package standard sont dorénavant intégrées au noyau. C'est par exemple le cas de la
plupart des fonctions statistiques qui figuraient dans toute une famille de packages.
Audio` MultivariateStatistics`
Benchmarking` Music`
BlackBodyRadiation` Notation`
Calendar` NumericalCalculus`
Combinatorica` NumericalDifferentialEquationAnaly-
sis`
ComputationalGeometry` PacletManager`
ComputerArithmetic` PhysicalConstants`
Developer` PlotLegends`
DiscreteMath`CombinatorialFunction-
s`
PolyhedronOperations`
DiscreteMath`Combinatorica` Polytopes`
DiscreteMath`ComputationalGeometry` PrimalityProving`
DiscreteMath`GraphPlot` Quaternions`
DiscreteMath`IntegerPartitions` ResonanceAbsorptionLines`
DiscreteMath`Tree` Splines`
EquationTrekker` StandardAtmosphere`
ErrorBarPlots` StatisticalPlots`
Experimental` Units`
FiniteFields` VariationalMethods`
FourierSeries` VectorAnalysis`
FunctionApproximations` WebServices`
GraphUtilities` WorldPlot`
GUIKit` XML`
HierarchicalClustering` XML`MathML`
HypothesisTesting` XML`NotebookML`
JLink` XML`Parser`
Packages standard de Mathematica dans sa version 7
11.2 La notion de contexte
Les contextes servent à organiser les noms donnés aux symboles (variables et fonctions) dans différentes catégories
permettant d'éviter notamment les conflits entre symboles. Cette notion prend toute son importance dans les packages
qui, lors de leur chargement, introduisent de nouvelles fonctions dans le noyau qui ne doivent pas entrer en conflit avec
des fonctions internes ou avec des fonctions créées par l'utilisateur au cours d'une session.
Redémarrons le noyau de Mathematica (commande menu : Evaluation!/!Quit Kernel / Local) et poursuivons.
158 11. Packages
Redémarrons le noyau de Mathematica (commande menu : Evaluation!/!Quit Kernel / Local) et poursuivons.
Chaque symbole est attaché à un contexte. Par exemple, les fonctions du noyau sont attachées au contexte System` :
Context@PlusD
System`
Context@IntegrateD
System`
Tandis que les symboles créés par un utilisateur sont créés dans le contexte Global` :
truc = 5;
Context@trucD
Global`
En pratique, le nom qu'on utilise pour désigner un symbole n'est que la partie émergée du nom complet donné au
symbole, ce nom complet étant constitué du contexte suivi du nom donné au symbole de la manière suivante :
Context`NomCourt. Ainsi on peut interroger Mathematica sur System`Plus :
? System`Plus
x+ y+ z represents a sum of terms. !à
Qui est strictement identique à Plus :
? Plus
x+ y+ z represents a sum of terms. !à
Cela permet d'envisager la création d'un nouveau symbole Plus, dans un contexte différent sans introduire de conflit :
Global`Plus@x_, y_D := x * y;
Et je peux utiliser cette définition en utilisant son nom complet :
Global`Plus@5, 7D
35
Par contre, si j'appelle la fonction standard, c'est l'opérateur Plus du noyau qui est utilisé (comportement qui a été
fort heureusement modifié depuis la version 6 de Mathematica)
Plus@5, 7D
12
Plus est maintenant le nom court de deux symboles : System`Plus et Global`Plus!et Mathematica doit choisir
lequel utiliser. Pour cela, Mathematica conserve en mémoire et dans un certain ordre une liste des contextes chargés en
mémoire. A l'appel d'un symbole, Mathematica cherche s'il se trouve dans l'un des contextes donnés par la variable
$ContextPath et dans l'ordre dans lequel ils apparaissent dans cette liste :
$ContextPath
8PacletManager`, WebServices`, System`, Global`<
Pour supprimer le symbole Global`Plus, on pourra tout simplement utiliser l'instruction suivante!:
11. Packages 159
Remove@Global`PlusD
Mais revenons aux packages. Comme nous allons le voir, il permettent la création de symboles dans de nouveaux
contextes, évitant ainsi les conflits éventuels avec des symboles existants ou permettant, dans certains cas, de modifier ou
compléter temporairement les définitions de symboles existants.
En effet, quand on charge un package, on fait entrer dans la mémoire du noyau de Mathematica des nouveaux symboles
(fonctions et variables) définis dans de nouveaux contextes. Ainsi, si l'on charge le package suivant :
<< StandardAtmosphere`
On accède à des nouveaux symboles comme le symbole Quartiles :
? AtmosphericPlot
AtmosphericPlot @ property D generates a plot of the specifiedproperty property as a function of geometric altitude. !à
? Pressure
Pressure @ altitude D gives the totalatmospheric pressure at the specified altitude altitude .!à
Dont le contexte est :
Map@Context, 8AtmosphericPlot, Pressure<D
8StandardAtmosphere`, StandardAtmosphere`<
Mathematica connaît donc maintenant les contextes suivants et on peut noter, dans ce cas précis, qu'un nouveau
contexte a fait son apparition (Units`), chargé directement lors du chargement du package
StandardAtmosphere`!:
$ContextPath
8StandardAtmosphere`, Units`,
PacletManager`, WebServices`, System`, Global`<
Et à l'appel d'un symbole, Mathematica regarde d'abord s'il est défini dans le contexte StandardAtmosphere`, puis
dans les différents contextes jusqu'aux contextes System` et Global`selon l'ordre donné dans $ContextPath.
AtmosphericPlot@PressureD
-10 -8 -6 -4 -2 0 2
0
200
400
600
800
1000
Log@10, PressureD
Altitude,Km
160 11. Packages
Puisque le contexte Units` a été chargé, on peut également appelé l'une des fonctions qui sont définies dans ce
contexte comme dans les deux cas suivants :
ConvertTemperature@20, Fahrenheit, CentigradeD êê N
-6.66667
SI@3 AtmosphereD
303 975. Pascal
$AddOnsDirectory
êLibraryêMathematica
11.3 Programmation d'un package
Physiquement, un package est un notebook Mathematica contenant des cellules dites d'initialisation (propriété qu'on
peut fixer manuellement au moyen de la commande menu Cell!/ Cell!Properties!/ Initialization!Cell) ce qui permet à
Mathematica d'exécuter automatiquement tout ce qu'elle contient à l'ouverture du fichier (ou plus simplement à la lecture
du fichier au moyen de la commande Get).
Par ailleurs, un package contient un certain nombre d'instructions particulières permettant de créer de nouveaux
contextes dans lesquels seront définis les symboles souhaités. Observons par exemple la structure du package
PhysicalConstants` (les "..." indiquent des lignes ou des instructions omises) :
...
BeginPackage@"PhysicalConstants`", "Units`"D;
...
PlanckConstant::usage =
"PlanckConstant is a universal constant of nature which
relates the energy of a quantum of radiation to the
frequency of the oscillator which emitted it."D;
...
Begin@"`private`"D;
...
NeutronMagneticMoment = -0.96623641*^-26 Joule ê Tesla H* CODATA 2006 *L
NeutronMass = 1.674927211*^-27 Kilogram H* CODATA 2006 *L
PlanckConstant = 6.62606896*^-34 Joule Second H* CODATA 2006 *L
PlanckConstantReduced = PlanckConstant ê H2 PiL H* definition *L
PlanckMass = 2.17644*^-8 Kilogram H* CODATA 2006 *L
ProtonComptonWavelength = 1.3214098446*^-15 Meter H* CODATA 2006 *L
...
End@ D;
...
EndPackage@ D;
La commande BeginPackage["PhysicalConstants`"], permet de créer et de se placer dans un nouveau
contexte. Le 2e argument utilisé (ici "Units`"), qui est facultatif, indique le package fait appel à des définitions se
trouvant le package Units`.
Après cette première ligne, tous les symboles nouveau inconnus de Mathematica, seront donc définis dans le contexte
PhysicalConstants`. C'est le cas du symbole PlanckConstant qui apparaît en dessous. La syntaxe ::usage
sert à définir l'aide en ligne des symboles créés, c'est-à-dire ce que renvoie Mathematica à l'appel de
?!PlanckConstant.
11. Packages 161
Après cette première ligne, tous les symboles nouveau inconnus de Mathematica, seront donc définis dans le contexte
PhysicalConstants`. C'est le cas du symbole PlanckConstant qui apparaît en dessous. La syntaxe ::usage
sert à définir l'aide en ligne des symboles créés, c'est-à-dire ce que renvoie Mathematica à l'appel de
?!PlanckConstant.
Les symboles créés entre l'instruction BeginPackage et l'instruction Begin ont un caractère public. Cela signifie
qu'ils seront accessibles à l'utilisateur sans l'indication explicite du contexte, c'est à dire par leur nom court.
L'instruction Begin["`private`"] (noter le ` placé avant et après) permet de créer un sous-contexte (on peut
utiliser n'importe quel autre nom que private), c'est à dire de nous placer, pour tous les nouveaux symboles qui seront
créés par la suite, dans le contexte PhysicalConstants`private`. Ces symboles n'auront pas de caractère public
(à cause de l'utilisation de Begin), c'est-à-dire qu'il ne seront pas accessibles en nom court, mais en nom complet
uniquement. C'est dans ce sous-contexte que seront créées toutes les fonctions intermédiaires (inutiles pour l'utilisateur)
servant à la programmation des fonctions publiques. L'instruction End permet de quitter le sous-contexte courant pour
revenir au context supérieur (ici PhysicalConstants`), on définit alors éventuellement les attributs des symboles
publics, on les protège (Protect) et on termine le package au moyen de l'instruction EndPackage, qui permet de
quitter le contexte précédent pour revenir au context courant qui précédait le chargement du package, c'est à dire
généralement le context Global`. On peut résumer tout cela par le schéma suivant :
(* Commentaires pour décrire le package *)
BeginPackage["Context`"]
Description des fonctions (ou symboles) du package. Les fonctions décrites ici seront d'office considérées comme des fonctions publiques,
c'est-à-dire utilisables dans une session Mathematica comme toute autre fonction interne, après chargement du package.
Begin["`private`"]
Définition des fonctions et de leur options. Les fonctions qui apparaissent ici et dont l'usage n'a pas été indiqué avant la commande
Begin sont des fonctions privées. Elles ne sont pas utilisables en dehors du package en tapant leur nom court, mais elles restent
accessibles à condition de taper leur nom long (Context`private`nom)
End[]
Définition des attributs des fonctions
Protection des symboles
EndPackage[]
Structure d'un package
L'instruction BeginPackage["Context`"] permet donc de changer le contexte courant au moment du
chargement du package pour qu'y soient placés les nouveaux symboles définis par la suite, jusqu'à la commande Begin.
Par convention, on donnera au contexte le nom du notebook dans lequel le package est créé, précédé éventuellement
du nom du répertoire dans lequel il sera placé si vous décomposer vos programmes en sous-fichiers pour plus de lisibilité.
Par exemple, le contexte NumericalMath`NLimit`est défini dans un notebook nommé NLimit.m, placé dans un
répertoire nommé NumericalCalculus, lui même placé dans le répertoire AddOns!/!Packages.
Sur Macintosh, pour consulter les packages standard, il faut "Afficher le contenu du paquet" en cliquant sur l'icône de
Mathematica comme illustré sur l'image ci-dessous :
162 11. Packages
On peut alors dérouler l'arborescence jusqu'à sélectionner par exemple le package NLimit` :
Quant aux packages que vous créerez vous-mêmes, il faudra les placer dans le répertoire Application que vous trouverez
dans l'un des répertoires donnés par les instructions suivantes (le premier pour tous les utilisateurs de la machine, le
deuxième pour vous-mêmes uniquement)
$AddOnsDirectory
êLibraryêMathematica
$UserAddOnsDirectory
êUsersêverdelêLibraryêMathematica
Comme mentionné au début de ce chapitre, toutes les instructions d'un package doivent être placées dans un nouveau
cahier contenant des cellules ayant l'option Initialization Cell activée (menu Cell!/ Cell Properties). En pratique,
on écrira nos définitions dans un nouveau notebook standard, on activera l'option Initialization Cell aux
cellules qui doivent figurer dans le package et on enregistrera le fichier. A ce moment, Mathematica affichera la fenêtre
suivante indiquant que Mathematica propose de créer automatiquement un package.
11. Packages 163
On choisira de répondre : Yes, et Mathematica se chargera de créer un fichier avec l'extension .m (pour package) lié au
fichier de travail. Chaque modification dans le fichier de travail (dont l'extension est .nb) modifiera automatiquement le
package correspondant. On pourra ainsi inclure dans le fichier de travail tous les commentaires supplémentaires
souhaités qui ne figureraient pas dans le package (à condition de ne pas déclarer les cellules de commentaires comme
cellule d'initialisation).
L'illustration suivante montre que les deux fichiers liés (denommés Perso.m et Perso.nb) ont été créés puis placés dans le
répertoire des applications :
On pourra dès lors accéder aux fonctions définies dans ce package sans même ouvrir le fichier qui les contient comme
indiqué ci-dessous :
<< Perso`
? mafonction
mafonction est une fonction test
mafonction@5D
CosBSin@5D
5F
164 11. Packages
11.4 Exercices
11.4.1 NormalPlot
Programmer une fonction NormalPlot[m,s] qui dessine la densité de probabilité de la loi normale de moyenne met d'écart-type s, la variable allant de m-4s à m+4s. La représentation graphique ne comportera pas d'axe vertical, mais
une ligne pointillée indiquant la moyenne, comme dans l'exemple suivant. Par ailleurs, on ne fera pas appel aux Add-
Ons Statistics`. Pour information, la densité de probabilité d'une loi normale de moyenne m et d'écart-type s
vaut!: ‰
-Hx-mL2
2 s2
2 p s
.
NormalPlot@10, 3D
0 5 10 15 20
11.4.2 NormalPlot avec des options
Ajouter maintenant les options LeftProba, RightProba et MiddleProba à la fonction NormalPlot,
permettant d'ajouter au dessin précédent, la ou les zones de probabilité indiquées par ces options, comme dans les
exemples suivants :
NormalPlot@10, 3, LeftProba Ø 0.05D
0 5 10 15 20
11. Packages 165
NormalPlot@10, 3, LeftProba Ø 0.05, RightProba Ø 0.05D
0 5 10 15 20
Ü Graphics Ü
NormalPlot@10, 3, MiddleProba Ø 0.9D
0 5 10 15 20
Ü Graphics Ü
NormalPlot@10, 3, LeftProba Ø 0.05, RightProba Ø 0.05, MiddleProba Ø 0.5D
0 5 10 15 20
Ü Graphics Ü
11.4.3 Package
Préparer maintenant un package contenant cette fonction qu'on documentera. Tester le package après avoir placé lefichier créé dans le répertoire dédié aux packages. S'il reste du temps, développer cet exercice au choix.
166 11. Packages
Chapitre 12
Interactivité
168 12. Interactivité
12 Interactivité
Depuis sa version 3, Mathematica s'est enrichi de nombreuses fonctions permettant de programmer ou d'interagir avec
des notebooks. Au fil des versions successives, ces fonctions ont été progressivement rationalisées et simplifiées de sorte
qu'il est devenu de plus en plus simple d'ajouter ou de créer liens, boutons et palettes, des graphiques interactifs ou
encore d'agir interactivement avec toutes sortes d'expressions.
Il faudrait probablement un ouvrage tout entier pour décrire et expliquer toutes les possibilités offertes aujourd'hui par
Mathematica dans ce domaine. Dans ce chapitre, nous nous limiterons donc à présenter un aperçu des méthodes
permettant de créer différentes formes d'interactivité afin d'enrichir l'expérience utilisateur.
12.1 Vues multiples
Par vues multiples nous entendons la possibilité, par le biais de quelques commandes particulières, d'afficher plusieurs
résultats préprogrammés de manière interactive. L'encadré suivant donne la liste de ces fonctions (elles sont
interchangeables avec la syntaxe par défaut) dont nous montrons quelques exemples par la suite. L'aide interactive de
Mathematica en montre beaucoup d'autres.
FlipView Vues multiples par feuilletage Hon passe d'une vue à l'autre en cliquant sur la vue couranteL
MenuView Vues multiples par dont le contrôleur est choisi dans un menu
Popupview Vues multiples placées elles-mêmes dans un menu
SlideView Vues multiples avec boutons suivants et précédents
TabView Vues multiples par tabulations
Différentes façons de présenter plusieurs résultats dans un même cadre
TabView@Table@Plot@Sin@n xD, 8x, 0, 10<D, 8n, 5<DD
2 4 6 8 10
-1.0
-0.5
0.5
1.0
1 2 3 4 5
Avec la possibilité, dans ce cas, de personnaliser l'intitulé des boutons :
12. Interactivité 169
TabView@Table@Sin@n xD -> Plot@Sin@n xD, 8x, 0, 10<D, 8n, 5<DD
2 4 6 8 10
-1.0
-0.5
0.5
1.0
Sin@xD Sin@2 xD Sin@3 xD Sin@4 xD Sin@5 xD
12.2 Interactivité avec les expressions : la fonction Manipulate
Mathematica propose quelques outils permettant d'afficher ou d'agir interactivement avec des expressions en y faisant
varier un ou plusieurs paramètres, grâce à la fonction Manipulate dont la syntaxe rappelle celle de Table :
Manipulate@x, 8x, 0, 1<D
x
0.613
Manipulate@Factor@x^n - 1D, 8n, 10, 100, 1<D
n
H-1 + xL H1 + xL I1 - x + x2 - x3 + x4M I1 + x + x2 + x3 + x4M
Le déplacement du curseur permet de faire varier la valeur du paramètre n, exposant de x dans l'expression :
170 12. Interactivité
n
H-1 + xL I1 + x + x2 + x3 + x4M
I1 + x + x2 + x3 + x4 + x5 + x6M I1 - x + x5 - x6 + x7 - x8 +
x10 - x11 + x12 - x13 + x14 - x16 + x17 - x18 + x19 - x23 + x24M
Cette fonction peut-être utilisée pour toutes sortes d'expressions comme le montrent les exemples ci-dessous :
Manipulate@Plot@Sin@a x + bD, 8x, 0, 6<D, 8a, 1, 10<, 8b, 0, 10<D
a
b
1 2 3 4 5 6
-1.0
-0.5
0.5
1.0
Dans le cas des graphiques et pour optimiser l'affichage et rendre les modifications interactives compréhensibles, il
faudra souvent ajuster les options comme dans l'exemple ci-dessous dans lequel on fixe les bornes du graphique une fois
pour toutes :
12. Interactivité 171
Manipulate@Plot@Sin@a x + bD ê x, 8x, 0, 6<, PlotRange Ø 8All, 8-5, 10<<D,
8a, 1, 10<, 8b, 0, 10<D
a
b
1 2 3 4 5 6
-4
-2
2
4
6
8
10
Voici un exemple tiré de l'aide de Mathematica et concernant une fonction à 2 variables dans laquelle les paramètres q1
et q2 peuvent varier de -3 à 3 (valeur par défaut égale à -1 pour q1 et à 1 pour q2) tandis que le paramètre p désigne la
position de deux points (positions initiales {-1,0} et {1, 0}) qu'on peut déplacer interactivement sur l'écran :
172 12. Interactivité
Manipulate@ContourPlot@q1 ê Norm@8x, y< - p@@1DDD + q2 ê Norm@8x, y< - p@@2DDD,
8x, -2, 2<, 8y, -2, 2<, Contours Ø 10D, 88q1, -1<, -3, 3<, 88q2, 1<, -3, 3<,
88p, 88-1, 0<, 81, 0<<<, 8-1, -1<, 81, 1<, Locator<, Deployed Ø TrueD
q1
q2
12.3 Boutons
Là encore, apparue avec la version 3, l'utilisation des boutons a été rendue progressivement plus simple au fil des
versions supérieures de Mathematica. Voici, pour commencer, un exemple simple de bouton utilisant la commande
Button dont le premier argument est l'intitulé et le second, l'action à réaliser :
Button@"Cliquez ici", Print@10!DD
Cliquez ici
3 628 800
Button@"Afficher la date", Print@DateString@DDD
Afficher la date
Fri 18 Sep 2009 15:50:01
Le bouton suivant active la palette de sélection d'une couleur :
12. Interactivité 173
Le bouton suivant active la palette de sélection d'une couleur :
Button@"Palette de couleur", SystemDialogInput@"Color"DD
Palette de couleur
L'apparence par défaut dépend du système d'exploitation utilisé. Mais elle peut être personnalisée :
Map@Button@"bouton", Null, Appearance Ø ÒD &,
8"DialogBox", "Palette", "Frameless", 8"DialogBox", "Pressed"<<D
: bouton , bouton , bouton, bouton >
Dans l'exemple suivant, le fait de survoler le bouton change le texte et son style (à tester dans une session Mathematica) :
Button@Mouseover@"Cliquez sur ce texte", Style@"Résultat", RedDD,
1, Appearance Ø NoneD
Cliquez sur ce texte
Enfin, dans l'exemple suivant inspiré de l'aide de Mathematica, nous montrons comment un bouton peut prendre la
forme d'un hyperlien (mais il y a d'autres manières de faire, notamment via la commande menu Insert > Hyperlink). Dans
ce cas, il faut effectivement activer cette commande dans une session mathematica pour en constater le fonctionnement.
Button@Mouseover@Style@"http:êêwww.thierry-verdel.com", "Hyperlink"D,
Style@"http:êêwww.thierry-verdel.com", "HyperlinkActive"DD,
NotebookLocate@8URL@"http:êêwww.thierry-verdel.com"D, None<D,
Appearance Ø NoneD
http:êêwww.thierry-verdel.com
Ce résultat peut également être obtenu plus simplement avec la commande Hyperlink :
Hyperlink@"http:êêwww.thierry-verdel.com",
"http:êêwww.thierry-verdel.com", BaseStyle Ø "Text"D
http:êêwww.thierry-verdel.com
Button Bouton standard
PasteButton Bouton simple renvoyant son contenu
ButtonBar Barre de boutons
RadioButton Bouton prenant la forme d'un radio bouton
ActionMenu Bouton prenant la forme d' un menu à choix multiples
Quelques uns des types de boutons disponibles
12.4 Dialogues
Mathematica propose plusieurs types de dialogues avec l'utilisateur. L'encadré suivant donne la liste des commandes qui
permettent de les afficher :
MessageDialog Affiche un message dans une fenêtre
ChoiceDialog Affiche une fenêtre proposant plusieurs choix prédéfinis
174 12. Interactivité
Affiche une fenêtre proposant plusieurs choix prédéfinis
DialogInput Affiche une fenêtre proposant de
choisir la valeur d' un paramètre et renvoie le résultat
CreateDialog Affiche une fenêtre proposant de choisir la valeur d ' un paramètre,
mais laisse Mathematica continuer l ' évaluation en cours
DialogNotebook Création d' une fenêtre de dialogue plus générale
Principaux types de dialogues avec l'utilisateur
Commençons par la fenêtre de message, la plus simple à mettre en oeuvre :
MessageDialog@"Attendez la fin du calcul qui peut prendre du temps"D;
Avec la commande ChoiceDialog, nous devons définir les différents choix possibles, donnés en 2e argument de la
commande. La réponse à l'instruction est alors la valeur correspondant donnée dans la règle de substitution :
res = ChoiceDialog@"Choisir votre valeur",
8"x=1" Ø 1, "x=2" Ø 2, "x=3" Ø 3, "x=4" Ø 4<D;
res
1
La commande DialogInput permet quant à elle la création d'une fenêtre de dialogue personnalisée. Notez
l'utilisation de la commande Dynamic que nous reverrons par la suite plus en détail. Ce premier exemple invite
l'utilisateur à entrer une valeur mémorisée temporairement dans la variable val (variable locale) et Mathematica attend
que l'utilisateur valide sa réponse avant de poursuivre tout calcul (le résultat est alors affecté au symbole res). Le
premier argument de la commande DialogInput est optionnel. Il permet ici d'initialiser la valeur à afficher à la
valeur "vide" et de la définir comme variable locale :
res = DialogInput@8val = ""<, Column@8"Choisir une valeur",
InputField@Dynamic@valD, NumberD, Button@"OK", DialogReturn@valDD<DD;
8res, val<
812, val<
A la différence de la commande DialogInput, la commande CreateDialog, qui fait sensiblement la même
chose, n'interrompt pas le calcul en cours (ce que l'on peut constater en observant le crochet de la cellule qui contient
cette instruction au moment où elle est validée). Du coup, l'instruction ne renvoie aucun résultat (pas d'équivalent de res
utilisé dans le cas précédent) et la valeur choisie n'est mémorisée que dans la variable val :
res = CreateDialog@8TextCell@"Entrez une valeur "D,
InputField@Dynamic@valD, NumberD, DefaultButton@DialogReturn@valDD<D;
12. Interactivité 175
8res, val<
:NotebookObjectB 22 F, 12>
Dans l'exemple suivant, CreateDialog permet de sélectionner une valeur en faisant glisser un curseur :
CreateDialog@8TextCell@"Choisir la valeur de x"D,
ExpressionCell@Dynamic@xDD, Slider@Dynamic@xD, 80, 1<D<D;
x
0.864
Avec la commande DialogNotebook on peut créer plusieurs éléments d'interface (dans le notebook courant ou
dans un nouveau notebook), comme le montre l'exemple suivant, inspiré de l'aide de Mathematica :
DialogNotebook@
Grid@88
Column@8
Row@8"n ", Slider@Dynamic@nD, 80, 1<D, " ", Dynamic@nD<D,
Row@8"m ", Slider@Dynamic@mD, 81, 8, 1<D, " ", Dynamic@mD<D<D,
Slider2D@Dynamic@ptDD<,
8Row@8RadioButton@Dynamic@rD, 1D, RadioButton@Dynamic@rD, 2D,
RadioButton@Dynamic@rD, 3D, Dynamic@rD<D,
Dynamic@ptD<<DD
n 0.697
m 3
2 80.83, 0.695<
8n, m, r, pt<
80.697, 3, 2, 80.83, 0.695<<
176 12. Interactivité
12.5 Variables dynamiques
Les variables dynamiques sont au coeur des processus d'interactivité apparus récemment dans Mathematica. Nous en
présentons le principe ci-dessous à travers quelques exemples. Là encore, l'aide interactive de Mathematica fournit de
nombreuses explications supplémentaires auxquelles le lecteur pour se référer pour aller plus loin.
Dynamic@exprD Permet de rendre expr dynamique
DynamicModule@8x, y, ...<, exprD Permet de localiser les variables dynamiques x, y, ...
Fonctions pour rendre dynamiques des expressions
La commande Dynamic exige au minimum un argument : le nom de la variable dynamique ou de l'expression
dynamique. Le 2e argument, qui est optionnel, permet d'évaluer une expression dynamiquement :
Clear@hD; Dynamic@hD
0.5
h = 0.5
0.5
Dans l'exemple précédent, la première instruction renvoie initialement le symbole h mais ce résultat est
automatiquement mis à jour quand la valeur 0.5 est ensuite affecté à h dans la 2e instruction. De même, dans l'exemple
suivant, la valeur de k est dynamiquement modifée en déplaçant le curseur :
8Slider@Dynamic@kD, 80, 10<D, Dynamic@kD<
: , 6.89>
k
6.89
La commande DynamicModule permet quant à elle de localiser les variables dynamiques comme le montre
l'exemple suivant où l'on peut vérifier que la variable dynamique z est bien une variable locale au module dynamique.
DynamicModule@8z<, 8Slider@Dynamic@zD, 80, 10<D, Dynamic@zD<D
: , 6.67>
z
z
Différentes utilisations de la commande Dynamic sont possibles. Par exemple, la valeur dynamique peut n'être
affichée qu'après le processus de sélection. Ainsi, dans l'exemple suivant, la valeur de t ne s'affiche qu'après avoir déplacé
le curseur (à tester dans une session Mathematica) :
8Slider@Dynamic@t, TemporaryDD, Dynamic@tD<
: , 0.736>
L'exemple suivant est plus subtil. On y indique, en 2e argument de Dynamic, les fonctions à évaluer avant (i prend la
valeur initiale de u), pendant (u égal à lui-même) et après le processus d'interactivité (j prend la valeur finale de u) :
12. Interactivité 177
u = 0.5; 8Slider@Dynamic@u, 8Hi = uL &, Hu = ÒL &, Hj = uL &<DD, Dynamic@uD<
: , 0.332>
8i, j<
80.5, 0.332<
Ces fonctions permettent de construire des éléments d'interface dynamique comme dans l'exemple suivant inspiré d'un
exemple donné dans l'aide interactive de Mathematica :
DynamicModule@8a = 0, b = 0, s = 884, 10<, 81, Infinity<<<,
Deploy@Style@Panel@Grid@Transpose@88Style@"Choisir un nombre", RedD,
Style@"Choisir un autre nombre", RedD, "Somme",
"Différence", "Produit"<, 8InputField@Dynamic@aD, NumberD,
InputField@Dynamic@bD, NumberD, InputField@Dynamic@a + bD,
Enabled Ø FalseD, InputField@Dynamic@a - bD, Enabled Ø FalseD,
InputField@Dynamic@a bD, Enabled Ø FalseD<<D,
Alignment Ø RightD, ImageMargins Ø 10D, DefaultOptions Ø
8InputField Ø 8ContinuousAction Ø True, FieldSize Ø s<<DDD
Choisir un nombre 10
Choisir un autre nombre 20
Somme 30
Différence -10
Produit 200
Les variables dynamiques peuvent également être introduites dans des graphiques. Pour interagir dynamiquement
avec un graphique, on utilisera la commande Locator qui permet d'afficher une cible déplaçable par l'utilisateur. Dans
cet exemple, la fonction graphique Text permet d'afficher dynamiquement les coordonnées du point p :
178 12. Interactivité
DynamicModule@8p = 80, 0<<,
Graphics@8Locator@Dynamic@pDD, Text@Dynamic@pD, 80, 1<, 80, 2<D<,
Frame Ø True, PlotRange Ø 1DD
L'exemple suivant montre le calcul et l'affichage interactif de la distance entre 2 points déplaçables :
DynamicModule@8p1 = 80, 0<, p2 = 81, 1<<,
Graphics@
8Dynamic@Line@8p1, p2<DD, Locator@Dynamic@p1DD, Locator@Dynamic@p2DD,
Dynamic@Text@EuclideanDistance@p1, p2D, Hp1 + p2L ê 2DD<,
PlotRange Ø 2, Frame Ø TrueDD
Dans l'exemple précédent, nous aurions pu utiliser la commande Dynamic devant chaque point p1 et p2 mais il est
plus simple d'y faire figurer directement l'ensemble des commandes graphiques faisant référence à ces points comme
nous l'avons fait. Par contre, pour que l'interactivité fonctionne correctement, l'argument de Locator doit utiliser la
commande Dynamic.
Différentes manières d'écrire ce programme sont possibles. Dans l'exemple suivant, nous décomposant les calculs à la
manière de ce que nous avons vu dans un chapitre précédent avec la commande Module :
12. Interactivité 179
DynamicModule@8p1 = 80, 0<, p2 = 81, 1<, d, line, text, loc1, loc2<,
d = Dynamic@EuclideanDistance@p1, p2DD;
line = Dynamic@Line@8p1, p2<DD;
text = Dynamic@Text@d, Hp1 + p2L ê 2DD;
loc1 = Locator@Dynamic@p1DD;
loc2 = Locator@Dynamic@p2DD;
Graphics@8line, loc1, loc2, text<, PlotRange Ø 2, Frame Ø TrueDD
Dans l'exemple suivant, nous interagissons directement avec un objet graphique en déplaçant les cibles :
DynamicModule@8p1 = 80, 0<, p2 = 80, 1<, p3 = 81, 1<, loc1, loc2, loc3, tri<,
loc1 = Locator@Dynamic@p1DD;
loc2 = Locator@Dynamic@p2DD;
loc3 = Locator@Dynamic@p3DD;
tri = Dynamic@8Red, Polygon@8p1, p2, p3<D<D;
Graphics@8tri, loc1, loc2, loc3<, PlotRange Ø 2, Frame Ø TrueDD
On peut également supprimer l'affichage des cibles grâce à l'option Appearance de la commande Locator sans
affecter la possibilité de déplacer les sommets du triangle :
180 12. Interactivité
DynamicModule@8p1 = 80, 0<, p2 = 80, 1<, p3 = 81, 1<, loc1, loc2, loc3, tri<,
loc1 = Locator@Dynamic@p1D, NoneD;
loc2 = Locator@Dynamic@p2D, NoneD;
loc3 = Locator@Dynamic@p3D, NoneD;
tri = Dynamic@8Red, Polygon@8p1, p2, p3<D<D;
Graphics@8tri, loc1, loc2, loc3<, PlotRange Ø 2, Frame Ø TrueDD
Voici enfin un exemple adapté de l'aide interactive dans lequel une contrainte est imposée au déplacement de la cible.
Pour interagir avec le graphique, il suffit de cliquer puis de déplacer le sommet de la flèche :
DynamicModule@8angle = 0, p = 81, 0<, loc, text<,
loc = Locator@Dynamic@p,
Hangle = Apply@ArcTan, ÒD; p = 8Cos@angleD, Sin@angleD<L &D, NoneD;
text = Dynamic@Text@angle, 0.4 * p, 80, 0<DD;
Graphics@8Circle@D, [email protected], Arrow@Dynamic@880, 0<, p<DD,
loc, text<, PlotRange Ø 88-1.2, 1.2<, 8-1.2, 1.2<<DD
D'autres outils permettent de fabriquer ainsi des interactions sur des objets graphiques comme indiqué dans l'encadré
suivant.
Locator@Dynamic@posDD Représente une cible interactive dans un graphique
Locator@Dynamic@posD, objD Affiche la cible sous la forme de obj
Locator@Dynamic@posD, NoneD La cible n ' est plus visible
12. Interactivité 181
La cible n ' est plus visible
LocatorPane@
Dynamic@8pt1, pt2, ...<D, backD
Représente un panneau avec des cibles
en position pt1 et pt2 et back en arrière plan
ClickPane@image, fonctionD Représente un panneau cliquable
qui affiche une image et applique la
fonction aux coordonnées de chaque clic
EventHandler@expr,
8ev1 ß action1, ev2 ß action2, ...<D
Commande Hdont ClickPane est un cas particulierL
permettant d ' afficher une expression
dynamique dépendant de l ' action
déclenchée par chaque événement
Commandes pour fabriquer des interactions dynamiques
A la différence de Locator qu'on place dans la commande Graphics, dans l'exemple suivant, on place le
Graphics dans le LocatorPane :
DynamicModule@8p = 881, 1< ê 2, 8-1, 1< ê 2<<,
8LocatorPane@Dynamic@pD, Graphics@8Blue, Disk@D<DD, Dynamic@pD<D
: , 88-0.394, -0.36<, 80.446, 0.52<<>
Quant à la commande ClickPane, elle permet d'interagir avec un objet graphique au moment où l'on clique sur
l'image comme dans l'exemple suivant où le disque apparaît à l'endroit où l'on a cliqué :
182 12. Interactivité
DynamicModule@8pt = 80, 0<, d, text<,
d = Dynamic@Disk@ptDD;
text = Dynamic@Text@pt, ptDD;
ClickPane@
Framed@Graphics@8Blue, d, Black, text<, PlotRange Ø 5, ImageSize Ø SmallDD,
Hpt = ÒL &DD
82.2037, -2.22486<
On peut procéder de même en utilisant des fonctions graphiques préprogrammées comme ci-dessous où la fonction
placée en 2e argument de ClickPane renvoie l'abcisse du point cliqué, notée u, par ailleurs défini comme la borne
supérieure de la variable t utilisée dans la fonction représentée. Ainsi, le dessin de la courbe s'arrête à l'abcisse du point
cliqué :
DynamicModule@8u = 10, plo<,
plo = Dynamic@Plot@Sin@2 tD, 8t, 0, u<,
PlotRange Ø 880, 10<, 8-1, 1<<, ImageSize Ø SmallDD;
ClickPane@plo, Hu = Ò@@1DDL &DD
2 4 6 8 10
-1.0
-0.5
0.0
0.5
1.0
Enfin, nous adaptons ci-après un excellent exemple donné dans l'aide interactive pour illustrer l'utilisation de la
commande EventHandler. Cet exemple dessine en temps réel la droite des moindres carrés d'un ensemble de points
créés en cliquant plusieurs fois sur le graphique. Dans un premier temps nous définissions la fonction lineFit dont
l'argument est une liste de points et le résultat la droite des moindres carrés.
lineFit@points_D := Module@8x, lf<,
lf = Apply@Function, 88x<, Fit@points, 8x, 1<, 8x<D<D;
Line@88-1, lf@-1D<, 81, lf@1D<<DD;
Ensuite, nous dessinons un graphique dynamique comprenant un ensemble de points (p) et une droite (l). Ce
graphique est affiché par la commande EventHandler dont le 2e argument indique la fonction à évaluer après
chaque clic. En l'occurence, après chaque clic, cette fonction consiste à ajouter le point cliqué à l'ensemble des points,
puis, quand le nombre de points atteint ou dépasse la valeur 2, à calculer et retourner la droite des moindres carrés
fabriqués à partir de l'ensemble des points (p), actualisant ainsi le graphique dessiné. Pour faire fonctionner ce graphique
interactif, il suffit de cliquer plusieurs fois de suite sur le graphique.
12. Interactivité 183
DynamicModule@8p = 8<, l = 8<, gra<,
gra = Dynamic@
Graphics@8Point@pD, l<, PlotRange Ø 1, Frame Ø True, ImageSize Ø SmallDD;
EventHandler@gra, "MouseClicked" ß
HAppendTo@p, MousePosition@"Graphics"DD;
If@Length@pD ¥ 2, l = lineFit@pDDLDD
-1.0 -0.5 0.0 0.5 1.0-1.0
-0.5
0.0
0.5
1.0
On pourra aller beaucoup plus loin dans l'utilisation des fonctions permettant de créer des interactions en s'aidant de
l'aide de Mathematica ou en consultant des ouvrages plus spécialisés consacrés à Mathematica.
12.6 Les projets de démonstration
Il est possible de transformer une animation interactive en projet de démonstration (utilisable sans disposer de
Mathematica) en plaçant les commandes nécessaires dans un nouveau document créé via la commande du menu File /
New / Demonstration. selon les instructions dnnées dans le document. Le projet ainsi créé devra ensuite être déposé sur le
site de l'éditeur pour le rendre accessible à toute la communauté. Le site web de l'éditeur propose une démonstration
video expliquant comment faire à cette adresse!:
http://reference.wolfram.com/mathematica/howto/CreateADemonstration.html
12.7 Exercice
Modifier l'exemple donné à la fin de ce chapitre pour y ajouter le dessin des droites de confiance à 95% de la droite et
des points en utilisant la fonction LinearModelFit qui permet de les obtenir par l'intermédiaire des paramètres
"MeanPredictionConfidenceIntervals" et "SinglePredictionConfidenceIntervals" :
-1.0 -0.5 0.0 0.5 1.0-1.0
-0.5
0.0
0.5
1.0
184 12. Interactivité
Chapitre 13
Le langage des notebooks
186 13. Le langage des notebooks
13 Le langage des notebooks
Avec sa version 3, Mathematica a introduit de nombreuses fonctions permettant la programmation du Front-End, c'est-
à-dire la création, la modification, la recherche ou la suppression des cellules d'un notebook par l'intermédiaire d'un
programme. Ces fonctions permettent ainsi de manipuler des expressions particulières servant à décrire le contenu d'un
notebook. Il faut comprendre en effet qu'un notebook Mathematica n'est en réalité d'un simple fichier texte décrivant sa
structure et son contenu par le biais de commandes particulières interprétées par le Front-End au moment de l'ouverture
du fichier. A la base de ce langage on trouve ainsi les commandes Notebook et Cell que nous allons étudier plus
particulièrement. Nous n'aborderons pas en détail toutes les possibilités offertes par ce langage comme je l'ai fait dans
mon livre "L'essentiel de Mathematica" à l'occasion de la sortie de la version 3 de Mathematica. Nous verrons simplement à
travers des exemples simples et pratiques, comment l'on peut s'en servir utilement.
13.1 Objets, commandes et manipulations de base
Un notebook est un document Mathematica constitué de cellules. Aussi, la commande Cell est-elle à la base des
fonctionnalités abordées dans ce chapitre. La définition d'un notebook comprend donc les instructions Notebook et
Cell. Un notebook est une liste de cellules et la commande Cell requiert 2 arguments, son contenu et son style (plus
d'éventuelles options). Voici par exemple des instructions servant à définir le contenu d'un notebook :
nbdata = Notebook@
8Cell@"Un titre", "Section"D, Cell@"Un sous-titre", "Subsection"D,
Cell@"Du texte, aussi long qu'on le souhaite", "Text"D,
Cell@"Integrate@x Sin@xD,8x,0,Pi<D", "Input"D<D;
Ensuite, pour créer le notebook (dans une nouvelle fenêtre), il faut le demander explicitement avec la commande
NotebookPut :
nb = NotebookPut@nbdataD
NotebookObjectB Untitled-13 F
Et Mathematica affiche alors la fenêtre suivante :
Avant d'afficher la fenêtre, Mathematica a créé un "objet notebook" (NotebookObject). On peut donc ensuite, à
n'importe quel moment, faire référence à ce nouveau document par le nom qu'on lui a donné (ici nb).
On peut également créer ce même notebook ligne par ligne, en créant tout d'abord un nouveau document vierge puis
en y ajoutant successivement les cellules qu'il contient. Ainsi, avec la série d'instructions suivantes on obtiendra
exactement le même résultat!que précédemment :
13. Le langage des notebooks 187
nb2 = CreateDocument@D;
NotebookWrite@nb2, Cell@"Un titre", "Section"DD;
NotebookWrite@nb2, Cell@"Un sous-titre", "Subsection"DD;
NotebookWrite@nb2,
Cell@"Du texte, aussi long qu'on le souhaite", "Text"DD;
NotebookWrite@nb2, Cell@"Integrate@x Sin@xD,8x,0,Pi<D", "Input"DD;
Nous voyons ainsi se dessiner la possibilité de créer automatiquement de nouveaux documents contenant des suites
d'instructions, du texte, des résultats divers, tous placés dans des cellules fabriquées au préalable par l'intermédiaire d'un
programme. Le principe de construction de ces "rapports automatiques" est simple et repose sur la connaissance et la
maîtrise de la commande Cell et de ses options.
Dès qu'un document a été créé, il est possible de naviguer dans ce document en y déplacement le curseur ou la ligne
d'insertion. On utilisera pour cela principalement la commande SelectionMove. Ainsi, dans l'exemple suivant, on
déplace le curseur d'insertion pour le placer sous la ligne de titre, puis on insère une nouvelle cellule à cet endroit :
SelectionMove@nb, Before, NotebookD;
SelectionMove@nb, Next, CellD;
SelectionMove@nb, After, CellD;
NotebookWrite@nb,
Cell@"Voici un texte inséré dans le notebook après avoir
créé au préalable toutes les autres cellules", "Text"DD
Dans un tel notebook (mais la remarque vaut pour n'importe quel notebook y compris le notebook courant), on pourra
insérer des cellules, mais aussi du texte à l'intérieur d'une cellule existante. On pourra également supprimer des cellules
ou du texte dans une cellule au moyen de la commande NotebookDelete qui supprime la sélection courante dans le
notebook spécifié. Ainsi, la commande suivante supprime la ligne que nous avons ajouté précédemment :
SelectionMove@nb, Previous, CellD;
NotebookDelete@nbD
Dans ce genre de manipulation, le point particulièrement important est de bien localiser la sélection courante puis de
la déplacer à partir de sa position initiale en utilisant les différentes possibilités offertes par SelectionMove. On se
référera à l'aide interactive pour connaître plus en détail les différentes façons d'utiliser cette fonction.
Dans l'exemple précédent, nous avons une cellule de style Input. Cette cellule peut être évaluée au moyen de la
commande NotebookEvaluate comme le montrent les instructions suivantes :
188 13. Le langage des notebooks
SelectionMove@nb, After, NotebookD;
SelectionMove@nb, Previous, CellD;
SelectionEvaluate@nbD;
Dans le cas particulier des cellules graphiques, on utilisera la commande ToBoxes pour transformer le graphique
créé en instructions compatibles avec la commande Cell, comme dans l'exemple suivant :
des = Plot@Sin@xD ê x, 8x, 0, 10<D;
desbox = ToBoxes@desD;
NotebookWrite@nb, Cell@BoxData@desboxD, "Output"DD
Pour se déplacer plus facilement dans un notebook, on pourra également étiqueter les cellules au moyen de l'option
CellTags puis utiliser la commande NotebookLocate pour localiser la ou les cellules ainsi étiquetées.
13. Le langage des notebooks 189
Cell@texte, styleD Objet décrivant le contenu d' une cellule dans un notebook
TextCell@texte, styleD Création d' une cellule contenant du texte
ExpressionCell@expr, styleD Création d' une cellule contenant une expression particulière
Notebook@8cellules<D Objet décrivant le contenu d' un notebook
NotebookPut@notebookD "Création d'un nouveau notebook à partir de sa description
CreateDocument@D Création d' un nouveau notebook vierge
NotebookWrite@nb, cellulesD Ajout d ' une ou plusieurs cellules dans un notebook
SelectionMove@nb, dir, unitD Déplacement de la sélection courante dans un notebook
NotebookDelete@nbD Suppression de la sélection courante dans un notebook
NotebookSave@nb, fichierD Enregistrement d ' un notebook dans un fichier
NotebookPrint@nbD Impression d' un notebook
NotebookClose@nbD Fermeture d ' un notebook
SelectionEvaluate@nbD Evaluation de la selection courante
NotebookLocate@tagD Permet de localiser toutes les cellules ayant l ' étiquette tag
Commandes de base pour la création et la manipulation de notebooks
13.2 Manipulation de fichiers
Dans l'encadré précédent, nous avons vu qu'il existait une commande pour enregistrer un notebook : la commande
NotebookSave. Aussi faut-il pouvoir naviguer dans l'arborescence de son disque dur pour enregistrer ce fichier à
l'endroit souhaité.
Le répertoire de travail par défaut de Mathematica est celui donné par l'instruction Directory :
Directory@D
êUsersêverdel
C'est dans ce répertoire que Mathematica exporte (Export) ou importe (Import) des données par défaut.
Dans les instructions suivantes, nous allons tout d'abord nous déplacer dans l'arbrorescence du disque pour créer un
nouveau répertoire dans lequel nous enregistrerons notre fichier :
Pour modifier tout d'abord le répertoire de travail, nous utilisons l'instruction SetDirectory (ici avec la syntaxe
propre aux ordinateurs Macintosh) :
SetDirectory@"êUsersêverdelêDocumentsê"D
êUsersêverdelêDocuments
Dans ce répertoire, nous pouvons créer un nouveau répertoire (et conserver son chemin en mémoire) :
dir = CreateDirectory@"Notebooks"D
êUsersêverdelêDocumentsêNotebooks
Il nous reste ensuite à donner un nom à notre fichier en le préfixant du chemin d'accès :
nom = ToFileName@dir, "automatic-report.nb"D
êUsersêverdelêDocumentsêNotebooksênouveau.nb
Pour ensuite le sauvegarder sur le disque dur :
NotebookSave@nb, nomD
Nous pouvons ensuite vérifier la bonne sauvegarde en nous déplaçant dans le répertoire concerné puis en y affichant
les fichiers qui s'y trouvent
190 13. Le langage des notebooks
SetDirectory@dirD
êUsersêverdelêDocumentsêNotebooks
FileNames@D
8automatic-report.nb<
Directory@D Affiche le répertoire de travail par défaut
SetDirectory@ ...D Changer le répertoire de travail par défaut
FileNames@D Affiche le nom des fichiers dans le répertoire de travail
ToFileName@rep, nomD Fabriquer un nom de fichier en concaténant
un nom de répertoire et une chaîne de caractère
Quelques commandes pour manipuler des fichiers
13.3 Autres outils
Nous présentons ci-après quelques outils bien pratiques qui pourront servir à compléter utilement les points vus
précédemment pour la fabrication de documents richessement mis en forme.
13.3.1 Tableaux visuels
Fonctionnalité longtemps attendue, la possibilité d'afficher des tableaux visuels est apparue avec la version 3 de
Mathematica mais sa mise en oeuvre était complexe. Depuis la version 6, cela est devenu plus simple grâce à la fonction
Grid comme le montrent les exemples suivants :
mat = Partition@Range@9D, 3D;
Grid@matD
1 2 3
4 5 6
7 8 9
C'est par le biais d'options que nous pourrons afficher les lignes séparatrices et régler différents paramètres :
Grid@mat, Frame Ø All, Spacings Ø 85, 2<,
FrameStyle -> Directive@Blue, Thick, DashedD,
BaseStyle Ø 8FontFamily Ø "Arial", FontSize Ø 12<D
1 2 3
4 5 6
7 8 9
L'exemple suivant, issu de l'aide interactive de Mathematica, illustre l'utilisation les possibilités de regroupement de
cellules grâce aux symboles SpanFromLeft et SpanFromAbove :
13. Le langage des notebooks 191
Grid@Table@
RandomChoice@8SpanFromLeft, SpanFromAbove, Item@RandomInteger@1000D,
Background Ø Hue@RandomReal@D, .2, .9DD<D, 810<, 810<D, Frame Ø AllD
529 ª 780 ª ! 371
! 83 204 51 783
773 63 341 ª ! ! ! 367 ª !
! ! ª 517 407 ª 453
68 688 ! ! ª ! 936
198 946 ª ª ! 637
888 ª 444 347 175 845 701 ª ª
! 204 294 ! 826 410
495 340 275 971
56 ª ! ! ! !
13.3.2 Fabrication de palettes
Les palettes permettent de rassembler dans de petites fenêtres et sous forme de boutons, des fonctions ou des
instructions dont on a fréquemment besoin et qu'on pourra facilement réutiliser. Le menu Palettes offre déjà un certain
nombres de palettes préfabriquées. Nous allons voir ci-dessous comment créer sa propre palette.
La manière la plus simple de procéder pour créer une nouvelle palette consiste à utiliser la commande
CreatePalette. Dans l'exemple suivant, nous créons tout d'abord le contenu de la palette puis nous la transformons
en fenêtre autonome.
pal = Grid@Partition@Table@PasteButton@iD, 8i, 1, 9<D, 3D, Spacings Ø 80, 0<D
1 2 3
4 5 6
7 8 9
CreatePalette@palD
NotebookObjectB Untitled-23 F
Une autre manière de procéder consiste à sélectionner la palette pal (sélectionner le crochet de la cellule qui la
contient) puis à activer la commande menu Palettes / Generate Palette from Selection. Pour enregistrer la palette
définitivement, il suffira de la fermer et de l'enregistrer à l'affichage de la fenêtre vous invitant à le faire. On pourra
ensuite l'installer dans le menu Palettes au moyen de la commande menu Palettes / Install Palette ....
Certaines palettes préfabriquées contiennent des cases noires ou blanches dans lesquelles nous pouvons écrire des
instructions et entre lesquelles nous pouvons naviguer avec la touche Í. L'encadré suivant montre comment les créer et
à quoi elles servent.
Ñ HÂplÂL Place une case dans laquelle nous pouvons taper une expression
É HÂsplÂL Remplace la case noire par la sélection courante au moment de cliquer sur le bouton
Defer@instD Permet d ' afficher la forme non évaluée de l ' instruction
tout en permettant son évaluation après le clic sur le bouton
Les cases de sélection et la fonction Defer
192 13. Le langage des notebooks
Les cases de sélection et la fonction Defer
La palette suivante montre leur fonctionnement
Column@8PasteButton@Defer@N@ÑDDD, PasteButton@Defer@N@ÉDDD<, Spacings Ø 0D
N@ÑD
N@ÉD
En sélectionnant successivement les instructions suivantes puis en cliquant respectivement sur chacun des boutons
précédents :
8Sin@5D, Sin@5D<
On obtient le résultat ci-dessous dans lequel on constate que la case noire du 2e bouton a été remplacée par la
sélection au moment du clic tandis que dans le cas du 1er bouton, la sélection a été remplacée par le contenu du bouton :
8N@ÑD, N@Sin@5DD<
13.3.3 Caractères spéciaux
Grâce à diverses palettes préfabriquées nous avons accès simplement à de nombreux caractères spéciaux. Mathematica
offre néanmoins des raccourcis clavier assez naturels pour un grand nombre d'entre eux. Ainsi, tout l'alphabet Grec peut
être obtenu par la combinaison de touches  lettre Â. D'autres symboles sont accessibles de cette manière dont
l'encadré suivant donne un tout petit échantillon :
a  a  p  p Â
b  b  µ  * Â
...  lettre !  div Â
Ÿ  math  "  + -Â
Ÿ  int  #  != Â
„  dd  ¥  >= Â
fl  = > ‡  fsq Â
 == >Â Ë Â fsci Â
Ø Â -> Â Ú \[FilledUpTriangle]
¶  inf  à  : -LÂ
Quelques raccourcis pratiques pour afficher des symboles spéciaux
13.4 Exercices
13.4.1 Notebooks automatiques
Concevoir un programme permettant, à partir d'une liste de points, de fournir un rapport complet de régression sous
la forme d'un nouveau notebook qui contiendra au moins les éléments suivants : un titre, un texte introductif, un premier
tableau comprenant l'expression de la droite des moindres carrés et la valeur du coefficient de régression, un second
tableau rassemblant la plupart des indicateurs statistiques permettant de juger de la qualité de la régression, puis le dessin
des points, de la droite et des intervalles de confiance de la droite et des points.
13.4.2 Palette
Fabriquer une palette (fonctionnelle) contenant quelques opérations courantes comme dans l'exemple suivant :
13. Le langage des notebooks 193
N@ÉD
Plot@Ñ, 8x, Ñ, Ñ<D
Ÿ Ñ „x
Solve@Ñ ã Ñ, xD
Solve@8Ñ ã Ñ, Ñ ã Ñ<, 8x, y<D
Table@Ñ, 8i, Ñ, Ñ, Ñ<D
194 13. Le langage des notebooks
© Thierry Verdel, Ecole des Mines de Nancy, 2009
