Scilab est un logiciel de calcul numrique fournissant un environnement de calcul pour des applications scientifiques. Dvelopp depuis 1990 par des chercheurs de lINRIA et de lENPC, il est, depuis la cration du Scilab Consortium en mai 2003, dvelopp et maintenu par l'INRIA.

La syntaxe et les possibilits offertes par Scilab sont similaires  celles de Matlab, mais les deux logiciels ne sont pas compatibles mme si un traducteur Matlab vers Scilab existe.

Distribu gratuitement et avec son code source via lInternet depuis 1994, il est disponible prcompil pour un grand nombre darchitectures. Nanmoins (contrairement  ce qui est prtendu sur son site) il ne sagit ni dun logiciel Open source selon l'Open Source Initiative ni dun Logiciel libre. En effet, la licence de Scilab nautorise pas la distribution commerciale dune version modifie. Selon la classification de la FSF, il s'agirait donc plutt d'un logiciel semi-libre [1].

Sommaire [masquer]
1 Prsentation succincte de lutilisation 
1.1 Syntaxe lmentaire en ligne de commande 
1.1.1 Boolens 
1.1.2 Polynmes et fractions rationnelles 
1.1.3 Caractre 
1.1.4 Matrices 
1.2 Calcul numrique 
1.3 Trac de fonction 
1.3.1 Trac 2D 
1.3.2 Carte dun champ 
1.3.3 Trac 3D 
1.3.4 Reprsentation de donnes statistiques 
1.3.5 Dessin 
1.3.6 Mise en forme, axes et fentrage 
1.3.7 Exemple 
1.4 Programmation 
1.5 Environnement 
2 Voir aussi 
2.1 Logiciels similaires 
2.2 Liens externes 
 


 Prsentation succincte de lutilisation  [modifier]
Scilab peut excuter des instructions en ligne de commande, ainsi que des fichiers de commande (scripts) contenant des instructions (format texte). On peut galement excuter des programmes Fortran ou C  partir de Scilab. Scilab est complte par un environnement graphique Scicos comparable  l'environnement graphique Simulink fourni avec Matlab.


 Syntaxe lmentaire en ligne de commande  [modifier]
Linvite de la ligne de commande (prompt) est constitue dune  flche  : deux tirets et un signe suprieur -->. Linstruction est tape puis valide avec la touche de retour chariot (Enter, Return). Le rsultat est affich  la suite, sauf si la ligne se termine par un point-virgule auquel cas le rsultat est cach. Par exemple :

-->a = 1;
-->A = 2;
-->a + A
ans =
 
3.
La premire commande associe la valeur  1   la variable  a  (rsultat cach), la seconde commande associe la valeur  2   la variable  A  (la syntaxe est sensible  la casse), la troisime commande calcule la somme des deux (ans est labrviation de answer qui signifie  rponse  en anglais).

On peut crire plusieurs instructions sur la mme ligne en les sparant dune virgule, ou dun point-virgule si lon ne veut pas en afficher le rsultat. On peut aussi mettre une instruction sur plusieurs lignes (par exemple pour des raisons de prsentation) en mettant trois points  ...  avant de presser la touche de retour chariot.

Scilab utilise les fonctions et oprateurs classiques (+, -, *, /, ^ ou **, sqrt() pour la racine carre, cos() pour le cosinus, int() pour la partie entire, round() pour larrondi au plus proche, abs() pour la valeur absolue) et quelques autres (par exemple rand pour avoir un nombre alatoire entre 0 et 1). La fonction who affiche les variables dclares. La variable ans contient le dernier rsultat.

Le sparateur dcimal est le point. Pour entrer limaginaire i, il faut utiliser %i ; il figure simplement sous la forme  i  dans les rsultats. Pour entrer linfini 8, il faut utiliser %inf ; il figure simplement sous la forme  inf  dans les rsultats. La valeur de p sobtient par %pi, et la constante de Neper e par %e.


 Boolens  [modifier]
Lorsque lon assigne une valeur boolenne, on utilise %t pour  vrai  (true) et %f pour  faux  (false). Le rsultat de lopration affich est respectivement T ou F.

Loprateur Ou est not  |  (tube), Et est not  &  (esperluette), Non est not  ~  (tilde). Exemple

-->(%t & %f) | %f
ans =
 
F.
Un boolen peut galement sobtenir en comparant deux valeurs, avec les relations dgalit == et de diffrence <> ou ~=, et les relations d'ordre <, <=, > et >=.


 Polynmes et fractions rationnelles  [modifier]
Il sagit ici non pas de fonctions polynmes qui ne permettraient que leur valuation numrique, mais de polynmes formels.

La dclaration dun polynme se fait avec deux fonctions. La premire fonction, x = poly(0, 'x') qui dfinit  x  comme lindtermine dun polynme, puis lnonc du polynme utilisant cette indtermine. Exemple

-->x = poly(0, 'x'); p = x ^ 2 + 2 * x + 1
p =
 
          2
1 + 2x + x
La fonction roots(p) donne les racines du polynme p, la fonction coeff(p) donne une matrice dont les coefficients sont les coefficients du polynme p. La fonction varn(p) renvoie le nom de lindtermine de p (ici, x).

En fait, la commande x = poly(0, 'x') dfinit que x est le polynme le plus simple dont lindtermine est le caractre  x  et dont la racine est 0, cest--dire le monme x. La commande x = poly(2, 'x') dfinit de mme le polynme le plus simple ayant pour racine 2, cest--dire x - 2.

Cette fonction permet de dfinir un polynme ayant plusieurs racines, en utilisant une matrice ligne au lieu dun simple nombre. Par exemple, x=poly([1 2],'x') dfinit le polynme le plus simple ayant pour racines 1 et 2, soit le polynme x2 - 3x + 2.

On peut aussi utiliser cette fonction pour gnrer un polynme dont les coefficients sont contenus dans une matrice ligne, en ajoutant le caractre 'c'  la fin des arguments. Par exemple, x = poly([a0, a1, , an], 'x', 'c') dfinit le polynme a0 + a1x +  + anxn.

Scilab gre de la mme manire les fractions rationnelles. Il suffit de dclarer un monme avec poly() et dfinir ensuite la fraction rationnelle. Exemple

-->x = poly(0, 'x'); f = (1 + x) / (1 - x)
f = 
 
1 + x
-----
1 - x

-->1/f
ans =
 
1 - x
-----
1 + x
Pour avoir le numrateur de f, il suffit de taper f.num ; le dnominateur de f sobtient avec f.den.

La fonction derivat(p) donne la drivation formelle du polynme ou dune fraction rationnelle p. La fonction simp(q) fait la simplification de la fraction rationnelle q.

Lutilisation du polynme ou dune fraction rationnelle en tant que fonction se fait par la fonction horner : horner(p,2) calcule p(2).


 Caractre  [modifier]
Les caractres isols ou les chanes de caractres sont nots entre apostrophes simples, ou bien entre guillemets : 'abc' ou "abc".

L'apostrophe indique la fin d'une chane ; pour mettre une apostrophe dans une chane, il faut en crire deux accoles ''.

Laddition + sur des chanes de caractres produit la concatnation. Une chane de caractre peut tre value, cest--dire transforme en commande Scilab, par la fonction evstr().


 Matrices  [modifier]
Scilab a t conu pour le calcul matriciel. Toutes les fonctions sappliquent  des matrices ; par exemple si M est une matrice, alors log(M) sera la matrice dont les coefficients sont les logarithmes des coefficients de M. Les lments des matrices peuvent tre de tout type (nombre rel, nombre complexe, boolen, polynme, fraction rationnelle, chane de caractres).

Pour dfinir une matrice  partir de ses coefficients, on les place entre deux crochets []. Les lments dune ligne sont spars dun espace ou dune virgule, les lignes sont spares dun point-virgule.  laffichage, la matrice est reprsente comme un tableau encadr par des points dexclamation. Par exemple :

-->[1,0,0;0,1,0;0,0,1]
ans =
 
! 1. 0. 0. !
! 0. 1. 0. !
! 0. 0. 1. !
La matrice vide est note par []. Lexpression M(i,j) dsigne llment (i, j) de la matrice M. Le caractre : (deux-points) signifie  tous les indices , par exemple M(1, :) est la premire ligne de la matrice (cest un vecteur ligne). Le caractre $ (dollar) dsigne le dernier indice (ligne ou colonne) dune matrice.

Lexpression N1:N2 permet de gnrer une matrice-ligne dont le premier coefficient est N1, le dernier est infrieur ou gal  N2, et le pas entre les coefficients est 1. Lexpression N1:pas:N2 permet de gnrer une matrice-ligne en choisissant le pas. Par exemple

-->1.1:5.2
ans = 
 
! 1.1 2.1 3.1 4.1 5.1 !
 
--> 1:2:5
ans =
 
! 1 3 5 !
 
-->'a' :'d'
ans =
 
abcd
La fonction zeros(m,n) cre une matrice mn remplie de 0 ; la fonction ones(m,n) cre une matrice mn remplie de 1. La fonction eye(n,n) cre une matrice unit nn. On peut aussi passer une matrice M en paramtre de ces fonctions ; elles crent alors une matrice de mme dimension que la matrice M. Par exemple, M=zeros(M) met tous les coefficients de M  zro.

Si f est une fonction extrieure (cest--dire par dfinie par deff ou par function, voir ci-aprs), et que x et y sont des vecteurs, alors la fonction feval permet de btir une matrice z = f(x, y)

z = feval(x, y, f) : on a z(i, j) = f(x(i), y(j)) 
La fonction size(M) renvoie la taille de la matrice sous la forme dune matrice 21 contenant le nombre de lignes puis le nombre de colonnes.

Les oprations spcifiques aux matrices classiques sont :

la transposition : il suffit de mettre une apostrophe  aprs la matrice ; 
le produit de matrices : * ; 
produit et rapport lment par lment : .* et ./ ; 
le produit tensoriel .*. ; 
le dterminant dune matrice carre M : det(M) (determ() pour une matrice de polynmes et detr() pour une matrice de fraction rationnelle) ; 
la trace dune matrice carre M : trace(M) ; 
linverse dune matrice inversible M : inv(M). 
Un vecteur est une matrice ligne ou colonne (matrice 1  n ou n  1) ; lexpression V(i) dsigne la composante i du vecteur V. Si V1 et V2 sont des vecteurs colonnes, alors le produit scalaire est V1' * V2 ; si ce sont des vecteurs lignes, le produit scalaire est V1 * V2'.


 Calcul numrique  [modifier]
Scilab peut effectuer des calculs numriques.

On peut en faire une utilisation triviale comme calculatrice, en entrant simplement les oprations  effectuer.

La fonction deff permet de dfinir de nouvelles fonctions (appeles  fonctions externes ) pouvant sexprimer avec les oprateurs dj prdfinis (les  fonctions primitives ). On passe deux chanes de caractres comme paramtre ; la premire indique le nom de la fonction et les variables utilises en entre et en sortie, et la deuxime indique la formule. Par exemple, la fonction

f(x) = 2  x 
peut se dfinir par

deff('[y] = f(x)', 'y = 2 * x') 
(voir aussi la section Programmation).

Intgration 
integrate('expression', 'x', x0, x1) calcule lintgrale de la fonction dcrite par expression (cest une chane de caractres interprtable par Scilab, comme par exemple 'sin(x)'), x tant la variable dintgration, entre les valeurs x0 et x1. 
Rsolution d'quations 
Scilab dispose de plusieurs primitives permettant la rsolution d'quations (voir Solveur d'quations), entres autres : 
linsolve : rsolution d'un systme d'quations linaires,
syntaxe : [x0,kerA]=linsolve(A,b)
o A est la matrice relle des coefficients du systme d'quations, et b un vecteur de constantes ; les solutions de Ax + b = 0 sont de la forme x0 + wkerA, w tant un rel arbitraire ; 
solve : rsolution symbolique d'un systme linaire,
syntaxe : w = solve(A,b)
o A est une matrice triangulaire suprieure de caractres (les coefficients du systme d'quation), b est un vecteur de caractres (la partie  droite des signes gal), et w est la matrice rsultat de Aw = b ; 
ode : rsolution d'une d'quation diffrentielle ordinaire (ordinary differential equation) ; si l'quation diffrentielle est dy/dt = (t), alors  ayant t dfinie (fonction externe), la syntaxe pour dterminer y(t) est
y = ode(y0,t0,t,f)
oy0 et t0 sont les valeurs initiales du systme, t est un vecteur de valeurs pour lesquelles on calcule les solutions, et y est le vecteur de solutions (plot(t,y) permet de tracer le graphique des solutions) ;
la primitive ode admet des arguments permettant de rsoudre des situations spcifiques : 'roots' pour rajouter une quation g(t,y) = 0, 'discrete' pour calculer de manire rcursive y(k+1)=(k,y(k))  partir d'un tat initial y(k0). 
Il existe d'autres primitives pour des systmes spcifiques. 

 Trac de fonction  [modifier]

 Trac 2D  [modifier]
Le trac dune fonction se fait en deux tapes

dfinir ltendue de la variable abscisse et le pas, sous la forme dun vecteur colonne, par exemple x = [dbut:pas:fin]' ; 
tracer la fonction avec la commande plot(x, f(x)) si  est la fonction. 
On peut tracer simultanment plusieurs fonctions en les mettant dans une matrice, par exemple plot(x, [f1(x) f2(x) f3(x)]).

On note en fait que (x) est elle-mme un vecteur. On peut de manire gnrale dfinir un vecteur des valeurs de x et un vecteur des valeurs de y, et la fonction plot(x, y) tracera le nuage de points.

Si  est une fonction externe (par exemple dfinie avec deff, voir ci-dessus, ou function, voir ci-aprs), alors on peut tracer directement la fonction avec fplot2d(x, f). On peut aussi dfinir y par y = feval(x, f), puis tracer avec plot(x,y).

La fonction xgrid permet dafficher une grille correspondant aux graduations.

Les fonctions plot2di, utilises  la place de plot, permettent de faire varier lapparence gnrale du trac :

plot2d : trait  normal  ; identique  plot, mais permet lutilisation de marqueurs ; 
plot2d2 : trait en escalier ; 
plot2d3 : trac en barres ; 
plot2d4 : trac en  flches  (pour un champ de vecteurs) ; 
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 spars par des virgules.

Pour placer des marqueurs, on utilise largument style = n ou n est un entier positif ou ngatif (par exemple plot2d(x, y, style = 1)) ; un nombre ngatif 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 dtermine (selon la carte de couleur dfinie, voir ci-aprs).

Si le trac comporte plusieurs courbes (donc mis dans une matrice ligne Y), largument style est une matrice, la valeur de chaque lment 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 lgende sous le graphique pour chaque symbole, avec largument leg = ('texte1@texte2'), larobase servant  sparer les lgendes, par exemple

plot2d(x, Y, style = [-2, -1], leg = 'cosinus@sinus') 
Pour une chelle logarithmique, on utilise largument logflag = type o type est une chane de deux caractres,  n  (pour normal) ou  l  (pour logarithmique), le premier caractre correspondant  laxe des x et le second  laxe des y. Par exemple

plot2d(x, y, logflag = 'nl') pour un axe des x linaire et un axe des y logarithmique ; 
plot2d(x, y, logflag = 'll') pour avoir deux chelles logarithmiques. 
On peut choisir le type daxe avec largument axesflag=n o n est un entier positif : 0 pour ne pas avoir daxe, 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 dfinir le nombre de graduations et de sous-graduations des axes avec largument nax = [nx, Nx, ny, Ny] o Nx est le nombre de graduations de laxe x, nx le nombre de sous-graduations

Largument rect = [xmin, ymin, xmax, ymax] permet de limiter le trac  la zone comprise dans le rectangle dfini par les valeurs dans la matrice.

La fonction polarplot ralise un trac en coordonnes polaires. La fonction r(theta) se trace par la commande :

polarplot(r,theta) 
o r et theta sont deux matrices de mme dimension.


 Carte dun champ  [modifier]
Si x est un vecteur colonne de m lments, y un vecteur colonne de n lments et z une matrice mn, 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 associe au coefficient z(i, j).

Les niveaux de couleur sont indiqus par la fonction

xset('colormap', cmap) 
o cmap est une matrice de trois colonnes dont chaque ligne contient la couleur associe  un niveau, sous la forme RVB (les lments de la matrice allant de 0  1). La premire ligne de la matrice correspond au plus bas niveau, la dernire ligne au plus haut. Cette matrice peut tre gnre de manire automatique par les fonctions colormap :

graycolormap(n), o n est un entier, gnre n niveaux de gris entre le noir et le blanc ; 
jetcolormap(n), o n est un entier, gnre n niveaux de couleur entre le bleu et le rouge ; 
hotcolormap(n), o n est un entier, gnre 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 raliser un dgrad 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 dgrad 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 utiliss lorsque lon trace plusieurs courbes sur le mme graphique. Dans ce cas-l, des dgrads ne fournissent pas un contraste permettant de distinguer facilement des courbes voisines ; on peut obtenir les niveaux de couleur par dfaut avec get(sdf(), 'color_map').

On peut tracer une courbe de niveaux avec la fonction

contour2d(x, y, z, n) 
o n est le nombre de niveaux que lon veut voir figurer ; on peut aussi donner les valeurs des niveaux z1, z2, , zn par un vecteur

contour2d(x, y, z, [z1,z2,...,zn]) 
On peut galement tracer un champ de vecteurs. Pour cela, il faut une matrice vx ayant les composantes 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) 
Avec la fonction champ1, les vecteurs tracs ont tous la mme longueur, la norme du champ est indique par la couleur du vecteur, suivant le principe expos pour grayplot.


 Trac 3D  [modifier]
Scilab permet galement le trac de surfaces  trois dimensions (x, y, z). Si x est une matrice colonne de m lments, y une matrice colonne de n lments, et z une matrice mn, alors la fonction

plot3d(x, y, z) 
va tracer la surface des points (x(i), y(j), z(i, j)). Sil sagit dune surface reprsentative dune fonction , on a

z(i, j) = f(x(i), y(j)). 
Si  est une fonction  externe  (par exemple dfinie par deff ou function), on peut dfinir 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 paramtrique ; t est un vecteur contenant les valeurs successives du paramtre.

Les fonctions plot3d1, fplot3d1 et param3d1 permettent dutiliser des niveaux de couleurs pour indiquer la valeur de z. Lutilisation est identique  celle de plot3d, mais les niveaux de couleur sont indiqus par la fonction

xset('colormap', cmap) 
(voir ci-dessus).

Le point de vue de la surface 3D est dfini par deux angles en degrs, ?, rotation autour de laxe des Z, et a, rotation autour de laxe des Y (voir aussi 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 planXY selon laxe Z ; 
plot3d(x, y, z, 90, 0) donne une vue de face, projection de la surface sur le planXZ selon laxe Y ; 
plot3d(x, y, z, 0, 90) donne une vue de ct, projection de la surface sur le planYZ selon laxe X ; 
plot3d(x, y, z, 45, 45) est la vue par dfaut, de type perspective isomtrique. 
On peut galement dfinir 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]) 

 Reprsentation de donnes statistiques  [modifier]
Si x est un vecteur, la fonction histplot(n, x), n tant un entier, va dcouper lintervalle de valeurs prises par les coefficients de x en n tranches dgale largeur, et tracer lhistogramme de rpartition des valeurs selon ces tranches. Si n est un vecteur dont les coefficients sont strictement croissants, les valeurs des coefficients de n servent  dterminer les tranches.

Si x est une matrice, hist3d(x) trace un histogramme 3D tel que le paralllpipde situ en (i, j) a pour hauteur x(i, j). Comme pour toutes les fonctions de trac en trois dimensions, on peut dfinir langle de vue avec ? et a.


 Dessin  [modifier]
Il est possible de dessiner directement des figures gomtriques 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 ordonnes des sommets (c'est une matrice de mme dimension que x). 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,'chane') crit la chane de caractre chane sur le graphique, le point en bas  gauche du texte tant au point (x,y).

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 trigonomtrique a164  et va jusqu' l'angle (a1+a2)64 . La fonction xfarc(x,y,l,h) trace un arc d'ellipse rempli.

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

line_style : type de trait ; c'est un entier, 0 pour un trait plein, 2 pour des pointills longs, trois pour des pointills 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'lment dessin ; cela se fait avec la fonction
variable = get('hdl')
hdl signifiant handle (littralement  poigne , intermdiaire d'action). Pour dfinir la proprit de cet lment, on fait

variable.proprit = valeur 
Ces deux mthodes sont valables quel que 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) // pointills
ou bien

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

 Mise en forme, axes et fentrage  [modifier]
La fonction xset permet de dfinir lapparence :

police des graduations et titres : xset('font', type, taille), o 
taille est un nombre dsignant la taille des caractres, en unit arbitraire ; 
type est un nombre dsignant le type de police : 1 pour les lettres grecques (police Symbol), 25 pour une police avec empattements type Times (2 pour des lettre romanes, 3 en italique, 4 en gras, 5 en gras italique) ; 69 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 daxe et du trac : xset('thickness', e) o e est un nombre dsignant lpaisseur en unit arbitraire ; 
taille des marqueurs (le cas chant, voir ci-aprs) avec xset('mark size', taille). 
Comme pour tous les objets graphiques, on peut changer les proprits des axes en les affectant  une variable par la commande var=get('current_axes'). Les principales proprits 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 nombr ede sous-graduation (il faut 4 sous-graduations pour que la graduation principale soit divise 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 tracs cte  cte avec linstruction subplot :

subplot(m, n, i) place le trac qui suit linstruction dans la i e case (dans lordre de lecture europen) dun tableau mn ; 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 fentre graphique.


 Exemple  [modifier]
 
Exemple de graphique obtenu avec ScilabVoici le graphique que lon 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)

 Programmation  [modifier]
Scilab accepte un certain nombre dinstructions :

excution conditionnelle if condition then, , else, , end 
boucle itrative for variable = dbut : fin, , end ou for variable = dbut : pas : fin, , end 
boucle itrative antconditionne : while condition do, , end ou while condition do, , else, , end 
Il est possible de dfinir des fonctions avec passage de paramtres. La fonction est un sous-programme avec ses variables propres, et qui peut contenir des boucles, des branchements conditionnels... Par exemple, pour dfinir une fonction f(x) :

-->function [y] = f(x)
--> 
--> endfunction
Le paramtre x est pass  la fonction f ; la valeur retourne par f sera celle qui est attribue  y dans la fonction.

On peut enregistrer lenvironnement, cest--dire lensemble des variables, dont notamment les fonctions, avec la commande save('fichier'). Ceci cre un fichier binaire (Scilab najoute pas dextension). Cet environnement peut tre recharg avec la fonction load('fichier').

On peut galement crire les instructions dans un fichier texte, puis faire du copier/coller depuis lditeur de texte vers la ligne de commande de Scilab. Le code source peut contenir des commentaires introduits par deux barres de fraction //.


 Environnement  [modifier]
Dans Scilab, lenvironnement est lensemble des variables (y compris les fonctions) qui ont t dfinies ; lenvironnement contient un certain nombre de variables prdfinies. Lensemble des variables est donn par la commande who.

Lorsque lon utilise une fonction, lexcution de la fonction se fait dans un nouvel environnement, copie de lenvironnement initial. Les variables qui y sont modifies ne le sont pas dans lenvironnement initial (on ne travaille quen variables locales), seul le rsultat de la fonction est renvoy.

On peut ouvrir  dessein un environnement, avec la fonction pause ; linvite devient alors -1->, indiquant que lon est dans le premier niveau de sous-environnement. On est galement dans une telle configuration lorsque lon interrompt lexcution dune fonction (par exemple avec la combinaison de touches CTRL+C). Pour revenir  lenvironnement prcdent, il faut utiliser la commande return.

Si lon utilise return sans argument, les variables ne sont pas transmises  lenvironnement pre. Il est possible de transmettre les variables a1, a2, , an dans lenvironnement pre, avec la syntaxe (x1, x2, , xn)=return(a1, a2, , an), o x1, x2, , xn sont les noms des variables dans lenvironnement pre.

La commande clear permet de  nettoyer  un environnement, cest--dire de supprimer toutes les variables.

