green arrow gif

Commentaires

Transcription

green arrow gif
16 - Représentations graphiques 2D
MAPLE permet de tracer des représentations graphiques cartésiennes, polaires, paramétriques, etc.
de fonctions, d'objets graphiques comme des polygones, des arcs d'ellipses, du texte, des formules, etc.
ainsi que de créer des animations. On donnera à ces opérations le terme de "graphisme 2D" pour les
distinguer des tracés en perspective dans l'espace (3D ; voir chapitre 17).
Les dessins s'affichent par défaut sur la feuille de calcul (Inline), mais on peut aussi les afficher sur
des fenêtres séparées (Window) avec le menu MAPLE 12/Préférences (Mac OS) ou Tools/Options
(Windows/Linux) et l'onglet Display, option Plot display (voir Ch 1, § 8.3.7). Pour compléter cette
information, voir le § 5.3 et la fonction plotsetup pour une modification ponctuelle.
On peut également créer des fichiers de dessins, par exemple aux formats GIF ou postscript, pour
un usage externe comme l'insertion dans un document de type Word ou LaTeX (voir le § 5).
Ce chapitre répondra aussi à la requête fréquente : "J'ai un fichier et je voudrais..." (Annexe 2).
Il existe d'assez nombreuses redondances dans les fonctions graphiques de MAPLE liées à
l'évolution du logiciel. Par exemple pour tracer des courbes en coordonnées polaires on pourra utiliser
plot avec l'option coords=polar ou la fonction polarplot de la librairie plots. On trouve parfois entre
ces possibilités des variantes qui peuvent être utiles. On pourra se faire une idée de toutes les
possibilités de tracés offertes par MAPLE avec la page d'aide illustrée
O ?PlottingGuide
1 Tracés en mode interactif
MAPLE offre la possibilité d'effectuer des tracés en mode interactif. Il suffit d'activer dans le
menu général Tools de MAPLE l'option Assistants/Plot Builder... puis de se laisser guider en
remplissant des champs appropriés. L'activation de ce menu écrit la commande suivante sur la
feuille de calcul puis affiche la (ou les) représentation(s) graphique(s) demandée(s).
O plots[interactive]();
4
2
K2
K2
K4
K6
1
2
3
La fonction interactive appartient à la librairie plots (voir le § 13) et on peut donner directement la
commande sans passer par ce menu (plusieurs formes d'appel sont possibles, voir Ch. 1, § 8.3.5).
L'expression suivante dépend des deux variables libres α et x. Aussi dans la fenêtre qui s'ouvrira on
pourra trouver plusieurs possibilités comme un tracé 3D z(α,x) (Ch. 17), un tracé implicite (voir §
13.3), une animation (voir § 13.6), etc. On laisse au lecteur le soin d'explorer les diverses
possibilités. Se reporter aussi au § 3.4 et § 4 pour les modifications interactives.
O plots:-interactive(sin(alpha*x)*x); # Commande non exécutée
2 Tracés "à la volée"
Supposons une expression affichée dont on veut tracer une représentation graphique
O exp(-x)+sin(5*x);
eKx C sin 5 x
Avec un clic droit sur le résultat on fait apparaître un menu contextuel. En choisissant dans celui1
ci Plots/Plot Builder une fenêtre s'ouvre qui permet certains choix, comme par exemple celui de
fixer l'intervalle de variation des abscisses (qui est par défaut [-10,+10]). L'application Plot
Builder construit, affiche et exécute la commande de tracé appropriée. Ici encore on laisse au
lecteur le soin d'explorer les diverses possibilités. On notera en particulier que l'application Plot
Builder déduit du nombre de variables libres (ici une seule : x), la nature des tracés possibles (2D,
3D, Implicites, etc).
O plot(exp(-x)+sin(5*x), x = -2 .. 3);
7
5
3
1
K2 K1 0
1
2
3
x
3 Fonction plot (utilisation élémentaire)
3.1 Tracé d'une expression
Comme le montre la génération automatique de la commande précédente, pour tracer la
représentation cartésienne d'une expression ne dépendant que d'une variable non assignée et
d'une seule on utilise la fonction plot dont le premier argument est cette expression (voir § 3.2
pour les fonctions et les procédures). Le deuxième argument est une équation donnant le nom de
cette variable considérée comme l'abscisse avec son intervalle de variation souhaité. On peut
remarquer que l'axe des ordonnées s'adapte à la représentation graphique et n'est pas
nécessairement orthonormé avec celui des abscisses. Le croisement des axes n'est pas non plus
nécessairement situé sur le point de coordonnées (0,0) (voir § 7.5).
O y:=2: # et l'expression ne dépend en réalité que de x
plot(exp(-abs(x-1))+y,x=-2..3);
2,9
2,6
2,4
2,2
K2 K1
0
x
1
2
3
En raison de l'évaluation préalable des arguments d'une fonction, l'expression peut aussi être
assignée à un nom et la commande précédente deviendrait par exemple
O f:=exp(-abs(x-1))+y;
plot(f,x=-2..3); # Graphique identique au précédent
# et volontairement effacé.
f := eKx K 1 C 2
ATTENTION : on notera bien que malgré un nom trompeur habituellement réservé aux
fonctions, f est ici le nom d'une simple expression, pas d'une fonction ou d'une procédure (voir
le paragraphe suivant). Ecrire f x ne générerait pas pour autant une erreur, mais il s'agit d'une
tolérance syntaxique admise par plot ! Par contre utiliser un autre nom de variable que x
2
> plot(f(t),t=-2..4);
engendrerait une erreur en renvoyant un graphique vide (voir § 6).
On peut aussi tracer une expression définie par intervalles (voir en complément l'option de
gestion des discontinuités discont au § 7.6).
O p:=piecewise(x<=0,exp(2*x),
x<3,1+(1-exp(-x))+0.2*sin(5*x)*exp(-0.1*x),1):
plot(p,x=-2..4);
2,0
1,6
1,0
0,6
0,2
K2 K1
0
1
x
2
3
4
MAPLE peut réaliser des tracés plus sophistiqués. Ici l'intégrale n'a pas pu être calculée
exactement...
O It:=sin(x^2)-int(exp(-cos(t)),t=0..x);
x
It := sin x2 K
eKcos
t
dt
0
ce qui n'empêche pas plot de donner une représentation graphique en évaluant numériquement
l'intégrale de façon interne (attention cependant aux temps de calculs dans certains cas).
O plot(It,x=0..3);
0
1
2
3
x
K1
K2
K3
3.2 Tracé d'une fonction définie par un opérateur ou une
procédure
3.2.1 Fonction définie par un opérateur
On peut procéder de deux façons
1) En donnant l'expression de cette fonction sous la forme f x ou en utilisant tout
autre nom de variable, ce qui nous ramène aux cas précédents.
O f:=x->exp(-x^2)/sqrt(Pi):
plot(f(t),t=-3..3); # Graphique effacé
2) En donnant seulement le nom de la fonction et en ne précisant pas de nom pour
3
l'abscisse mais seulement l'intervalle de variation.
O plot(f,-3..3);
0,5
0,4
0,3
0,2
0,1
K3 K2 K1 0
1
2
3
Pour les fonctions de plusieurs variables, disons fp x, y, z on ne pourra utiliser que la
forme 1) en précisant la ou les valeurs numériques des autres variables, par exemple
O plot(fp(3.2,z,5/3),z=0..Pi); # Commande non exécutée
3.2.2 Fonction définie par une procédure
On peut aussi utiliser deux syntaxes.
1) Comme précédemment en n'utilisant pas de nom de variable
O G:=proc(x) if x<=0 then exp(-x^2) else sin(x)/x fi end:
plot(G,-Pi..Pi);
1
0,8
0,6
0,4
0,2
K3 K2 K1 0
1
2
3
2) Comme pour le tracé d'une expression, mais en prenant bien soin de retarder
son évaluation en utilisant '...'. On peut aussi utiliser la fonction evaln (evaluate as a
name). En cas d'oubli le message d'erreur qui en résulterait peut de ne pas être très facile à
interpréter...
O plot('G(x)',x=-Pi..Pi); # Graphiques effacés
plot(evaln(G(x)),x=-Pi..Pi);
Pour une procédure à plusieurs variables, disons Gp x, y, z , on ne peut avoir qu'une seule
variable indéterminée (la variable "abscisse") et la syntaxe donnée en 1) ne peut pas être
employée. On ne pourra utiliser que les deux formes
O plot('Gp(1/3,z,5)',z=0..Pi); # Commandes non exécutées
plot(evaln(Gp(1/3,z,0.5)),z=0..Pi);
La procédure peut être aussi une fonction de MAPLE. On pourra se reporter à l'exercice 6.8
pour un exemple.
3.3 Fonction plot et tracés multiples
On obtient plusieurs tracés simultanés en demandant à plot de tracer la liste des expressions.
Par défaut, une couleur est associée automatiquement à chaque courbe, mais on verra par la suite
que l'on peut tout contrôler (voir par exemple § 7.3). On peut aussi donner l'ensemble des
expressions, mais attention alors à la correspondance des options.
O n:=0:
4
O
plot([BesselJ(n,x),sin(x)/x],x=-3*Pi..3*Pi);
1
0,8
0,6
0,4
0,2
K8
K6
K4
K0,2
2
4
6
8
x
K0,4
-------ATTENTION----On montrera dans les prochains paragraphes comment effectuer des tracés de fonctions en
coordonnées polaires, de fonctions définies par une équation cartésienne, etc. Mais on ne peut
pas toujours afficher avec une commande unique sur un même graphique, des représentations
de natures différentes. On utilisera pour cela la fonction display de la bibliothèque plots (voir le
§ 14.1)
------------------------------
3.4 Fonctions plot et Explore
La fonction Explore n'est pas spécifique aux tracés (Ch. 1, § 8.4.8.1), mais permet de faire
varier "à la souris" des paramètres dans une expression et d'en observer les effets de façon
immédiate (l'application est du type de celle décrite au Ch. 1, § 8.4.8.4-3a). Dans l'exemple
suivant que l'on pourra reproduire, Explore va déterminer que les seuls paramètres libres sont a
et x_max.
O Explore(plot(exp(-a*x)*cos(Pi*x),x=0..x_max));
Cette fonction est aussi accessible par un clic droit quand la commande est écrite en mode
"Math", par exemple : plot exp Ka$x $cos p$x , x = 0 ..x_max
Exercice : pourquoi aucune des cases "skip" qui apparaissent dans cette application ne doivent
être cochées quand on utilise la combinaison Explore-plot.
4 Modifications interactives des dessins
ATTENTION : Lors d'une prévisualisation, création d'un pdf, impression sur papier, les
illustrations des graphiques peuvent être modifiées et même altérées. Si cette opération est
envisagée, il est prudent de se reporter au § 8.4.6 du Ch. 1 pour pallier cette difficulté.
4.1 Taille et proportion Longueur/Largeur
Quand on clique sur un dessin, celui-ci apparaît entouré d'un cadre qui permet par le
glissement des petits "carrés" avec la souris de modifier la taille et la proportion du dessin. En
maintenant la touche "Shift" enfoncée on modifie la taille en conservant la proportion.
4.2 Modifications interactives
MAPLE permet de modifier, illustrer, sauvegarder un graphique simplement par menus et/ou
au clavier. A partir du dessin précédent (§ 3.3) on peut obtenir celui qui suit et l'Annexe 1 en fin
de chapitre décrit les diverses possibilités de MAPLE. Mais il faut savoir que la plupart des
actions que l'on réalise "à la main" peuvent aussi être définies par des options de commandes
telles scaling, color, title, etc (§ 7). Ceci est extrêmement utile, voire indispensable, quand on
5
veut automatiser ces actions. Même les écritures de formules peuvent être automatisées. La suite
de ce chapitre en montrera des exemples.
Comparaison entre la fonction de Bessel J0 et le Sinus Cardinal
y
Fonction de Bessel
Sinus cardinal
1
J0 x
1
2
Sinc x =
CN
KN
1
p
J0 x dx = 1
0,5
CN
sin x
x
Sinc x dx = 1
KN
x
K10
0
K5
5
10
K0,5
5 Enregistrement d'un graphique dans un fichier
Il est souvent nécessaire de sauvegarder une représentation graphique dans un fichier afin de
l'inclure ensuite dans un autre fichier (types Word, PowerPoint, LaTeX, etc.). On peut opérer de
trois manières:
5.1 Copier-coller
Il est possible d'importer un graphique MAPLE dans certains logiciels d'édition par un
simple copier-coller, mais généralement la qualité sera moyenne.
5.2 Enregistrement interactif
On utilise le menu général Plot/Export de MAPLE. Ce menu n'est actif (non grisé) que
lorsque l'on a cliqué sur le dessin. On pourra aussi utiliser l'item Export du menu contextuel
apparaissant avec un clic "droit" sur le dessin. Selon la plateforme utilisée, un certain nombre de
formats sont proposés qu'il suffit de sélectionner. Une fenêtre s'ouvrira pour demander de
préciser le nom et l'emplacement du fichier créé. Les fichiers au format postscript encapsulé
(eps) ainsi créés sont directement utilisables sous LaTeX où l'environnement \usepackage
{graphicx} permet le redimensionnement d'une figure, par exemple : \includegraphics[width=
8cm]{Gauss.eps}. Le format eps crée des graphiques de qualité, mais beaucoup de logiciels
d'édition ne reconnaissent pas ce format (parce que sa génération est libre de droit, mais son
6
interprétation ne l'est pas). Cependant si l'on dispose d'un logiciel de conversion de format, une
exportation par MAPLE en eps suivie d'une conversion (par exemple au format TIFF) donne en
général de très bons résultats. Une exportation-importation directement au format GIF donne
aussi de bons résultats.
Le contenu de ce fichier peut, si besoin (?), être inséré et affiché dans une feuille MAPLE
sauf au format eps et pour la raison donnée ci-dessus (voir Ch. 1, § 8.4.8.4-5).
Les séquences animées (voir § 13.6 et § 14.3) seront enregistrées dans des fichiers au
format GIF (Graphics Interchange Format).
5.3 Enregistrement par commande
La sauvegarde interactive est pratique pour un ou quelques dessins isolés. Mais si l'on doit
automatiser la tâche, on peut à l'aide de la fonction plotsetup, modifier la façon dont MAPLE va
renvoyer son graphique. Il est possible de lui demander de ne ne pas l'afficher sur l'écran mais
de l'écrire directement dans un fichier. Dans ce cas toutes les finitions du dessin (titre, légendes,
textes, etc.) doivent être contenues dans la ou les commandes qui créent le dessin (ou faites a
posteriori avec un autre logiciel).
On doit préciser
- Le nom du "pilote" qui va fixer le format du fichier, ici gif.
- Le nom du fichier avec l'option plotoutput="nom_du_fichier". Le nom_du_fichier
est une chaîne de caractères pouvant contenir le chemin d'accès complet au répertoire (voir des
explications plus complètes au chapitre 20, Lecture, écriture et fichiers). Ici on écrit le fichier
Gauss.gif sur le Bureau d'un Mac ou Linux
O G:=exp(-t^2):
plotsetup(gif,
plotoutput=cat(kernelopts(homedir),
"/Desktop/Gauss.gif")):
plot(G,t=-3..3);
Sous Windows on utilisera la même syntaxe bien que le caractère standard séparateur de
répertoires soit "\" (voir chapitre 18). MAPLE ré-interprètera la chaîne correctement.
Ces commandes vont construire un fichier de type graphique (son contenu peut, si besoin (?),
être inséré et affiché dans une feuille MAPLE sauf au format eps ; voir § 5.2 et le Ch. 1 §
8.4.8.4-5).
On revient à un affichage à l'écran dans la feuille de calcul (ou dans une fenêtre séparée
suivant l'option choisie par défaut ; voir l'introduction du chapitre) avec
O plotsetup(default);
Remarque : l'option window force, indépendamment de l'option par défaut, l'affichage du
graphique sur une fenêtre séparée. De même il existe inline qui, au contraire, forcera l'affichage
sur la feuille de calcul.
O plotsetup(window):
plot(G,t=-3..3);
plotsetup(inline);
On trouvera des informations sur les nombreux pilotes avec la commande suivante. L'aide
contient un hyperlien spécifique pour le pilote postscript.
O ?plot/device
Créons maintenant un fichier de type postscript encapsulé (eps). Avec plotoptions on a fixé
- la taille du dessin avec width (largeur) et height (hauteur). Préciser l'unité (pt, cm, in; pt par
défaut où pt vaut 1/72 d'in). On notera que les options sont quotées par "..." ou par `...` et non
par '...'
- l'orientation de la feuille de papier en mode portrait. L'option par défaut est landscape
(paysage).
- la suppression du cadre avec l'option noborder.
- la marge à gauche avec leftmargin et en bas avec bottommargin (préciser ici aussi les
unités).
7
Il existe d'autres options (voir > ?plot/ps).
O plotsetup(eps,plotoutput=cat(
kernelopts(homedir),"/Desktop/Gauss.eps"),
plotoptions="width=10cm,height=10cm,portrait,noborder,
leftmargin=8cm,bottommargin=17cm"):
plot(G,t=-3..3);
On rappelle que LaTeX autorise le redimensionnement d'une figure au format eps (voir § 5.2).
6 Quelques erreurs classiques avec l'utilisation de plot
On recense ici quelques erreurs classiques que l'on peut rencontrer lors de l'utilisation de cette
fonction.
1) On lance une commande plot et aucun dessin ne s'affiche, mais aucun message d'erreur
n'est renvoyé ?
O plot(sin(x),x=-Pi..Pi);
Soit on a terminé la commande par ":", soit on a oublié, comme ici, de demander à MAPLE de
revenir à l'affichage par défaut (voir la fin du § 5.3). On a détruit dans ce cas le contenu du fichier
"Gauss.eps" en le remplaçant par cette représentation du sinus car les options précédentes de
plotsetup sont toujours actives. On corrige avec (voir § 5.3)
O plotsetup(default);
2) On demande le tracé d'une expression, mais un message d'erreur du type suivant revient
O E:=exp(-sin(y)):
plot(E,y=-3..3);
Error, (in plot) unexpected option: 2 = -3 .. 3
La raison est que 2 est assigné à y (voir § 3.1) et l'évaluation préalable des arguments remplace
y=−3..3 par 2=−3..3
O y;
2
3) Le graphique est celui d'une constante. L'utilisation de la forme désassignée (on devrait dire
plus exactement "évaluation retardée") de y permet de contruire le graphique précédent, mais ne
change pas le fait que E est une constante puisque y vaut 2 (E = exp Ksin 2 ). Déassigner y
(> y:='y':) avant de lancer la commande ne changera rien puisque E a été construite avec y
assigné (voir Ch. 2).
O E;
evalf(E);
plot(E,'y'=-3..3);
eKsin 2
0.4028071261
0,6
0,5
0,4
0,3
K3 K2 K1
8
0
y
1
2
3
Un exemple très classique...
O S:=[seq(k*sin(2*Pi*y/k^2),k=1..10)]:
y:='y':plot(S,y=-1..1);
2,5
2
1,5
1
0,5
K1
K0,5
0
0,5
y
1
4) Le dessin est "écrasé" et illisible en raison d'un axe des ordonnées trop étendu. Il ne s'agit
pas véritablement d'une erreur : voir le remède au § 7.5-e.
O plot(x+1/(x-1),x=-0.5..b);
K0,5 0
K1000
0,5 1 1,5 2
x
K2000
K3000
K4000
5) Le graphique s'affiche vide.
a)
O plot(G,x=-3..3);
Warning, unable to evaluate the function to numeric values in the
region; see the plotting command's help page to ensure the calling
sequence is correct
10
5
K3 K2 K1 0
1
2
3
x
K5
K10
La raison vient de la définition de l'expression G qui dépend de t et non de x (voir § 5.3). Il suffit
donc de remplacer x=-3..3 par t=-3..3 dans la commande précédente.
O G;
2
eKt
Les graphiques vides des exemples suivants on été effacés.
9
b) On a un résultat strictement identique avec un nom erroné mais non assigné pour désigner
l'expression. L'interprétation est un peu différente car plot "voit" maintenant une expression
parfaitement correcte qui se résume à la seule nouvelle variable libre Gx. Par exemple
> plot(Gx,Gx=-3..3); serait correct et tracerait une droite.
O plot(Gx,x=-3..3);
Warning, unable to evaluate the function to numeric values in the
region; see the plotting command's help page to ensure the calling
sequence is correct
c) Ou bien on pense que le nom est associé à une fonction alors qu'il ne s'agit que d'une expression.
La fonction plot admettrait néanmoins dans ce cas que l'on écrive
> plot(Z(t),t=-3..3)
O Z:=sin(t)/t-t:
plot(Z(x),x=-3..3);
Warning, unable to evaluate the function to numeric values in the
region; see the plotting command's help page to ensure the calling
sequence is correct
d) Autre possibilité : on a oublié de fixer le nom de la variable en donnant l'intervalle.
O plot(x*exp(-x),-3..3);
Warning, unable to evaluate the function to numeric values in the
region; see the plotting command's help page to ensure the calling
sequence is correct
e) Il se peut aussi que l'intervalle de tracé soit réduit à un point. En effet on a t=0..0 puisque n vaut
0 (voir § 3.3). Aucun message d'avertissement n'apparaît dans ce cas.
O plot(G,t=0..n);
f) L'exemple suivant, lié au domaine de définition de la fonction, relève du cas 6).
O plot(ln(x-3),x=1..2);
Warning, unable to evaluate the function to numeric values in the
region; see the plotting command's help page to ensure the calling
sequence is correct
g) L'expression dépend de plus d'une variable libre : ici n et x. Evidemment, aucun tracé n'est
possible.
O n:='n':
plot(BesselJ(n,x),x=0..10);
Warning, unable to evaluate the function to numeric values in the
region; see the plotting command's help page to ensure the calling
sequence is correct
Attention : ce diagnostic n'est pas toujours immédiat ! On sait (voir § 3.1) que y vaut 2 et il ne
devrait pas y avoir de souci...
O plot(BesselJ(y,x),x=0..10);
Warning, unable to evaluate the function to numeric values in the
region; see the plotting command's help page to ensure the calling
sequence is correct
Mais il y a "ce que l'on croit savoir" et "ce qui est"... Examiner attentivement au cas 3) "Un exemple
très cassique..." (et sans compter le fait qu'une commande peut avoir été exécutée puis effacée...)
Exercice : par contre... Expliquer.
O plot([seq(BesselJ(n,x),n=0..3)],x=0..10);
1
0,8
0,6
0,4
0,2
0
K0,2
K0,4
2
4
6
x
10
8
10
6) Le graphique ne s'affiche que partiellement.
Seule la représentation de la première fonction s'affiche car l'image de 1 K x K 4 2 n'est pas
définie dans ℝ pour aucune valeur (sauf une) des abscisses contenues dans l'intervalle choisi pour
le tracé (voir la fonction complexplot § 13.5).
O plot([sin(-x^2+3),sqrt(1-(x-4)^2)],x=1..3);
1
0,5
0
1,5
K0,5
2
x
2,5
3
K1
Mais il suffit d'un sous intervalle correct pour que plot soit satisfait... Si aucune fonction n'est
calculable dans ℝ avec aucune valeur de l'intervalle des abscisses, le graphique revient vide avec un
message d'avertissement.
O plot([sin(-x^2+3),sqrt(1-(x-4)^2)],x=1..4);
1
0,5
0
2
3
4
x
K0,5
K1
7) La syntaxe pour une fonction ou une procédure est incorrecte (voir § 3.2).
O f:=x->x*exp(-x);
plot(f,t=-3..3);
f := x/x eKx
Error, (in plot) expected a range but received t = -3 .. 3
Maintenant f(t) est bien une expression (celle de f quand la variable vaut t) et on est ramené à un des
cas de graphiques vides. Voir le cas d) dans 5) ci-dessus.
O plot(f(t),-3..3);
Warning, unable to evaluate the function to numeric values in the
region; see the plotting command's help page to ensure the calling
sequence is correct
Pour une procédure (plus compliquée que celle-ci) le message d'erreur qui en résulte n'est pas
forcément très clair...
O F:=proc(x,y) if x<=0 then exp(-x^2+y) else y+sin(x)/x fi end:
plot(F(x,2),x=-Pi..Pi);
Error, (in F) cannot determine if this expression is true or
false: x <= 0
11
7 Exemples de quelques options de plot
------Important-----Les options sont décrites ici sous forme de commandes, mais sont pour la plupart accessibles
par le menu général Plot de MAPLE. Ce menu n'est actif (non grisé) qu'après avoir cliqué sur
un dessin (voir l'Annexe 1 en fin de chapitre). On peut aussi accéder à ces options par un "clic
droit" sur le graphique qui fait apparaître un menu contextuel. Bien que ponctuellement très
pratique, cette méthode de gestion par menu pourrait s'avérer rapidement fastidieuse et celle par
commandes plus avantageuse en fonction du contexte de travail.
-------------------------On n'a pas voulu donner ici le catalogue exhaustif des options. Seules les principales sont
classées par paragraphe, certaines autres apparaîtront au fur et à mesure des exemples. On pourra
toujours les explorer avec l'aide en ligne.
O ?plot/options
Les options color (§ 7.3), scaling et view (§ 7.5) sont les plus fréquemment utilisées. Une autre
option importante, style, sera décrite au § 9.2.
Quand une option doit s'appliquer sur plusieurs tracés avec différentes valeurs on utilise une liste
qui s'applique par correspondance. Si une option s'applique à toutes les courbes avec la même
valeur, il est inutile de former une liste (voir ci-dessous des exemples avec les options de couleur et
de style). On peut remplacer dans plot la liste [...] des expressions à tracer par un ensemble
{...}, mais l'association par correspondance n'est plus garantie.
7.1 Options permanentes
Lorque l'on doit faire un nombre important de dessins avec les mêmes options (scaling, color
ou autres) il peut être intéressant de définir ces options de façon permanente pour la durée de la
session ou entre deux ordres restart avec la fonction setoptions de la librairie plots (§ 13). Par
exemple
plots:-setoptions(scaling=constrained,color=["Black","Blue"]):
Une option spécifiée dans une commande annule et remplace une option permanente juste pour
cette commande.
7.2 Légendes des courbes
Les légendes sont de petits encadrés automatiques obtenus avec l'option legend et qui
permettent de repérer chaque courbe (voir le second exemple au § 13.5.1 et l'annexe 1 § A1- 3 à
la fin de ce chapitre). Une option du menu Tools/Options (Windows/Linux) ou MAPLE
12/Préférences (Mac) onglet Display permet de rendre automatique ou non l'apparition des
légendes (voir Ch. 1, § 8.3.7).
7.3 Les couleurs, les styles et les épaisseurs des tracés des courbes
- On peut imposer les couleurs des courbes avec l'option color="Nom_couleur" (toutes les
courbes prennent la même couleur) ou color=["Nom_couleur_1","Nom_couleur_2", ...] (une
couleur est associée à chaque courbe par correspondance de listes ; voir aussi la fonction
setcolors de la bibliothèque plots). Les couleurs pré-nommées sont au nombre de 142 et on les
trouvera dans l'aide en ligne
O ?plot/colornames
On peut définir ses propres couleurs (voir exercice 6.10) et également utiliser d'autres modes
plus sophistiqués avec des fonctions de couleurs. On notera avec l'exemple suivant qu'une seule
couleur est affectée à color imposant ainsi aux deux courbes de prendre la même couleur.
- On peut également imposer divers styles de tracés avec l'option linestyle. Les possibilités
sont solid, dot, dash, dashdot, longdash, spacedash, spacedot qui peuvent être désignées
par leurs noms ou par le numéro d'ordre de cette liste (2 ⇒ dot).
12
Attention : l'option linestyle est différente de l'option style qui sera définie au § 9.2.
- L'épaisseur est fixée par l'option thickness qui prend des valeurs entières 0, 1, 2, ...
Contrairement à ce que dit l'aide en ligne, la valeur par défaut est 1 et non 0.
O restart:
plot([exp(sin(-x^2)/x),BesselK(0,x)],x=1/2..3,
color="Blue",
linestyle=[solid,2],thickness=[0,3]);
1,4
1,2
1,0
0,8
0,6
0,4
0,2
0,5
1
1,5
x
2
2,5
3
On veut tracer sur [−1,+1] les polynômes de Tchébycheff Tn x pour n allant de 1 à 6, colorier
T1 x en bleu, T6 x en rouge et tous les autres en noir. Noter l'utilisation de l'opérateur seq
pour construire la liste des polynômes ainsi que de l'opérateur $ qui évite une écriture répétitive
pour construire la liste des couleurs (x$n ⇒ x,x,x,... n fois).
O plot([seq(ChebyshevT(n,x),n=1..6)],x=-1..1,
color=["Blue","Black"$4,"Red"]);
1
0,5
K1 K0,5 0
K0,5
0,5
x
1
K1
7.4 Titres, légendes, formules, flèches ou polygones, fonction
typeset
L'option title permet de rajouter un titre (au dessus) et l'option caption une légende (en
dessous). Elles peuvent prendre diverses formes:
1) title="Texte a écrire" où "..." est une chaîne de caractères (voir chapitre 18).
2) title=un symbole assigné ou non assigné. S'il est assigné il sera évalué et substitué. Ci2
dessous title=G donnerait e Kt comme titre.
3) title="Texte" ou symbole et titlefont=[Police,Style,Taille] . Pour les polices et leurs
styles, voir l'aide en ligne et les divers exemples.
4) title=["Texte" ou symbole , font=[Police,Style,Taille]] où Police, style et taille sont
chacun optionnel (voir ci-dessous).
5) Tout est identique pour caption, sauf pour titlefont. Seules les formes 1), 2) et 4) sont
utilisables.
13
7.4.1 La fonction typeset
Les "Textes" peuvent être écrits avec la fonction typeset qui permet de composer des chaînes
avec des formules. Tout ce qui n'est pas mis entre deux " sera évalué et si on remplace Int
(G,...) par int(G,...) dans l'exemple ci-dessous, caption écrira p = p car l'intégrale sera
évaluée (voir le chapitre Intégration à propos de l'opérateur inerte Int). On notera le caractère
"\n" (dans "\nNormalisation...") qui permet de forcer un retour sur une nouvelle ligne (voir
une autre façon de faire avec le second exemple du § 13.7). Les polices de texte suivent la
spécification de l'option associée mais les symboles mathématiques s'adapteront à la norme
conforme à l'usage (police grecque, italique, etc.).
O G:=exp(-t^2):
plot(G,t=-3..3,
title="Courbe de Gauss",titlefont=[HELVETICA,italic,12],
caption=[typeset("La fonction est définie par :
",
f(t)= G,"\nNormalisation : ",
Int(G,t=-infinity..infinity)=sqrt(pi)),
font=[12]],
labels=["",""]); # voir § 7.5 "La gestion des axes"
Courbe de Gauss
1
0,8
0,6
0,4
0,2
K3
K2
K1
0
1
2
3
La fonction est définie par : f t = eKt2
N
Normalisation :
eKt2 dt =
p
KN
L'affichage, par commandes, de formules de flèches ou de polygones sur le dessin lui-même
nécessite l'utilisation de la librairie plots avec les fonctions textplot, arrow, polygonplot et
display (voir § 14.2).
7.5 La gestion des axes
a) Il existe un grand nombre d'options et sous-options permettant de contrôler finement la
construction des axes, leurs écritures associées, les tracés de grilles, etc. On notera aussi la
possibilité de construire une représentation avec deux axes différents pour les ordonnées (voir §
13.7). On ne donnera ici à titre d'illustration qu'un exemple rassemblant quelques unes des
options, mais le lecteur devra se référer à l'aide en ligne pour une information complète.
O ?plot/options
- Pour l'option labels on a écrit N='A'... pour éviter que A ne soit remplacé par sa valeur 1.2.
Pour supprimer les labels par défaut on écrira labels=["",""] (voir l'exemple précédent).
L'option axesfont s'adresse à l'écriture des valeurs sur les axes, alors que labelfont d'adresse à
leurs légendes. Les polices de texte suivent la spécification de l'option associée mais les
14
symboles mathématiques s'adapteront à la norme conforme à l'usage (police grecque, italique,
etc.). On pourra aussi utiliser typeset (voir § 7.4.1).
- L'option tickmarks=n n'est qu'une indication que plot adapte à la situation (pour l'axe des
abscisses axis[1]=[tickmarks=[10,...]] pour x=0..1.6 ne donne que 9 "ticks" pour tomber sur
des valeurs affichées "raisonnables" telles 0,2 ... 0,8 ...). L'option subticks=n affiche n
"subticks" et divise donc l'intervalle entre deux "ticks" en n+1 sous-intervalles (par conséquent...
éviter subticks= 5 ou 10 et utiliser plutôt subticks= 4 ou 9 !).
- Les options color, thickness, etc. de gridlines sont les mêmes que pour les courbes.
- Il existe également une option générale gridlines=true qui s'applique aux deux axes.
Le dessin des axes peut aussi être contrôlé par le menu Plot/Axes/Properties,etc. (accessible
également par un clic droit sur le dessin).
Attention : une axe logarithmique pour les abscisses (option axis[1]=[mode=log]) peut
engendrer un échantillonage insuffisant. On trouvera une solution pour pallier cette difficulté au
§ 13.4).
O A:=1.2:
plot([A*exp(-1.1*x),A*exp(-0.55*x^4)],x=0..1.6,
color=["Red","Green"],
axesfont=[TIMES,bolditalic,8],
labelfont=[HELVETICA,10],
labels=[t,N='A'*exp(-lambda*t)],
labeldirections=[horizontal,vertical],
axis[1]=[tickmarks=[10,subticks=3]],
axis[2]=[color="DarkBlue",mode=log,
gridlines=[10,thickness=1,
linestyle=dot,color="DarkGrey"]] );
1
0,8
0,6
N = A eKl t
0,4
0,2
0,1
0,08
0,06
0,04
0
0,2
0,4
0,6
0,8
1
1,2
1,4
1,6
t
b) On trouve aussi quatre possibliliés pour présenter les axes avec l'option axes. Les valeurs
de axes sont aussi accessibles par le menu apparaissant après avoir cliqué sur le graphique (voir
). En anticipant un peu sur l'utilisation de la fonction display (voir § 14) de la
bibliothèque plots, on montre comment tracer un tableau (Array) de graphiques. On rappelle
que les éléments d'un tableau à deux dimensions sont donnés sous la forme d'une liste de listes
de la forme [ [A,B,...],[X,Y,...] ] (voir chapitre 5). Une présentation similaire pourrait être
obtenue avec une table (voir § 8.4.8.4-7, Chapitre 1).
Attention : l'option axes est différente de l'option axis (voir pour axis l'exemple ci-dessus ainsi
que § 13.4).
15
O plots:-display(Array([
[ plot(exp(cos(x^2)),x=-Pi..Pi/2,axes=normal,
title="axes = normal (defaut)"),
plot(exp(cos(x^2)),x=-Pi..Pi/2,axes=boxed,
title="axes = boxed") ],
[ plot(exp(cos(x^2)),x=-Pi..Pi/2,axes=frame,
title="axes = frame"),
plot(exp(cos(x^2)),x=-Pi..Pi/2,axes=none,
title="axes = none")] ]));
axes = normal (defaut)
2,5
2
1,5
1
K3
K2
K1
x
0
axes = boxed
2,5
2
1,5
1
0,5
1
K3
K2
axes = frame
K1
x
0
1
axes = none
2
1
K3
K2
K1
x
0
1
c) La fonction plot adapte l'échelle du dessin en fonction de l'amplitude des valeurs prises par
les ordonnées pour donner une représentation graphique apparaissant dans un rectangle aux
dimensions standard. Les axes sont alors seulement orthogonaux. On peut imposer que les axes
soient aussi orthonormés avec l'option scaling=constrained. Elle est aussi accessible en cliquant
sur le graphique puis avec l'item Scaling Constrained du menu principal Plot ou avec le menu
contextuel (clic droit sur le graphique) ou encore en appuyant sur le bouton-icône 1:1 dans le
menu graphique. On peut dans certains cas être amené à utiliser l'option contraire
scaling=unconstrained (voir § 8).
O plots:-display(Array([
plot(sqrt(1-x^2),x=0..1.2,color="Black"),
plot(sqrt(1-x^2),x=0..1.2,color="Black",
scaling=constrained) ]));
1,0
0,7
0,4
0,1
1,0
0,7
0,4
0,1
0
0,2 0,4 0,6 0,8
x
1
1,2
16
0
0,6 1
x
d) Si on précise un intervalle de tracé infini (de la forme a ..N ou KN ..b ou KN ..N), on
obtient un graphique pour lequel les abscisses et les ordonnées reçoivent une transformation
ananorphique par un arctan. Ceci permet de se faire une idée du comportement général de la
fonction.
O plot(x^3-4*x^2+4*3*sin(x)/x,x=-infinity..infinity,
color="DarkGreen");
N
0
KN
N
x
KN
e) Lorsque plot rencontre une discontinuité avec branches asymptotiques l'axe des ordonnées
calculé est trop grand et "écrase" le dessin en le rendant illisible.
- On peut forcer, par un troisième argument l'intervalle des valeurs de cet axe. Si on lui
donne la forme nom=a..b, par exemple y=-8..10, alors nom sera affiché sur le graphique (label
automatique). Il faut remarquer que l'argument est optionnel, mais n'est pas une option ?! Il est
optionnel puisqu'il n'est pas obligatoire, mais ce n'est pas vraiment une option car il doit être
placé obligatoirement en troisième argument et ne possède pas de mot clé associé.
- L'option view (qui elle, est une véritable option) permet de définir les intervalles des
valeurs pour les deux axes, et notamment pour l'axe des abscisses ([-1..1.5]) de façon
indépendante de l'intervalle des valeurs fixées pour les calculs ([-0.5..2]). Voir par exemple
l'exercice 2.1 du fascicule.
O Array([
plot(x+1/(x-1),x=-0.5..2,color="Red"),
plot(x+1/(x-1),x=-0.5..2,-8..10,color="Purple"),
plot(x+1/(x-1),x=-0.5..2,color="Maroon",
view=[-1..1.5,-8..10]) ]):
plots[display](%);
0 0,5 1 1,5 2
x
K1000
K2000
K3000
K4000
10
10
6
6
2
2
0,5 1 1,5 2
x
K2
K8
K1
K2
0,5 1 1,5
x
K8
7.6 Traitement des discontinuités
La droite "verticale" des trois représentations précédentes n'est pas une asymptote. Pour tracer
une représentation graphique la fonction plot calcule un ensemble de points qu'elle interpole par
des segments de droites. On peut visualiser ces points en cliquant sur le graphique et en
17
sélectionnant la sinusoïde en pointillés rouges (
) qui apparaît dans le menu
. Le trait
"vertical" précédent n'est que celui qui joint les deux points extrêmes calculés pour les deux
branches asymptotiques de la fonction. On peut demander à plot (d'essayer) de traiter les
discontinuités d'une fonction avec l'option discont = true.
O plot(x+1/(x-1),x=-0.5..2,discont=true,
color="Blue",view=[-1..1.5,-8..10]);
10
6
2
K1
K2
0,5
x
1
1,5
K8
Voir aussi l'exercice 2.3 du fascicule.
7.7 Précision du tracé
La fonction plot adapte le nombre de points calculés pour définir le tracé de façon à
représenter au mieux la courbe (option adaptive=true par défaut). On peut aussi fixer le nombre
n minimal de points utilisés (50 par défaut) avec l'option numpoints=n.
7.8 Echantillonnage
On peut imposer un échantillonnage en abscisse pour l'évaluation du tracé avec l'option
sample= x1 , x2 ,..., xN . Si l'on pose aussi adaptive=false, la fonction plot (et fonctions
assimilées) utilisera strictement cette grille en abscisse pour le tracé. Sinon, avec adaptive=true
(le défaut), le tracé sera adapté avec cette grille pour base de calcul (voir un exemple d'application
au § 13.4 à propos des tracés logarithmiques).
8 Création d'une fonction graphique
Les images d'une fonction de MAPLE créée par l'utilisateur peuvent être de nature quelconque
(Chapitre 7). En particulier, une image (au sens mathématique) peut être une représentation
graphique.
On veut dessiner des ellipses de couleur c, de demi grands axes a et b ayant pour "centre" un
point de coordonnées (x,y) dans un système d'axes orthonormés que l'on ne veut pas tracer. Une
représentation paramétrique sera bien adaptée. On peut définir pour cela une fonction E:
O restart:
E:=(a,b,x,y,c)->plot([x+a*cos(theta),y+b*sin(theta),
theta=0..2*Pi],scaling=constrained,
axes=none,color=c):
On pourra alors écrire (on notera l'option de display (voir § 14), scaling=unconstrained qui
annule l'option donnée dans la définition de la fonction E)
O plots:-display(Array([
E(2,1.5,1,3,"Blue"),
plots:-display(E(2,1,1,3,"Red"),
E(1,1,0,0,"DarkMagenta"),
E(1,3,1,1,"NavyBlue"),
axes=normal,scaling=unconstrained)]));
18
4
1
K1
K1
1
2
3
Exercice: créer une fonction qui dessine un carré dont le côté a une longueur a et dont les
diagonales se coupent en (x, y) (voir aussi § 16.1).
9 Tracés de coordonnées discrètes
On peut obtenir le tracé d'une fonction à partir d'une série de valeurs des coordonnées. Il existe
plusieurs syntaxes pour introduire ces coordonnées dans la fonction plot (pour importer des
données contenue dans un fichier, voir annexe 2 en fin de chapitre).
9.1 Syntaxes d'introduction des coordonnées dans plot
1) Les coordonnées en abscisses et ordonnées sont sous la forme de deux listes séparées
O restart:
X:=[0.6,0.7,1,1.3,1.5,2,2.5,2.7]:
Y:=[3.1,2.4,2,2.2,2.5,3,3.0,2.9]:
On peut utiliser de même des vecteurs (X:=<0.6,0.7,...> ; voir chapitre 4) ou des tableaux (X:=
Array([0.6,0.7,...], voir chapitre 5). Pour une très grande quantité de données on préférera une
structure de tableau. On écrira simplement:
O plot(X,Y); # ou bien sûr > plot(X,Y,options...)
3
2,8
2,6
2,4
2,2
2
1
1,5
2
2,5
2) Les coordonnées en abscisses et ordonnées sont sous la forme d'une liste de listes
construite ainsi : (x1 , y1 ), (x2 , y2 ),.. ⇒
x1 , y1 , x2 , y2 ,...
O XY:=[[0.6,3.1],[0.7,2.4],[1,2],[1.3,2.2],
[1.5,2.5],[2,3],[2.5, 3.0],[2.7,2.9]]:
On écrira alors
O plot(XY); # ou bien sûr > plot(XY,options...)
# Graphique identique au précédent et effacé
------ REMARQUES IMPORTANTES -----a) La syntaxe donnée en 1) est pratique, mais incompatible avec une commande simple pour
tracés multiples. En effet on ne peut pas écrire plot([X , Y , f(x)] , ...) qui provoquerait
logiquement une erreur (de même pour plusieurs jeux de données X1 , Y1 , X2 , Y2 ,... ; voir §
19
9.2). Ce n'est pas le cas avec 2) où la forme plot([XY_1 , XY_2 , f(x)] , ...) est correcte.
b) Il est très fréquent que les abscisses et les ordonnées soient rangées dans deux listes
séparées. Voici comment obtenir simplement une liste de listes adaptée pour un tracé (voir la
fonction zip à la fin du chapitre 7, Fonctions).
O XY:=zip((x,y)->[x,y],X,Y);
XY := 0.6, 3.1 , 0.7, 2.4 , 1, 2 , 1.3, 2.2 , 1.5, 2.5 , 2, 3 , 2.5, 3.0 , 2.7, 2.9
c) Si X et Y sont tous deux des Vecteurs (Vector) ou des Tableaux a une dimension
(Array) la fonction zip construit un vecteur ou un tableau qui sont aussi acceptés par plot pour
un tracé simple. Toutefois, pour certains tracés combinés (points + courbes) plot refuse le tracé
(?). On complétera donc la transformation par une conversion en liste si X ou Y sont des
vecteurs ou des tableaux.
> XY:=convert(zip((x,y)->[x,y],X,Y),list):
-----------------------------------------------------3) Si on veut tracer des ordonnées contenues dans une liste simple en fonction d'un
numéro d'ordre, ce qui revient à tracer (voir 2) la liste de listes 1, y1 , 2, y2 ,... n, yn , on
pourra utiliser la fonction listplot de la bibliothèque plots (voir § 13).
O plots:-listplot(Y); # Graphique effacé
Exercice : Créer à l'aide des fonctions plot et seq (et éventuellement zip) une commande
équivalente à listplot.
9.2 Tracés par points non interpolés
Souvent on souhaite supprimer l'interpolation linéaire (présente par défaut) entre les données
et représenter celles-ci par des marqueurs. Ceci s'obtient avec
- L'option style=point. L'autre valeur (par défaut) de style est line (ne pas confondre avec
l'option linestyle ; voir § 7.3). Comme pour toutes les options, on donnera une liste de styles
pour plusieurs jeux de données, par exemple : style=[point,line]. Dans l'exemple suivant le style
unique s'applique aux deux jeux de données.
- L'option symbol qui permet de fixer la forme des marqueurs. On peut ainsi distinguer
plusieurs jeux de données tracés simultanément en associant à cette option une liste de
marqueurs (et/ou de couleurs) différents. Les formes disponibles des marqueurs sont : asterisk,
box, circle, cross, diagonalcross, diamond, point, solidbox, solidcircle et soliddiamond.
L'option symbol est ignorée lors d'un tracé interpolé.
- L'option symbolsize qui fixe (en unités de points par pouce) la taille des marqueurs (qui
s'adapte proportionnellement lors d'une réduction du dessin).
- Pour afficher simultanément symboles et interpolation il faut superposer deux tracés en
donnant deux fois le même jeu de données.
O XY_bis:=[[0.5,1.6],[1,1.35],[1.5,1.2],
[1.85,1.15],[2.3,1.2]]:
plot([XY,XY_bis],style=point,
symbol=[solidcircle,asterisk],symbolsize=20,
color= ["Blue","Green"],view=[0..3,0..4]);
4
3
2
1
0
0
1
20
2
3
9.3 Tracés mixtes
On donne, en rappelant quelques options, un exemple de tracé simultané de points et de
courbes d'interpolation par un polynôme (en rouge) et par une spline (en bleu). On rappelle
qu'aussi bien Spline que PolynomialInterpolation acceptent les coordonnées sous la forme de
listes séparées (ou de vecteurs ou de tableaux à une dimension) ou d'une liste de listes à la façon
décrite au § 9.2-2 (voir le chapitre 7, Fonctions).
O Spl:=CurveFitting[Spline](X,Y,x):
Pol:=CurveFitting[PolynomialInterpolation](XY,x):
Spl et Pol sont deux expressions qui dépendent de x et il nécessaire de fixer un intervalle de
calcul tel x=0.5..3 quelque soient les abscisses de XY. L'option view de son coté fixe les
intervalles des coordonnées du graphique. On notera que l'option style fixe le mode de chacun
des trois tracés, "line$2" remplaçant à l'aide de l'opérateur de répétition $ la suite "line,line".
O plot([XY, Spl, Pol], x=0.5..3,
style=[point,line$2],symbol=circle,symbolsize=20,
color=["Black","Blue","Red"],
axes=boxed,axis=[tickmarks=[10,subticks=4]],
view=[0..3.5,0..5], gridlines,
title="Interpolation",
titlefont=[Times,bolditalic,15],
caption="Spline en bleu et polynôme en rouge");
Interpolation
5
4,5
4
3,5
3
2,5
2
1,5
1
0,5
0
0
0,5
1
1,5
2
2,5
x
Spline en bleu et polynôme en rouge
3
3,5
10 Tracés de données importées
Le tracé (et le traitement) de données contenues dans des fichiers externes à MAPLE est un
point très important. Afin de ne pas encombrer la lecture, il fait l'objet d'une annexe autonome à la
fin de ce chapitre (Annexe 2).
11 Courbes paramétriques
MAPLE permet de tracer simplement des courbes en coordonnées paramétriques toujours à
l'aide de la fonction plot. Il suffit de remplacer l'expression et les variations de la variable par une
liste de la forme x t , y t , t = a ..b où x t est l'expression décrivant les variations de l'abscisse
et y t celles de l'ordonnées. Il est souvent utile, principalement en raison de la présence de
branches asymptotiques qui "écrasent" la partie utile du dessin (à gauche), d'imposer les intervalles
de variation des abscisses et des ordonnées avec l'option view.
21
O plots:-display(Array([
plot([(t^3+1)/(t^2-1),t-1/t,t=-3..5]),
plot([(t^3+1)/(t^2-1),t-1/t,t=-3..5],
view=[-4..6,-5..5]),
plot([(t^3+1)/(t^2-1),t-1/t,t=-3..5],
view=[-4..6,-5..5],discont=true) ]) );
400
300
200
4
4
2
2
100
K100
K200
K300
100 300
600
K4 K2 0
2
4
K4 K2 0
6
K2
K2
K4
K4
2
4
6
On peut tracer plusieurs représentations paramétriques en créant une liste [...]. Les tracés
2
paramétriques sont compatibles avec les tracés cartésiens de la forme y = f x , ici 1 C 4e Kx . Pour
tracer cette dernière, la donnée de l'intervalle en abscisse reste nécessaire (x = K3 ..4).
O plot([ 1+4*exp(-x^2),[(t^3+1)/(t^2-1),t-1/t,t=-3..5],
[2*cos(t),sin(t),t=0..2*Pi] ],x=-3..4,
view=[-6..6,-6..5],discont=true,
color=["Red","Blue","Black"]);
4
2
K6 K4 K2 0
K2
2
x
4
6
K4
K6
12 Coordonnées polaires, elliptiques,... Option coords (2D)
Les courbes en coordonnées polaires sont introduites dans plot comme des courbes
paramétriques mais pour que plot interprète les deux premiers termes de la liste, non comme une
abscisse et une ordonnée, mais comme un rayon r t , et un angle q t exprimés tous deux en
fonction d'un paramètre t, on ajoute l'option coords = polar. Définissons deux fonctions
O rho:=t->sin(t):
theta:=t->exp(t/10):
· En coordonnées paramétriques sans l'option coords ; r donne l'abscisse et q l'ordonnée.
· En coordonnées polaires avec l'option coords=polar qui transforme la première donnée de la
liste en rayon et la seconde en angle. Il existe 15 possibilités de représentations : bipolar, cardioid,
cassinian, cartesian, elliptic, hyperbolic, invcassinian, invelliptic, logarithmic, logcosh, maxwell,
parabolic, polar, rose et tangent, dont on trouvera les définitions dans l'aide en ligne (qui contient
aussi les représentations 3D listées en premier dans la page d'aide).
22
O ?coords
· Si q t = t la syntaxe peut se simplifier par omission sous la forme plot(ρ(t), t=a..b,
coords=...).
O plots:-display(Array([
plot([rho(t),theta(t),t=0..8*Pi],axes=boxed,
title="Coordonnées paramétriques"),
plot([rho(t),theta(t),t=0..8*Pi],axes=boxed,
coords=polar,title="Coordonnées polaires"),
plot( rho(t),t=0..2*Pi,axes=boxed,
coords=polar,
title=typeset(''rho(theta)''=rho(theta),
" avec ",''theta(t)=t'',
"\n(le cercle n'est pas centré sur l'origine !)"))]),
scaling=constrained );
Coordonnées
paramétriques
Coordonnées
polaires
r q = sin q avec q t = t
(le cercle n'est pas centré sur l'origine !)
1
0,8
10
6
2
0,6
0
1
K0,6
K0,6 0
0
0,8
0
0,4
On comprend donc qu'en raison de la syntaxe des commandes, les courbes en polaires ou dans
une autre de ces représentations, soient incompatibles avec des représentations cartésiennes et/ou
paramétriques (voir au § 14 la fonction display de plots pour résoudre ce problème). Par contre on
peut tracer plusieurs courbes de même nature en en faisant la liste ([..]).
L'option axiscoordinates=polar permet de remplacer le système de cordonnées cartésiennes par
un système polaire. L'option scaling est alors inopérante et vaudra toujours constrained. Pour les
autres systèmes de coordonnées (elliptiques, etc.) voir § 13.8.
O plot([ [sin(t)*cos(t),t,t=0..2*Pi],[1/2,t,t=0..2*Pi] ],
coords=polar,axiscoordinates=polar,
color=["Red","Blue"]);
p
2
3p
4
p
0 0,1
5p
4
3p
2
23
p
4
0,4
7p
4
0
On peut aussi obtenir des représentations polaires avec la fonction polarplot de la bibliothèque
plots (voir § 13). Cette fonction permet aussi le tracé du système de coordonnées polaires, mais
possède en plus de nombreuses options (version 12 de MAPLE). L'option scaling est inopérante et
vaudra toujours constrained.
O plots:-polarplot([ [theta/(2*Pi),theta,theta=-2*Pi..2*Pi],
[sin(t),cos(t),t=0..Pi] ],
color=["Red","Blue"],
axis[angular]=[color="Green",
tickmarks=[16,subticks=2],
gridlines=[16,color="Magenta"]],
axis[radial]=[gridlines=[color="Black"]]);
p
2
5p
8
3p
8
7p
8
p
0 0,2
p
4
0,8
p
8
0
15 p
8
5p
4 11 p
8
3p
2
13 p
8
L'option angularunit=degrees de polarplot permet de travailler avec des angles en degrés. On
devra alors être attentif à opérer les transformation appropriées. Dans l'exemple précédent l'angle
balayé pour la courbe bleue est défini par cos t , t 2 [0,π], c'est-à-dire de +1 rad à -1 rad
(tangentes à l'origine à la courbe). On devra donc remplacer
[sin(t),cos(t),t=0..π] par [sin(π*t/180),180/π*cos(p*t/180),t=0..180]
pour obtenir le même résultat.
On pourra compléter ces possibilités avec la fonction coordplot (voir § 13.8).
13 La bibliothèque plots (2D)
Cette bibliothèque contient un nombre total de 57 fonctions. Certaines complètent la fonction
plot, mais d'autres concernent les tracés en 3 dimensions (surfaces ; voir chapitre 17). Attention au
s de plots.
O restart:
?plots
On rappelle que l'on peut appeler les fonctions de plots de plusieurs façons (voir Ch 1, § 8.3.5):
1) > with(plots): et toutes les fonctions sont accessibles de façon permanente.
2) > with(plots,f,g); et seules les fonctions f et g sont accessibles de façon
permanente.
3) > plots[f](...); ou indifféremment > plots:-f(...); et on utilise la
fonction f directement, mais elle n'est pas accessible de façon permanente.
Pour éviter d'avoir à donner à chacun des appels des fonctions de plots le préfixe plots:-, on
donne accès à toute la bibliothèque avec with. Terminer cette commande par ; donne la liste des
fonctions.
O with(plots):
On ne donnera que quelques exemples dans ce paragraphe et dans les suivants des fonctions de
24
plots et on laisse au lecteur le soin d'explorer l'aide en ligne... La fonction interactive de cette
blibliothèque a été sommairement présentée au début du chapitre (§ 1). On a déjà aussi utilisé la
fonction display pour afficher des tableaux de représentations graphiques et listplot pour tracer une
liste d'ordonnées (§ 9.1-3).
Attention : les informations ne sont pas nécessairement complètes et on visitera l'aide en ligne.
13.1 Représentations graphiques multiples, fonction display
La librairie plots contient la fonction display qui permet d'afficher plusieurs représentations
qui ne peuvent pas être tracées sur un même graphique avec une même commande plot
(paramétrique et polaire par exemple). On l'utilise aussi, comme sur des exemples précédents,
pour afficher plusieurs graphiques sous forme de tableau. Elle permet également d'afficher
simultanément plusieurs animations créées par animate. L'option insequence de display fournit
encore un autre mode pour les tracés animés. En raison de l'importance de la fonction display,
un paragraphe séparé lui est consacré (§ 14). On y examinera aussi sommairement la notion de
sructure PLOT.
13.2 Affichage de formules, de flèches et de polygones
La bibliothèque plots contient les fonctions qui permettent d'écrire du texte avec des formules,
des flèches ou des polygones sur un dessin. Ces opérations sont aussi décrites au
§ 14.2.
13.3 Courbes définies de façon implicite par des équations
cartésiennes: fonction implicitplot
La fonction implicitplot permet de tracer des courbes définies de façon implicite, c'est-à-dire
par des équations cartésiennes (ou des inéquations) de la forme f x, y = g x, y (ou, ce qui
revient au même, h x, y = Cte). L'équation (ou la liste d'équations) sera le premier argument et
sera mise par implicitplot sous la forme F(x,y)=0. Les deuxième et troisième arguments sont
obligatoires et donnent les intervalles de variations autorisés pour les deux variables. On notera
que
- Si le premier argument est une simple expression F, implicitplot supposera F=0. Bien
entendu, F ne doit dépendre que de deux et exactement deux variables libres. On peut aussi
donner des inégalités.
- La fonction implicitplot se comporte comme plot pour ce qui concerne la syntaxe des
arguments introduisant des opérateurs ou des procédures. On se reportera au § 3.2, mais bien
sûr en tenant compte du fait que l'on doit avoir deux variables libres ( f:=x->... devient
F:=(x,y)->..., etc.).
- On peut donner plusieurs courbes à tracer en donnant une liste d'équations ou
d'expressions.
O implicitplot([x^2+y^2-2*x-3*y = 0, y^2=4*sin(2*x)],
x=-2..2,y=-1.5..4,color=["DarkBlue","Red"]);
3
y
2
1
K2
K1
0
K1
1
x
2
Attention : toutes les options d'implicitplot de ne seront pas décrites.
25
L'option rangeasview vaut false par défaut et recadre automatiquement le domaine du dessin
en le restreignant autour de la ou les courbes détectées (dessin de gauche). Si on veut conserver
les intervalles originaux de recherche du tracé pour définir l'espace du dessin (ici [−1.2,1.2]×
[−1.2,1.2]) on doit poser rangeasview=true (ou simplement rangeasview). La notion d'abscisse
et d'ordonnée n'a avec impliciplot que le sens que l'on veut bien lui donner. C'est l'ordre des
arguments qui détermine l'orientation de la représentation.
O F:=x^2+5*y^2=1: F;
display(Array([
implicitplot(F,x=-1.2..1.2,y=-1.2..1.2),
implicitplot(F,x=-1.2..1.2,y=-1.2..1.2,rangeasview),
implicitplot(F,y=-1.2..1.2,x=-1.2..1.2,rangeasview)]),
scaling=constrained);
x2 C 5 y2 = 1
1
y
y
0,4
K0,8 K0,2 0,2
x
x
0,5
K1 K0,5 0
K0,5
0,8
1
0,5
x
0,5
K1 K0,5 0
K0,5
1
K1
0,5
y
1
K1
Pour comprendre certaines options il est indispensable de connaître le principe du tracé. Pour
trouver les courbes associées à F x, y = 0, la fonction implicitplot calcule les quantités
Fi, j = F xi , yj
pour chaque point d'une grille 26#26 (par défaut) dans le rectangle défini par les intervalles
donnés pour x et y (en notation simplifiée Fi, j 0 F1 , F2 , ... sur le dessin ci-dessous
représentant une portion de la grille). Si par exemple le produit F1 F2 ! 0 , alors implicitplot
calcule une valeur approchée de F x, y = 0 (point A) sur le segment qui relie les deux points de
la grille et ainsi de suite pour tous les couples adjacents. On notera par parenthèse que la
condition F1 F2 ! 0 ne garantit pas l'unicité de la solution, mais seulement un nombre impair de
celles-ci et, de même F1 F2 O 0 signifie soit une absence soit un nombre pair de solutions. La
fonction relie ensuite les points A, B, C... par des segments de droites.
F1
T
F4
A F2
?
B
U
F5
F3
C
F6
On peut modifier le nombre de points de la grille (la taille des mailles) avec l'option grid =
[n,m]. Si des courbes associées à une même expression deviennent "proches", on peut trouver
des points T ou U voisins de A (voir le dessin). L'algorithme risque alors de faire le mauvais
choix en reliant A à T ou à U. On suspecte que la première des trois représentations suivantes
26
n'est pas correcte. L'interpolation se fait mal car les mailles de la grille sont trop larges. On
augmente la résolution avec grid (deuxième dessin) et tout rentre dans l'ordre. Attention
cependant au temps de calcul.
L'option gridrefine=n (troisième dessin) conserve la grille standard (ou celle définie par grid
si cette option est présente) et autorise n subdivisions des seules cellules de la grille traversées
par une ou plusieurs courbes. Cette méthode est beaucoup plus avantageuse en terme de temps
de calcul, mais seulement si la grille de départ est suffisamment dense pour détecter toutes les
courbes solution (voir l'exemple suivant).
O F:=sin(x^2+6*y^2)=0: F;
display(Array([
implicitplot(F,x=0..Pi,y=0..Pi,color="DarkBlue"),
implicitplot(F,x=0..Pi,y=0..Pi,grid=[75,100],
color="DarkBlue"),
implicitplot(F,x=0..Pi,y=0..Pi,gridrefine=1,
color="DarkBlue") ])
,scaling=constrained );
sin x2 C 6 y2 = 0
3
y
3
2
y
1
0
3
2
y
1
0
1
2
0
3
2
1
0
1
x
2
0
3
x
0
1
2
3
x
Voici un autre exemple illustrant diverses options de implicitplot et notamment la différence
entre les rôles joués par grid et gridrefine. On recherche dans [0,2]×[0,2] les pics dont les
positions sont supposées inconnues, d'une fonction émergeant d'un plan z = z_min. Ces pics
sont simulés ici par deux gaussiennes bidimentionnelles.
O x[1]:=1:
y[1]:=1:
sigma[1]:=0.06:
x[2]:=0.5: y[2]:=0.5: sigma[2]:=0.06:
z_min:=1:
G:=(x,y,x0,y0,s)->2*exp(-(((x-x0)/s)^2+((y-y0)/s)^2)):
Pics:=G(x,y,x[1],y[1],sigma[1])+
G(x,y,x[2],y[2],sigma[2]):
En projection sur l'axe x ceci donne
O plot([[[0,z_min],[2,z_min]],
G(x,y[1],x[1],y[1],sigma[1])+
G(x,y[2],x[2],y[2],sigma[2])],
x=0..2,z,color="Black",linestyle=[dot,solid]);
2
1,5
z 1
0,5
0
z = z_min
0
0,5
1
x
1,5
2
On fera les remarques suivantes à propos des résultats ci-dessous :
- sur le dessin de gauche on ne voit que la trace d'un seul pic car, par malchance, la courbe
associée au deuxième est complètement contenue dans une cellule de la grille de calcul et n'en
27
coupe pas (ou pas suffisamment) de bords.
- sur le deuxième dessin on a posé gridrefine=5, mais on peut constater que l'on a toujours
qu'un seul pic détecté pour la même raison que précédemment. Par contre la subdivision a eu lieu
dans la ou les cellules qui ont détecté le pic et on pourrait constater une nette amélioration du
tracé sur un dessin plus grand. L'option filledregions est posée égale à true. Ceci entraîne la
coloration de la partie du plan correspondant à Pics-z_min > 0. On choisit les couleurs des deux
régions (<0 et >0) avec coloring. La couleur de la courbe solution est donnée par color.
- Sur le troisième dessin la taille de la maille de la grille a été diminuée en augmentant les
valeurs de grid et le deuxième pic est détecté.
O display(Array([
implicitplot(Pics=z_min,x=0..2,y=0..2,
rangeasview),
implicitplot(Pics=z_min,x=0..2,y=0..2,
rangeasview,gridrefine=5,
filledregions=true,
coloring=["White","Cyan"],
color="DarkBlue"),
implicitplot(Pics=z_min,x=0..2,y=0..2,
rangeasview,grid=[50,50],gridrefine=5,
filledregions=true,coloring=["Pink","Cyan"],
color="DarkBlue")]),
scaling=constrained);
2
1,5
y
1
0,5
0
0 0,5 1 1,5 2
x
L'option crossingrefine=n améliore la méthode d'interpolation, linéaire par défaut (n=1),
sans changer les paramètres de la grille.
L'augmentation globale de la résolution de la grille avec l'option grid n'est pas la
solution la plus économique en temps de calcul pour améliorer un tracé et doit être évitée
dès lors que toutes les courbes sont détectées.
Comme expliqué plus haut la fonction implicitplot calcule F(x,y) pour chaque point de la grille
afin de localiser par interpolation les points tels que F=0. Cette opération peut être coûteuse en
temps de calcul si F est longue à calculer. L'augmentation de la résolution de toute la grille
aggrave les choses. Si on sait qu'il n'y aura pas de problème de détection des parties de courbe(s)
comme avec l'exemple précédent, on aura même intérêt à diminuer le nombre de points de la
grille (voir l'exemple ci-dessous avec la courbe algébrique S dite strophoïde ; la motivation n'est
pas ici de réduire le temps de calcul (!), mais de trouver un exemple parlant). D'une grille 25×25
par défaut on passe à 6×6 et on joue avec les autres options. La petite taille du dessin ne le
montre pas clairement, mais le tracé de la dernière courbe est un peu meilleur.
Remarque : il existe une fonction de tracé spécifique pour les courbes algébriques (voir la
fonction plot_real_curve de la bibliothèque algcurves), mais la méthode de construction du
tracé est radicalement différente.
O grille:=[6,6];
grille := 6, 6
28
O S d x3 C x y2 K x2 C y2 = 0 :
display(Array([
[implicitplot(S,x=-1..1,y=-1..1,grid=grille),
implicitplot(S,x=-1..1,y=-1..1,grid=grille,
crossingrefine=2) ],
[implicitplot(S,x=-1..1,y=-1..1,grid=grille,
gridrefine=2),
implicitplot(S,x=-1..1,y=-1..1,grid=grille,
gridrefine=2,crossingrefine=2) ] ]),
scaling=constrained,title="Strophoïde");
Strophoïde
1
y
Strophoïde
1
0,5
y
0 0,2 0,4 0,6 0,8
x
K0,4
K0,4
K0,5
0 0,2 0,4 0,6 0,8
x
K0,5
K0,5
K1
K1
Strophoïde
1
y
0,5
Strophoïde
1
0,5
0
y
0,5
x
1
K0,5
0,5
0
K0,5
K0,5
K1
K1
0,5
x
1
Il est clair que l'équation suivante n'a pas de solution. Néanmoins un cercle apparaît dont
l'équation est donnée par le dénominateur. Par défaut la fonction implicitplot trace la courbe
associée au changement de signe de la fonction qui correspond dans ce cas à un lieu de
singularités. L'interpolation linéaire utilisée par défaut est dans ce cas mauvaise en dépit de la
présence de l'option gridrefine. On utilisera alors l'option rational=true. On peut supprimer ce
tracé avec signchange=false.
29
O F :=
1
=0:
x C y2 K 1
display(Array([
implicitplot(F,x=-1.1..1.1,y=-1.1..1.1,gridrefine=2,
rangeasview),
implicitplot(F,x=-1.1..1.1,y=-1.1..1.1,gridrefine=2,
rangeasview,rational=true),
implicitplot(F,x=-1.1..1.1,y=-1.1..1.1,gridrefine=2,
rangeasview,signchange=false)]),
scaling=constrained);
2
1
y
1
y
0,5
K1 K0,5 0
K0,5
0,5
x
1
y
0,5
K1 K0,5 0
K0,5
1
K1
0,5
x
1
0,5
K1 K0,5 0
K0,5
K1
0,5
x
1
K1
Exercice : pas d'interprétation hâtive ! Expliquer ces deux figures tirées de la même équation.
O F :=
2
xCy
K xKy
2
=0:
x2 C y K 1
display(Array([
implicitplot(F,x=-1.1..1.1,y=-1.1..1.1,gridrefine=2,
rangeasview,rational=true),
implicitplot(F,x=-1.1..1.1,y=-1.1..1.1,gridrefine=2,
rangeasview,signchange=false,axes=boxed)]),
scaling=constrained);
1
y
1
0,5
0,5
y
K1
K0,5
0
K0,5
0,5
x
1
0
K0,5
K1
K1 K0,5
K1
30
0
x
0,5
1
13.4 Tracés logarithmiques
La librairie plots contient trois fonctions relatives aux tracés logarithmiques : logplot,
semilogplot, et loglogplot (visiter l'aide en ligne). Par exemple
O f := x/
xK3
:
106
X:=[0.01,0.2,0.7,1,2,5]:
Lxy:=[seq([x,f(x)],x in X)]:
display(Array([
logplot([Lxy,f(x)],x=0.01..6,style=[point,line],
symbol=diamond,symbolsize=20,
color=["Red","DarkBlue"],title="logplot"),
semilogplot([Lxy,f(x)],x=0.01..6,style=[point,line],
symbol=diamond,symbolsize=20,
color=["Red","DarkBlue"],title="semilogplot"),
loglogplot([Lxy,f(x)],x=0.01..6,style=[point,line],
symbol=diamond,symbolsize=20,
color=["Red","DarkBlue"],title="loglogplot")
]) );
logplot
semilogplot
10 0
10 - 2
10 - 4
10 - 6
10 - 8
1 2 3 4 5 6
x
loglogplot
10 0
1
0,8
0,6
0,4
0,2
0
10 - 2
10 - 4
10 - 6
10 - 8
0,1
x
1
5
0,1
x
1
5
On peut également obtenir de tels tracés avec l'option axis[n]=[mode=log,...] de plot (voir un
exemple au § 7.5).
O ?plot,axis
Attention : que ce soit avec l'option axis[1]=[mode=log] de plot ou avec les fonctions
loglogplot ou semilogplot de plots qui portent les abscisses sur un axe logarithmique, on peut
se trouver confronté à une difficulté due à un sous-échantillonage de la fonction.
Par exemple on veut tracer l'expression y=sin(1/x) avec ce mode sur l'intervalle 10K2 , 3 p .
Le dessin de gauche ci-dessous fait clairement apparaître le problème. On peut tenter
d'augmenter le nombre de points de calcul avec l'option numpoints=M, mais cela n'améliore pas
la situation de façon satisfaisante. Construire une liste de listes de la forme XY:=
x1 , y1 , x2 , y2 ,... xM, yM (voir § 9.1-2) avec des xi adaptés ne résout pas d'avantage le
problème (voir l'explication ci-dessous).
Pour contourner cette difficulté on propose d'utiliser l'option sample déjà mentionnée au §
7.8. On transforme l'intervalle de tracé a, b en un intervalle log10 a , log10 b que l'on
divise en N intervalles égaux de longueur dx
a d 10K2 : b d 3 p : N d 50 :
log10 b Klog10 a
dx d evalf
N
0.05948542255
31
On construit ensuite une liste d'abscisses sur l'axe linéaire telles qu'elles soient régulièrement
espacées sur l'axe logarithmique
log10 a C k $d
x
Lx d seq 10
, k = 0 ..N
:
et on utilise ensuite l'option sample=Lx dans plot
O display(Array([
plot(sin(1/x),x=a..b,axis[1]=[mode=log],color="Red"),
plot(sin(1/x),x=a..b,axis[1]=[mode=log],color="Blue",
sample=Lx) ]));
0,8
0,6
0,4
0,2
0
K0,2
K0,4
K0,6
K0,8
1
0,5
0,1
0,5 1
5
x
0
0,1
0,5 1
5
x
K0,5
K1
Pour bien comprendre la signification des options sample et adaptive il faut noter le point
suivant : comme indiqué au § 7.8 la courbe bleue ci-dessus est correctement tracée car plot
utilise pour base de calcul l'échantillonnage calculé dans Lx. Ceci signifie que le tracé utilise en
réalité plus de points que n'en contient la liste car l'option adaptive vaut true par défaut. Poser
adaptive=false forcerait plot à utiliser strictement les valeurs imposées par Lx, ce qui reviendrait
à effectuer un tracé avec la liste de listes XY.
1
XY d seq x, sin
, x in Lx :
x
O display(Array([
plot(XY,x=a..b,axis[1]=[mode=log],color="Red"),
plot(sin(1/x),x=a..b,axis[1]=[mode=log],color="Blue",
sample=Lx, adaptive=false) ]));
0,8
0,6
0,4
0,2
0
K0,2
K0,4
K0,6
K0,8
0,1
0,5 1
5
x
32
0,8
0,6
0,4
0,2
0
K0,2
K0,4
K0,6
K0,8
0,1
0,5 1
x
5
On peut résumer ces calculs dans une procédure plot_xlog (voir Ch. 19)
plot_xlog
:=proc(E::algebraic,itv::name=range(realcons),
couleur::string,N::posint)
local log_a,delta,Lx;
log_a:=evalf(log10(op(1,rhs(itv)))):
delta:=(evalf(log10(op(2,rhs(itv))))-log_a)/N:
Lx:=[seq(10^(log_a+k*delta),k=0..N)]:
plot(E,itv,color=couleur,sample=Lx,axis[1]=[mode=log]):
end proc:
O plot_xlog(sin(1/x),x=1e-2..3*Pi,"Blue",50);
1
0,5
0
0,05 0,1
0,5
1
5
x
K0,5
K1
On montre maintenant comment tracer deux courbes obtenues avec cette procédure sur un même
graphique en utilisant à nouveau display (la figure de gauche est incorrecte).
O f,g:=(1-exp(-sqrt(1e6*x)))/sqrt(1e6*x),
1-exp(-sqrt(1e6*x));
f, g :=
0.001 1 K eK1000.
x
x
, 1 K eK1000.
x
O display(Array([
plot([f,g],x=1e-10..1e-2,0..1,
axis[1]=[mode=log],color=["Blue","Red"]),
display(
plot_xlog(f,x=1e-10..1e-2,"Blue",50),
plot_xlog(g,x=1e-10..1e-2,"Red" ,50)) ]));
1
1,0
0,8
0,7
0,6
0,5
0,4
0,3
0,2
0
0,1
10 - 9
10 - 7
10 - 5
10 - 2
x
33
10 - 10 10 - 8
10 - 6
x
10 - 4
10 - 2
13.5 Tracés dans le plan complexe
13.5.1 Fonction complexplot
La fonction complexplot de plots permet d'obtenir la représentation dans le plan
complexe des valeurs d'une fonction à valeurs complexes.
- Le tracé de x sur [−1,+1] est instructif. Pour x 2 K1, 0 , x = i x , ce qui
correspond au segment "vertical" sur l'axe imaginaire. De même pour x 2 0,C 1 , x est
réel et correspond au segment "horizontal" sur l'axe réel.
- Les valeurs de la variable doivent être réelles (par exemple x=−1..1 et non x=−i..+i ; voir
sinon la fonction conformal de plots ci-dessous). Les fonctions du second graphique sont
explicitement définies comme complexes.
- Quand l'objet à tracer est une liste de nombres complexes ou réels Z1 , Z2 ,..., Zi ,... ,
complexplot trace par défaut une ligne polygonale reliant les affixes R Zi , I Zi .
L'option style=point, permet de tracer ces affixes sous forme de marqueurs.
Attention : comme pour plot on peut donner simultanément plusieurs courbes à tracer dans
une liste (deuxième graphique), mais on ne peut pas donner à la fois une liste de points et une
courbe. Plusieurs listes de points peuvent être données mais seulement sous la forme [op
(L1),op(L2),...] pour former une liste unique. Voir le remède à ces difficultés avec la
fonction display au §14.
On notera que scaling et ici une option de display et s'applique aux trois représentations.
O P:=add((-1)^i*x^i,i=0..11);
L:=[solve(P,x)]:
display(Array([
complexplot(sqrt(x),x=-1..1,
axes=boxed,view=[-1.1..1.1,-1.1..1.1],
color="Blue",
title=typeset(sqrt(x)," , ",x in [-1,+1])),
complexplot([1+I+exp(2*I*t),(1/8)*sin(t^2+I*t)],
t=0..Pi,color=["Blue","Red"],
title=typeset(1+i+exp(2*i*theta)," (bleu)
,\n",
(1/8)*sin(theta^2+i*theta)," (rouge) , ",
theta in [0,Pi])),
complexplot(L,style=point,symbol=cross,symbolsize=20,
color="Red",axesfont=[Times,8],
title=typeset("Racines de ",''P(x)'')) ]),
scaling=constrained);
P := 1 K x C x2 K x3 C x4 K x5 C x6 K x7 C x8 K x9 C x10 K x11
x ,
x 2 K1, 1
1
1
2
sin q C i q (rouge)
8
, q 2 0, p
2
1
0
K1
1 C i C e2 i q (bleu) ,
0 0,5 1
0 0,5 1 1,5 2
K1
34
Racines de P x
1
0,5
K0,8 K0,4 0 0,2
K0,5
K1
0,8 1
La variable de complexplot doit prendre des valeurs réelles, mais rien n'empêche de
construire par exemple les tracés de cos(z) et sin(z) pour z = e i q avec q ∈ [0,π]. On a utilisé
l'opérateur de composition de fonctions @ (f @ g, la syntaxe habituelle étant f o g), mais on
aurait pu aussi écrire
> complexplot([sin(exp(I*theta)),cos(exp(I*theta))],
theta=0..Pi,...
Voir aussi l'exercice 7.6.
On notera les options legend et legendstyle. Les textes des légendes peuvent être
composés avec typeset (voir § 7.4.1) et/ou édités manuellement. Les options de legendstyle
sont font=[Nom_police,taille] et location=[top/bottom/right/left]
O s:=t->exp(I*t):
complexplot([[email protected],[email protected]],0..Pi,
color=["Red","Blue"],
title=typeset(z=e^(i*theta)," , ",theta in [0,Pi]),
legend=[sin(z),cos(z)],
legendstyle=[location=top,font=[TIMES,12]],
scaling=constrained);
z = ei q , q 2
sin z
0, p
cos z
1
0,5
0
K0,5
0,5
1
1,5
K0,5
13.5.2 Fonction conformal
La fonction conformal de plots permet donner une représentation d'une fonction à
valeurs complexes (et une seule à la fois, mais on peut utiliser display ; voir § 14.1) de la
façon suivante : on définit un rectangle dans le plan complexe d'une variable u en donnant
deux affixes (dans cet exemple on a pris 1/4+i / 2 et 1+i) et en utilisant une syntaxe
d'intervalle, u= 1/4+I/2..1+I. Avec grid=[n,m] on définit n segments à parties réelles
constantes (rouge) et m segments à parties imaginaires constantes (bleu) qui seront
35
considérés comme régulièrement espacés (en l'absence de cette option les valeurs par défaut
sont n=m=11). La fonction calcule ensuite les valeurs complexes de la fonction quand la
variable suit chacun des segments, dessinant ainsi dans le plan complexe image un réseau de
courbes. Un troisième argument (facultatif) donne, avec ici aussi une syntaxe d'intervalle, le
domaine du plan complexe dans lequel on souhaite représenter ce réseau de courbes. C'est en
quelque sorte l'équivalent de l'option view qui d'ailleurs pourrait remplacer "l'intervalle" 0.
.1.5+1.2*I en écrivant view=[0..1.5,0..1.2]. On peut également modifier le nombre de points
utilisés pour tracer les courbes avec l'option numxy=[N,M], c'est-à-dire N points pour
chaque segment parallèle à l'axe réel et M dans la direction imaginaire. On peut utiliser
l'option coord pour cette fonction (par exemple en polaire, les segments deviendraient des
cercle et des rayons).
Pour mériter son qualificatif de "transformation conforme" (i.e. qui conserve les angles :
les droites du plan de la variable se "coupent à angles droits", alors les courbes images aussi)
il est impératif d'introduire l'option scaling=constrained.
La fonction conformal possède son équivalent en 3D sur une sphère de Riemann.
i
I u
z z
i
2
R u
(z
1
4
1
O conformal(sin(u),u=1/4+I/2..1+I,0..1.5+1.2*I,
grid=[5,4],color=["Red","Blue"],
title=sin(u),titlefont=[TIMES,12],
scaling=constrained);
sin u
1,2
1
0,8
0,6
0,4
0,2
0
0
0,5
1
1,5
13.6 Représentations animées
La fonction animate permet de construire un graphique animé d'une représentation
cartésienne, polaire ou autres et dépendante d'un paramètre qui sera associé au temps.
- Le premier argument est le nom d'une fonction de tracé : plot, implicitplot, etc.
36
- Il ne peut y avoir qu'une seule courbe animée. On peut cependant, à l'aide de la fonction
display, animer simultanément plusieurs courbes (voir § 14.3).
- Le deuxième argument est la liste de tous les paramètres et options de construction propres
à la fonction de tracé choisie (et non à animate). Le paramètre d'animation (ici t) peut
apparaître dans chacun des éléments de cette liste (ici dans l'expression et dans l'intervalle de
tracé).
- Le troisième argument fixe l'intervalle de variation du paramètre d'animation. Il peut être
suivi d'options propres à animate (voir l'exemple suivant).
- Par défaut, animate va contruire 25 images (frames) qui seront affichées successivement.
- On peut voir défiler (en haut du dessin) les valeurs du paramètre d'animation t associées à
chaque image qui s'affiche. On peut effacer cette information avec l'option paraminfo=false.
- L'option trace=n laisserait n traces fixes de l'animation également réparties sur l'intervalle
d'animation.
Attention : La représentation qui s'affiche initialement correspond à la première image qui peut
être vide, ce qui ne signifie pas qu'il y ait une erreur... Supposons que l'on pose t = −1..3. Alors
l'intervalle de construction de la première courbe serait x = −1..−1 et la première image serait
vide.
O animate(plot,[t*x^3/10-5*sin(x)^2+t,x=-1..t,
color="Blue"],
t=0..3);
t = 2.6250
10
8
6
4
2
K1
0
1
2
3
x
K2
Il suffit ensuite de cliquer sur le graphique et lancer l'animation (
) à l'aide du nouveau
menu qui apparaît
...
...
MAPLE va afficher successivement les 25 représentations graphiques (frames) donnant
l'illusion d'une animation. L'option FPS (Frame Per Second) permet de régler la vitesse du
défilement. Noter aussi le menu
contenant
qui permet la répétition sans
interruption de la séquence. Si la séquence est périodique et si la dernière image est construite,
comme dans l'exemple suivant, identique à la première (ou l'équivalent de sa précédente) on
verra un mouvement ininterrompu et sans saccade. Le menu
permet de jouer la séquence
à l'endroit ou à l'envers et l'item
rend l'animation "oscillante". Le menu contextuel (clic droit
37
sur le graphique, item Animation) permet aussi d'accéder à ces options. Le défilement peut aussi
être obtenu en manipulant le curseur
avec la souris.
Avec ce nouvel exemple animate va mémoriser les représentations graphiques d'une rosace
décrite en coordonnées polaires par l'angle q appartenant à 0, 2 p . Le paramètre d'animation
sera le déphasage f variant dans [0 , π/4] pour 50 valeurs (50 images) fixées par l'option frames
(25 par défaut). On impose avec numpoints que chacune des 50 représentations soit définie
avec 100 points.
- On peut créer une image de fond fixe que l'on associe avec l'option background (pour la
fonction implicitplot, voir le paragraphe correspondant).
ATTENTION : rien n'interdit de créer une image de fond animée, mais mieux vaut savoir ce
que l'on fait ! La fonction animate risque de créer un "objet" énorme en terme de taille mémoire
et de taille de fichier de sauvegarde (parce que n images pour le fond et m images pour
l'animation donnent n#m images et non n+m). D'autant que le résultat risque de ne pas être celui
attendu... Voir plutôt le paragraphe de la fonction display de plots.
O Fond:=implicitplot(x^2+y^2-1/4=0,
x=-1.2..1.2, y=-1.2..1.2,
filledregions=true,coloring=["DarkBlue","SkyBlue"],
color="DarkBlue"):
O animate(plot,[[cos(4*(theta+phi)),theta,theta=0..2*Pi],
coords=polar],phi=0..Pi/4,numpoints=100,frames=50,
background=Fond,paraminfo=false,axes=none,
thickness=3);
ENREGISTREMENT : on peut enregistrer une séquence animée dans un fichier au format
GIF (Graphics Interchange Format). Voir § 5.2.
Exercice: animez la courbe définie paramétriquement par
x t = cos t
et y t = sin a t C f
où le déphasage f sera le paramètre d'animation variant de 0 à 2 p. On prendra a = 3, t dans
0, 2 p , 80 points pour définir chaque courbe et 100 images pour l'animation. Comment
appelle-t-on ce type de courbes ?
13.7 Axes duaux pour les ordonnées
La fonction dualaxisplot de plots permet de tracer deux axes différents pour les
ordonnées sur une même représentation. On peut utiliser deux formes d'appel
38
- plots:-dualaxisplot(f(x),g(x),x=a..b,options);
- plots:-dualaxisplot(P1,P2);
où P1 et P2 sont des structures PLOT qui peuvent être pré-établies (par exemple X ; voir § 14.1
pour les structures PLOT) ou introduites directement (plot). Par exemple
O X:=plot(exp(-sin(x)),x=1..3.5,
axis[2]=[color="Red"],view=[1..3.5,0.2..0.9]):
dualaxisplot(X,
plot(1/t^3*abs(cos(Pi*t)),t=1..3,
color="Blue",
axis[2]=[mode=log,color="Blue"],
numpoints=1000,view=[1..4,1e-5..1]));
10 0
0,9
0,8
10 - 1
0,7
0,6
10 - 2
0,5
10 - 3
0,4
10 - 4
0,3
0,2
1
1,5
2
2,5
3
3,5
x
Avec le dessin suivant on veut tracer un axe secondaire qui permette une lecture directe des
ordonnées en degrés Fahrenheit pour les mesures en degrés Celsius suivantes:
O Mesures:=[[5,20.06],[12.,20.17],[24.,20.27],[36.,20.34],
[42.,20.38],[48.,20.43],[54.,20.5],[60.,20.59]]:
On établit la correspondance entre échelles pour les valeurs extrêmes choisies pour les axes des
ordonnées (Celsius →Fahrenheit).
O convert(20, temperature,Celsius,Fahrenheit),
convert(20.7,temperature,Celsius,Fahrenheit);
68, 69.2600000
Dans la commande suivante le deuxième tracé a été rendu volontairement absent en prenant 0
comme valeur constante et donc hors des valeurs choisies pour les ordonnées. Il ne sert qu'à
tracer l'axe secondaire. On notera également qu'un retour à la ligne dans un texte (voir le titre)
peut aussi (voir § 7.4.1) être obtenu par un retour à la ligne (Shift-Return) dans la chaîne de
caractères de la commande.
O dualaxisplot(plot(Mesures,
style=point,symbol=solidcircle,
symbolsize=15,view=[0..70,20..20.7],
labels=["Temps [s]","Température [C]"],
labeldirections=[horizontal,vertical],
title="Evolution de la température
en fonction du temps",
titlefont=[TIMES,12]),
plot(0,0..1,labels=["","Température [F]"],
labeldirections=[horizontal,vertical],
axis[2]=[color="Blue"],view=[0..70,68..69.26]));
39
Evolution de la température
en fonction du temps
20,7
69,2
69
20,5
68,8
20,4
68,6
20,3
68,4
20,2
68,2
20,1
20
Température [F]
Température [C]
20,6
0
10
20
30 40 50
Temps [s]
60
70
68
13.8 Autres fonctions de plots
On n'a pas tout épuisé... Il existe encore des possibilités offertes par la bibliothèque plots
comme les tracés de champs de vecteurs gradplot, fieldplot , les tracés de polygones (voir §
14.2), la programmation linéaire avec inequal (voir aussi la bibliothèque simplex), etc.
O ?plots
O display(Array([
densityplot(abs(cos(x+I*y)),x=-Pi..Pi,y=-1..1,
colorstyle=HUE,style=PATCHNOGRID),
contourplot(abs(cos(x+I*y)),x=-Pi..Pi,y=-1..1,
contours=10,grid=[75,75],
filledregion,coloring=["Red","Green"])]));
On notera aussi l'existence de la fonction coordplot qui permet de tracer un des systèmes de
coordonnées (2D) décrits dans
O ?coords
40
et déjà mentionnés au § 12. On peut ainsi associer à un tracé son système de coordonnées avec
display (§ 14). La fonction coordplot possède de nombreuses options que l'on ne décrira pas.
O P:=[cos(t),sin(t),t=0..Pi]:
display(Array([
display(coordplot(polar),plot(P,coords=polar,
color="DarkGreen",
title=typeset("Coordonnées polaires\n",P))),
display(coordplot(elliptic),plot(P,coords=elliptic,
color="DarkGreen",
title=typeset("Coordonnées elliptiques\n",P))) ]),
scaling=constrained);
Coordonnées polaires
cos t , sin t , t = 0 ..p
Coordonnées elliptiques
cos t , sin t , t = 0 ..p
Attention : la courbe verte à droite ressemble de très près à un cercle, mais n'en est pas un !
14 Fonction display de plots
14.1 Affichages combinés. Notion de structures PLOT
On peut se trouver dans l'impossibilité d'afficher des courbes issues de représentations
différentes, soit parce que les options sont incompatibles dans une même commande
(cartésiennes et polaires par exemple), soit parce qu'elles sont issues de fonctions graphiques
différentes comme plot et implicitplot. Nous allons voir comment pallier cette difficulté.
Lorsqu'on lance une commande de tracé, on déclenche deux étapes:
1) La construction d'une structure de données PLOT. Elle n'est pas la description d'un
graphique mais contient simplement les informations définissant sa nature et les données
numériques nécessaires à sa construction.
2) La construction et l'affichage du graphique.
On peut cependant éviter la deuxième étape et conserver la structure créée en 1) en l'assignant à
un nom. On reprend un des exemples précédents (§ 13.5) où P est un polynôme de degré 11 et
L la liste de ses racines. L'option view, inutile ici, a été introduite à dessein pour illuster la
deuxième étape.
O P:=add((-1)^i*x^i,i=0..11):
L:=[solve(P,x)]:
A:=complexplot(L,style=point,symbol=cross,symbolsize=20,
color="Red",axesfont=[Times,8],
view=[-1.2..1.2,-1..1]);
A := PLOT ...
Le contenu de la structure PLOT peut être détaillé en écrivant > op(A); Ceci montrerait en
particulier les couples de valeurs calculées pour construire le graphique, mais l'affichage est en
41
général assez lourd. Dans les exemples des paragraphes précédents, les structures n'étaient pas
assignées à des noms et n'avaient d'existence que pendant la durée du tracé.
Pour afficher le graphique correspondant on écrira simplement (on passe maintenant à l'étape 2)
O A;
1
0,5
K1
0
K0,5
0,5
1
K0,5
K1
On veut maintenant réunir avec cette figure le cercle unité du plan complexe. La difficulté vient
de ce que complexplot ne sait pas construire avec une même commande, deux représentations,
l'une de type "marqueurs" et l'autre de type "courbe". On doit les construire séparément et les
réunir ensuite avec display.
Pour ce qui concerne la représentation graphique, on se moque de savoir que l'on superpose le
plan ℝ2 avec le plan complexe. On peut donc construire ce cercle soit avec complexplot ( e i q ),
soit en paramétrique ( cos q , sin q , q = 0 ..2 p ) ou encore en polaire:
O B:=plot(1,theta=0..2*Pi,coords=polar,
color="Blue",title="Cercle unité du plan complexe",
view=[-1.1..1.1,-1.5..1.5]):
que l'on peut afficher avec
O B;
Cercle unité du plan complexe
1,5
1
0,5
K1
K0,5
K0,5
K1
K1,5
0,5
1
On réunit maintenant ces graphiques avec la fonction display de la bibliothèque plots en
indiquant les deux structures A et B que l'on a pris soin de mémoriser. On remarquera les points
suivants:
- Le titre "Racines de..." remplace le titre "Cercle unité..." donné pour B.
- L'option axes=boxed a changé la façon de représenter les axes.
- L'option scaling=constrained peut être donnée dans display.
- Les longeurs des axes résultent d'une combinaison optimale des deux tracés précédents
(dans ce cas des deux options view).
On peut ainsi fixer dans display certaines spécifications d'affichage à condition qu'elles ne
modifient pas la nature des représentations.
O display(A,B,title=typeset("Racines de ",P),
42
O
scaling=constrained,axes=boxed);
Racines de
1 K x C x2 K x3 C x4 K x5 C x6 K x7
1,5
C x8 K x9 C x10 K x11
1
0,5
0
K0,5
K1
K1,5
K1 K0,5
0
0,5
1
On n'est pas obligé d'assigner les structures PLOT à des noms et on peut donner directement
les commandes graphiques en arguments de display. Les 3 courbes suivantes ont des modes de
construction différents et incompatibles pour être tracées par un même ordre plot (f(x), polaire et
implicite). Au même titre que toute fonction gaphique 2D, display crée une structure PLOT que
l'on peut assigner à un nom en écrivant : > X:=display(...):. Noter que les options title,
titlefont, scaling et axes sont ici des arguments de display et s'appliquent donc aux trois
représentations.
O display(
plot(exp(-x^2),x=-3..3,color="Blue"),
plot([3*sin(t)+2*cos(t),t,t=0..Pi],coords=polar,
color="Black"),
implicitplot((x/y)^2-abs(x*y)=0,x=-3..3,y=-3..3,
gridrefine=5),
title="Mélange",
titlefont=[TIMES,12],scaling=constrained,axes=boxed);
Mélange
3
2
1
0
K1
K2
K3
K2 K1
0
x
1
2
3
14.2 Affichage de textes, de formules, de flèches et de polygones
Ces objets sont construit séparément et rassemblés ensuite avec display de plots. On rappelle
que toutes ces opérations "cosmétiques" peuvent se faire "à la main" si elles n'ont pas besoin
d'être automatisées (voir l'Annexe 1 en fin de ce chapitre). Pour illustrer ce paragraphe on va
43
construire un exemple.
1) Si le document doit être imprimé on rappelle qu'un formatage préalable à l'écran de la
feuille de calcul peut être nécessaire pour éviter les mauvaises surprises (voir Ch. 1, § 8.4.6).
2) Généralement on construit d'abord la représentation graphique et on voit ainsi l'espace
dont on dispose. On notera comment on a effacé avec l'option labels les noms automatiques mal
placés des axes (dans ce cas, seul celui des abscisses existait) et comment on peut les écrire
exactement là où on le souhaite avec textplot (voir aussi 3). On notera dans la création du titre
l'utilisation d'un double "\n" (saut à la ligne) permettant de laisser un espace entre le titre et le
dessin.
O P:=plot([AiryAi(x),AiryBi(x)],x=-10.1..4,-1/2..1.3,
color=["Red","Blue"],
title="Fonctions d'Airy\n\n",titlefont=[Times,15],
numpoints=100,labels=["",""]):
X:=textplot([3.75,0.1,x]):
display(P,X):
# ou bien directement
display(P,textplot([3.75,0.1,x]));
Fonctions d'Airy
1,2
1
0,8
0,6
0,4
0,2
K10 K8 K6 K4
K0,2
K0,4
x
2
4
3) On écrit du texte et des formules au point (x , y) avec textplot et on mémorise les
structures PLOT (ici T1 et T2). La syntaxe est une liste de listes (ou une liste simple) composée
comme
[x, y, Texte, Position par rapport à (x, y)]
où Position... est une sous-option align qui peut valoir right (droite), left (gauche), above
(dessus) ou below (dessous). On peut donner une combinaison de deux de ces options.
Le Texte peut être composé avec typeset comme montré au § 7.4.1. En regardant le dessin
final, on examinera soigneusement les arguments de typeset et leurs évaluations.
O T1:=textplot([[-10,1.1,typeset("Ai(0) = ",
AiryAi(0)=evalf[4](AiryAi(0)),"..."),
align=right],
[-10,0.7,typeset("Bi(0) = ",
AiryBi(0)=evalf[4](AiryBi(0)),"..."),
align=[above,right]]], font=[Times,10]):
T2:=textplot([[3,0.9,"Bi",color="Blue"],
[3,0.4,"Ai",color="Red"]],font=[Times,10]):
4) On trace des flèches avec la fonction arrow de plots. On examinera l'aide en ligne pour
compléter ces informations sur les options. On pourra aussi utiliser arrow de plottools (§ 16.1).
- Les coordonnées (en 2D) sont indiquées sous la forme de deux vecteurs <x1 , y1 > et <x2 ,
y2 >. La flèche commence en <x1 , y1 > et se termine en <x1 + x2 , y1 + y2 >. Avec l'option
difference la flèche se termine en <x2 , y2 >. L'utilisation de cette notation plutôt que de listes est
44
très pratique en algèbre linéaire pour la représentation géométrique des vecteurs.
- Le profil d'une tête de flèche est donné par l'option shape qui peut prendre les valeurs
symboliques harpoon, arrow, double_arrow (cylindrical_arrow uniquement pour le
graphisme 3D).
- Les options width et head_length définissent la largeur et la longueur de la tête de flèche.
Si elles sont écrites par exemple par width=x, x sera la longueur absolue calculée dans les unités
de l'un ou de l'autre des axes suivant les orientations des traits tracés. Ceci peut donner un aspect
dissymétrique à la flèche quand elle a le profil shape=arrow ou double_arrow. La symétrie
n'est alors préservée qu'avec l'option scaling=constrained. Ces options peuvent aussi s'écrire
par exemple head_length=[x,relative] qui dit que la longueur de la tête est relative à la longueur
totale de flèche par un facteur x.
- Comme pour les courbes, l'option thickness définit l'épaisseur.
- Un segment ne se trace pas avec arrow, mais avec, par exemple (voir § 9.1):
plot([[x1,y1],[x2,y2]],...);
O F:=arrow([[<2.5,0.9>,<0.85,0.9>],[<2.5,0.4>,<0.8,0.25>]],
difference,color="Black",shape=arrow,
width=[0.02,relative],head_length=[0.2,relative],
thickness=2):
5) On trace un rectangle avec la fonction polygonplot de plots pour faire ressortir les deux
formules. L'option transparency prend des valeurs comprises entre 0 (couleur de fond
totalement opaque) et 1 (couleur de fond totalement transparente).
O Cadre:=polygonplot(
[[-10,0.6],[-2.5,0.6],[-2.5,1.3],[-10,1.3]],
color="DarkBlue",transparency=0.8):
On rassemble le tout sans se soucier de l'ordre...
O display(P,T1,T2,Cadre,F,X);
Fonctions d'Airy
1
Ai(0) = 3
3 1/ 3
2
G 3
1
3 5/ 6
Bi(0) = 3
2
G 3
1,2
= 0.3550...
1
Bi
= 0.6149...
0,8
0,6
Ai
0,4
0,2
x
K10
K8
K6
K4
0
K2
K0,2
K0,4
Attention : "... sans se soucier de l'ordre"... pas toujours !
45
2
4
O a:=1: b:=3/4:
C1:=polygonplot([[a,0],[0,a],[-a,0],[0,-a]],color="Red"):
C2:=polygonplot([[b,b],[-b,b],[-b,-b],[b,-b]],
color="Blue"):
display(Array([ display(C1,C2),
display(C2,C1) ]),
scaling=constrained,axes=none);
14.3 Animations avec la fonction display
Enregistrement : on peut enregistrer une séquence animée dans un fichier au format GIF
(Graphics Interchange Format). Voir § 5.2.
14.3.1 Combinaison de fonctions animate
La fonction animate n'anime qu'une fonction à la fois (§ 13.6). On peut cependant, avec
display, afficher plusieurs animations et les faire jouer simultanément. On notera avec
l'exemple ci-dessous que
- Les trois représentations sont de natures différentes: cartésienne (A), polaire (B ; § 12)
et implicite (C ; § 13.3).
- Les paramètres d'animation n'ont pas besoin ni de porter le même nom ni d'explorer le
même domaine (t=0..Pi alors que phi=0..2*Pi , ...).
- Le nombre d'images (frames) n'est pas nécessairement le même pour chaque animation
(A est construit avec 50 images et B et C avec 25 par défaut). Les 25 premières images
seront affichées ensemble pour A, B et C puis B et C disparaîtront et seules les 25 restantes
de A seront affichées.
O A:=animate(plot,[sin(3*x),x=0..t],t=0..Pi,frames=50):
B:=animate(plot,[[sin(theta),cos(3*theta),
theta=0..phi],
coords=polar,color="Blue"],phi=0..2*Pi):
C:=animate(implicitplot,[sin(x^2+u)-cos(x+y)=0,
x=0..Pi,y=-1..Pi,
filledregions=true,
coloring=["White","LightBlue"],
gridrefine=2,crossingrefine=2,
color="DarkBlue"],u=0..2*Pi):
display(A,B,C,scaling=constrained);
46
14.3.2 Option insequence
Il existe une autre possibilité avec l'option insequence de la fontion display. Elle permet
d'afficher successivement une série de graphiques fixes pouvant provenir de méthodes de
construction diverses. On va construire un exemple d'animation avec une courbe générée par
un point d'un cercle roulant sans glisser sur une autre cercle. Si le cercle roule à l'extérieur de
l'autre (k=+1) on parle d'épicycloïde et sinon d'hypocycloïde (k=-1). La figure sera
périodique si le rapport des rayons est un rationnel. Le point dessinant la courbe n'est pas
nécessairement sur le cercle roulant et peut être à une distance ρ de son centre (ρ≠r). On parle
alors d'épitrochoïde et d'hypotrochoïde. Ces courbes peuvent être représentées par les
équations paramétriques suivantes
O restart:
with(plots):
x:=(R,r,k,rho,t)->(R+k*r)*cos(t)k*rho*cos((R+k*r)/r*t);
y:=(R,r,k,rho,t)->(R+k*r)*sin(t)rho*sin((R+k*r)/r*t);
RCk r t
x := R, r, k, r, t / R C k r cos t K k r cos
r
RCk r t
y := R, r, k, r, t / R C k r sin t K r sin
r
Si R / r = 1, ρ=r et k = 1 on parle de cardioïde (épicycloïde). Pour R / r = 4, ρ=r et k = −1 on
parle d'astroïde (hypocycloïde).
O display(Array([
plot([x(1,1,1,1,theta),y(1,1,1,1,theta),theta=0..2*Pi],
title="Cardioïde (Epicycloïde)"),
plot([x(3,1,1,1,theta),y(3,1,1,1,theta),theta=0..2*Pi],
title="Epicycloïde"),
plot([x(3,1,1,1/2,theta),y(3,1,1,1/2,theta),
theta=0..2*Pi],
title=typeset("Epitrochoïde , ",rho < r)),
plot([x(4,1,-1,1,theta),y(4,1,-1,1,theta),
theta=0..2*Pi],
title="Astroïde (Hypocycloïde)")] ),
scaling=constrained);
Cardioïde
(Epicycloïde)
2
1
K3 K2
K1
K2
1
Epicycloïde
Epitrochoïde ,
r!r
4
4
4
1
1
K4 K2 12 34
K3 K1 1 2 3
K4
Astroïde
(Hypocycloïde)
K3 K1 1 2 3 4
K4
La fonction seq(...,n=0..N) construit N+1 images que l'on va afficher successivement avec
display(... , insequence=true). Si cette option n'était pas précisée, les N+1 images seraient
affichées simultanément en un seul dessin fixe. Chacune de ces images est construite en
rassembant avec une autre fonction display le cercle central fixe C, la portion d'épitrochoïde
tracée, le cercle roulant et les deux flèches. Le paramètre d'animation est
n*delta.
47
O R:=3: r:=2: rho:=3*r/2 : k:=1: N:=100: delta:=4*Pi/N:
C:=plot(R,theta=0..4*Pi,coords=polar,color="Black"):
display(seq( display(C,
plot([x(R,r,k,rho,phi),y(R,r,k,rho,phi),
phi=0..n*delta],color="DarkBlue"),
plot([(R+k*r)*cos(n*delta)+r*cos(theta),
(R+k*r)*sin(n*delta)+r*sin(theta),
theta=0..2*Pi]),
arrow([[<0,0>,<(R+k*r)*cos(n*delta),
(R+k*r)*sin(n*delta)>],
[<(R+k*r)*cos(n*delta),
(R+k*r)*sin(n*delta)>,
<x(R,r,k,rho,n*delta),
y(R,r,k,rho,n*delta)>]],difference,
color="DarkGreen",shape=arrow,
width=[abs((R+k*r))/20],
head_length=[abs((R+k*r))/10],
thickness=2))
,n=0..N),
insequence=true,scaling=constrained,axes=none);
Exercice : animer le cas R=2, r=1, ρ=r et k=−1. Le résultat est connu sous le nom de
théorème de La Hire (ou mouche de la Hire ; Philippe de la Hire, 1640-1718). Retrouver
analytiquement ce résultat et donner l'équation du mouvement.
15 Représentations des solutions d'équations différentielles
On présente ici la fonction DEplot de la bibliothèque DEtools. Cet outil est surtout utile pour les
équations qui doivent être intégrées numériquement, mais pas seulement. On peut obtenir d'autres
méthodes de tracés avec dsolve(...,numeric) et odeplot de plots (voir chapitre 15, Equations
différentielles). Mais il existe encore d'autres possibilités comme phaseportrait, dfieldplot,
poincare, etc. On pourra aussi se reporter à l'exercice 6.3 et sa correction pour des compléments
d'information.
On ne donnera ici qu'un exemple avec la fonction DEplot de la bibliothèque DEtools et avec
l'aide d'un grand classique. Soit l'équation différentielle du pendule pesant simple et amorti (y est
l'angle de déviation par rapport à la verticale et t le temps ; l'amortissement est proportionnel à la
vitesse angulaire y' )
48
O restart:
eqd:=diff(y(t),t$2)+alpha*diff(y(t),t)+omega*sin(y(t))=0:
eqd;
d2
d
y t Ca
y t C w sin y t = 0
2
dt
dt
La fonction dsolve exprime bien une solution formelle, mais son intérêt pratique est assez limité...
O sol:=dsolve(eqd,y(t));
d
sol := y t = _a &where
_b _a _b _a C a _b _a C w sin _a = 0 , _a
d_a
= y t , _b _a =
d
y t , t=
dt
1
_b _a
d_a C _C1, y t = _a
On rappelle à ceux qui s'étonneraient de ce résultat "négatif" qu'une solution exacte (du point de vue
mathématique, pas physique !) n'est obtenue qu'en faisant l'approximation dite "des petits angles"
qui consiste à poser sin y t x y t tant que y reste petit, autrement dit tant que le pendule ne
s'éloigne pas trop de la verticale.
Exercice : résoudre exactement cette équation simplifiée et en déduire la relation entre α et ω qui
sépare deux régimes physiques qualitativement distincts du comportement du pendule. En donner
une interprétation physique.
15.1 Représentation de la solution
Une solution exacte de l'équation non simplifiée ne pouvant être explicitée, on va utiliser la
fonction DEplot pour intégrer numériquement l'équation différentielle et tracer la solution.
a) Les trois premiers arguments sont
- L'équation différentielle pour laquelle tous les paramètres tels α ou ω doivent avoir des
valeurs numériques fixées.
- Le nom de la fonction solution, ici y t , est donné soit comme y(t) soit comme
[y(t)] .
- L'intervalle d'intégration, ici t=0..10
b) Les conditions initiales
- Elles doivent aussi être complétement définies numériquement (1+(nK1) conditions où n est
l'ordre de l'équation). On peut en donner plusieurs correspondant à des situations physiques
initiales différentes et on les écrit sous la forme d'une liste de listes, par exemple
[[y(0)=0,D(y)(0)=2],[y(2)=1/2,D(y)(2)=0]]
On rappelle que D(y)(0)=2 signifie y' 0 = 2 (voir le chapitre 8, Dérivation). La fonction
DEplot tracera autant de courbes que de condions (Attention cependant: voir l'option
obsrange à la fin du paragraphe). Attention : si on ne donne qu'une seule condition initiale on
devra quand même l'écrire sous la forme d'une liste d'une liste: [[la_condition_initiale]].
- Une condition initiale doit être définie au même temps t (par exemple y t = 0 = 0 et
y' t = 0 = 2), ce qui ne signifie pas que toutes les conditions initiales doivent être données au
même temps (ici t = 0 pour l'une et t = 2 pour l'autre).
c) La méthode
La méthode d'intégration numérique par défaut est rkf45 (méthode de Runge-Kutta-Fehlberg).
Elle peut être changée avec l'option method=...
O ?dsolve,numeric
d) Le pas de calcul et/ou de tracé
Pour comprendre les options associées, il faut distinguer le pas d'intégration et le pas du tracé
des courbes.
- Si L est la longueur de l'intervalle d'intégration total, sans spécification particulière le pas de
calcul pour intégrer l'équation vaut |L| / 48 (ici (10−0)/48). On peut modifier ce pas avec l'option
numsteps=m où m est le nombre de pas (m=48 par défaut). On peut aussi fixer le pas
d'intégration avec stepsize=longueur_du_pas.
49
- Sans spécification la courbe est tracée avec 49 points. On peut modifier cette valeur avec
numpoints=k, par exemple si le nombre de pas d'intégration est très grand. Le tracé de la courbe
est alors surdéfini ce qui l'alourdit (suivant la nature de l'équation et la méthode choisie on peut
avoir besoin d'un pas d'intégration petit sans pour autant avoir besoin de beaucoup de points de
tracé).
e) La couleur et l'épaisseur des tracés
Elle est définie par linecolor et non color (voir l'exemple suivant pour l'option color). La
fonction DEplot ne reconnaît pas les nouveaux noms de couleur tels "Black", "Red", etc. et on
doit utiliser les anciens: black, red, etc. Mais on peut utiliser aussi des structures COLOR.
L'épaisseur vaut 3 par défaut et se modifie avec thickness (voir les options de plot).
Contrairement à linecolor, cette option ne peut prendre qu'une valeur commune à toutes les
courbes (?).
f) Représentation
L'option scene=[t , y(t)] ou scene=[y(t) , t] permet de fixer l'orientation du dessin (surtout utile
dans le second exemple). On peut également imposer l'intervalle des ordonnées avec par
exemple
y=-1..1.
g) Animation
En posant animatecurves=true il est possible d'animer l'évolution de la ou des courbe en
fonction de l'évolution de la variable indépendante dans l'intervalle d'integration (ici t). Le
nombre d'images (25 par défaut) peut être modifié par numframes (l'équivalent de frames dans
animate de plots). On peut recevoir un message d'avertissement indiquant une correction
automatique de numpoints pour l'adapter à la valeur imposée par numframes.
La bibliothèque DEtools n'est pas (encore) une bibliothèque de modules et la syntaxe
DEtools:-DEplot ne peut pas être utilisée. Certaines options comme
labelsdirections=[horizontal,vertical], caption="...", ne sont pas reconnues ainsi que les
nouveaux noms de couleur. L'option thickness n'admet qu'une valeur commune pour toutes les
courbes, etc. La fonction DEplot fonctionne très bien mais une petite mise à jour semble
nécessaire...
O alpha:=0.5:
omega:=10:
DEtools[DEplot](eqd,y(t),t=0..10,
[[y(0)=0,D(y)(0)=2],[y(2)=1/2,D(y)(2)=0]],y=-1..1,
stepsize=0.05,linecolor=[blue,green],thickness=1,
title=typeset("Pendule amorti :\n",eqd));
Pendule amorti :
d
y t C 0.5
y t C 10 sin y t
2
dt
dt
1
d2
y(t)
=0
0,5
0
2
4
K0,5
K1
50
t
6
8
10
15.2 Portrait de phase, champ de directions
Il est en général très instructif, de découpler une équation du second ordre en un système
(une liste ou un ensemble) de deux équations du premier ordre en posant z t = y' t (voir aussi
la fonction convertsys de DEtools).
O alpha:='alpha': omega:='omega':
sys:={diff(y(t),t)=z(t),
diff(z(t),t)+alpha*z(t)+omega*sin(y(t))=0};
d
d
sys :=
z t C a z t C w sin y t = 0,
y t =z t
dt
dt
Ceci permet de construire le "champ de direction" et le portrait de phase de l'équation en dressant
une représentation paramétrique y t , z t (pour une représentation de y t, x t on utilisera
DEplot3d)
a) Les trois premiers arguments sont
- Le système d'équations différentielles pour lesquelles tous les paramètres tels α ou ω
doivent avoir des valeurs numériques fixées. Les équations peuvent être d'ordre et en nombre
quelconque.
- Les noms des fonctions solutions, ici x t et y t , donnés sous la forme d'une liste.
- L'intervalle d'intégration, ici t=0..15
b) La représentation
- Par défaut la section de plan est définie pour contenir le tracé des courbes, mais on peut
fixer les intervalles sous la forme y(t)=-3..10 ,z(t)=-6..10 (ou simplement y=-3..10 , z=-6..10).
Attention: voir plus loin l'option obsrange (e).
- L'option scene=[X,Z] où X et Y sont les noms de deux des fonctions solutions des
équations. Elle permettra de choisir de représenter X t (en abscisses) et Y t (en ordonnées)
avec scene=[X(t), Y(t)] ou inversement. Ceci permet aussi de choisir les deux fonctions à
représenter quand il y a plus de deux équations.
- L'option linecolor fixe le couleur de courbes solution.
c) Les conditions initiales : Voir l'exemple précédent.
d) Le champ de directions : Il est représenté à l'aide de petites flèches et ne peut être tracé que
pour un couple d'équations autonomes du premier ordre ou une équation du premier ordre.
- La forme des flèches est modifiable avec l'option arrows. Si elle est absente des flèches
ordinaires seront tracées, sinon les valeurs possibles sont small (défaut), smalltwo, medium,
mediumfill, large, curve, comet, line et none cette dernière valeur supprimant le tracé du
champ.
- L'option color fixe la couleur des flèches.
- L'option size fixe la taille des flèches et peut prendre la valeur magnitude ou une valeur
numérique (1.0 par défaut).
- L'option dirfield permet de définir la grille où doivent être tracé les flèches. Elle peut prendre
3 formes
- dirfield=[n,m] répartit les flèches sur n colonnes de m lignes.
- dirfield=[[x1 , y1 ] , [x2 , y2 ] , ...] permet d'imposer la position des flèches par leurs
coordonnées.
- dirfield=m trace m flèches aléatoirement réparties dans le plan.
On notera la construction du titre (l'option caption n'est pas reconnue). Le petit cercle rouge
(voir exercice suivant) a été dessiné avec le menu "Drawing" (voir Annexe A-1.4).
O alpha:=0.5: omega:=10:
DEtools[DEplot](sys,[y(t),z(t)],t=0..15,
y=-3..10,z=-6..10,
scene=[y(t),z(t)],
[[y(0)=Pi/4,z(0)=0],[y(0)=-Pi/2,z(0)=9]],
arrows=comet,color=black,
linecolor=[green,blue],thickness=2,
stepsize=0.05,
51
title=typeset("Portrait de phase du pendule amorti\n",
sys[2]," , ",sys[1]));
Portrait de phase du pendule amorti
d
d
y t =z t ,
z t C 0.5 z t C 10 sin y t
dt
dt
10
=0
8
z(t)
K2
6
4
2
2
K2
K4
4
6
8
10
y(t)
K6
Exercice : donner l'interprétation du champ de directions et des courbes en termes physiques (et
notamment la courbe en bleu). A quelle situation physique particulière correspond le point
entouré d'un petit cercle rouge. En déduire ses coordonnées exactes sur le plan de phase.
Exercice : constuire le système d'équations différentielles dans l'approximation des petits angles
et tracer le champ de directions ainsi que les solutions associées aux mêmes conditions initiales
que précédemment. Donner un interprétation de cette représentation graphique.
Un champ de direction apparaît aussi pour une équation du premier ordre (autonome ou
non) et permet d'identifier divers comportement des solutions. Cette équation de Riccati peut être
intégrée exactement par dsolve (combinaison de fonctions d'Airy et de leurs dérivées premières),
mais le comportement des solutions en fonction des conditions initiales n'est pas une évidence
quand on regarde les solutions symboliques d'un premier coup d'oeil... Le champ de direction
suivant, au contraire, indique clairement les différents régimes de solutions en fonction de y(0).
O eqd:=diff(y(t),t)=1-t*y(t)^2:
DEtools[DEplot](eqd,y(t),t=-1.8..3,y=-2..3.1,
stepsize=0.05,
[[y(0)=1],[y(0)=-1],[y(0)=-1.5],[y(0)=3]],
linecolor=[blue,red,green,magenta],thickness=2,
color=black,title=eqd);
d
y t = 1Kt y t
dt
3
y(t)
2
2
1
K1
0
1
2
t
K1
K2
52
3
e) L'option obsrange
L'intégration numérique s'effectue avec un accroissement positif de la variable indépendante et si
l'une des fonctions prend une valeur qui n'est plus contenue dans l'un des intervalles spécifiés,
l'intégration s'arrête par défaut pour cette fonction (courbe violette, représentation en haut à
gauche). Si la condition initiale est donnée en dehors du champ (y(0)=3), la courbe peut même
disparaître totalement (courbe verte absente en haut à gauche). Si l'on veut que l'intégration se
poursuive ou même se fasse on doit poser obsrange=false.
O plots:-display(Array([
[ DEtools[DEplot](eqd,y(t),t=-2..3,stepsize=0.05,
y=-1/2..2,[[y(0)=1],[y(-1.5)=0],[y(0)=3]],
linecolor=[blue,magenta,green],
thickness=2,color=black),
DEtools[DEplot](eqd,y(t),t=-2..3,stepsize=0.05,
y=-1/2..2,[[y(0)=1],[y(-1.5)=0],[y(0)=3]],
obsrange=false,linecolor=[blue,magenta,green],
thickness=2,color=black) ],
[ DEtools[DEplot](sys,[y(t),z(t)],t=0..15,
y=0..10,z=0..10,
stepsize=0.05,scene=[y(t),z(t)],
[[y(0)=0,z(0)=9]],arrows=comet,color=black,
linecolor=blue,thickness=2),
DEtools[DEplot](sys,[y(t),z(t)],t=0..15,
y=0..10,z=0..10,
scene=[y(t),z(t)],[[y(0)=0,z(0)=9]],
arrows=comet,color=black,obsrange=false,
linecolor=blue,thickness=2,stepsize=0.05)] ]));
y(t)
2
2
1,5
1,5
y(t)
1
0,5
K2
z(t)
0,5
0
K1
K0,5
1
2
3
K2
t
0
K1
K0,5
10
10
8
8
6
z(t)
4
2
2
0
2
4
6
y(t)
8
10
53
1
2
3
t
6
4
0
1
0
0
2
4
6
y(t)
8
10
16 Divers
16.1 La bibliothèque plottools
Elle permet de créer et manipuler des objets géométriques standard (en 2D et en 3D). Ceux-ci
peuvent être associés avec display avec des objets graphiques divers tels ceux créés par plot,
implicitplot, etc. Avec le menu
décrit en annexe A1-2 on peut contrôler individuellement
les tracés des contours des objets (mais pas de tous ? , pieslice par exemple).
O restart:
with(plottools):
Carre:=rectangle([-1,-1],[1,1],color="SkyBlue"):
plots:-display(
plot(x^3-2*x,x=-1.6..1.8,color="DarkBlue"),
rotate(Carre,Pi/3),
translate(ellipticArc([0,0],1,1/4,3*Pi/4..2*Pi,
filled=true, color="LightGreen"),1,1),
circle([0,0],2,color="Red"),
arc([0,0],3/2,Pi/4..Pi,color="DarkGreen"),
pieslice([0,0],3/2,0..Pi/6,color="Red"),
scaling=constrained,axes=none);
16.2 La bibliothèque geometry
Elle permet de traiter la géométrie euclidienne dans le plan (voir l'exercice 8.1, question 8.1.2
pour quelques compléments d'information).
O with(geometry):
triangle(T, [point(A,1,0),point(B,4,1),point(C,2,4)]):
incircle(C_ins,T): bisector(bA,A,T):
bisector(bB,B,T): bisector(bC,C,T):
O AreConcurrent(bA,bB,bC);
true
O draw([C_ins,T,bA,bB,bC],color=black);
4
3
2
1
0
1
2
3
4
On rappelle l'existence d'une page d'aide illustrée qui résume les diverses possibilités de tracés de
MAPLE 12.
O ?PlottingGuide
54
ANNEXE 1 - Modifications interactives des dessins
Le but de cette annexe est de donner l'essentiel des éléments permettant de modifier et d'illustrer un
graphique simplement par menus et/ou au clavier. On va construire un exemple à partir du dessin
"brut" suivant:
O restart:
plot([BesselJ(0,x),sin(x)/x],x=-3*Pi..3*Pi);
1
0,8
0,6
0,4
0,2
K8
K6
K4
K2
0
2
4
K0,2
x
6
8
K0,4
Bessel J0 x
Sinc x =
sin x
x
On note la présence des légendes des coubes (voir ci-dessous, § A1-3).
Important
Il ne faut pas oublier que la plupart des actions que l'on réalise "à la main" peuvent être définies par
des options de commandes telles scaling, color, title, etc. Ceci est extrêmement utile, voire
indispensable, quand on veut automatiser ces actions. Même les écritures de formules peuvent être
automatisées et les différents paragraphes de ce chapitre en donne des exemples.
Lors d'une prévisualisation, d'une création d'un pdf ou une impression sur papier, les illustrations
des graphiques peuvent être modifiées et même altérées. Si une de ces opérations est envisagée, il est
prudent de se reporter au § 8.4.6 du Chapitre I pour pallier cette difficulté.
Pour l'enregistrement dans un fichier voir § 5.
------------Les actions décrites ne peuvent être exécutées que si l'on a cliqué sur le graphique.
A partir du dessin précédent on peut obtenir le graphique suivant uniquement au clavier et
manipulation de menus.
55
Comparaison entre la fonction de Bessel J0 et le Sinus Cardinal
Fonction de Bessel
y
Sinus cardinal
1
J0 x
1
2
Sinc x =
CN
KN
J0 x dx = 1
0,5
1
p
CN
sin x
x
Sinc x dx = 1
KN
x
K10
K5
0
5
10
K0,5
A1-1 Taille et proportion Longueur/Largeur
Quand on clique sur le dessin celui-ci s'entoure d'un cadre et un menu apparaît. Par glissement
des petits "carrés" on peut modifier la taille et la proportion du dessin. En maintenant la touche
"Shift" enfoncée pendant cette oération on modifie la taille en conservant la proportion.
On notera le "label" x automatiquement généré par plot sur la première représentation, mais que
l'on peut trouver mal placé. On reviendra sur ce détail en montrant comment le corriger (sousparagraphes consacrés aux menus "Plot" et "Drawing").
Conseils : n'aborder la finition du dessin que lorsque que la proportion Longueur/Largeur est
fixée et que toutes les courbes sont tracées. Tenir compte de la remarque dans l'encadré de
l'introduction de cette annexe. Si l'on doit utiliser un système d'axes orthonormés, le définir avant
toute manipulation, soit avec l'item
du menu qui apparaît en mode
quand on clique sur
le dessin, soit avec l'option de commande scaling=constrained,soit avec le menu général
Plot/Scaling Constrained.
A1-2 La palette
Ce "bouton" fait apparaître la palette d'outils suivante
L'utilisateur n'aura aucune difficulté à comprendre par une simple expérimentation les actions
associées aux différents items de ces menus. On notera cependant
- Le menu associé à
qui permet différentes options de tracés qui sont :
56
-
le tracé de toutes les courbes avec un trait continu (ou seulement la courbe
sélectionnée en cliquant dessus avec l'outil
).
le tracé de toutes les courbes (ou seulement la courbe sélectionnée) avec uniquement
les points que plot a calculés. On remarque que l'algorithme choisit (par défaut) des points non
équidistants en tenant compte des variations des courbes. La représentation en trait continu n'est
qu'une interpolation de ces points par des segments de droites.
et
, dits respectivement "Patch" (le défaut) et "Patchnogrid", ne concernent que les
représentations de figures, telles des polygones, qui seraient inclus dans le graphique (voir l'aide en
ligne de plottools[polygon] ou § 16.1). En l'absence, comme ici, de tels objets ces deux options
sont équivalentes à
. Ce ne sont pas les seules options de tracé possibles (voir le menu A1-3)
- L'icône
qui permet d'obtenir par un simple clic un système d'axes orthonormés.
A1-3 Le menu Plot de la barre des menus MAPLE
On rapelle que ce menu n'est actif (non grisé) que si on a cliqué sur le graphique. Plutôt
complet, il permet un grand nombre de manipulations que l'on explorera sans difficulté. Il apparaît
également comme menu contextuel avec un "clic droit" sur le graphique. On ne citera ici que les
quelques actions effectuées sur le dessin précédent.
- Les légendes automatiques des courbes qui apparaissent sur le premier dessin de l'annexe sont
introduites (ou supprimées) avec l'item Legend/Show Legend. Elles sont directement éditables à
l'aide d'un double clic (voir ci-dessous). Elles peuvent aussi être introduites par commandes avec
l'option legend=["Texte_1",...], l'association avec chaque courbe se faisant par correspondance de
liste (voir les exemples A2-2.3.2 et A2-2.3.3 ou l'avant-dernier exemple du § 13.5). Une option du
menu Tools/Options (Windows/Linux) ou MAPLE 12/Préférences (MacOS), onglet Display
permet de rendre automatique ou non l'apparition des légendes.
- Par défaut les extentions des axes sont définies par les intervalles de variations imposés
(abscisses) et calculés (ordonnées). Avec Plot/Axes/Properties... on a fixé les intervalles de tracé
des axes sans modifier les intervalles de calcul : ([-9.41..+9.41] et [-0.4..1] sont devenus [-10..10]
et [-0.5..1.1]).
- Pour enlever le "label" automatique x mal placé, on a utilisé Plot/Axes/Labels/Remove
horizontal. On l'a remplacé avec l'outil d'écriture du menu "Drawing" décrit ci-après.
- La courbe du Sinus cardinal originellement verte a été sélectionnée en cliquant dessus avec
l'outil
. Avec Plot/Color on a alors changé sa couleur en bleu (on peut de même changer le
style de trait avec Plot/Line).
- Avec Plot/Title/Add Title on a rajouté un titre (voir les modes d'écriture ci-après).
A1-4 La palette
Ce "bouton" fait apparaître la palette d'outils suivante
L'usage des outils apparaîtra familier aux utilisateurs de logiciels de dessin qui y retrouveront les
grands classiques de ce type de manipulations.
- Chaque outil est sélectionable soit avec la souris, soit au clavier : "S" ou "s" pour "Selection
Tool", "P" pour "Pencil", etc. (La mnémonique apparaît quand on pointe l'outil). Lorsqu'un outil est
selectionné il prend une couleur bleue. Quand l'action de dessin associée est terminée (voir ci
dessous) la "main est rendue" à l'outil "Selection"
. Mais si on "double clique" sur les outils
, ils se colorent en jaune et "gardent la main" quand l'action est terminée,
57
permettant d'enchaîner plusieurs actions de même nature sans être obligé de re-sélectionner l'outil.
- L'outil
permet de sélectionner un "objet" (texte, formule, dessin...), de le déplacer ou de
contrôler la taille de sa zone d'affichage. Cliquer une fois sur l'objet (pour un figure comme un
rectangle, cliquer sur son contour) pour faire apparaître les limites. Par exemple
Vous pouvez alors déplacer le texte (pointer dans le rectangle et glisser) ou modifier la zone
d'affichage avec la souris (pointer et glisser un des petits carrés).
- L'outil de "Trait"
permet de tracer des lignes polygonales qui peuvent bien sûr se réduire
à un segment unique. Les clics successifs définissent le début et la fin de chaque segments, un
double clic termine le dessin. Si la touche "Shift" est maintenue enfoncée les traits sont tracés
comme "horizontaux", "verticaux" ou "à 45°".
- L'utilisation des outils
va de soi. Si la touche "Shift" est maintenue enfoncée
avant de commencer on définira strictement des cercles ou des carrés. Pour un tracé déjà existant,
ceci permet de préserver le rapport Longueur/Largeur lors d'une modification de taille (sélection
puis glissement des "petits carrés").
- Les outils
,
et
permettent de modifier les propriétés des rectangles et ellipses
(intérieur et bordure), traits ou flèches, etc. Il est possible avec l'option "browse..." de
de
remplir une figure avec une image.
----------ATTENTION : le remplissage avec des images photographiques haute résolution peut s'avèrer
prohibitif en terme de temps de sauvegarde et taille de fichier.
----------L'outil
de
permet de sélectionner une couleur n'importe où dans la fenêtre MAPLE.
- Les outils
permettent d'effectuer des alignement de plusieurs objets que l'on devra au
préalable sélectionner avec
et soit par clic et glissement entourant les objet, soit par clics
successifs sur les objets, mais en maintenant la touche "Shift" enfoncée.
- Le mode "Texte"
. Un fois l'outil sélectionné, cliquer dans le cadre du graphique à la
position voulue (sachant que l'on pourra toujours déplacer le texte ultérieurement). Un cadre
"double trait grisé" apparaît, définissant la zone d'insertion. Si des "retours lignes" apparaissent
inopinément on pourra tout corriger en modifiant ensuite la taille ou la forme de la zone d'affichage
(voir ci-dessus). Noter que ce cadre n'est ni déplaçable ni de taille modifiable directement. Pour ce
faire on reviendra à la sélection décrite précédemment après avoir terminé l'insertion du texte.
L'insertion de texte peut se faire avec le mode
et/ou le mode
qui apparaissent
dans le menu associé. Ces deux modes peuvent alterner dans une même phrase (voir l'insertion de
J0 dans le titre). Pour le mode
on utilisera la frappe directe au clavier ainsi que la palette
située à gauche de la fenêtre MAPLE, ou d'autres palettes pour insérer des lettres
grecques, des symboles, des flèches, etc. Pour écrire des "indices" ou des "puissances" en mode
on pourra utiliser la syntaxe LaTeX avec un "_" ou un "^" (exemple : J02 (x) ⇒ J_0
/ [flèche à droite pour quitter le mode "indice"] ^ 2 / [flèche à droite pour quitter le mode
"puissance"] (x)). Pour faire de même en mode
on utilisera le menu général de Maple
58
Format/Character/Subscript ou Superscript. Si l'outil
est sélectionné, un double clic sur un
texte permet d'accéder directement au mode "écriture" permettant la modification du texte.
----------Remarque : l'utilisation de la variable x dans la commande plot affiche automatiquement le nom de
l'axe des abscisses, mais ce dernier n'est pas nécessairement bien placé. Pour le supprimer on
utilisera le menu général Plot/Axes/Labels/Remove horizontal (voir ci-dessus). On pourra ensuite
utiliser le mode
pour écrire ce nom où l'on veut (ce que l'on a fait pour x et y sur le graphique
précédent)
-----------
59
ANNEXE 2 - Tracés (et/ou traitements) de données importées
"J'ai un fichier et je voudrais..."
A2-1 Importation des données
Avant de pouvoir traiter et tracer des données il faut les importer dans MAPLE. Cette opération
effectuée par lectures de fichiers, que ce soit avec MAPLE ou un autre logiciel, est souvent une
source de problèmes potentiels en raison de la variété des formats. Dans les cas les plus classiques
cependant, elle ne présentera pas de difficulté.
Cette opération est décrite au chapitre 20 dont on reprend quelques éléments avec deux exemples
simples, l'importation d'un tableau Excel et celle d'un tableau ASCII rangé en colonnes.
On peut aussi importer sans difficulté des fichiers de type Matrix Market, MATLAB, Image
(jpeg, bmp et tiff), et Audio (PCM Wave et ADPCM Wave). MAPLE contient des librairies
spécialisées pour le traitement des images (ImageTools) et des fichiers audio (AudioTools) et on
sera bien inspiré d'en explorer les aides en ligne si besoin. On peut utiliser des lectures plus
sophistiquées pour certains fichiers ASCII dont on présente quelques éléments au chapitre 20 de ce
manuel.
ATTENTION
Lorsque l'on demande de sauvegarder la feuille de calcul après avoir importé de tels fichiers (en
fait dès que l'on crée de gros tableaux ou de grosses matrices), MAPLE interroge l'utilisateur dans
une fenêtre pour savoir s'il souhaite enregistrer leurs contenus. Dans la mesure ou l'on pourra relire
ultérieurement ces fichiers et/ou on pourra refaire les calculs en des temps raisonnables, on ne
demandera pas cette sauvegarde avec celle de la feuille de calcul. On s'expose sinon à des
sauvegardes longues et des fichiers MAPLE très gros.
O restart:
A2-1.1 Fichiers Excel
On dispose d'un fichier Excel au format .xls dont voici l'image des premières lignes (pour le
format .csv, voir la dernière remarque du § A2-1.2).
On peut construire la commande d'importation suivante, ExcelTools:-Import(...), avec
le menu Tools/Assistants/Import Data... (ou bien directement au clavier avec un peu
d'habitude). On devra sélectionner dans la fenêtre qui s'ouvre
1) Le format : Select a format => Excel
2) Le nom du fichier (et éventuellement le nom de son répertoire) : ici Helmert.xls sur le
Bureau (Desktop) d'un Mac (voir chapitre 20), puis Next
3) Le fichier peut contenir plusieurs feuilles de calcul. Dans la nouvelle fenêtre on choisira
celle désirée avec Sheet : ici THEO_NXYZ_1406_2007
4) Avec Named Range on sélectionne la partie de la feuille que l'on souhaite lire : C1:F2 sur
le deuxième exemple donné plus bas (la syntaxe est propre à Excel ; voir l'aide en ligne ?
ExcelTools/Import). Si on ne mentionne rien, tout la feuille est lue.
5) Done
On notera par parenthèses que si Import existe dans la librairie ExcelTools, Export existe
aussi !
Les données sont importées sous la forme d'un tableau (Array). Le Data Type du tableau
60
construit étant anything, tout ce qui n'est pas compris comme un nombre est mis sous la forme
d'une chaîne de caractères. Les cellules vides des colonnes incomplètes sont remplacées par des
0. On rappelle que quand un tableau contient plus de 10 lignes et/ou 10 colonnes, l'affichage par
défaut se fait de façon résumée. Un double-clic sur ce tableau symbolique permet de visualiser
les éléments sans les écrire sur la feuille avec un afficheur spécialisé (voir Chapitre 4, §
Affichage des grosses matrices).
O ExcelTools:-Import("/Users/Jean/Desktop/Helmert.xls",
"THEO_NXYZ_1406_2007");
1..58 x 1..8 Array
Data Type: anything
Storage: rectangular
Order: Fortran_order
On donne un nom à ce tableau. On peut aussi corriger la commande précédente quand elle est
construite automatiquement avec Tools... en écrivant M:=ExcelTools(...), avant de la
relancer.
O M:=%:
Les indices d'un tableau ne commencent pas nécessairement à 1 (-2, -1, 0, 1, 2, 3 seraient par
exemple des indices valables pour un tableau). C'est la raison pour laquelle ils sont données en
général sous la forme d'intervalles n..m (-2..3 par exemple)
O ArrayDims(M); # ou bien
op(2,M);
1 ..58, 1 ..6
1 ..58, 1 ..6
Il existe plusieurs façons de récupérer le nombre de lignes et de colonnes (voir chapitre 2)
O nl:=op([2,1,2],M);
nl:=op(2,ArrayDims(M)[1]):
nc:=op([2,2,2],M);
nl := 58
nc := 6
ou, tout simplement si on n'a pas besoin d'automatiser
O nl,nc:=58,6;
nl, nc := 58, 6
On ne refera pas ici le chapitre 5 sur l'accès aux éléments d'un tableau... On rappelle juste la
syntaxe sur deux exemples. Elle est la même que pour les matrices, sauf pour des indices
négatifs. On pourra toujours transformer ce tableau en matrice avec
> M:=convert(M,Matrix);.
On se reportera au § A2-2 et pour des exemples de traitements et de tracés.
O M[1,3];
M[1..2,nc-1];
13.184
3.16433938 105 3.16360535 105
Remarques :
- Le type des éléments du tableau est anything, c'est à dire que les éléments du tableau
peuvent être de nature quelconque (entiers, réels, chaînes de caractères, etc.).
- On peut sélectionner la lecture d'une partie de la feuille : ici les contenus des cellules d'un
sous tableau allant de C1 à F2 (voir l'image de la feuille Excel en introduction de A2-1.1).
O ExcelTools:-Import("/Users/Jean/Desktop/Helmert.xls",
"THEO_NXYZ_1406_2007","C1:F2");
61
13.184
3.05
3.16433938 105
"0 de référence"
146.95 K4.749 3.16360535 105 "Toulon piquet 3"
Noublions pas que les constructions de fonctions permettent des combinaisons infinies et on
peut élaborer des commandes sophistiquées. Par exemple, supposons que i et j soient des
variables entières dont les valeurs sont déterminées au cours d'un calcul (dans une procédure par
exemple) et que l'on veuille, sans intervenir, sélectionner et lire les éléments d'un sous tableau de
la feuille Excel allant de Ci à Fj. On pourra écrire (voir la fonction cat de concaténation de
caractères au chapitre 18)
O i:=3: # Simulations de valeurs
j:=4: # calculées ou lues
ExcelTools:-Import("/Users/Jean/Desktop/Helmert.xls",
"THEO_NXYZ_1406_2007",cat("C",i,":","F",j));
151.43 K9.964 3.16236321 105 "vector_01EPOC_ref"
27.598 K9.177 3.16292396 105
"LEGI_ref_ADVP"
A2-1.2 Fichiers ASCII
Notes : pour les fichiers Excel enregistrés au format .csv, voir la dernière des remarques cidessous. MAPLE sait aussi importer directement les fichiers aux formats Matlab ou Matrix
Market (voir ci-dessous l'option Select a format).
On dispose d'un fichier de type ASCII structuré en colonnes dont les éléments sont séparés par
un ou des "espaces" et dont voici les premières lignes
On construit la commande suivante d'importation, ImportMatrix(...), avec le menu
Tools/Assistants/Import Data... (ou bien directement au clavier avec un peu d'habitude). On
devra sélectionner diverses options dans la fenêtre qui s'ouvre.
1) Les éléments de ce type de fichiers sont délimités par un séparateur qui sont ici des
espaces (au moins un) : Select a format ⇒ Delimited
2) Le nom du fichier (et éventuellement le nom de son répertoire) : ici Mesures.dat sur le
Bureau (Desktop) d'un Mac (voir chapitre 20), puis Next
3) La nouvelle fenêtre donne un apperçu du début du fichier et propose des options. Laisser
Data Type à anything (les nombres peuvent être entiers, réels, voire même symboliques) et
Source Form à Rectangular.
4) Dans le cas de ce fichier, on doit sauter les 4 premières lignes (compter la ligne vide ; 30
représente le nombre de lignes qui suivent et que l'on n'a pas besoin de lire). On posera donc
Skip Lines à 4.
5) Généralement on ne demande pas la transposition du tableau (les colonnes deviendraient
les lignes et réciproquement).
62
6) On sélectionne Separator qui définit la nature du séparateur entre les éléments d'une ligne :
on choisira ici (Space Separated)
7) Done
Remarques : il faut éviter certains pièges, du moins avec ImportMatrix (sinon voir Ch 20):
- Tous les séparateurs doivent être identiques (pas d'espaces et de tabulations mélangés par
exemple, ce qui n'est pas toujours immédiatement visible). Avec Word par exemple, afficher les
marques avec le bouton ¶ (dit "pied de mouche") et vérifier.
- La présence de chaînes de caractères dans la partie lue peut être source d'échecs (par exemple
des commentaires) sans générer nécessairement de message d'erreur.
- Attention aux lignes vides au milieu ou en fin de fichier ainsi qu'aux lignes ou colonnes
incomplètes (sauf fichier .csv ; voir ci-dessous). On aura le message d'erreur : Error, (in
ImportMatrix) end of input encountered while reading Matrix. Word peut générer tout seul de
telles lignes en fin de fichier : afficher les marques avec le bouton ¶ et vérifier ou bien déplacer le
pointeur et vérifier qu'il ne peut pas aller au delà de la dernière ligne.
- Avec Word ou tout autre traitement de texte, prendre soin de faire un enregistrement en
mode texte, c'est-à-dire sans mise en forme (pas de formats de type .doc ou .rtf).
- Les fichiers Excel enregistrés au format .csv seront lus avec les options Select a format ⇒
Delimited, Data Type ⇒ anything, Separator ⇒ ; (Semicolon Separated). On prendra soin
de supprimer les cellules de commentaires avant de procéder à l'enregistrement sous Excel au
format .csv. Les éléments vides des lignes ou colonnes incomplètes auront la valeur NULL
(voir ce concept au Chapitre 2).
En cas de problèmes, se reporter aux fonctions décrites au chapitre 20.
Les données sont importées sous la forme d'une matrice et non plus d'un tableau comme
pour un fichier Excel. On rappelle que quand une matrice contient plus de 10 lignes et/ou 10
colonnes, l'affichage se fait par défaut de façon résumée. Un double-clic sur cette matrice
symbolique permet de visualiser les éléments sans les écrire sur la feuille avec un afficheur
spécialisé (voir Chapitre 4, § Affichage des grosses matrices).
O restart:
ImportMatrix("/Users/Jean/Desktop/Mesures.dat",
source=delimited,delimiter=" ",format=rectangular,
datatype=anything,transpose=false,skiplines=4);
30 x 5 Matrix
Data Type: anything
Storage: rectangular
Order: Fortran_order
On donne un nom à cette matrice. On peut aussi corriger la commande précédente après l'avoir
construite automatiquement avec Tools... en écrivant M:=ImportMatrix(...), puis en la
relançant.
O M:=%:
A2-2 Lecture, manipulations et tracés des éléments
La lecture des données s'écrira en utilisant la syntaxe réservée aux matrices. Par exemple il existe
plusieurs façons de récupérer le nombre de lignes et de colonnes de M (voir chapitre 4).
O nl:=LinearAlgebra:-RowDimension(M);
nl:=op(1,M)[1]:
nl:=op([1,1],M):
nc:=LinearAlgebra:-ColumnDimension(M);
nc:=op([1,2],M):
63
nl := 30
nc := 5
ou, tout simplement si on n'a pas besoin d'automatiser...
O nl,nc:=30,5;
nl, nc := 30, 5
On ne refera pas ici le chapitre 4 sur l'accès aux éléments d'une matrice. On rappelle juste la syntaxe
sur deux exemples. Le terme −1 désigne la dernière colonne (=nc), −2 l'avant dernière, etc. Ceci n'a
pas la même signification avec un tableau et si on a obtenu, avec l'importation Excel par exemple, un
tableau M (Array) au lieu d'une matrice (Matrix), on pourra toujours opérer une conversion avec
(attention au M majuscule de Matrix)
> M:=convert(M,Matrix):
O M[2,3];
M[1..2,2..-1];
2.88
0.0828 3.12 0.220 0.0866
0.144 2.88 0.441 0.406
MAPLE 12 reconnaît aussi une syntaxe par défaut "..n" signifiant des éléments de 1 à n, "m.."
signifiant de l'élément m au dernier et "..", tous les éléments.
O M[..2,..]; # Lignes 1 à 2 de toutes les colonnes
1 0.0828 3.12 0.220 0.0866
2 0.144 2.88 0.441 0.406
Généralement le traitement des données se fait par lignes ou colonnes entières et il est pratique de
construire quelques fonctions de lecture pour simplifier la syntaxe des commandes.
A2-2.1 Un seul fichier est importé
On va supposer que les données sont importées dans une matrice à laquelle on a donné le
nom M. Ici C(k) ou L(k) extraient respectivement la colonne et la ligne k de M. L'extraction
d'une ligne ou d'une colonne d'une matrice tel qu'écrit ci-dessus produit respectivement des
objets de type "Vecteur ligne" et "Vecteur colonne" (voir Chapitre 4). Ceci devrait suffire pour
beaucoup de traitements, mais en raison de la restriction indiquée au § 9.1-2c, on transformera
systématiquement ces objets en listes.
O C:=k->convert(M[1..-1,k],list);
L:=k->convert(M[k,1..-1],list);
C := k/convert M1 ..K1, k, list
L := k/convert Mk, 1 ..K1 , list
Alors, pour extraire la ligne 2 ou les deux premiers éléments de la colonne 3 on écrira
O L(2), C(3)[..2];
2, 0.144, 2.88, 0.441, 0.406 , 3.12, 2.88
Pour tracer la colonne 3 en fonction de la colonne 2 il suffira donc d'écrire (voir § 9.1-1)
O plot(C(2),C(3),style=point);
64
3
2,5
2
1,5
1
0,5
0,20,40,6 0,81,0 1,21,41,6 1,82,0
mais on a vu au § 9.1-2a/b qu'il était préférable de construire des listes entrelacées des abscisses
et ordonnées. On construira donc la fonction
O S:=(x,y)->zip((u,v)->[u,v],C(x),C(y));
S := x, y /zip u, v / u, v , C x , C y
La commande du tracé précédent devient
O plot(S(2,3),style=point); # graphique identique et effacé
A2-2.2 Plusieurs fichiers sont importés
Si plusieurs fichiers sont importés on assignera les données à des matrices ayant des noms
différents. Pour pouvoir les distinguer il faut modifier un peu les fonctions précédentes en
introduisant le nom F de la matrice en argument.
O C_F:=(F,k)->convert(F[1..-1,k],list);
L_F:=(F,k)->convert(F[k,1..-1],list);
S_F:=(F,x,y)->zip((u,v)->[u,v],C_F(F,x),C_F(F,y));
C_F := F, k /convert F1 ..K1, k, list
L_F := F, k /convert Fk, 1 ..K1 , list
S_F := F, x, y /zip u, v / u, v , C_F F, x , C_F F, y
O L_F(M,2);
2, 0.144, 2.88, 0.441, 0.406
O plot(S_F(M,2,3),style=point); # graphique effacé
A2-2.3 Quelques exemples de traitement simples
On se place dans le cas A2-2.1, les modifications pour le cas avec plusieurs importations
étant évidentes.
A2-2.3.1 Fonctions de traitement
On peut aisément construire des outils de calcul. Ici µ(k) calcule la moyenne de la colonne
k alors que Trp(x,y) calcule, par la méthode des trapèzes, l'intégrale des ordonnées de la
colonne n° y sachant que les abscisses correspondantes (supposées croissantes) sont dans la
colonne n° x (voir un exemple en A2-2.3.2).
O mu:=i->evalf(add(C(i)[k],k=1..nl)/nl);
Trp:=(x,y)->1/2*add((C(x)[i+1]C(x)[i])*(C(y)[i]+C(y)[i+1]),
i=1..nl-1);
65
add C i k, k = 1 ..nl
µ := i/evalf
Trp := x, y /
1
add
2
C x
nl
iC1
KC x
i
C y iCC y
iC1
, i = 1 ..nl K 1
O mu(2);
1.039126667
Dès lors que les données sont devenues accessibles, tout l'attirail de MAPLE est à
disposition (interpolation, lissage, convolution, filtrage, transformations de Fourier rapides,
ondelettes, etc). Comme indiqué dans l'introduction on noubliera pas les bibliothèques
spécialisées telles ImagesTools ou AudioTools.
A2-2.3.2 Lissage linéaire ou exponentiel par moindres carrés
On veut lisser ces données par moindres carrés. MAPLE dispose de nombreux outils
statistiques dans sa bibliothèque Statistics. Pour quelques détails sur le lissage et les outils
de Statistics, on renvoie le lecteur aux corrections des exercices 6.9 et 8.1. On trouve en
particulier un lissage par un modèle du type Ae lt , dit ExponentialFit et que l'on pense
adapté dans ce cas. Mais on veut aussi essayer un modèle parabolique que l'on obtiendra
avec LinearFit (attention : linéaire ne signifie pas nécessairement lissage par une droite !
voir l'hyperlien dans l'introduction de la correction de l'exercice 6.9).
O f[e]:=Statistics:-ExponentialFit(C(2),C(3),t);
f[p]:=Statistics:-LinearFit([1,t,t^2],C(2),C(3),t);
fe := 3.45188578307415 eK1.28817036644000970 t
fp := 3.24934648421344185 K 3.16272371236901994 t C 0.859629734717129444 t2
On peut réduire la précision des constantes si on la trouve inutile (précision due à des calculs
faits automatiquement en mode evalhf). Pour la fonction fnormal voir Chapitre 1 § 7.3.
O f[e]:=fnormal(f[e],4);
f[p]:=fnormal(f[p],4);
fe := 3.452 eK1.288 t
fp := 3.249 K 3.163 t C 0.8596 t2
On compare l'intégrale par la méthode des trapèzes et l'intégrale des fonctions de lissage par
les modèles exponentiel et polynomial
O Int(Colonne[3],t=Colonne[2]..``) = fnormal(Trp(2,3),4);
Int(f[e],t=C(2)[1]..C(2)[-1]): % = fnormal(value(%),4);
Int(f[p],t=C(2)[1]..C(2)[-1]): % = fnormal(value(%),4);
Colonne
2.01
Colonne3 dt = 2.212
2
3.452 eK1.288 t dt = 2.208
0.0828
2.01
3.249 K 3.163 t C 0.8596 t2 dt = 2.210
0.0828
Exercice : on calcule les estimateurs des deux écarts type. Expliquer. On aura noté que fe et
fp ne sont pas des fonctions mais des expressions, d'où l'utilisation de eval... Proposer une
autre écriture en transformant fe et fp en fonctions. Pourquoi utilise-t-on (nlK2) dans un cas
et (nlK3) dans l'autre ? (cette dernière question ne concerne pas MAPLE mais les propriétés
statistiques du lissage...).
66
O sigma[e]=sqrt(add((M[i,3]-eval(f[e],t=M[i,2]))^2,
i=1..nl)/(nl-2)),
sigma[p]=sqrt(add((M[i,3]-eval(f[p],t=M[i,2]))^2,
i=1..nl)/(nl-3));
se = 0.03295297968, sp = 0.06377963613
On veut tracer maintenant les points de mesures et ces lissages sur une même
représentation. On notera que l'on a choisi d'utiliser M[1,2] et M[-1,2] pour désigner les
abscisses extrêmes qui vont servir aux calculs de f[e] et f[p] (la première et la dernière
composante de la colonne 2 puisqu'elles sont supposées croissantes), mais on aurait pu aussi
bien écrire par exemple t=0..3. On rappelle que f[e] et f[p] sont des expressions qui
dépendent de la seule variable t (voir § 3.1 et § 9.3). On donne brièvement les définitions des
options utilisées (voir § 7) :
- L'option style fixe par une liste les trois modes de tracé par correspondance (la syntaxe
x$n permet d'éviter une écriture répétitive et crée x,x,x,... n fois).
- L'option linestyle donne la forme du tracé des courbes, mais pour établir la
correspondance on doit donner trois valeurs. La première (solid) sera donc inutilisée puisque
s'appliquant au style de tracé point.
- On améliore la présentation des axes avec view et on leur donne des noms avec labels.
On ajoute un titre avec title et typeset qui permet une combinaison de texte et d'écriture
mathématique. Les options legend et legendstyle permettent d'associer automatiquement un
texte à chaque tracé.
Attention : la commande > plot(C(2),C(3),f[e],...) provoquerait une erreur
dans plot (voir § 9.1.2a). D'où la nécessité ici de construire la fonction S (voir A2-2.2)
O plot([S(2,3),f[e],f[p]],t=M[1,2]..M[-1,2],
style=[point,line$2],linestyle=[solid$2,dash],
labels=[t,N],color=["Black","Blue","Red"],
thickness=[1,1,2],symbol=circle,symbolsize=15,
title=typeset(N[e]=N[0]*exp(-lambda*t),"
et
",
N[P]=alpha*t^2+beta*t+N[1]),
legend=["Données",N[e],N[P]],
legendstyle=[location=bottom],
view=[0..2.1,0..3.5]);
Ne = N0 eKl t et NP = a t2 C b t C N1
3
N
2
1
0
0
0,5
1
Données
1,5
t
Ne
2
NP
On rappelle que le graphique peut être modifié, complété et sauvegardé par manipulation au
clavier et à la souris (voir l'Annexe 1).
67
A2-2.3.3 Lissage non linéaire par moindres carrés
On s'intéresse maintenant aux données des colonnes 4 (abscisses) et 5 (ordonnées). On
pense qu'elles pourraient être représentées par le modèle F ci-dessous dont on cherche à
déterminer les paramètres A, B, α, β, ω et φ. Un lissage par moindres carrés est dans ce cas
non linéaire et se calcule par un processus itératif qui nécessite la connaissance approchée de
ces paramètres (voir l'exercice 6.9). On estime (par exemple visuellement sur un tracé des
données et en s'adressant à son bon sens...) ces valeurs que l'on range dans une liste
d'équations (Ve) dont l'ordre est sans importance.
O F:=A*(1-exp(-alpha*t))+
B*exp(-beta*t)*cos(omega*Pi*t+phi);
Ve:=[A=1.2,B=0.5,alpha=1,beta=0.5,omega=1,phi=0];
F := A 1 K eKa t C B eKb t cos w p t C f
Ve := A = 1.2, B = 0.5, a = 1, b = 0.5, w = 1, f = 0
Noter que F est une expression (pas une fonction) et noter comment les valeurs contenues
dans Ve (liste d'égalités) sont subtituées avec subs dans F pour pouvoir effectuer son tracé
(nécessité de fixer des valeurs numériques pour les paramètres de F, voir § 3.1).
O plot([S(4,5),subs(Ve,F)],t=0..6,style=[point,line],
symbol=solidcircle,symbolsize=10,
color=["Black","Red"]);
1,4
1,2
1,0
0,8
0,6
0,4
0,2
0
1
2
3
t
4
5
6
Le tracé précédent montre que les valeurs estimées des paramètres sont très médiocres, mais
on pourra peut-être s'en contenter quitte à recommencer si le processus de calcul ne converge
pas. Le traitement se fait avec NonlinearFit de la librairie Statistics (voir l'exercice 6.9). Les
valeurs initiales sont introduites avec l'option initialvalues. Elles peuvent aussi être données
sous la forme d'une liste d'intervalles de valeurs autorisées (initialvalues=[A=a..b , B=c..d , .
..]). La fonction fnormal (voir Ch 1, § 7.3) n'est utilisée que pour réduire le nombre de
chiffres significatifs des constantes.
O Fnl:=fnormal(Statistics:-NonlinearFit(
F,C(4),C(5),t,initialvalues=Ve),4);
Fnl := 1.306 K 1.306 eK1.209 t K 0.2781 eK0.2894 t cos 2.108 p t K 1.911
Attention : une bonne concordance graphique entre le lissage et les données ou une
estimation de l'écart type conforme aux erreurs de mesures n'est en aucun cas le gage
d'une détermination robuste des paramètres !!! Cette remarque est inhérente au problème
du lissage et sans rapport avec MAPLE. On trouvera un exemple avec l'hyperlien "SVD"
68
dans l'introduction 8.1.1-b de la correction de l'exercice 8.1. On y trouvera aussi la façon de
tracer des barres d'erreur.
O plot([S(4,5),Fnl],t=0..6,style=[point,line],
symbol=solidcircle,
symbolsize=10,color=["Black","Blue"],
title="Lissage non linéaire",
titlefont=[TIMES,15],
legend=["Valeurs expérimentales",Fnl],
legendstyle=[location=bottom],
view=[0..6.5,0..1.5]);
Lissage non linéaire
1,5
1
0,5
0
0
1
2
3
4
5
6
t
Valeurs expérimentales
K1.209 t
1.306 K 1.306 e
K0.2894 t
K 0.2781 e
cos 2.108 p t K 1.911
On rappelle une fois encore que le graphique peut être modifié, complété et sauvegardé par
manipulation au clavier et à la souris (voir l'Annexe 1).
69
70

Documents pareils