Découvrir Scilab/Graphiques et sons

Un livre de Wikibooks.

Table des matières — Index

4. Graphiques

[modifier] Tracé de fonction

[modifier] Tracé 2D

[modifier] En Coordonnées cartésiennes

Le tracé d’une fonction se fait en deux étapes

1. définir l’étendue de la variable abscisse et le pas, sous la forme d’un vecteur ligne ou colonne, par exemple
   x = [début:pas:fin], ou
   x = linspace(début, fin, nombre_de_points) ;
2. tracer la fonction avec la commande
plot(x, f(x))
si ƒ est la fonction.

On peut tracer simultanément plusieurs fonctions en les mettant dans une matrice, par exemple

plot(x, [f1(x) f2(x) f3(x)])

ou bien en répétant la matrice des abscisses :

plot(x, f1(x), x, f2(x), x, f3(x))

On peut définir la manière dont est tracée la courbe en mettant une chaîne de caractère après la matrice des y. Cette chaîne de caractère peut contenir :

• un signe moins « - » pour indiquer que l'on trace la ligne ;
• un signe pour indiquer que l'on met un marqueur : un plus « + », un astérisque « * », un « o » (rond), un accent circonflexe « ^ » (triangle pointe en haut), un « v » (triangle pointe en bas), un « d » (losange, diamond), un « p » pour une étoile à cinq branches (pentagram), un « s » pour un carré (square), un « x » pour des croix de saint André ;
• une lettre indiquant la couleur : « c » pour cyan, « g » pour vert (green), « k » pour noir (black), « m » pour magenta, « r » pour rouge, « w » pour blanc (white), « y » pour jaune (yellow).

Ces paramètres ne fonctionnent qu'avec la fonction plot et pas avec les fonctions plot2d (voir ci-après).

Exemple

x=linspace(0,%pi,50);
plot(x,sin(x),"+g",x,cos(x),"-^r")

trace un sinus en croix droites vertes et un cosinus en trait plein et avec des triangles en rouge.

On note qu'en fait, ƒ(x) est elle-même un vecteur. On peut de manière générale définir un vecteur des valeurs de x et un vecteur des valeurs de y, et la fonction plot(x, y) tracera le nuage de points (x(i ),y(i )).

Si ƒ est une fonction externe (par exemple définie avec deff ou function, voir Calcul numérique), alors on peut tracer directement la fonction avec

fplot2d(x, f).

On peut aussi définir le vecteur y par

y = feval(x, f),

puis tracer avec

plot(x,y).

Les fonctions plot2di, utilisées à la place de plot, permettent de faire varier l’apparence générale du tracé :

• plot2d : trait « normal » ; identique à plot, mais l’utilisation de marqueurs et des couleurs est différente (voir ci-après) ;
• plot2d2 : trait en escalier ;
• plot2d3 : tracé en barres ;
• plot2d4 : tracé en « flèches » : les points adjacents sont reliés par une flèche ;

Ces fonctions plot2di acceptent des arguments modifiant le tracé, sous la forme

plot2di(x, y, arguments).

Les arguments sont de la forme mot-clef = valeur, et sont séparés par des virgules.

Pour placer des marqueurs, on utilise l’argument style = n ou n est un entier positif ou négatif (par exemple plot2d(x, y, style = 1)) :

• un nombre négatif remplace les points par des marqueurs (une étoile pour -10, des ronds pour -9, …, des petits points pour 0, la liste s'obtient en tapant la commande getsymbol) et
• un nombre positif indique un trait plein mais de couleur déterminée (selon la carte de couleur définie, voir ci-après).

L’argument rect = [xmin, ymin, xmax, ymax] permet de limiter le tracé à la zone comprise dans le rectangle défini par les valeurs dans la matrice.

Modes de tracé 2d

Exemple

clear; clf;
x = [0:0.5:2*%pi]';

subplot(2,2,1)
plot2d1(x,sin(x),rect=[0,-1,2*%pi,1])
xtitle('plot2d1')

subplot(2,2,2)
plot2d2(x,sin(x),rect=[0,-1,2*%pi,1])
xtitle('plot2d2')

subplot(2,2,3)
plot2d3(x,sin(x),rect=[0,-1,2*%pi,1])
xtitle('plot2d3')

subplot(2,2,4)
plot2d4(x,sin(x),rect=[0,-1,2*%pi,1])
xtitle('plot2d4')

[modifier] En coordonnées polaires

La fonction polarplot permet en tracé en coordonnées polaires. La fonction r(theta) se trace par la commande :

polarplot(r,theta)

où r et theta sont deux matrices de même dimension.

[modifier] Carte d’un champ

Si x est un vecteur colonne de m éléments, y un vecteur colonne de n éléments et z une matrice m×n, alors la fonction

grayplot(x, y, z)

va associer une couleur à chaque valeur de z et tracer une carte de couleurs, chaque point (x(i ), y(j )) ayant la couleur associée au coefficient z(i, j ).

Les niveaux de couleur sont indiqués par la fonction

xset('colormap', cmap)

où cmap est une matrice de trois colonnes dont chaque ligne contient la couleur associée à un niveau, sous la forme RVB (les éléments de la matrice allant de 0 à 1). La première ligne de la matrice correspond au plus bas niveau, la dernière ligne au plus haut. Cette matrice peut être générée de manière autmatique par les fonctions colormap :

graycolormap(n), où n est un entier, génère n niveaux de gris entre le noir et le blanc ;

jetcolormap(n), où n est un entier, génère n niveaux de couleur entre le bleu et le rouge ;

hotcolormap(n), où n est un entier, génère n niveaux de couleur entre le rouge et le jaune.

On peut par exemple utiliser xset('colormap',graycolormap(32)) pour avoir 32 niveaux de gris. On peut réaliser un dégradé du noir vers le rouge avec

cmap = graycolormap(32); cmap(:, 2:3) = 0

ou avec

r = [0:32 / 31:32]' / 32; cmap = [r zeros(32, 2)]

et un dégradé du bleu vers le blanc avec

cmap = graycolormap(32); cmap(:, 2:3) = 1

ou avec

r = [0:32 / 31:32]' / 32; cmap = [r ones(32, 2)]

Les niveaux de couleur sont également utilisés lorsque l’on trace plusieurs courbes sur le même graphique. Dans ce cas-là, des dégradés ne fournissent pas un contraste permettant de distinguer facilement des courbes voisines ; on peut obtenir les niveaux de couleur par défaut avec get(sdf(), 'color_map').

On peut tracer des courbes de niveau avec la fonction

contour2d(x, y, z, n)

où n est le nombre de niveaux que l’on veut voir figurer ; on peut aussi donner les valeurs des niveaux z₁, z₂, …, z_n par un vecteur

contour2d(x, y, z, [z1,z2,...,zn])

On peut également tracer un champ de vecteurs, sous la forme de flèches. Pour cela, il faut une matrice vx ayant les composante selon x du champ de vecteur, une matrice vy ayant les composantes selon y de ce champ, et utiliser la fonction

champ(x, y, vx, vy)

le vecteur (vx(i,j ),vy(i,j )) étant placé en (x(i ), y(j )). Avec la fonction champ1, les vecteurs tracés ont tous la même longueur, la norme du champ est indiquée par la couleur du vecteur, suivant le principe exposé pour grayplot.

[modifier] Tracé 3D

Scilab permet également le tracé de surfaces à trois dimensions (x, y, z). Si x est une matrice colonne de m éléments, y une matrice colonne de n éléments, et z une matrice m×n, alors la fonction

plot3d(x, y, z)

va tracer la surface des points (x(i ), y(j ), z(i, j )). S’il s’agit d’une surface représentatrice d’une fonction ƒ, on a

z(i, j ) = ƒ(x(i ), y(j )).

Si ƒ est une fonction « externe » (par exemple définie par deff ou function, voir Calcul numérique), on peut définir z avec la fonction feval (voir plus haut), ou bien utiliser fplot3d(x, y, f).

La fonction

param3d(fx(t), fy(t), fz(t))

trace la courbe paramétrique ; t est un vecteur contenant les valeurs successives du paramètre.

Les fonctions plot3d1, fplot3d1 et param3d1 permettent d’utiliser des niveaux de couleurs pour indiquer la valeur de z. L’utilisation est identique à celle de plot3d, mais les niveaux de couleur sont indiqués par la fonction

xset('colormap', cmap)

(voir ci-dessus).

Le point de vue de la surface 3D est défini par deux angles en degrés, θ, rotation autour de l’axe des Z, et α, rotation autour de l’axe des Y (angles d'Euler) : plot3d(x, y, z, theta, alpha), param3d(x, y, z, theta, alpha)… ;

• plot3d(x, y, z, 0, 0) donne une vue de dessus, semblable aux cartes 2D, projection de la surface sur le plan XY selon l’axe Z ;
• plot3d(x, y, z, 90, 0) donne une vue de face, projection de la surface sur le planXZ selon l’axe Y ;
• plot3d(x, y, z, 0, 90) donne une vue de côté, projection de la surface sur le planYZ selon l’axe X ;
• plot3d(x, y, z, 45, 35.5) est la vue par défaut, de type perspective isométrique.

On peut également définir les limites des axes avec le mot-clef ebox :

• plot3d(x, y, z, ebox=[xmin, xmax, ymin, ymax, zmin, zmax])
• plot3d(x, y, z, theta, alpha, ebox=[xmin, xmax, ymin, ymax, zmin, zmax])

[modifier] Tracé de statistiques

Si x est un vecteur, la fonction histplot(n, x), n étant un entier, va découper l’intervalle de valeurs prises par les coefficients de x en n tranches d’égale largeur, et tracer l’histogramme de répartition des valeurs selon ces tranches. Si n est un vecteur dont les coefficients sont strictements croissants, les valeurs des coefficients de n servent à déterminer les tranches.

Si x est une matrice, hist3d(x) trace un histogramme 3D tel que le parallélépipède situé en (i, j ) a pour hauteur x(i, j ). Comme pour toutes les fonctions de tracé en trois dimension, on peut définir l’angle de vue avec θ et α.

[modifier] Dessin

Il est possible de dessiner directement des figures géométriques sur le graphique.

La fonction

xpoly(x,y,'lines',1)

permet de tracer un polygone fermé, x étant la liste des abscisses des sommets (sous la forme d'un vecteur ou d'une matrice) et y étant la liste des ordonnées des sommets (c'est une matrice de même dimension que x) ; la ligne relie les points (x(i ), y(i )). La fonction

xfpoly(x,y,'lines',1)

permet de tracer un polygone rempli.

La fonction

xrect(x,y,l,h)

trace un rectangle dont le point en haut à gauche est (x, y), de largeur l et de hauteur h. La fonction

xfrect(x,y,l,h)

trace un rectangle rempli.

La fonction

xstring(x, y, 'chaîne')

écrit la chaîne de caractère chaîne sur le graphique, le point en bas à gauche du texte étant au point (x,y). Cela permet par exemple de placer une étiquette (label) sur le graphique.

La fonction

xarc(x,y,l,h,a1,a2)

trace un arc d'ellipse compris dans le rectangle dont le point en haut à gauche est (x, y), de largeur l et de hauteur h. Chaque degré d'angle est divisé en 64 secteurs, l'arc part de l'angle trigonométrique a1×64 ° et va jusqu'à l'angle (a1+a2)×64 °. Pour tracer une ellipse entière, il faut donc entrer :

xarc(x,y,l,h,0,360*64)

La fonction

xfarc(x,y,l,h,a1,a2)

trace un arc d'ellipse rempli.

La fonction

xarrows(nx,ny)

petmet de tracer des flèches. Deux cas se présentent :

• nx et ny sont des vecteurs : scilab trace un polygone de flèches reliant les points (n_x(i), n_y(i)) → (n_x(i+1), n_y(i+1)) ;
• nx et ny sont des matrices de deux lignes et ayant le même nombre de colonnes :
  • la première ligne de nx indique les abscisses des points de départ des flèches, la première ligne de ny en indique les ordonnées ;
  • la deuxième ligne de nx indique les abscisses des points d'arrivée des flèches, la deuxième ligne de ny en indique les ordonnées.

Pour changer les propriétés des traits des dessins, il faut utiliser la commande : set('propriété', valeur). Les principales propriétés d'un objet sont :

• line_style : type de trait ; c'est un entier, 0 pour un trait plein, 2 pour des pointillés longs, 3 pour des pointillés courts, 4 pour un trait d'axe (alternance trait-point)…
• thickness : épaisseur du trait, sous la forme d'un entier positif ;
• mark_size : dans le cas d'un tracé par marqueurs, taille des marqueurs.

On peut aussi associer une variable à l'élément dessiné ; cela se fait avec la fonction

variable = get('hdl')

hdl signifiant handle (littéralement « poignée », intermédiaire d'action). On peut aussi utiliser l'abréviation variable = gce() (pour « get current entity »). Pour définir la propriété de cet élément, on fait

variable.propriété = valeur

Ces deux méthodes sont valables quelque soit l'objet (courbe, polygone, arc d'ellipse…).

Par exemple

xarc(0,1,0.5,0.5,0,360*64) // ellipse
set('line_style',2) // pointillés

ou bien

xarc(0,1,0.5,0.5,0,360*64) // ellipse
a=get('hdl')
a.line_style=2 // pointillés

[modifier] Mise en forme, axes et fenêtrage

[modifier] Paramètres de la fonction plot2d

Dans un tracé 2D, le format des axes peut se définir avec des arguments des fonctions plot2di.

Rappel

les arguments se placent après les vecteurs de valeurs

plot2di(x, y, arguments).

On peut choisir le type d’axe avec l’argument axesflag=n où n est un entier positif :

• 0 pour ne pas avoir d’axe,
• 1 pour des axes « classiques » se recoupant en bas à droite,
• 4 pour des axes « classiques » se coupant au centre,
• 5 pour des axes se coupant en (0, 0)…

On peut définir le nombre de graduations et de sous-graduations des axes avec l’argument nax = [nx, Nx, ny, Ny] où Nx est le nombre de graduations de l’axe x, nx le nombre de sous-graduations…

Pour une échelle logarithmique, on utilise l’argument logflag = type où type est une chaîne de deux caractères, « n » (pour normal) ou « l » (pour logarithmique), le premier caractère correspondant à l’axe des x et le second à l’axe des y. Par exemple

• plot2d(x, y, logflag = 'nl') pour un axe des x linéaire et un axe des y logarithmique ;
• plot2d(x, y, logflag = 'll') pour avoir deux échelles logarithmiques.

Deux tracés superposés, l'un avec des styles positifs (traits pleins en couleur), l'autre avec des styles négatifs (marqueurs)

Si le tracé comporte plusieurs courbes (donc mis dans une matrice ligne Y), l’argument style est une matrice, la valeur de chaque élément indiquant le style de chaque courbe, par exemple

Y = [cos(x), sin(x)]; plot2d(x, Y, style = [-2, -1])

Dans ce cas-là, on peut inscrire une légende sous le graphique pour chaque symbole, avec l’argument leg = ('texte1@texte2'), l’arobase « @ » servant à séparer les légendes, par exemple

plot2d(x, Y, style = [-2, -1], leg = 'cosinus@sinus')

[modifier] Autres fonctions

En tracé 2D, la fonction xgrid permet d’afficher une grille correspondant aux graduations.

La fonction xset permet de définir l’apparence :

• police des graduations et titres : xset('font', type, taille), où
  • taille est un nombre désignant la taille des caractères, en unité arbitraire ;
  • type est un nombre désignant le type de police : 1 pour les lettres grecques (police Symbol), 2–5 pour une police avec empattements type Times (2 pour des lettre romanes, 3 en italique, 4 en gras, 5 en gras italique) ; 6–9 pour une police sans empattement type Arial (6 pour des lettres romaines, 7 en italique, 8 en gras, 9 en gras italique) ;
• épaisseur des traits d’axe et du tracé : xset('thickness', e) où e est un nombre désignant l’épaisseur en unité arbitraire ;
• taille des marqueurs (le cas échéant, voir ci-après) avec xset('mark size', taille).

Comme pour tous les objets graphiques, on peut changer les propriétés des axes en les affectant à une variable par la commande var=get('current_axes') ; on peut aussi utiliser l'abréviation var=gca(). Les principales propriétés sont :

• x_location et y_location : prennent les valeurs 'top', 'middle' ou 'bottom' selon que l'on veut que l'axe soit en haut, passe par l'origine, ou soit en bas ;
• isoview : vaut 'on' si l'on veut que les échelles soient identiques sur les axes, 'off' si l'échelle est libre ;
• sub_ticks : matrice [nx,ny] où nx et ny est le nombre de sous-graduation (il faut 4 sous-graduations pour que la graduation principale soit divisée en 5).

Exemple

a=get('current_axes')
a.x_location='middle'
a.y_location='middle'
a.isoview='on'
a.sub_ticks=[4,4]

On peut placer plusieurs tracés côte-à-côte avec l’instruction subplot :

subplot(m, n, i) place le tracé qui suit l’instruction dans la i^e case (dans l’ordre de lecture européen) d’un tableau m×n ; le tracé peut comporter plusieurs instructions plot, xset, xtitle.

La fonction

xtitle('nom du graphique','axe des x', 'axe des y')

met un titre au graphique et aux axe. La fonction

titlepage('titre')

met un titre au milieu du graphique. La fonction

clf

efface la fenêtre graphique.

[modifier] Exemple

Exemple de graphique obtenu avec Scilab

Voici le graphique que l’on obtient avec les instructions ci-dessous.

clear; clf;
 
deff('[z] = f(x, y)', 'z = sin(x) * cos(y)')
 
xset('colormap', jetcolormap(32))
 
x = %pi * [-1:0.05:1]';
y = x;
z = feval(x, y, f);
 
subplot(2, 2, 1)
grayplot(x, y, z)
 
subplot(2, 2, 2)
contour2d(x, y, z, 5)
 
subplot(2, 2, 3)
plot3d1(x, y, z, 0, 90)
 
subplot(2, 2, 4)
plot3d1(x, y, z, 70, 70)

[modifier] Animations

Si voux utilisez une fonction paramétrique (en fait, une fonction de deux variables), il est alors possible de considérer la deuxième variable comme le temps et d'afficher l'évolution de la courbe en fonction du temps. Ceci se fait avec la fonction paramfplot2d.

Pour cela, vous devez définir :

• l'ensemble des valeurs que prend la première variable, sous la forme d'un vecteur ;
• l'ensemble des valeurs que prend le paramètre, sous la forme d'un vecteur.

Si f est la fonction, x le vecteur pour la variable et t le vecteur pour les paramètres, alors la syntaxe est :

paramfplot2d(f,x,t)

Vous pouvez aussi faire générer plusieurs fichier images, puis ensuite générer un GIF animé avec ces images (par exemple avec JASC Animation Shop ou encore le programme Convert de la suite ImageMagick). Vous pouvez générer des noms de fichier numérotés en utilisant la fonction code2str :

si i est un entier compris entre 1 et 9, alors code2str(i) est la chaîne de caractère formée par ce chiffre.

Exemple

for i=0:9
   for j=0:9
      clf;
      y=feval(x,t,f);
      plot2d(x,y)
      nom='test'+code2str(i)+code2str(j)+'.gif';
      xs2gif(0,nom,1)
   end;
end;

(Voir aussi Gestion des fichiers > Images.)

[modifier] Sons

Scilab peut générer ou analyser des sons. Il peut même lire et écrire des fichiers .WAV (voir Gestion des fichiers).

Un son est en fait un vecteur dont les valeurs sont comprises entre -1 et 1 ; les valeurs hors de cet interval sont ignorées (phénomène d'écrêtage).

Si ƒ_s est la fréquence d'échantillonage en hertz, alors le pas d'échantillonage est 1/ƒ_s. L'instruction soundsec permet de générer un vecteur correspondant au pas d'échantillonnage :

t=soundsec(n, fs)

où n est le nombre de secondes et ƒ_s est la fréquence. Si l'on omet ƒ_s, Scilab prend la valeur 22 050.

Si l'on a défini la fonction de son s (pression relative de l'air/tension d'alimentation normée du haut-parleur en fonction du temps), alors on peut générer un vecteur de valeurs u :

u = s(t)

et jouer le son

sound(u, fs)

L'instruction analyze détermine le spectre sonore du son et trace le graphique.

analyze(s)

[modifier] Annexes : fonctions de la bibliothèque graphique

• plot2d : représentation de courbes dans le plan
  • plot2d2 : représentation d'une fonction constante par morceaux
  • plot2d3 : représentation de courbes dans le plan sous forme de barres verticales
  • plot2d4 : représentation de courbes dans le plan sous forme de flèches
  • fplot2d : représentation d'une courbe définie par une fonction
• champ : champ de vecteur 2D
  • champ1 : champ de vecteur 2D, flèches colorées
  • fchamp : champ défini par une équation différentielle du premier ordre
• contour2d : courbes de niveau d'une surface
  • fcontour2d : courbes de niveau d'une surface (définie par une fonction)
• vgrayplot : représentation d'une surface en 2D sous forme de couleurs
  • fgrayplot : représentation d'une surface (définie par une fonction) en 2D sous forme de couleurs
• Sgrayplot : représentation d'une surface en 2D sous forme de couleurs interpolées
  • Sfgrayplot : représentation d'une surface (définie par une fonction) en 2D sous forme de couleurs interpolées
• xgrid : ajoute une grille sur un dessin 2D
• errbar : ajoute des barres d'erreur sur un dessin 2D
• histplot : dessine un histogramme
• Matplot : dessin en 2D d'une matrice en pseudo-couleurs

[modifier] Dessins 3D

• plot3d : représentation en en couleurs d'une surface
  • plot3d1 : représentation en en couleurs d'une surface
  • fplot3d : représente une surface non paramétrique définie par une fonction
  • fplot3d1 : représente une surface non paramétrique définie par une fonction
• param3d : représente une courbe paramétrique en 3D
  • param3d1 : représente des courbes paramétriques en 3D
• contour : courbes de niveau sur une surface en 3D
  • fcontour : courbes de niveau sur une surface en 3D définie par une fonction
• hist3d : représentation d'un histogramme en 3D
• genfac3d : calcule les facettes d'une surface non paramétrique
• eval3dp : calcule les facettes d'une surface paramétrique
• geom3d : projection 3D vers 2D après un dessin 3D

[modifier] Dessins de polygones et de lignes

• xpoly : dessine une ligne brisée ou un polygone
• xpolys : dessine un ensemble de lignes brisées ou de polygones
• xrpoly : dessine un polygone régulier
• xsegs : dessine des segments déconnectés
• xfpoly : remplit un polygone
• xfpolys : remplit un ensemble de polygones

[modifier] Dessins de rectangles

• xrect : dessine un rectangle
• xfrect : remplit un rectangle
• xrects : dessine ou remplit un ensemble de rectangles

[modifier] Dessins des arcs

• xarc : dessine un arc d'ellipse
• xarcs : dessine des arcs d'ellipses
• xfarc : remplit un secteur angulaire d'ellipse
• xfarcs : remplit des secteurs angulaires d'ellipses

[modifier] Dessins de flèches

• xarrows : dessine un ensemble de flèches

[modifier] Dessins de textes

• xstring : dessine des chaînes de caractères
• xstringl : calcule une boîte contenant des chaînes de caractères
• xstringb : dessine des chaînes de caractères dans une boîte
• xtitle : ajoute des titres et légendes sur une fenêtre graphique
• titlepage : ajoute un titre au milieu d'une fenêtre graphique
• xinfo : affiche une chaîne de caractères dans la sous-fenêtre des messages

[modifier] Cadres et axes

• xaxis : dessine un axe
• graduate : graduations simplifiées
• plotframe : dessine un cadre avec axes et mise à l'échelle

[modifier] Transformations de coordonnées

• isoview : échelle isométrique (fonction obsolète)
• square : échelle isométrique (par changement de la taille de la fenêtre)
• scaling : transformation affine d'un ensemble de points
• rotate : rotation d'un ensemble de points
• xsetech : choix d'une sous-fenêtre graphique
• subplot : divise la fenêtre graphique en sous-fenêtres
• xgetech : donne l'échelle graphique courante
• xchange : transformation de coordonnées réelles vers pixels

[modifier] Couleurs

• colormap : utilisation des tables de couleurs
• getcolor : boîte de dialogue pour sélectionner des couleurs dans la table des couleurs
• addcolor : ajout de nouvelles couleurs à la tables des couleurs
• graycolormap : table de couleurs du noir au blanc
• hotcolormap : table de couleurs « chaude » du rouge au jaune

[modifier] Contexte

• xset : change des valeurs du contexte graphique
• xget : récupère des valeurs du contexte graphique
• xlfont : charge une police dans le contexte graphique ou donne la liste des polices
• getsymbol : boîte de dialogue pour choisir un marqueur (ou symbole)

[modifier] Sauvegarde et chargement

• xsave : sauve les graphiques dans un fichier
• xload : charge des graphiques sauvés
• xbasimp : envoie des graphiques à une imprimante Postscript ou un fichier
• xs2fig : envoie des graphiques dans un fichier au format XFig

[modifier] Fonctions internes graphiques

• xbasc : efface une fenêtre graphique et les graphiques enregistrés
• xclear : efface une fenêtre graphique
• driver : choisit un pilote graphique
• xinit : initialisation d'un pilote graphique
• xend : termine une session graphique
• xbasr : redessine une fenêtre graphique
• replot : redessine une fenêtre graphique avec de nouvelles bornes
• xpause : suspend l'exécution de Scilab
• xselect : met une fenêtre graphique au premier plan
• xclea : effacement d'un rectangle
• xclip : définit de la zone dans laquelle s'effectue l'affichage, ce qui sort de la zone étant tronqué (clipping)
• xdel : supprime une fenêtre graphique
• winsid : renvoie la liste des fenêtre graphiques
• xname : change le nom d'une fenêtre graphique

[modifier] Position de la souris

• xclick : attend un clic de souris
• locate : sélection d'un ensemble de points
• xgetmouse : renvoie la position courante du pointeur de la souris

[modifier] Éditeur interactif

• edit_curv : éditeur graphique interactif
• gr_menu : éditeur graphique élémentaire
• sd2sci : conversion d'objets gr_menu en instructions Scilab
• ged : éditeur interactif des propriétés des entités graphiques

[modifier] Fonctions graphiques en automatique

• bode : diagramme de Bode
• gainplot : diagramme de magnitude
• nyquist : diagramme de Nyquist
• m_circle : M-circle plot
• chart : diagramme de Nichols
• black : diagramme de Black
• evans : lieu des pôles d'Evans
• sgrid : tracé de la transformée de Laplace, dans le plans des s
• plzr : tracé de pôles zéro
• zgrid : grille de la transformée en z

[modifier] Voir aussi

Dans Wikipédia

• Angle
  • Angles d'Euler
• Arobase
• Coordonnées polaires
• Diagramme de Bode
• Diagramme de Nyquist
• Échelle logarithmique
• Ellipse
• Perspective isométrique
• Police d'écriture
  • Arial
  • Empattement
  • Times
• Polygone
• RVB
• Son
• Théorie du contrôle
• Transformée en Z
• WAVEform audio format

[modifier] Notes

Calcul numérique < ↑ > Programmation