Mathematica Graphiques

2Legraphique.
nb Page 1 sur 25
Le graphique en Mathematica
Programmation Fonctionnelle et Logique en Mathematica
Jean-Paul Sansonnet
Chapitre 2 : Le graphique
• Affichage de fonctions mathématiques
Mathematica dispose d'opérateurs puissants pour l'affichage des fonctions mathématiques. Cette
section n'est qu'un survol rapide des possibilités. Il faudra se reporter au manuel pour découvrir
toutes les subtilités des options possibles
• Affichage de fonctions d'une seule variable
• Plot simple
Si nous voulons tracer la fonction mathématique bien connue Sinus, disons entre 0 et 4 Pi, il faut
utiliser d'opérateur d'affichage Plot qui prend comme argument
- la fonction à tracer avec sa variable : Sin[x]
- un itérateur qui dit à partir de qu'elle valeur commence à varier la variable x et où elle finit de
varier (définissant ainsi les bornes du tracé)
Plot[Sin[x], {x, 0, 4Pi}]
Mathematica construit un objet graphique, d'où la notation << -Graphics- >> qui apparaît sous
l'affichage (la structure interne des objets de type Graphics sera exposée plus loin). Ensuite, il
affiche cet objet à l'écran, dans une cellule qui n'est pas de type Output mais de type Graphics,
comme on peut s'en rendre compte en clickant dessus (on voit alors le nom du type de la cellule dans
la règle). Le menu << Graph >> permet de faire toutes sortes d'opérations sur le graphique affiché
http://www.limsi.fr/%7Ejps/enseignement/tutoriels/math/2.mathgraphique/mathgraphi... 14/01/2011
2Legraphique.nb Page 2 sur 25
(voir le menu et le manuel). On peut utiliser la souris pour déplacer le graphe, le copier/coller,
l'agrandir, le rétrécir etc.
• Ajout d'options aux opérateurs Mathematica
En Mathematica, certains opérateurs possèdent ce qu'on appelle des options. Une option sert à
modifier le comportement standard de l'opérateur. Beaucoup d'opérateurs de Mathematica acceptent
une ou plusieurs options qui sont décrites dans le manuel ; par exemple, Plot accepte 27 options !
Pour donner une option à un opérateur, on utilise une nouvelle notation de la forme
nom-d'option -> expression-valeur-de-l'option
Où nom-d'option est un symbole. Par exemple, pour un opérateur qui utilise normalement deux
expressions
opérateur[expr1, expr2]
Si on lui ajoute deux options, prises parmi les n options qu'il accepte, on obtient
opérateur[expr1, expr2, opt1 -> Valeur1, opt2 -> valeur2]
Il n'y a pas d'ordre entre les options : on aurait tout aussi bien pu écrire
opérateur[expr1, expr2, opt2 -> valeur2, opt1 -> Valeur1]
Par exemple, une des options possibles de Plot est Frame qui entoure l'affichage d'un rectangle
gradué. Nous écrivons donc
Plot[Sin[x], {x, 0, 4Pi}, Frame -> True]
Remarque : lorsque Plot affiche une fonction mathématique, elle place sur l'axe horizontal la
variation de la variable donnée par l'utilisateur et sur l'axe vertical les variations qui, elles, dépendent
de la fonction.
• Plot de plusieurs fonctions sur un même graphique
Il est possible de tracer plusieurs fonctions en même temps pourvu que la variable et les bornes
soient communes (partage du même itérateur). On donne non plus un fonction à tracer mais une liste
de fonctions
Plot[{Sin[x], Cos[x]}, {x, 0, 2Pi}]
Ceci nous a permis de voir comment évoluent respectivement les fonctions Sinus et Cosinus sur un
même intervalle de la variable (ici nous avons pris une période entière soit entre 0 et 2Pi).
• Affichage avec des styles différents
Le problème est que dans le graphique ci-dessus, on ne sait pas qui est Sinus et qui est Cosinus ! On
peut essayer de colorer les courbes. Pour cela, il nous faut définir deux symboles utilisateurs rouge
et vert qui seront des couleurs. C'est le symbole prédéfini RGBColor qui permet de définir des
couleurs en Mathematica (voir manuel). Posons donc
Clear[rouge, bleu, vert, jaune]

rouge = RGBColor[1., 0., 0.];
bleu = RGBColor[0., 0., 1.];
vert = RGBColor[0., 1., 0.];
jaune = RGBColor[0.964, 0.960, 0.630];
Alors, il est possible de dire à Plot que l'on veut que le style d'affichage change d'une courbe à
l'autre. On utilise une nouvelle option, PlotStyle, qui accepte une liste de couleurs qu'elle applique
aux tracés respectifs des fonctions.
Plot[{Sin[x], Cos[x]}, {x, 0, 2Pi},

PlotStyle -> {rouge, vert}]
Ainsi, la première fonction (Sinus) sera colorée à l'écran avec la première couleur de la liste des
styles (rouge) et la seconde fonction (Cosinus) sera colorée avec la seconde couleur (vert).
Remarque : sur le papier, le rouge apparaît en grisé. On peut aussi dessiner avec plein d'autres
styles : en pointillés, en gras etc.
Maintenant traçons ensemble Sinus, Cosinus et Tangente
Plot[{Sin[x], Cos[x], Tan[x]}, {x, 0, 2Pi},

PlotStyle -> {rouge, bleu, vert}]
On voit que Mathematica a ajusté les bornes verticales pour qu'on puisse mieux voir la tangente.
Cela eu pour effet de “tasser” un peu Sinus et Cosinus. Mathematica est très fort pour déterminer les
bornes verticales afin que la visualisation soit la meilleure possible. Rappelons que les bornes
horizontales sont fixées par l'utilisateur. Cependant, dans certains cas pathologiques,
Mathematica échoue et l'utilisateur mécontent peut fournir ses propres bornes avec l'option
PlotRange
Plot[{Sin[x], Cos[x], Tan[x]}, {x, 0, 2Pi},

PlotStyle -> {rouge, bleu, vert},
PlotRange -> {{0,2Pi}, {-2,2}},
Frame -> True]
Ici, Nous avons conservé les bornes horizontales telles quelles {0, 2Pi} et nous avons “forcé” les
bornes verticales entre {-2, 2} au lieu du calcul automatique précédent qui avait donné {-6, 6}
environ. La fonction Tangente se voit moins bien, mais on voit mieux Sinus et Cosinus.
• Plot d'une famille de fonctions
Il est possible de donner à Plot une liste de fonctions calculées symboliquement, et qui définit ce
qu'on appelle une famille de fonctions. Par exemple, construisons la table de 10 polynômes en x du
3ème degré, ayant la même forme, mais où le paramètre a varie de 1 à 10
Clear[a,l,x]
l = Table[x^3 - a x, {a, 0, 10}]
On obtient une famille de fonctions en x que Plot peut afficher d'un seul coup
Plot[Evaluate[l], {x, -5, 5}]
Remarque : nous avons écrit la formule cryptique Evaluate[l] au lieu de l, sinon Plot a des
problèmes, qui ne seront pas explicités ici (voir manuel).
• Affichage de fonctions de deux variables
En mathématiques, il y a aussi des fonctions de plusieurs variables. Mathematica affiche aussi les
fonctions de deux variables et ceci de plusieurs manières.
• Contours
Une fonction de deux variables n'est plus une ligne mais une surface. On peut afficher cette surface
en montrant ses contours comme dans les cartes géographiques. On utilise l'opérateur ContourPlot
qui prend comme argument la fonction de deux variables, un itérateur pour la première variable et un
itérateur pour la seconde variable
ContourPlot[Sin[x y], {x, -2, 2}, {y, -2, 2}]
Nous avons affiché la fonction Sinus(x*y) vue “de dessus”.
• Densité
Il est possible d''afficher cette même fonction de deux variables Sinus(x*y) sous forme de niveaux
de gris (ou de niveaux de couleurs) grâce à l'opérateur DensityPlot. Il marche comme ContourPlot
DensityPlot[Sin[x y], {x, -2, 2}, {y, -2, 2},

PlotPoints -> 50,
Mesh -> False ]
Nous avons ajouté deux options (parmi bien d'autres...)
- PlotPoints porte le nombre de points de discrétisation de la surface de 30 (valeur standard) à 50,

donc le dessin est plus fin
- Mesh -> False supprime l'affichage de la grille
• Plot 3D
Une fonction de deux variables étant une surface, on peut la visualiser en trois dimensions grâce à
l'opérateur Plot3D qui marche comme les opérateurs ContourPlot et DensityPlot
Plot3D[Sin[x + Sin[y]], {x, -Pi, Pi}, {y, -Pi, Pi}]
Plot3D[Sin[x y], {x,0, 2 Pi}, {y,0, 2 Pi}, PlotPoints->50]
Le Front-end de Mathematica possède un outil permettant de construire une option ViewPoint qui
spécifie le point de vue qu'on désire avoir sur l'objet visualisé (voir le manuel du Front-end). Ainsi,
cette même surface est vue ci-dessous d'un autre point de l'espace dont les coordonnées sont fixées
par l'option ViewPoint
Plot3D[Sin[x y], {x,0, 2 Pi}, {y,0, 2 Pi},

PlotPoints -> 50,
ViewPoint -> {2.055, -0.714, 2.591}]
• Affichage de fonctions paramétriques
• Fonctions paramétriques dans le plan
En mathématiques, une fonction paramétrique est définie par la conjonction de deux fonctions de la
même variable. Il suffit de donner la liste des deux fonctions et l'itérateur à l'opérateur
ParametricPlot
ParametricPlot[{Sin[t], Sin[2t]}, {t, 0, 2Pi}]
On voit que la syntaxe de ParametricPlot est la même que celle de Plot à deux fonctions (voir ci-
dessus l'exemple {Sin, Cos}) mais la sémantique n'est pas du tout la même. Il s'agit ici d'une seule
fonction qui trace une courbe dans le plan.
• Fonctions paramétriques dans l'espace
Avec des fonctions paramétriques de trois fonctions d'une même variable, il est possible de tracer des
courbes dans l'espace. Voici un “tire-bouchon”
ParametricPlot3D[{t/3, Sin[t], Cos[t]}, {t, 0, 12Pi},

ViewPoint->{2.403, -2.001, 1.294}]
• Fonctions paramétriques de deux variables
Avec des fonctions paramétriques de trois fonctions de deux variables, nous avons affaire non plus à
une courbe paramétrique mais à une surface paramétrique. Par exemple, on peut visualiser un tore
dans l'espace comme étant la surface définie par les trois fonctions des deux variables t et u ci-
dessous
ParametricPlot3D[{Cos[t] (3+ Cos[u]), Sin[t] (3 + Cos[u]), Sin[u]},

{t, 0, 2Pi}, {u, 0, 2Pi}]
• Affichage de listes de nombres
• Affichages Monodimensionnels
• Plot d'une liste simple de nombres
Supposons qu'à la suite d'un examen, nous possédions une liste des notes des étudiants
Clear[ListeDesNotes]
ListeDesNotes = {12.5,13,15,16,16,15.5,12,13,
11,2,11,4,14,12,9,8,17,12,13.5,11.5,13.5,5,11};
Il y a 23 notes dans la liste.
Length[ListeDesNotes]
Il est possible de l'afficher telle quelle grâce à l'opérateur ListPlot
ListPlot[ListeDesNotes]
l'opérateur ListPlot affiche en abcisses les indices des notes (de 1 à 23) et en ordonnées il trace un
point correspondant à la valeur de la note. ListPlot possède 25 options dont PlotJoined qui permet
de joindre les points par une ligne
ListPlot[ListeDesNotes, PlotJoined -> True]
On peut trier les notes avant de les tracer
ListPlot[Sort[ListeDesNotes], PlotJoined->True]
• Plot d'une liste de coordonnées (paramétriques)
Si au lieu d'une liste de nombres, on dispose d'une liste de couples de nombres
Clear[étoile]
étoile = {{8.938958, 10.631507}, {10.745409, 16.20307},
{12.456783, 10.517801}, {18.066288, 14.611195}, {15.213997, 8.58481},
{19.397357, 1.989898}, {12.551859, 6.651819}, {7.798042, 1.193961},
{8.273423, 7.447756}, {1.427926, 14.952311}, {8.843881, 10.745212}};
Length[étoile]
On peut considérer que cette liste est une matrice de 11 lignes et 2 colonnes
TableForm[étoile]
8.938958` 10.631507`
10.745409` 16.20307`
12.456783` 10.517801`
18.066288` 14.611195`
15.213997` 8.58481`
19.397357` 1.989898`
12.551859` 6.651819`
7.798042` 1.193961`
8.273423` 7.447756`
1.427926` 14.952311`
8.843881` 10.745212`
ListPlot accepte ce type de liste et considère que chaque couple de nombres représente un point dans
le plan (le premier nombre du couple est l'abcisse du point et le second nombre du couple est
l'ordonnée du point)
ListPlot[étoile]
Avec l'option PlotJoined, on y voit un peu plus clair
ListPlot[étoile, PlotJoined->True, Axes->None]
L'option Axes -> None supprime le tracé des axes.
• Affichages Bidimensionnels
• Création d'une matrice des restes de la division de y par x
Nous allons construire une matrice m à deux dimensions (20 x 20) dont chaque élément représente le
résultat de la division entière de son numéro de colonne par son numéro de ligne
Clear[m]
m = Table[Mod[y,x], {x, 20}, {y, 20}];
TableForm [m, TableSpacing -> {0,1}]
0000000000 0 0 0 0 0 0 0 0 0 0
1010101010 1 0 1 0 1 0 1 0 1 0
1201201201 2 0 1 2 0 1 2 0 1 2
1230123012 3 0 1 2 3 0 1 2 3 0
1234012340 1 2 3 4 0 1 2 3 4 0
1234501234 5 0 1 2 3 4 5 0 1 2
1234560123 4 5 6 0 1 2 3 4 5 6
1234567012 3 4 5 6 7 0 1 2 3 4
1234567801 2 3 4 5 6 7 8 0 1 2
1234567890 1 2 3 4 5 6 7 8 9 0
1 2 3 4 5 6 7 8 9 10 0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9 10 11 0 1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8 9 10 11 12 0 1 2 3 4 5 6 7
1 2 3 4 5 6 7 8 9 10 11 12 13 0 1 2 3 4 5 6
1 2 3 4 5 6 7 8 9 10 11 12 13 14 0 1 2 3 4 5
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 0 1 2 3 4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 0 1 2 3
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 0 1 2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 0 1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0
Dans TableForm, l'option TableSpacing règle l'écartement entre les lignes (resp. les colonnes).
• Plot dans l'espace
Avec ListPlot3D, il est possible d'afficher cette matrice, vue comme une surface valuée
ListPlot3D[m]
• Contour
De même, pour les contours
ListContourPlot[m]
• Densité
Ou encore la densité
ListDensityPlot[m, ColorFunction->Hue]
• Le Dessin
• Mon premier dessin
• Notion sommaire de type
Mathematica possède des opérateurs d'un genre un peu particulier, en ceci qu'il ne semblent pas
produire d'effet. Par exemple
Line[{{0,0},{10,10}}]
a pour résultat lui-même. On peut croire qu'il s'agit d'une expression constante mais ce n'est pas le
cas car
Line[{{1-1, 1-1},{1+2+3+4, 10}}]
n'a pas pour résultat lui-même. Les expressions sont calculées (si possible) et le résultat est ensuite
laissé tel quel. L'utilisateur peut obtenir le même effet au moyen d'un symbole indéfini
Clear[maLigne]
maLigne[{{1-1, 1-1},{1+2+3+4, 10}}]
On dira grossièrement que Line et maLigne sont des types. Line est un type prédéfini et maLigne
est un type de l'utilisateur.
• Types d'objets graphiques de base
Mathematica utilise un certain nombre de types prédéfinis, en particulier pour construire des objets
graphiques. Nous ne donnerons ici que les six principaux types d'objets graphiques
Clear[p,l,r,c,d,t]
p = Point[{1,3}];
l = Line[{{0,0},{10,10}}];
r = Rectangle[{2,2}, {8,3}];
c = Circle[{5,5}, 2];
d = Disk[{5,5}, 1/2];
t = Text["Mon premier dessin", {5,1}];
1) le type Point : on donne le couple de coordonnées du point {abcisse, ordonnée}
2) le type Line : on donne une liste de coordonnées de points. La ligne rejoint ces points
2) le type Rectangle : on donne les coordonnées du point << en bas à gauche >> et les coordonnées du point << en haut
à froite >>. Un rectangle a une surface colorée
3) le type Circle : on donne les coordonnées du point central et le rayon
4) le type Disk : on donne les coordonnées du point central et le rayon. Un disque est un cercle dont la surface est colorée
5) le type Text : on donne la chaîne de caractères à écrire, suivie des coordonnées du point central où on désire placer le
texte
• Composition d'un graphique
Avec ces objets de base, il est possible de composer des graphiques plus complexes en les agrégeant
au moyen de listes et du type Graphics
Clear[g]
g = Graphics[{p,l,r,c,d,t}]
g est un symbole qui est défini comme un objet de type Graphics (contenant {p,l,r,c,d,t,p}). Si on
évalue g, il reste tel quel
On devrait voir ce qui est associé à g
?g
Global`g
Mais comme les objets graphiques sont souvent très complexes, cela afficherait plusieurs pages de
texte. Aussi, on donne une abbréviation (c'est le format de sortie) qui est << -Graphics- >>.
Montrons le sur un exemple de graphique simple
Clear[gf]
gf = Plot[Sin[x], {x,0,2Pi}]
Puisque gf est de type Graphics, montrons son “ventre” avec la commande cryptique
InputForm[gf]
Graphics[{{Line[{{2.617993877991494*^-7, 2.6179938779914644*^-7},
{0.25488992540742256, 0.25213889196341294}, {0.5328694051959509, 0.508006999749293},
{0.7939393140028286, 0.7131204212611485}, {1.04500937601917, 0.864929243756943},

{1.1741328775392965, 0.9223551787683757}, {1.2459531215560486, 0.9477007807106171},
{1.3122595300248905, 0.9667651045914426}, {1.3796587590126155, 0.9817887599829266},
{1.4151712519040447, 0.9879148386395655}, {1.452818517786423, 0.9930486867121877},
{1.4685459219881412, 0.9947769803573822}, {1.4854640561545152, 0.9963614104927859},
{1.500086156059384, 0.9975010773404583}, {1.51604684666487, 0.9985016215519943},
{1.5257154450014152, 0.9989840291277866}, {1.5346917166321437, 0.9993482993604226},
{1.5432702860122063, 0.9996211824589527}, {1.5476633256302652, 0.99973244406044},
{1.5524154112126216, 0.9998310757272946}, {1.557095534347201, 0.9999061456112971},
{1.5614014708893083, 0.9999558686658562}, {1.5698668259401665, 0.9999995680141116},
{1.57756114604427, 0.9999771186975212}, {1.5856899292294537, 0.9998890923534056},
{1.5937347090403413, 0.999736926845371}, {1.5982802149227149, 0.9996223417200457},
{1.602485706217873, 0.9994979336332918}, {1.6183967320355177, 0.9988673146044424},
{1.6328563679169932, 0.9980748936376652}, {1.6482179131722097, 0.997004445734794},
{1.6800794238288492, 0.9940345429176443}, {1.7152483657654019, 0.9895849335338148},
{1.777634170587595, 0.9786852066169908}, {1.8362027188838577, 0.9649859833349604},
{1.96935359953808, 0.9216218596882011}, {2.091436795752561, 0.8675007654055193},
{2.3528511178201073, 0.7094669459933797}, {2.6042655930971175, 0.511841554314526},
{2.8718601603635063, 0.26647361190518665}, {3.129454880839359, 0.012137474718667576},
{3.403229693304591, -0.258662225484852}, {3.667004658979287, -0.5015694802512557},
{3.920779777863447, -0.7027013025535859}, {4.049329732663053, -0.7881128613261783},
{4.190734988736986, -0.8669961574133123}, {4.325038532491689, -0.9259131412077234},
{4.450690352819988, -0.965951900053347}, {4.519350313521828, -0.9814258230717512},
{4.553172855688176, -0.9873518656643328}, {4.58453217088966, -0.9918374469130117},
{4.612871648977648, -0.995052235828352}, {4.6430429975047485, -0.9975965307241794},
{4.660289968485605, -0.9986431534294095}, {4.6687462414940395, -0.999047806821418},
{4.676516169447837, -0.9993566397149916}, {4.6834667753234696, -0.9995817821814739},
{4.691086112958075, -0.9997731025006338}, {4.698745200202966, -0.9999069250750359},
{4.706826115311297, -0.9999845273059885}, {4.715467134414191, -0.999995262487626},
{4.723451258164842, -0.9999388136291295}, {4.727619549176575, -0.9998840171292116},
{4.732214472348086, -0.9998034813711373}, {4.741512035166449, -0.9995759538126735},
{4.749667910636782, -0.9993052211474813}, {4.758448417490483, -0.9989394516402537},
{4.774327573059229, -0.9980824185354398}, {4.7899679225898915, -0.9969922628207964},
{4.806412896322693, -0.9955830070890066}, {4.835792493229592, -0.992395444313023},
{4.869997057698077, -0.9876055357375542}, {4.90177824537703, -0.9821193947063364},
{4.973863410215748, -0.9660098805988246}, {5.043467528958331, -0.9456922972001947},
{5.109091761474971, -0.9223399824753976}, {5.231802543952269, -0.8681104190514858},
{5.485922076097097, -0.7154466815504685}, {5.756221700231304, -0.502911193409889},
{6.016521477574974, -0.2635146543573849}, {6.266821408128108, -0.01636316874809926},
{6.283185045380199, -2.6179938774695577*^-7}}]}},
{PlotRange -> Automatic, AspectRatio -> GoldenRatio^(-1),
DisplayFunction :> $DisplayFunction, ColorOutput -> Automatic, Axes -> Automatic,
AxesOrigin -> Automatic, PlotLabel -> None, AxesLabel -> None, Ticks -> Automatic,
GridLines -> None, Prolog -> {}, Epilog -> {}, AxesStyle -> Automatic,
Background -> Automatic, DefaultColor -> Automatic, DefaultFont :> $DefaultFont,
RotateLabel -> True, Frame -> False, FrameStyle -> Automatic, FrameTicks -> Automatic,
FrameLabel -> None, PlotRegion -> Automatic, ImageSize -> Automatic,
TextStyle :> $TextStyle, FormatType :> $FormatType}]
On voit que la courbe Sinus est essentiellement représentée par un objet graphique Line possédant
beaucoup de points définis avec beaucoup de précision. Remarquons aussi qu'il est possible d'ajouter
des options à un objet de type Graphics. En fait, Graphics possède 23 options très proches de celles
de Plot.
• Affichage d'un graphique
Maintenant il faut afficher le graphique g. C'est l'opérateur Show qui s'en charge
Show[g]
Show a les mêmes options que Graphics. Par exemple, on peut demander à avoir un cadre
Show[g, Frame->True]
Nous avons tracé un cercle (objet c dans g) et un disque noir (objet d dans g). Ils ne sont pas ronds !
Ceci est dû au fait que Mathematica affiche les dessins dans un cadre dont le rapport
Longueur/Hauteur = GoldenRatio, le nombre d'or, respectant ainsi les canons de la représentation
classique.
Pour que les cercles soient ronds, il faut que Longueur/Hauteur = 1. Ceci peut être demandé avec
l'option AspectRatio
Show[g, Frame->True, AspectRatio->1]
On constate que le cadre est carré, en conséquence, le cercle et le disque sont ronds.
• Primitives de dessin
• Lignes
La principale primitive de dessin est Line. Une ligne prend une liste de coordonnées de points, ce
qui permet de tracer en fait un polygone
Clear[star, nose, g]
star = Line[{{4, 6}, {5, 9}, {5, 6}, {8, 8}, {6, 4}, {8, 1},
{5, 3}, {3, 1}, {3, 4}, {1, 8}, {4, 6}}]
nose = Line[{{4, 5}, {4, 4}, {5, 5}}]
Construisons un objet graphique en agrégeant le polygone star et le polygone nose
g = Graphics[{star, nose}]
Pour le voir
Show[g];
• Polygones
En Mathematica, on appelle Polygon un objet analogue à un objet Line, mais dont la surface est
colorée (en noir par défaut)
Clear[mouth]
mouth = Polygon[{{3.6, 3.6}, {3.8, 3.3}, {4.1, 3.3}, {4.4, 3.5},
{4.7, 3.7}, {4.4, 3.0}, {4.0, 2.7}, {3.7, 2.9}, {3.6, 3.6}}];
Ajoutons la bouche mouth. On peut construire directement l'expression à afficher de la manière
suivante
Show[Graphics[{star, nose, mouth}]];
On vérifie que contrairement à une Line, un Polygon est “rempli” de couleur (noire par défaut)
• Cercles et disques
Les disques sont aux cercles ce que les polygones sont aux lignes. On spécifie le point central {x,y}
et le rayon (un nombre non complexe)
Clear[eyeLeft, eyeRight]
eyeLeft = Circle[{3, 6}, 0.3];
eyeRight = Disk[{5, 5.5}, 0.3];
Show[Graphics[{star, nose, mouth, eyeLeft, eyeRight}]];
• Points
On peut aussi ajouter quelques points
Clear[peas]
peas = {Point[{5.1, 4.1}], Point[{5.3, 4.5}], Point[{5.6, 4.6}],
Point[{5.7, 4.1}], Point[{5.4, 4.3}], Point[{5.4, 3.7}] };
Show[Graphics[{star, nose, mouth, eyeLeft, eyeRight, peas}],

Frame->True];
• Rectangle et couleur
Nous avons placé le dessin ci-dessus dans un cadre pour voir ses dimensions. Supposons que nous
voulions l'encadrer nous-même en utilisant un Rectangle
Clear[cadre, figure]
cadre = Rectangle[{0,0}, {10,10}];
Pour structurer les idées, plaçons le dessin ci-dessus dans un symbole appelé figure et le cadre dans
un symbole appelé cadre. Le type Graphics permet d'imbriquer des dessins les uns dans les autres
i.e. de les structurer hiérarchiquement
figure = {star, nose, mouth, eyeLeft, eyeRight, peas};

g = Graphics[{figure, cadre}];
On peut le montrer
Show[g];
Mais on ne voit rien ! En effet, Rectangle dessine un rectangle de couleur (noire par défaut) qui
empêche de voir le dessin. Ce qu'il faudrait c'est une couleur plus claire.
Rappelons les couleurs déjà utilisées plus haut
Clear[rouge, bleu, vert, jaune]

rouge = RGBColor[1., 0., 0.];
bleu = RGBColor[0., 0., 1.];
vert = RGBColor[0., 1., 0.];

jaune = RGBColor[0.964, 0.960, 0.630];
On peut considérer maintenant que RGBColor est un type au même titre que Line ou Circle mais il
dénote un objet graphique particulier : une couleur. Ansi, placé dans un agrégat d'objets graphiques,
il les colore avec sa couleur. En général, si on veut colorer un (ou plusieurs) objet(s), on place la
couleur en tête de liste et l'(es) objet(s) à colorer derrière.
Clear[cadre]
cadre = {jaune, Rectangle[{0,0}+0.1, {10,10}-0.1]};
Ainsi, le cadre sera un Rectangle peint en jaune. De même, on peut peindre en rouge la bouche
(mouth) et les points (peas) en vert
figure = {star, nose, {rouge, mouth}, eyeLeft, eyeRight, {vert, peas}};

g = Graphics[{cadre, figure}];
Enfin on montre
Show[g];
Remarque : les couleurs appraissent en niveaux de gris sur le papier.
• Texte
On peut ajouter des textes et ceci de multiples façons. On se contente ici de placer une légende,
composée d'une chaîne de caractères (sans accents) suivi des coordonnées du point central du texte
Clear[legend]
legend = Text["A star is Borgne", {7.5, 9.2}];
g = Graphics[{cadre, figure, legend}];
Show[g];
Retour

Mathematica Graphiques

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Mathematica Graphiques

Hochgeladen von

Copyright:

Verfügbare Formate

2Legraphique.

• Affichage de fonctions d'une seule variable

- la fonction à tracer avec sa variable : Sin[x]

Plot[Sin[x], {x, 0, 4Pi}]

• Ajout d'options aux opérateurs Mathematica

nom-d'option -> expression-valeur-de-l'option

opérateur[expr1, expr2, opt1 -> Valeur1, opt2 -> valeur2]

opérateur[expr1, expr2, opt2 -> valeur2, opt1 -> Valeur1]

Plot[Sin[x], {x, 0, 4Pi}, Frame -> True]

• Plot de plusieurs fonctions sur un même graphique

Plot[{Sin[x], Cos[x]}, {x, 0, 2Pi}]

• Affichage avec des styles différents

Clear[rouge, bleu, vert, jaune]

Plot[{Sin[x], Cos[x]}, {x, 0, 2Pi},

Maintenant traçons ensemble Sinus, Cosinus et Tangente

Plot[{Sin[x], Cos[x], Tan[x]}, {x, 0, 2Pi},

Plot[{Sin[x], Cos[x], Tan[x]}, {x, 0, 2Pi},

• Plot d'une famille de fonctions

Plot[Evaluate[l], {x, -5, 5}]

• Affichage de fonctions de deux variables

ContourPlot[Sin[x y], {x, -2, 2}, {y, -2, 2}]

Nous avons affiché la fonction Sinus(x*y) vue “de dessus”.

DensityPlot[Sin[x y], {x, -2, 2}, {y, -2, 2},

Nous avons ajouté deux options (parmi bien d'autres...)

- PlotPoints porte le nombre de points de discrétisation de la surface de 30 (valeur standard) à 50,

- Mesh -> False supprime l'affichage de la grille

Plot3D[Sin[x + Sin[y]], {x, -Pi, Pi}, {y, -Pi, Pi}]

Plot3D[Sin[x y], {x,0, 2 Pi}, {y,0, 2 Pi}, PlotPoints->50]

Plot3D[Sin[x y], {x,0, 2 Pi}, {y,0, 2 Pi},

• Affichage de fonctions paramétriques

• Fonctions paramétriques dans le plan

ParametricPlot[{Sin[t], Sin[2t]}, {t, 0, 2Pi}]

• Fonctions paramétriques dans l'espace

ParametricPlot3D[{t/3, Sin[t], Cos[t]}, {t, 0, 12Pi},

• Fonctions paramétriques de deux variables

ParametricPlot3D[{Cos[t] (3+ Cos[u]), Sin[t] (3 + Cos[u]), Sin[u]},

• Affichage de listes de nombres

• Plot d'une liste simple de nombres

Il y a 23 notes dans la liste.

Il est possible de l'afficher telle quelle grâce à l'opérateur ListPlot

ListPlot[ListeDesNotes, PlotJoined -> True]

On peut trier les notes avant de les tracer

• Plot d'une liste de coordonnées (paramétriques)

Si au lieu d'une liste de nombres, on dispose d'une liste de couples de nombres

Avec l'option PlotJoined, on y voit un peu plus clair

ListPlot[étoile, PlotJoined->True, Axes->None]

L'option Axes -> None supprime le tracé des axes.

• Création d'une matrice des restes de la division de y par x

• Plot dans l'espace

De même, pour les contours

• Mon premier dessin

• Notion sommaire de type

Line[{{1-1, 1-1},{1+2+3+4, 10}}]

• Types d'objets graphiques de base

1) le type Point : on donne le couple de coordonnées du point {abcisse, ordonnée}

3) le type Circle : on donne les coordonnées du point central et le rayon

• Composition d'un graphique

On devrait voir ce qui est associé à g

{0.7939393140028286, 0.7131204212611485}, {1.04500937601917, 0.864929243756943},

• Affichage d'un graphique

Show[g, Frame->True, AspectRatio->1]

nose = Line[{{4, 5}, {4, 4}, {5, 5}}]

Construisons un objet graphique en agrégeant le polygone star et le polygone nose