Scilab
178356
31610819
2008-07-15T22:09:09Z
NeMeSiS
8528
{{ébauche|logiciels libres}}
{{Infobox Logiciel
| nom = Scilab
| image =
| description =
| développeur = Scilab Consortium
| dernière version = 4.1.2
| date de dernière version = {{Date|24|octobre|2007|en informatique}}
| version avancée = 5.0 beta3
| date de version avancée = {{Date|10|juillet|2008|en informatique}}
| environnements = [[Multiplate-forme]]
| type = [[Calcul numérique]]
| licence = [[Licence CeCILL|CeCILL]]
| site web = [http://www.scilab.org/ www.scilab.org]
}}
'''Scilab''' est un [[logiciel]] de [[calcul numérique]] fournissant un environnement de calcul pour des applications scientifiques. Développé depuis [[1990]] par des chercheurs de l’[[Institut national de recherche en informatique et en automatique|INRIA]] et de l’[[École nationale des ponts et chaussées|ENPC]], il est, depuis la création du Scilab Consortium en mai [[2003]], développé et maintenu par l'INRIA.
Il est disponible pour [[Microsoft Windows|Windows]], [[Mac OS X]], [[Linux]] et [[Berkeley Software Distribution|BSD]].
La [[syntaxe]] et les possibilités offertes par Scilab sont similaires à celles de [[Matlab]], mais les deux logiciels ne sont pas compatibles bien qu'existe un traducteur de Matlab vers Scilab.
== Licence ==
Distribué gratuitement et avec son [[code source]] via l’[[Internet]] depuis [[1994]], il est disponible précompilé pour un grand nombre d’[[Architecture informatique|architectures]]. Néanmoins, il ne s’agissait ni d’un logiciel [[Open source]] selon l'[[Open Source Initiative]] ni d’un [[Logiciel libre]]. En effet, l'ancienne licence Scilab<ref>[http://www.scilab.org/legal/licence.html Licence de Scilab]</ref> n’autorise pas la distribution commerciale d’une version modifiée. Selon la classification de la [[Free Software Foundation|FSF]], il s'agissait donc plutôt d'un [[logiciel semi-libre]]<ref>[http://www.gnu.org/philosophy/categories.fr.html#semi-freeSoftware Définition d'un logiciel semi-libre]</ref>. Scilab est donc devenu un logiciel libre lors du changement de licence, il est distribuée sous la [[licence CeCILL]] depuis la version 5.0-beta-2, licence libre compatible [[Licence publique générale GNU|GNU GPL 2]]<ref>[http://www.scilab.org/download/index_download.php?page=CHANGES_5.0-beta-2 Annonce du changement de licence]</ref>.
== Présentation succincte de l’utilisation ==
Scilab peut exécuter des [[Instruction (informatique)|instructions]] en ligne de commande, ainsi que des fichiers de commande (''scripts'') contenant des instructions (format texte). On peut également exécuter des programmes [[Fortran]] ou [[C (langage)|C]] à partir de Scilab.
Scilab est complété par un environnement graphique [[Scicos]] comparable à l'[[environnement graphique]] [[Simulink]] fourni avec Matlab.
=== Syntaxe élémentaire en ligne de commande ===
L’invite de la ligne de commande (''prompt'') est constituée d’une « flèche » : deux tirets et un signe supérieur <code>--></code>. L’instruction est tapée puis validée avec la touche de [[retour chariot]] (''Enter'', ''Return''). Le résultat est affiché à la suite, sauf si la ligne se termine par un [[point-virgule]] auquel cas le résultat est caché. Par exemple :
-->a = 1;
-->A = 2;
-->a + A
ans =
3.
La première commande associe la valeur « 1 » à la variable « a » (résultat caché), la seconde commande associe la valeur « 2 » à la variable « A » (la syntaxe est sensible à la [[casse (typographie)|casse]]), la troisième commande calcule la somme des deux (''ans'' est l’abréviation de ''answer'' qui signifie « réponse » en anglais).
On peut écrire plusieurs instructions sur la même ligne en les séparant d’une [[virgule]], ou d’un point-virgule si l’on ne veut pas en afficher le résultat. On peut aussi mettre une instruction sur plusieurs lignes (par exemple pour des raisons de présentation) en mettant trois points « <code>...</code> » avant de presser la touche de retour chariot.
Scilab utilise les fonctions et opérateurs classiques (<code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>^</code> ou <code>**</code>, <code>sqrt()</code> pour la [[racine carrée]], <code>cos()</code> pour le [[cosinus]], <code>int()</code> pour la [[partie entière]], <code>round()</code> pour l’[[arrondi]] au plus proche, <code>abs()</code> pour la [[valeur absolue]]…) et quelques autres (par exemple <code>rand</code> pour avoir un nombre aléatoire entre 0 et 1). La fonction <code>who</code> affiche les variables déclarées. La variable <code>ans</code> contient le dernier résultat.
Le [[séparateur décimal]] est le point. Pour entrer l’[[Nombre imaginaire pur|imaginaire]] ''i'', il faut utiliser <code>%i</code> ; il figure simplement sous la forme « i » dans les résultats. Pour entrer l’infini ∞, il faut utiliser <code>%inf</code> ; il figure simplement sous la forme « inf » dans les résultats. La valeur de [[Pi|π]] s’obtient par <code>%pi</code>, et la [[Base naturelle des logarithmes|constante de Neper]] ''e'' par <code>%e</code>.
==== Booléens ====
Lorsque l’on assigne une valeur [[algèbre de Boole|booléenne]], on utilise <code>%T</code> pour « vrai » (''true'') et <code>%F</code> pour « faux » (''false''). Le résultat de l’opération affiché est respectivement <code>T</code> ou <code>F</code>.
L’opérateur [[fonction logique|Ou]] est noté « | » ([[tube nommé|tube]]), [[fonction logique|Et]] est noté « & » ([[esperluette]]), [[fonction logique|Non]] est noté « ~ » ([[tilde]]). Exemple
-->(%T & %F) | %F
ans =
F.
Un booléen peut également s’obtenir en comparant deux valeurs, avec les relations d’[[égalité (mathématiques)|égalité]] <code>==</code> et de différence <code><></code> ou <code>~=</code>, et les [[relation d'ordre|relations d'ordre]] <code><</code>, <code><=</code>, <code>></code> et <code>>=</code>.
==== Polynômes et fractions rationnelles ====
Il s’agit ici non pas de [[fonction polynôme|fonctions polynômes]] qui ne permettraient que leur évaluation numérique, mais de [[polynôme]]s formels.
La déclaration d’un polynôme se fait avec deux fonctions. La première fonction, <code>x = poly(0, 'x')</code> qui définit « x » comme l’indéterminée d’un polynôme, puis l’énoncé du polynôme utilisant cette indéterminée. Exemple
-->x = poly(0, 'x'); p = x ^ 2 + 2 * x + 1
p =
2
1 + 2x + x
La fonction <code>roots(p)</code> donne les racines du polynôme ''p'', la fonction <code>coeff(p)</code> donne une matrice dont les coefficients sont les coefficients du polynôme ''p''. La fonction <code>varn(p)</code> renvoie le nom de l’indéterminée de ''p'' (ici, ''x'').
En fait, la commande <code>x = poly(0, 'x')</code> définit que ''x'' est le polynôme le plus simple dont l’indéterminée est le caractère « x » et dont la racine est 0, c’est-à-dire le monôme ''x''. La commande <code>x = poly(2, 'x')</code> définit de même le polynôme le plus simple ayant pour racine 2, c’est-à-dire ''x'' - 2.
Cette fonction permet de définir un polynôme ayant plusieurs racines, en utilisant une matrice ligne au lieu d’un simple nombre. Par exemple, <code>x=poly([1 2],'x')</code> définit le polynôme le plus simple ayant pour racines 1 et 2, soit le polynôme ''x''{{exp|2}} - 3''x'' + 2.
On peut aussi utiliser cette fonction pour générer un polynôme dont les coefficients sont contenus dans une matrice ligne, en ajoutant le caractère <code>'c'</code> à la fin des arguments. Par exemple, <code>x = poly([''a0'', ''a1'', …, ''an''], 'x', 'c')</code> définit le polynôme ''a0'' + ''a1''·''x'' + … + ''an''·''x''{{exp|''n''}}</sup>.
Scilab gère de la même manière les [[fraction rationnelle|fractions rationnelles]]. Il suffit de déclarer un monôme avec <code>poly()</code> et définir 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 numérateur de ''f'', il suffit de taper <code>f.num</code> ; le dénominateur de ''f'' s’obtient avec <code>f.den</code>.
La fonction <code>derivat(''p'')</code> donne la dérivation formelle du polynôme ou d’une fraction rationnelle ''p''. La fonction <code>simp(''q'')</code> fait la simplification de la fraction rationnelle ''q''.
L’utilisation du polynôme ou d’une fraction rationnelle en tant que fonction se fait par la fonction <code>horner</code> : <code>horner(p,2)</code> calcule ''p''(2).
==== Caractère ====
Les caractères isolés ou les chaînes de caractères sont notés entre apostrophes simples, ou bien entre guillemets : <code>'abc'</code> ou <code>"abc"</code>.
L'apostrophe indique la fin d'une chaîne ; pour mettre une apostrophe dans une chaîne, il faut en écrire deux accolées <code><nowiki>''</nowiki></code>.
L’addition <code>+</code> sur des chaînes de caractères produit la [[concaténation]]. Une chaîne de caractère peut être évaluée, c’est-à-dire transformée en commande Scilab, par la fonction <code>evstr()</code>.
==== Matrices ====
Scilab a été conçu pour le [[calcul matriciel]]. Toutes les fonctions s’appliquent à des [[matrice (mathématiques)|matrice]]s ; par exemple si ''M'' est une matrice, alors <code>log(M)</code> sera la matrice dont les coefficients sont les logarithmes des coefficients de ''M''. Les éléments des matrices peuvent être de tout type ([[nombre réel]], [[nombre complexe]], [[algèbre de Boole|booléen]], [[polynôme]], [[fraction rationnelle]], [[chaîne de caractères]]…).
Pour définir une matrice à partir de ses coefficients, on les place entre deux crochets <code>[…]</code>. Les éléments d’une ligne sont séparés d’un espace ou d’une virgule, les lignes sont séparées d’un point-virgule. À l’affichage, la matrice est représentée comme un tableau encadré par des points d’exclamation. 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 notée par <code>[]</code>. L’expression <code>M(i,j)</code> désigne l’élément (''i'', ''j'') de la matrice ''M''. Le caractère <code>:</code> ([[deux-points]]) signifie « tous les indices », par exemple <code>M(1, :)</code> est la première ligne de la matrice (c’est un [[vecteur ligne]]). Le caractère <code>$</code> ([[dollar]]) désigne le dernier indice (ligne ou colonne) d’une matrice.
L’expression <code>''N1'':''N2''</code> permet de générer une matrice-ligne dont le premier coefficient est ''N1'', le dernier est inférieur ou égal à ''N2'', et le pas entre les coefficients est 1. L’expression <code>''N1'':''pas'':''N2''</code> permet de générer 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 <code>zeros(''m'',''n'')</code> crée une matrice ''m''×''n'' remplie de 0 ; la fonction <code>ones(''m'',''n'')</code> crée une matrice ''m''×''n'' remplie de 1. La fonction <code>eye(''n'',''n'')</code> crée une [[matrice unité]] ''n''×''n''. On peut aussi passer une matrice ''M'' en paramètre de ces fonctions ; elles créent alors une matrice de même dimension que la matrice ''M''. Par exemple, <code>M=zeros(M)</code> met tous les coefficients de M à zéro.
Si ''f'' est une fonction extérieure (c’est-à-dire par définie par <code>deff</code> ou par <code>function</code>, voir ci-après), et que ''x'' et ''y'' sont des vecteurs, alors la fonction <code>feval</code> permet de bâtir une matrice ''z'' = ''f''(''x'', ''y'')
: <code>z = feval(x, y, f)</code> : on a ''z''(''i'', ''j'') = ''f''(''x''(''i''), ''y''(''j''))
La fonction <code>size(M)</code> renvoie la taille de la matrice sous la forme d’une matrice 2×1 contenant le nombre de lignes puis le nombre de colonnes.
Les opérations spécifiques aux matrices classiques sont :
* la transposition : il suffit de mettre une apostrophe <code>’</code> après la matrice ;
* le produit de matrices : <code>*</code> ;
* produit et rapport élément par élément : <code>.*</code> et <code>./</code> ;
* le [[produit tensoriel]] <code>.*.</code> ;
* le [[déterminant (mathématiques)|déterminant]] d’une matrice carrée ''M'' : <code>det(''M'')</code> (<code>determ()</code> pour une matrice de polynômes et <code>detr()</code> pour une matrice de fraction rationnelle) ;
* la [[trace (algèbre)|trace]] d’une matrice carrée ''M'' : <code>trace(''M'')</code> ;
* l’inverse d’une [[matrice inversible]] ''M'' : <code>inv(''M'')</code>.
Un [[vecteur]] est une matrice ligne ou colonne (matrice 1 × ''n'' ou ''n'' × 1) ; l’expression <code>V(i)</code> désigne la composante ''i'' du vecteur ''V''. Si ''V1'' et ''V2'' sont des [[vecteur colonne|vecteurs colonnes]], alors le [[produit scalaire]] est <code>V1' * V2</code> ; si ce sont des [[vecteur ligne|vecteurs lignes]], le produit scalaire est <code>V1 * V2'</code>.
=== Calcul numérique ===
Scilab peut effectuer des calculs numériques.
On peut en faire une utilisation triviale comme [[calculatrice]], en entrant simplement les opérations à effectuer.
La fonction <code>deff</code> permet de définir de nouvelles fonctions (appelées « fonctions externes ») pouvant s’exprimer avec les opérateurs déjà prédéfinis (les « fonctions primitives »). On passe deux chaînes de caractères comme paramètre ; la première indique le nom de la fonction et les variables utilisées en entrée et en sortie, et la deuxième indique la formule. Par exemple, la fonction
: ''f''(''x'') = 2 · ''x''
peut se définir par
: <code>deff('[y] = f(x)', 'y = 2 * x')</code>
(voir aussi la section ''[[#Programmation|Programmation]]'').
; Intégration
: <code>integrate(<nowiki>'</nowiki>''expression''<nowiki>'</nowiki>, 'x', x0, x1)</code> calcule l’intégrale de la fonction décrite par ''expression'' (c’est une chaîne de caractères interprétable par Scilab, comme par exemple <code>'sin(x)'</code>), ''x'' étant la variable d’intégration, entre les valeurs ''x0'' et ''x1''.
; Résolution d'équations
: Scilab dispose de plusieurs primitives permettant la résolution d'équations (voir ''[[Solveur d'équations]]''), entres autres :
* <code>linsolve</code> : résolution d'un [[système d'équations]] linéaires,<br /> syntaxe : <code>[x0,kerA]=linsolve(A,b)</code><br /> où ''A'' est la matrice réelle des coefficients du système d'équations, et ''b'' un vecteur de constantes ; les solutions de ''A''×''x'' + ''b'' = 0 sont de la forme ''x''0 + ''w''×''kerA'', ''w'' étant un réel arbitraire ;
* <code>solve</code> : résolution symbolique d'un système linéaire,<br />syntaxe : <code>w = solve(A,b)</code><br /> où ''A'' est une matrice triangulaire supérieure de caractères (les coefficients du système d'équation), ''b'' est un vecteur de caractères (la partie à droite des signes égal), et ''w'' est la matrice résultat de ''A''×''w'' = ''b'' ;
* <code>ode</code> : résolution d'une d'[[équation différentielle ordinaire]] (''ordinary differential equation'') ; si l'équation différentielle est ''dy''/''dt'' = ƒ(''t''), alors ƒ ayant été définie (fonction externe), la syntaxe pour déterminer ''y''(''t'') est <br /><code>y = ode(y0,t0,t,f)</code><br /> où''y''0 et ''t''0 sont les valeurs initiales du système, ''t'' est un vecteur de valeurs pour lesquelles on calcule les solutions, et ''y'' est le vecteur de solutions (<code>plot(t,y)</code> permet de tracer le graphique des solutions) ;<br /> la primitive <code>ode</code> admet des arguments permettant de résoudre des situations spécifiques : <code>'roots'</code> pour rajouter une équation ''g''(''t'',''y'') = 0, <code>'discrete'</code> pour calculer de manière [[récursivité|récursive]] ''y''(''k''+1)=ƒ(''k'',''y''(''k'')) à partir d'un état initial ''y''(''k''0).
: Il existe d'autres primitives pour des systèmes spécifiques.
=== Tracé de fonction ===
==== Tracé 2D ====
Le tracé d’une fonction se fait en deux étapes
# définir l’étendue de la variable abscisse et le pas, sous la forme d’un vecteur colonne, par exemple <code>x = [''début'':''pas'':''fin'']'</code> ;
# tracer la fonction avec la commande <code>plot(x, ''f''(x))</code> si ƒ est la fonction.
On peut tracer simultanément plusieurs fonctions en les mettant dans une matrice, par exemple <code>plot(x, [''f1''(x) ''f2''(x) ''f3''(x)])</code>.
On note en fait que ƒ(''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 <code>plot(x, y)</code> tracera le nuage de points.
Si ƒ est une fonction externe (par exemple définie avec <code>deff</code>, voir ci-dessus, ou <code>function</code>, voir ci-après), alors on peut tracer directement la fonction avec <code>fplot2d(x, f)</code>. On peut aussi définir ''y'' par <code>y = feval(x, f)</code>, puis tracer avec <code>plot(x,y)</code>.
La fonction <code>xgrid</code> permet d’afficher une grille correspondant aux graduations.
Les fonctions <code>plot2d''i''</code>, utilisées à la place de <code>plot</code>, permettent de faire varier l’apparence générale du tracé :
* <code>plot2d</code> : trait « normal » ; identique à <code>plot</code>, mais permet l’utilisation de marqueurs ;
* <code>plot2d2</code> : trait en escalier ;
* <code>plot2d3</code> : tracé en barres ;
* <code>plot2d4</code> : tracé en « flèches » (pour un champ de vecteurs) ;
Ces fonctions <code>plot2d''i''</code> acceptent des arguments modifiant le tracé, sous la forme <code>plot2d''i''(x, y, ''arguments'')</code>. Les arguments sont de la forme <code>''mot-clef'' = ''valeur''</code>, et sont séparés par des virgules.
Pour placer des marqueurs, on utilise l’argument <code>style = ''n''</code> ou ''n'' est un entier positif ou négatif (par exemple <code>plot2d(x, y, style = 1)</code>) ; 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 <code>getsymbol</code>) 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).
Si le tracé comporte plusieurs courbes (donc mis dans une matrice ligne ''Y''), l’argument <code>style</code> est une matrice, la valeur de chaque élément indiquant le style de chaque courbe, par exemple
: <code>Y = [cos(x), sin(x)]; plot2d(x, Y, style = [-2, -1])</code>
Dans ce cas-là, on peut inscrire une légende sous le graphique pour chaque symbole, avec l’argument <code>leg = (<nowiki>'</nowiki>''texte1''@''texte2''<nowiki>'</nowiki>)</code>, l’[[@|arobase]] servant à séparer les légendes, par exemple
: <code>plot2d(x, Y, style = [-2, -1], leg = 'cosinus@sinus')</code>
Pour une [[échelle logarithmique]], on utilise l’argument <code>logflag = ''type''</code> 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
* <code>plot2d(x, y, logflag = 'nl')</code> pour un axe des ''x'' linéaire et un axe des ''y'' logarithmique ;
* <code>plot2d(x, y, logflag = 'll')</code> pour avoir deux échelles logarithmiques.
On peut choisir le type d’axe avec l’argument <code>axesflag=''n''</code> 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 <code>nax = [''nx'', ''Nx'', ''ny'', ''Ny'']</code> où ''Nx'' est le nombre de graduations de l’axe ''x'', ''nx'' le nombre de sous-graduations…
L’argument <code>rect = [''xmin'', ''ymin'', ''xmax'', ''ymax'']</code> permet de limiter le tracé à la zone comprise dans le rectangle défini par les valeurs dans la matrice.
La fonction <code>polarplot</code> réalise un tracé en [[coordonnées polaires]]. La fonction ''r''(''theta'') se trace par la commande :
: <code>polarplot(r,theta)</code>
où ''r'' et ''theta'' sont deux matrices de même dimension.
==== 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
: <code>grayplot(x, y, z)</code>
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
: <code>xset('colormap', ''cmap'')</code>
où ''cmap'' est une matrice de trois colonnes dont chaque ligne contient la couleur associée à un niveau, sous la forme [[Rouge vert bleu|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 automatique par les fonctions <code>colormap</code> :
: <code>graycolormap(''n'')</code>, où ''n'' est un entier, génère ''n'' niveaux de gris entre le noir et le blanc ;
: <code>jetcolormap(''n'')</code>, où ''n'' est un entier, génère ''n'' niveaux de couleur entre le bleu et le rouge ;
: <code>hotcolormap(''n'')</code>, où ''n'' est un entier, génère ''n'' niveaux de couleur entre le rouge et le jaune.
On peut par exemple utiliser <code>xset('colormap',graycolormap(32))</code> pour avoir 32 niveaux de gris. On peut réaliser un dégradé du noir vers le rouge avec
: <code>cmap = graycolormap(32); cmap(:, 2:3) = 0</code> ou avec <code>r = [0:32 / 31:32]' / 32; cmap = [r zeros(32, 2)]</code>
et un dégradé du bleu vers le blanc avec
: <code>cmap = graycolormap(32); cmap(:, 2:3) = 1</code> ou avec <code>r = [0:32 / 31:32]' / 32; cmap = [r ones(32, 2)]</code>
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 <code>get(sdf(), 'color_map')</code>.
On peut tracer une courbe de niveaux avec la fonction
: <code>contour2d(x, y, z, ''n'')</code>
où ''n'' est le nombre de niveaux que l’on veut voir figurer ; on peut aussi donner les valeurs des niveaux ''z''<sub>1</sub>, ''z''<sub>2</sub>, …, ''z<sub>n</sub>'' par un vecteur
: <code>contour2d(x, y, z, [z1,z2,...,zn])</code>
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
: <code>champ(x, y, vx, vy)</code>
Avec la fonction <code>champ1</code>, 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 <code>grayplot</code>.
==== 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
: <code>plot3d(x, y, z)</code>
va tracer la surface des points (''x''(''i''), ''y''(''j''), ''z''(''i'', ''j'')).
S’il s’agit d’une surface représentative d’une fonction ƒ, on a
: ''z''(''i'', ''j'') = ''f''(''x''(''i''), ''y''(''j'')).
Si ƒ est une fonction « externe » (par exemple définie par <code>deff</code> ou <code>function</code>), on peut définir ''z'' avec la fonction <code>feval</code> (voir plus haut), ou bien utiliser <code>fplot3d(x, y, f)</code>.
La fonction <code>param3d(fx(t), fy(t), fz(t))</code> trace la courbe paramétrique ; ''t'' est un vecteur contenant les valeurs successives du paramètre.
Les fonctions <code>plot3d1</code>, <code>fplot3d1</code> et <code>param3d1</code> permettent d’utiliser des niveaux de couleurs pour indiquer la valeur de ''z''. L’utilisation est identique à celle de <code>plot3d</code>, mais les niveaux de couleur sont indiqués par la fonction
: <code>xset('colormap', ''cmap'')</code>
(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'' (voir aussi ''[[Angles d'Euler]]'') : <code>plot3d(x, y, z, ''theta'', ''alpha'')</code>, <code>param3d(x, y, z, ''theta'', ''alpha'')</code>… ;
* <code>plot3d(x, y, z, 0, 0)</code> donne une vue de dessus, semblable aux cartes 2D, projection de la surface sur le plan''XY'' selon l’axe ''Z'' ;
* <code>plot3d(x, y, z, 90, 0)</code> donne une vue de face, projection de la surface sur le plan''XZ'' selon l’axe ''Y'' ;
* <code>plot3d(x, y, z, 0, 90)</code> donne une vue de côté, projection de la surface sur le plan''YZ'' selon l’axe ''X'' ;
* <code>plot3d(x, y, z, 45, 45)</code> est la vue par défaut, de type [[perspective]] isométrique.
On peut également définir les limites des axes avec le mot-clef <code>ebox</code> :
* <code>plot3d(x, y, z, ebox=[xmin, xmax, ymin, ymax, zmin, zmax])</code>
* <code>plot3d(x, y, z, theta, alpha, ebox=[xmin, xmax, ymin, ymax, zmin, zmax])</code>
==== Représentation de données statistiques ====
Si ''x'' est un vecteur, la fonction <code>histplot(''n'', ''x'')</code>, ''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 strictement croissants, les valeurs des coefficients de ''n'' servent à déterminer les tranches.
Si ''x'' est une matrice, <code>hist3d(''x'')</code> 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 dimensions, on peut définir l’angle de vue avec θ et α.
==== Dessin ====
Il est possible de dessiner directement des figures géométriques sur le graphique.
La fonction <code>xpoly(x,y,'lines',1)</code> permet de tracer un [[polygone]] fermé, <code>x</code> étant la liste des abscisses des sommets (sous la forme d'un vecteur ou d'une matrice) et <code>y</code> étant la liste des ordonnées des sommets (c'est une matrice de même dimension que <code>x</code>). La fonction <code>xfpoly(x,y,'lines',1)</code> permet de tracer un polygone rempli.
La fonction <code>xrect(x,y,l,h)</code> trace un rectangle dont le point en haut à gauche est (''x'', ''y''), de largeur ''l'' et de hauteur ''h''. La fonction <code>xfrect(x,y,l,h)</code> trace un rectangle rempli.
La fonction <code>xstring(''x'',''y'',<nowiki>'</nowiki>''chaîne''<nowiki>'</nowiki>)</code> écrit la chaîne de caractère ''chaîne'' sur le graphique, le point en bas à gauche du texte étant au point (''x'',''y'').
La fonction <code>xarc(x,y,l,h,a1,a2)</code> trace un arc d'[[Ellipse (mathématiques)|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 °. La fonction <code>xfarc(x,y,l,h)</code> trace un arc d'ellipse rempli.
Pour changer les propriétés des traits des dessins, il faut utiliser la commande <code>set(<nowiki>'</nowiki>''propriété<nowiki>'</nowiki>,''valeur'')</code>. Les principales propriétés d'un objet sont :
* <code>line_style</code> : type de trait ; c'est un entier, 0 pour un trait plein, 2 pour des pointillés longs, trois pour des pointillés courts, 4 pour un trait d'axe (alternance trait-point)…
* <code>thickness</code> : épaisseur du trait, sous la forme d'un entier positif ;
* <code>mark_size</code> : 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<br /> <code>''variable'' = get('hdl')</code><br/> <code>hdl</code> signifiant ''handle'' (littéralement « poignée », intermédiaire d'action). Pour définir la propriété de cet élément, on fait
: <code>''variable''.''propriété'' = ''valeur</code>
Ces deux méthodes 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) // pointillés
ou bien
xarc(0,1,0.5,0.5,0,360*64) // ellipse
a=get('hdl')
a.line_style=2 // pointillés
==== Mise en forme, axes et fenêtrage ====
La fonction <code>xset</code> permet de définir l’apparence :
* [[police d’écriture|police]] des graduations et titres : <code>xset('font', ''type'', ''taille'')</code>, 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 [[Empattement (typographie)|empattement]]s 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é : <code>xset('thickness', ''e'')</code> où ''e'' est un nombre désignant l’épaisseur en unité arbitraire ;
* taille des marqueurs (le cas échéant, voir ci-après) avec <code>xset('mark size', ''taille'')</code>.
Comme pour tous les objets graphiques, on peut changer les propriétés des axes en les affectant à une variable par la commande <code>''var''=get('current_axes')</code>. Les principales propriétés sont :
* <code>x_location</code> et <code>y_location</code> : prennent les valeurs <code>'top'</code>, <code>'middle'</code> ou <code>'bottom'</code> selon que l'on veut que l'axe soit en haut, passe par l'origine, ou soit en bas ;
* <code>isoview</code> : vaut <code>'on'</code> si l'on veut que les échelles soient identiques sur les axes, <code>'off'</code> si l'échelle est libre ;
* <code>sub_ticks</code> : matrice <code>[''nx'',''ny'']</code> où ''nx'' et ''ny'' est le nombr ede 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 <code>subplot</code> :
: <code>subplot(''m'', ''n'', ''i'')</code> place le tracé qui suit l’instruction dans la ''i''<sup> e</sup> case (dans l’ordre de lecture européen) d’un tableau ''m''×''n'' ; le tracé peut comporter plusieurs instructions <code>plot</code>, <code>xset</code>, <code>xtitle</code>.
La fonction <code>xtitle(<nowiki>'</nowiki>''nom du graphique''<nowiki>'</nowiki>,<nowiki>'</nowiki>''axe des x''<nowiki>'</nowiki>, <nowiki>'</nowiki>''axe des y''<nowiki>'</nowiki>)</code> met un titre au graphique et aux axe. La fonction <code>titlepage(<nowiki>'</nowiki>''titre''<nowiki>'</nowiki>)</code> met un titre au milieu du graphique. La fonction <code>clf</code> efface la fenêtre graphique.
==== Exemple ====
[[Image:Scilab exemple 3d 2.png|thumb|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)
=== Programmation ===
Scilab accepte un certain nombre d’instructions :
* exécution conditionnelle <code>if ''condition'' then, …, else, …, end</code>
* boucle itérative <code>for ''variable'' = ''début'' : ''fin'', …, end</code> ou <code>for ''variable'' = ''début'' : ''pas'' : ''fin'', …, end</code>
* boucle itérative antéconditionnée : <code>while ''condition'' do, …, end</code> ou <code>while ''condition'' do, …, else, …, end</code>
Il est possible de définir des fonctions avec passage de paramètres. La fonction est un sous-programme avec ses variables propres, et qui peut contenir des boucles, des branchements conditionnels... Par exemple, pour définir une fonction ''f''(x) :
-->function [y] = f(x)
--> …
--> endfunction
Le paramètre ''x'' est passé à la fonction ''f'' ; la valeur retournée par ''f'' sera celle qui est attribuée à ''y'' dans la fonction.
On peut enregistrer l’environnement, c’est-à-dire l’ensemble des variables, dont notamment les fonctions, avec la commande <code>save(<nowiki>'</nowiki>''fichier''<nowiki>'</nowiki>)</code>. Ceci crée un fichier binaire (Scilab n’ajoute pas d’extension). Cet environnement peut être rechargé avec la fonction <code>load(<nowiki>'</nowiki>''fichier''<nowiki>'</nowiki>)</code>.
On peut également écrire les instructions dans un fichier texte, puis faire du copier/coller depuis l’éditeur de texte vers la ligne de commande de Scilab. Le code source peut contenir des commentaires introduits par deux barres de fraction <code>//</code>.
=== Environnement ===
Dans Scilab, l’environnement est l’ensemble des variables (y compris les fonctions) qui ont été définies ; l’environnement contient un certain nombre de variables prédéfinies. L’ensemble des variables est donné par la commande <code>who</code>.
Lorsque l’on utilise une fonction, l’exécution de la fonction se fait dans un nouvel environnement, copie de l’environnement initial. Les variables qui y sont modifiées ne le sont pas dans l’environnement initial (on ne travaille qu’en variables locales), seul le résultat de la fonction est renvoyé.
On peut ouvrir à dessein un environnement, avec la fonction <code>pause</code> ; l’invite devient alors <code>-1-></code>, indiquant que l’on est dans le premier niveau de sous-environnement. On est également dans une telle configuration lorsque l’on interrompt l’exécution d’une fonction (par exemple avec la combinaison de touches <code>CTRL+C</code>). Pour revenir à l’environnement précédent, il faut utiliser la commande <code>return</code>.
Si l’on utilise <code>return</code> sans argument, les variables ne sont pas transmises à l’environnement père. Il est possible de transmettre les variables ''a1'', ''a2'', …, ''an'' dans l’environnement père, avec la syntaxe <code>(''x1'', ''x2'', …, ''xn'')=return(''a1'', ''a2'', …, ''an'')</code>, où ''x1'', ''x2'', …, ''xn'' sont les noms des variables dans l’environnement père.
La commande <code>clear</code> permet de « nettoyer » un environnement, c’est-à-dire de supprimer toutes les variables.
== Voir aussi ==
=== Logiciels similaires ===
* [[PsiLAB]] [http://psilab.sourceforge.net/], homonyme (en pronociation anglaise) et également destiné aux calculs mathématiques, traitement des données et affichage graphique
* [[AMESim]]
* [[MATLAB|MatLab]]
* [[GNU Octave]]
* [[Sysquake]]
=== Liens externes ===
{{Autres projets
| commons = Category:Scilab
| b = Scilab
}}
* {{fr}} [http://www.scilab.org Site officiel]
=== Notes et références ===
<references />
{{Portail|logiciels libres|mathématiques}}
[[Catégorie:Logiciel de statistiques]]
[[Catégorie:Logiciel scientifique libre]]
[[Catégorie:Logiciel de calcul numérique]]
[[cs:Scilab]]
[[de:Scilab]]
[[en:Scilab]]
[[es:Scilab]]
[[fa:سایلب]]
[[ht:Scilab]]
[[it:Scilab]]
[[ja:Scilab]]
[[nn:Scilab]]
[[pl:Scilab]]
[[pt:Scilab]]
[[ru:Scilab]]
[[ur:سائیلیب]]
[[zh:Scilab]]