LES GRAPHIQUES SOUS MAPLE
§1 Graphiques en 2D
Maple permet de tracer des graphiques grâce à la fonction plot et ses nombreuses options.
1.1 Une seule courbe
> plot (nomfn , a .. b); # tracé sur [a,b] de la courbe représentative d'une fonction nommée nomfn
> plot (expr (var) , var = a .. b , y = c .. d , options) ; # tracé de la courbe y = expr (var); dans ce cas, il faut préciser le nom de la variable var en abscisses (y = c .. d est facultatif et on peut choisir un autre nom que y pour les ordonnées).
1.2 Famille de courbes : on utilise les structures de listes ou d'ensemble pour regrouper les courbes :
> plot ({f1 , … , fn} , a..b , options) ; # tracé simultané des courbes des fonctions f1 , … , fn sur [a,b]
> plot ([f1 , … , fn] , a..b , options) ; # même chose
> plot ({seq (expr (var , par) , par = s..t )} , var = a..b , options) ; # tracé sur [a,b] de la famille de courbes y = expr (var , par), le paramètre par variant entre s et t
Pour davantage de lisibilité, il est commode de générer la famille de courbes à l'extérieur du plot ; par exemple :
> F:= par −> exp (var, par) : suite_fns:= {seq (F(par) , par = s .. t)};
> plot(F , var = a..b , options) ;
‹
Les courbes sont tracées avec des couleurs distinctes sauf si on impose la couleur par l'option color = couleur où couleur ∈ {black, red, blue, … }De façon plus précise :
> plot({f1 , … , fn} , a..b , color = [coul1, … , couln]); # autant de couleurs que de courbes à tracer
L'option color = COLOR(RGB,rand()/10^12, rand()/10^12, rand()/10^12) choisit une couleur aléatoire pour le tracé.
L'option color = COLOR(HUE , p) choisit la couleur codée par le réel p ∈ [0,1] dans le système HUE.
L'option : scaling = constrained impose un repère orthonormé.
Exemples
> plot ({cos , sin , cos@cos} , 0..1,color=[red,blue,green]) ;
> plot ({seq ((x − a)/(1 + a*x) , a = −1..1)} , x = −4..4 , y = −4..4 , color = black) ;
> plot ({seq (cos@@n , n = 0..3)} , 0..Pi/2) ;
> plot (x + 1/x , x = −2..2 , view = [−2..2 , −4..4] , color = violet , discont = true) ; # discont = true empêche le tracé de l'asymptote; view fixe la fenêtre d'affichage.
1.3 Famille de points : on crée la liste des coordonnées des points :
> plot ([ [abs1 , ord1] , [abs2 , ord2] , … , [absn , ordn] ]) ; # relie les points successifs par des segments
> plot ([ [abs1 , ord1] , [abs2 , ord2] , … , [absn , ordn] ] , style = point) ; # crée seulement les points indiqués
> T:= plot ([[−1,2] , [1,4] , [2,1] , [−1,2] ] , view = [−1..3 , −1..5] , symbol = cross , style=point) :
‹
Terminer la commande par “ : “ et non “ ; “ sinon Maple affiche, non pas le graphique, mais la description du graphique !> T ; # affiche le triangle
1.4 Courbes paramétriques :
> plot ([abs(par) , ord(par) , par = a .. b] , options) ; # abs(par) = x(t) et ord(par) = y(t) si le paramètre est t et les coordonnées (x,y)
> plot ([rayon(par) , angle(par) , par = a .. b], coords = polar, options); # crée la courbe en coordonnées polaires OM(t)
t
= r(t)(cos θ(t) it + sin θ(t) jt ) si t est le paramètre, r(t) le rayon polaire et θ(t) l'angle polaire (en général, θ (t) = t )‹
Ne pas oublier d'ajouter l'option coords = polarPour une famille de courbes paramétrées, on regroupe les différentes courbes dans une liste :
> F:= par −> [x(var , par), y(var , par) , var = a(par) .. b(par)] : # l'intervalle [a(par) .. b(par)] où varie var peut dépendre a priori du paramètre par
> plot ([seq (F(par) , par = c..d )] , options);
Cela permet en particulier de tracer une famille de courbes représentant des fonctions de domaine distinct :
> F:= par −> [var , fn(var , par) , var = a(par) .. b(par)] :
> plot ([seq (F(par) , par = a..b)] , options) ;
Exemples :
> plot ( [t*cos(3*t) , 1 − t *sin(t) , t = − Pi..Pi] , view = [−3..3 , −1.5..1.5]) ;
> plot ( [t*sin(4*t) , t , t = 0..2*Pi] , coords = polar) ;
> F:= t -> [x , t*x + t/x , x = abs(t)..abs(t) + 4] : plot ([seq (F(t /3) , t = − 9..9 )]) ; # une famille de courbes dont le domaine varie
> plot({seq([k*cos(t),sin(t),t=0..2*Pi],k=1..2)}); plot({[cos(t),sin(t),t=0..2*Pi],[2*cos(t),0.5*sin(t),t=0..2*Pi]});
1.5 Courbes définies implicitement (nécessite le package plots) : ce sont des courbes données par une équation F(x,y) = 0 (c'est le cas par exemple des courbes du second degré).
Syntaxe :
> plots[implicitplot] (equation (var1 , var2) , var1 = xmin .. xmax , var2 = ymin .. ymax , options) ;
> plots [implicitplot] charge la fonction implicitplot du package plots. On peut aussi charger tout le package plot :
> with (plots):
Exemple
> plots[implicitplot] ( -3*x^2 + 4*y^2 – 5 , x = −3..3 , y = −3..3);
> plots[implicitplot](x*exp(−y) − y , x = 0..5 , y = 0..1.5);
1.6 Commandes display, replot, contourplot, showtangent
1.6.1 On a vu en 2.2 et 2.4 comment tracer sur un même graphique, plusieurs courbes. Si on désire que les options ne soient pas communes à toutes ces courbes (en particulier la couleur), il faut créer un plot pour chaque courbe et faire un tracé simultané à l'aide de display. En effet, la commande display permet de superposer plusieurs graphiques ou de
rassembler plusieurs commandes concernant le même graphique. On peut par exemple insérer du texte à un endroit précis du graphique.
Il faut charger le package plots pour pouvoir utiliser display.
Exemple
on crée trois type de plot : une courbe, un point, un texte et on les regroupe avec display
> restart : parabole:= plot (−1/2*(x − 1)^2 + 5/2 , x = −1.5 .. 2 , view = [−1..3 , −0.5..2.5]) : # “ : “ au lieu de “ ; “ pour empêcher l'affichage du graphique
> F:= plot ([[1,2]] , symbol = circle , view = [−1..3 , −0.5..2.5] , style = point) : # ne pas oublier le crochet autour du point [1,2]
> texte:= textplot ([1 , 1.75 ,`foyer`]) :
> with(plots): display (parabole , F , texte) ;
1.6.2 Fonction replot : permet de reprendre un graphique pour en modifier les paramètres sans que Maple ait tout à recalculer. Utile pour faire un zoom par exemple.
> courbe := plot (sin(1/x) , x = 0.04..Pi/6) :
> with(plots) : courbe ; replot (courbe , view =[0.04..0.05 , −1..1]) ;
1.6.3 La commande contourplot trace les lignes de niveaux d'une fonction F(x,y), c'est à dire les courbes F(x,y) = k pour un échantillon de valeurs de k. L'option contours=n permet d'augmenter le nombre de lignes de niveaux.
Exemple :
> plots[contourplot](x^2 − y^2 , x = − 3..3 , y = −3..3,contours=12,filled=true,coloring=[grey,maroon]) ;
1.6.4 La commande showtangent permet de tracer la tangente à une courbe en un point donné.
Exemple
> with (student): showtangent (x/(x^2 + 1) , x = sqrt(3) , x = −1..4) ;
1.6.5 La commande fieldplot pour tracer les champs de vecteurs.
> fieldplot([(y^2 − x^2)/(x^2 + y^2) , 2*x*y/(x^2 + y^2)] , x = − 1 .. 1 , y = − 1 .. 1 , color = blue , grid = [30,30]);
1.6.6 Commande animate
Cette commande permet de créer une animation pour visualiser les courbes d'un échantillon de courbes paramétrées extraites d'une famille.
> with(plots):
> animate([x(s,t) , y(s,t), t = a .. b], s = c .. d, frames = nombre de courbes dans l'échantillon, options);
L'animation se déclenche avec un clic droit sur la figure et en sélectionnant play.
Exemple
> a:=2: b:=1: c:= sqrt(a^2 − b^2):
x:= t −> a*cos(t): y:= t −> b*sin(t): # paramétrage d'une ellipse de demi-grand axe a et demi-petit axe b.
display(plot([x(t), y(t), t = 0 .. 2*Pi], scaling = constrained, color = black), animate([x(t) + s*(c − x(t)), y(t) − s*y(t), s
= 0 .. 1], t = 0 .. 2*Pi, frames = 50, color = red), animate([x(t) + s*(− c − x(t)), y(t) − s*y(t), s = 0 .. 1], t = 0 .. 2*Pi, frames = 50, color = red));
1.7 Le package DEtools
Le package DEtools offre diverses possibilités pour tracer les courbes intégrales d'une équation différentielle.
1.7.1 DEplot, phaseportrait : trace si possible le champ des directions d'un système différentiel du premier ordre et les
Syntaxe :
> with (DEtools, DEplot):
> DEplot ({eqn_diff } , {x(t), y(t), … } , t = a .. b , [[cond. init. en t0] , [cond. init. en t1] , … ] , scene = S, options);
avec plusieurs possibilités pour S : [t , x(t)] , [t , y(t)] , [x(t) , y(t)] …
NB : Les noms de la variable indépendante t et des fonctions inconnues x(t), y(t) sont arbitraires.
Les conditions initiales en t0 s'écrivent sous forme d'une liste
[y(t0) = y0, D(y)(t0) = y1, … ]
les dérivées s'exprimant obligatoirement avec l'opérateur D. On peut superposer plusieurs courbes correspondant à des conditions initiales à t = t0 , t = t1 , … (autant de listes que de valeurs de t )
‹
Il faut placer l'intervalles t = a .. b avant les conditions initiales.Même syntaxe et mêmes options pour phaseportrait.
Il y a des options possibles (voir l'aide) :
stepsize = pas : le pas utilisé pour la résolution numérique de l'équation; par défaut (b − a)/20. Lorsqu'on obtient des courbes aberrantes avec beaucoup de points anguleux, il faut diminuer stepsize.
On peut limiter la fenêtre du tracé en rajoutant x = c..d , y = c'..d'
linecolour = nom_couleur ou bien linecolour = COLOR(`RGB`, … ), ou bien encore linecolour = une fonction de la variable indépendante (permet un tracé avec un dégradé de couleurs)
obsrange = true : stoppe l'évaluation d'une courbe intégrale dès lors que les composantes sortent de l'intervalle spécifié x = c .. d
scene : permet de préciser ce qui est porté en abscisses et en ordonnées sur le graphique.
arrows = none : pour empêcher le tracé du champ des directions etc …
Exemples
> DEtools[DEplot]({diff(y(t) , t) + 2*y(t) = (t +1) * y(t)^2}, {y(t)} , t = −1..1 , [[y(0) = 1]] , y = −3..3 , linecolour = t , scene = [t , y(t)] , stepsize = 0.01) ;
> with(DEtools) : phaseportrait ({diff(x(t) , t$2) + 4*x(t) = t*sin(t)} , {x(t)}, t = 0..2 , [[x(0) = 1 , D(x)(0) = −0.5]] , scene = [t , x(t)]) ;
> phaseportrait ({diff(x(t) , t) − 4*y(t) = sin(t) , diff(y(t) , t) + x(t) = cos(t)} , {x(t) , y(t)} , t = 0..10 , [[x(0) = 1 , y(0) = 0]] , scene = [x(t) , y(t)] , stepsize =0.01 , linecolour = blue) ;
> DEplot({diff(x(t) , t) - 4*y(t) = sin(t) , diff(y(t) , t) + x(t) = cos(t)} , {x(t) , y(t)} , t = 0..10 , y =-0.5..0.5, [[x(0) = 1 , y(0) = 0]] , scene = [x(t) , y(t)] , stepsize =0.01 , linecolour = blue,obsrange=false); # obsrange = false permet la poursuite du tracé même s'il sort de la fenêtre.
1.7.2 odeplot : on résout d'abord l'équation différentielle de façon numérique avec l'option numeric puis on utilise odeplot pour le tracé.
> plots[odeplot] (solution d'une ED retournée par dsolve avec le type numeric , [variables] , a..b , options);
Les options sont celles de plot; numpoints précise le nombre de points utilisés pour le tracé.
Exemple
> soln:= dsolve({diff(x(t) , t) − 4*y(t) = sin(t) , diff(y(t) , t) + x(t) = cos(t) , x(0) = 1 , y(0) = 0} , {x(t) , y(t)} , type = numeric) ;
> plots[odeplot](soln , [x(t) , y(t)] , 0..10 , numpoints = 100 , color = COLOR(`HUE` , 0.8)) ;
> a:= 2 : sol1:= dsolve({diff(y(t) , t) + 2*y(t) = (t + 1) *y(t)^2 , y(−1) = a} , y(t) , numeric) ; # les conditions initiales sont obligatoires; sol1 est une procédure qui calcule les valeurs de y (t)
> plots[odeplot] (sol1 , [t , y(t)] , −3..3) ;
1.7.3 Lorsque Maple sait résoudre l'équation, on peut tracer un échantillon de courbes intégrales : Exemple
> a:= 'a' : sol2:= dsolve({diff(y(t) , t) + 2*y(t) = t , y(0) = a}, y(t)) ;
> f:= unapply(rhs(sol2) , a , t) : # on extrait de sol2 l'expression des solutions en la variable t et avec le paramètre a = y(0) pour former une fonction f de deux variables
> plot({seq (f (a , t) , a = −3..3)} , t = −3..3 , y = −5..5 ) ;
1.8 Options
Lorsqu'on clique sur un graphique, la barre d'outils se modifie et de nouveaux menus apparaissent (style, axes, projection, animation) permettant de modifier directement certaines options du graphique (on peut aussi y accéder par un clic droit sur la zone du graphique).
Le tableau suivant donne quelques unes des options disponibles.
Tableau des options de plot (taper > ?plot,options; pour plus de détails)
syntaxe description
numpoints = nbpts nombre de points utilisés par Maple pour construire le graphique (défaut = 50) xtickmarks = n, ytickmarks = m
tickmarks = [n,m]
n (resp. m) = nombre de graduations marquées sur les abscisses (resp. sur les ordonnées)
view = [xmin .. xmax , ymin .. ymax] fixe la fenêtre d'affichage
scaling = constrained fixe un repère orthonormé (par défaut, unconstrained = repère orthogonal) labels = [`nom_abs`,`nom_ord`] nomme les abscisses et les ordonnées (noms entre backquotes)
title = `nom_graphique` titre du graphique sous forme d'une chaîne de caractères
axes = normal, none, boxed, frame position des axes (normal, aucun axe dessiné, encadré, axes sur le côté) style = LINE , POINT , … style de tracé : par défaut LINE (les points sont reliés)
symbol = box, circle, cross, POINT,
diamond, DEFAULT motif utilisé pour marquer les points (en style POINT) filled = true permet de remplir l'enveloppe convexe d'un graphique
color = nom_couleur nom_couleur ∈ { black blue navy cyan green grey magenta maroon red violet white yellow … } liste : > ?plot,color;
color = COLOR(…) COLOR(`RGB`, x, y, z) où x, y, z sont trois réels dans [0,1]
COLOR(`HUE`, x) où x est dans [0,1]
linecolour = code de couleur ou bien
fonction de la variable indépendante seulement avec certaines commandes comme phaseportrait, DEplot
discont = true pour plot (exp(var), …), l'option supprime les droites verticales marquant les points singuliers
linestyle = Solid, Dot, Dash, DashDot type de tracé des droites
§2 Graphiques 3D
2.1 Surfaces cartésiennes z = F (x,y)
Ce sont les points de l'espace de la forme (x , y ,F (x,y)) avec (x,y) ∈ I × J Syntaxe :
> plot3d (F(x,y) , x = xmin..xmax , y = ymin..ymax , options);
Exemple :
> plot3d((2 − x)^2 + y^2 , x = 0..2 , y = 0..2 , axes = NORMAL);
2.2 Surfaces paramétrées
C'est l'image d'une application D t3 où D est un pavé de 2. Syntaxe :
> plot3d ([x(u,v) , y (u,v) , z(u,v)] , u = umin..umax , v = vmin..vmax , options) Exemples :
> plot3d ([cos(t) *sin(u) , sin(t) *sin(u) , cos(u)], u = 0..Pi , t = 0..2*Pi ); # sphère de rayon 1
2.3 Courbes en coordonnées cartésiennes
On peut utiliser spacecurve (disponible dans le package plots) :
> plots[spacecurve]({courbe1 , courbe2 , … courben}, options) ; avec courbei = [expr_x(t) , expr_y(t) , expr_z(t) , t = a..b]
Exemple
> plots[spacecurve]( {[cos(t) * (1 − cos(t)) , sin(t) * (1 − cos(t)) , 0.25*t − cos(4*t)],[sin(t/2),cos(t/2),t sin(t/4)]} , t = 0..8*Pi , numpoints = 200) ;
2.4 Surfaces en coordonnées cylindriques
Dans un repère (O, it , jt , kt ), on écrit OM
t
= r utθ
+ z kt ; le triplet ( r , θ , z ) est le triplet des coordonnées cylindriques de M.
Syntaxe :
> plot3d ([rayon (u , v), θ(u,v) , z(u,v)] , u = umin .. umax , v = vmin .. vmax , coords = cylindrical , options ) ; surface en coordonnées cylindriques paramétrée par u et v .
> cylinderplot([rayon (u , v) , θ(u,v) , z(u,v)] , u = umin .. umax , v = vmin .. vmax , options ) ; cylinderplot est disponible dans le package plots
> plot3d (rayon (θ , z), angle = θmin .. θ max , z = zmin .. zmax , coords = cylindrical , options )
> cylinderplot (rayon (θ , z), angle = θmin .. θ max , z = zmin .. zmax , options ); # il faut charger le package plots
Exemples :
> with (plots) : display(plot3d([0,0,t],t = −5..15 , u = 0..1) , cylinderplot([3,t,t] , t = 0..15 , u = 0..1 , grid = [100,10]));
> plot3d([3,t,abs(t − 8)] , t = 0..15 , u = 0..1 , coords = cylindrical , grid = [100,10]);
> cylinderplot ([4 − 2*cos (v) , u , 2*sin (v)] , u = 0..2*Pi , v = 0..2*Pi , style = PATCH , scaling = constrained) ; # tore
> R:=4 : r:=2 : cylinderplot ([R + u*r/Pi + r*cos(v), u , r*sin(v)] , u = 0..6*Pi , v = 0..2*Pi , style = PATCH , scaling = constrained , grid = [200,10]);
> cylinderplot ((5 − z) * (1 − cos(t)) , t = 0 .. 2*Pi , z = 0..5);
> cylinderplot ([ u , t , 2.5*t] , t = 0 .. 15 , u = 0 .. 2 , grid = [100,10] , view = [−2..2 , −2..2 , −1..35]) ;
> cylinderplot ([4 − cos(z) , t , z] , t = 0..2*Pi , z = 0..2*Pi , style = PATCH , scaling = constrained) ;
2.5 Surfaces en coordonnées sphériques
On écrit OM
t
= rsin ϕ utθ + rcos ϕtk ; le triplet ( r , θ , ϕ ) est le triplet des coordonnées sphériques de M (θ angle polaire, ϕ colatitude).Syntaxe :
> plot3d (rayon (θ , ϕ) , θ = θmin .. θ max , ϕ = ϕmin .. ϕmax , coords = spherical, options );
> sphereplot (rayon (θ , ϕ), θ = θmin .. θ max , ϕ = ϕmin .. ϕmax , options ) ;
sphereplot est disponible dans le package plots ; il faut respecter l'ordre : angle polaire θ puis colatitude ϕ .
> sphereplot([rayon (u , v) , θ(u,v) , ϕ (u,v)] , u = umin .. umax , v = vmin .. vmax , options ) ; surface paramétrée en coordonnées sphériques, paramétrée par u et v
Exemples
> sphereplot (2 , t = 0..3*Pi/2 , u = 0..Pi/3 , style = PATCH , scaling = constrained); # morceau de sphère
> sphereplot (5*sin(u) , u = 0..Pi , v = 0..Pi , style = PATCH , scaling = constrained , grid = [50,30] );
> sphereplot([2*sin(2*v) *sin(2*u) , u , Pi/4*(1+sin(2*v))] , u = 0..2*Pi , v = Pi/4..3*Pi/8 , numpoints = 5000);
2.6 Choix des options
On peut superposer des graphiques à l'aide de la fonction display comme en 2D.
Par défaut les axes ne sont pas affichés; pour les afficher, faire un clic droit sur le graphique et sélectionner axes;
essayer les différentes possibilités.
Essayer les autres options, par exemple les différents styles.
Quand on clique sur le graphique, une nouvelle barre d'outils apparaît en haut de la feuille; le bouton R permet de redessiner le graphique lorsqu'on a modifié les paramètres.
On peut faire tourner la figure dans l'espace : faire un clic gauche sur le graphique, puis sans relâcher, bouger la souris.
Cliquer ensuite sur R pour redessiner le graphique.
L'option grid = [n,m] permet d'augmenter le nombre de points pour améliorer la précision du tracé, n et m étant le nombre de points pour le premier et le second paramètre respectivement.
Taper > ? plot3d[option] ; pour davantage de précision.
