Représenter des fonctions

Le plus simple pour commencer est de tracer le graphe d'une fonction de $\mathbb{R}$ dans $\mathbb{R}$ à l'aide de plot2d. On crée pour cela un vecteur x d'abscisses, et on prend l'image de ce vecteur par la fonction pour créer un vecteur y d'ordonnées. La commande plot2d(x,y) représente les points de coordonnées (x(i),y(i)) en les joignant par des traits noirs (par défaut), ou selon un autre style, si le style de base a été changé. La qualité de la représentation dépend donc du nombre de points.

x=linspace(0,3*%pi,10); y=x.*sin(x);
plot2d(x,y)
clf()                                // sinon superposition
x=linspace(0,3*%pi,100); y=x.*sin(x);
plot2d(x,y)

On obtient le même résultat par fplot2d, mais il faut pour cela prédéfinir la fonction à représenter. Les tracés successifs se superposent.

deff("y=f(x)","y=x.*sin(x)")
x=linspace(0,3*%pi,10);
fplot2d(x,f)
x=linspace(0,3*%pi,100);
fplot2d(x,f)                     // superposition des deux graphiques

Quand on veut superposer plusieurs courbes avec les mêmes échelles de représentation, il est préférable d'utiliser plot2d, qui autorise des styles différents pour chaque courbe. La syntaxe générale est la suivante.

plot2d(abscisses,ordonnees [,clef1=valeurs1 [,clef2=valeurs2]] )

Après les deux premiers, les arguments sont facultatifs, les «clefs» indiquent les paramètres du graphique que l'on désire fixer à «valeurs», voir la suite.

Signification des arguments :

$\bullet$ abscisses, ordonnees : Si ce sont des vecteurs (une seule courbe à tracer), ils peuvent être ligne ou colonne. Si plusieurs courbes doivent être tracées, soit abscisses est un vecteur colonne et ordonnees une matrice ayant le même nombre de lignes (i.e. nombre de points) et un nombre de colonnes donné (i.e. le nombre de courbes) ; soit ce sont des matrices de mêmes dimensions : à chaque vecteur colonne «abscisse» correspond un vecteur colonne «ordonnée» de même taille.
Par défaut les points seront reliés par des segments. À chaque courbe correspond une couleur de la palette : il y en a 32 ; getcolor affiche la palette.

x=linspace(0,3.5*%pi,30);
y=x.*sin(x);
plot2d(x,y)
clf()
y2=2*y;
plot2d([x,x],[y,y2])   // incorrect : deux courbes concatenees
clf()
plot2d([x;x],[y;y2])   // incorrect : trace 30 segments
clf()
plot2d([x;x]',[y;y2]') // correct
clf()
plot2d(x',[y;y2]')     // correct
clf()
X=x'*ones(1,20);
Y=y'*[1:20];
plot2d(X,Y)

Les clefs et une partie des valeurs possibles sont présentées ci-dessous, sous la forme clef=valeur. Pour plus de détails se référer à l'aide en ligne de plot2d.

$\bullet$ style=vect_style : vect_style est un vecteur ligne dont la dimension est le nombre de courbes à tracer, c'est-à-dire le nombre de colonnes des matrices abscisses et ordonnees. Les coordonnées sont positives ou négatives. Si le style est positif, les points sont joints par des segments. Si le style est nul, les points sont affichés comme des pixels noirs. Si le style est négatif, des marques de formes particulières sont affichées.

x=linspace(0,3*%pi,30); X=x'*ones(1,10);
y=x.*sin(x); Y=y'*[1:10];
couleurs=matrix([2;5]*ones(1,5),1,10)
clf()
plot2d(X,Y,style=couleurs)
marques=-[0:9]
clf()
plot2d(X,Y,style=marques)

$\bullet$ rect=vect_rect : vect_rect est le rectangle de représentation, décrit par les deux coordonnées du coin inférieur gauche, suivies des deux coordonnées du coin supérieur droit : [xmin,ymin,xmax,ymax].

x=linspace(0,3*%pi,30);
y=x.*sin(x);
clf()
plot2d(x,y)
scf()
plot2d(x,y,rect=[0,-10,9.5,10])

$\bullet$ frameflag=int_ff : int_ff est un entier entre 0 et 8 qui code le calcul des échelles en abscisse et ordonnée.
Pour frameflag=0 on utilise les échelles du graphique précédent ;
pour frameflag=1 on calcule les échelles grâce à vect_rect ;
pour frameflag=2 on détermine les échelles optimales à partir des données abscisses, ordonnees. pour frameflag=6 on détermine les échelles optimales à partir des données abscisses, ordonnees mais de façon à avoir de «jolies» graduations.

$\bullet$ axesflag=int_ax : int_ax est un entier entre 0 et 5 qui code le tracé des axes et du cadre.
Pour axesflag=0 rien n'est tracé ;
pour axesflag=1 les axes sont tracés avec les ordonnées à gauche ;
Pour axesflag=2 un cadre est tracé autour du graphe.

x=linspace(0,3*%pi,30);
y=x.*sin(x);
clf()
plot2d(x,y)
y2=2*y;
plot2d(x,y2,style=2)         //  echelles differentes adaptees
scf()
plot2d(x,y)
plot2d(x,y2,style=2,axesflag=0, frameflag=0) 
                             // on utilise les axes precedents
scf()
plot2d(x,y2,style=2)         
plot2d(x,y,axesflag=0, frameflag=0) 
                             // on utilise les axes precedents

$\bullet$ leg=legendes : c'est une chaîne de caractères contenant les différentes légendes, séparées par @.

x=linspace(0,3*%pi,30); X=x'*ones(1,5);
y=x.*sin(x); Y=y'*[1:5];
vect_styles=[-2:2]
legendes="x sin(x)@2 x sin(x)@3 x sin(x)@4 x sin(x)@5 x sin(x)"
clf()
plot2d(X,Y,style=vect_styles,leg=legendes)
scf() // meme affichage
plot2d(X,Y,style=vect_styles, frameflag=6, axesflag=1,leg=legendes)

Les commandes captions et legend sont plus flexibles, donc préférables.

$\bullet$ nax=graduations : graduations est un vecteur de quatre entiers qui permet de préciser le nombre des graduations et sous-graduations en abscisse et ordonnée. Par exemple, avec [4,11,4,5], l'intervalle des abscisses sera divisé en 10 intervalles, i.e. 11 graduations, chacun des 10 intervalles étant subdivisé par 4 sous-graduations, i.e. 5 sous-intervalles. Pour les ordonnées il y aura 4 intervalles, chacun subdivisé en 5 sous-intervalles.

x=linspace(0,3*%pi,30);
y=x.*sin(x);
clf()
plot2d(x,y, rect=[0,-10,10,10])
scf()
plot2d(x,y, rect=[0,-10,10,10],nax=[4,11,4,5])

$\bullet$ logflag=ch_log : ch_log est une chaîne de deux caractères parmi : "nn" (défaut), "nl", "ln" et "ll", où n indique l'échelle habituelle, tandis que l indique que l'on utilise une échelle logarithmique. Ainsi logflag="nl" utilise en abscisse l'échelle normale et en ordonnée l'échelle logarithmique.

N=[2:100000]';
C1=N.*log(N);
C2=N.^2;
clf()
plot2d(N,[ C1 C2],style=[2,3],leg="N ln(N) @ N^2" )
scf()
plot2d(N,[ C1 C2],style=[2,3], logflag="ll",leg="N ln(N) @ N^2")

Figure 1: Représentation de plusieurs courbes.

Graphes de fonctions
plot2d	plusieurs courbes avec styles différents
plot2d1	idem, avec plus d'options
plot2d2	représentation en escalier
plot2d3	barres verticales
plot2d4	flèches
fplot2d	représenter des fonctions

Les échelles de représentation, choisies automatiquement, ne sont pas les mêmes en abscisse et en ordonnée. On peut corriger ceci grâce à l'option frameflag de plot2d ou à l'aide des commandes isoview et square.