Voir la source de Scilab

{{Infobox Logiciel
 | logo                     = Scilab Logo.png
 | image                    = Screenshot scilab 3.png
 | dépôt                    = https://gitlab.com/scilab
 | état                     = actif
 | environnement            = Windows, Linux, MacOS
 | langues                  = Multilingue
 | type                     = [[Calcul numérique]]
 | politique de prix        = 
 | licence                  = [[GPLv2]], anciennement [[Licence CeCILL|CeCILL v2]]
 | site web                 = {{URL|https://www.scilab.org/}}
}}
'''Scilab''' (prononciation : {{MSAPI|saɪləb}}{{refnec}} contraction de ''Scientific Laboratory'' en anglais) est un [[logiciel libre]] de [[calcul numérique]] multi-plateforme fournissant un environnement de calcul pour des applications scientifiques. 

Il possède un [[langage de programmation]] orienté calcul numérique de [[Langage de programmation de haut niveau|haut niveau]]. Il peut être utilisé pour le [[traitement du signal]], l’[[analyse statistique]], le [[Traitement d'images|traitement d’images]], les simulations de [[dynamique des fluides]], l’[[Optimisation (mathématiques)|optimisation]] numérique, et la modélisation et simulation de [[Théorie des systèmes dynamiques|systèmes dynamiques]] explicites et implicites.

Il est disponible pour [[Microsoft Windows|Windows]], [[MacOS]], [[Linux|GNU/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’un traducteur de MATLAB vers Scilab existe<ref>{{lien web| url=https://help.scilab.org/docs/5.3.3/fr_FR/mfile2sci.html| titre=mfile2sci (fonction de conversion de M-file MATLAB vers Scilab)| consulté le=18 février 2020}}, voir aussi {{lien web| url=https://help.scilab.org/docs/5.4.1/fr_FR/section_e4263201a8aaae1452311455f0c059e7.html| titre=Aide à la conversion MATLAB vers Scilab| consulté le=18 février 2020}}.</ref>.

== Historique ==
Le projet est né à l'[[Institut national de recherche en informatique et en automatique|Inria]] en 1982 sous le nom de '''Blaise''', à partir de Matlab<ref>{{lien web |titre=Scicos >History |url=http://www.scicos.org/history.html |site=scicos.org |consulté le=14-04-2023}}.</ref>{{,}}<ref>{{Lien brisé |url= http://www.scilab.org/scilab/history |titre=scilab.org/scilab/history |brisé le=14-04-2023}}.</ref>. Il s'agit donc initialement d'une surcouche de [[Fortran]] permettant une [[programmation structurée]], la syntaxe étant proche du [[Pascal (langage)|Pascal]]. L'Inria fonde en 1984 une jeune-pousse, Simulog, pour commercialiser le produit sous le nom de '''Basile'''.

Dans les années 1990, Simulog cesse la distribution de Basile et le projet, alors baptisé '''Meta2''', devient le fruit d'une collaboration de chercheurs de l'Inria et de [[École nationale des ponts et chaussées|l’Ecole Nationale des Ponts et Chaussées]]. La première version de Scilab, nommée alors '''Ψlab'''<ref>{{lien web |titre=META2.3.1.1.html META2.3.1.1 |url=http://raweb.inria.fr/rapportsactivite/RA94/meta2/META2.3.1.1.html |site=inria.fr |consulté le=14-04-2023}}.</ref> (''Psilab'', même prononciation), est mise à disposition en 1994. Le développement de [[Scicos]] commence à la même époque, en tant que boîte à outils graphique.

En 1998, un ancien doctorant du projet Meta2, Habib Jreige, fonde la jeune pousse Saphir-Control pour fournir une assistance aux entreprises privées utilisant Scilab.

L'équipe Metalau est fondée en 2000 pour développer un traducteur Matlab/Scilab et assurer l'intégration de bibliothèques graphiques orientées objet, et en particulier d'une interface graphique en Java.

Début 2003, l'Inria décide de créer le Consortium Scilab, avec le soutien de sociétés et d’organisations académiques pour faire face à l’augmentation du nombre de personnes téléchargeant et utilisant Scilab et assurer son avenir et son développement. En 2005, le Consortium Scilab décide de se tourner vers un développement Java ; l'équipe Metalau décide de rester sur la technologie [[GTK+|Gtk]] et crée donc une scission ''(fork)'' appelée ScilabGtk basée sur Scilab 4 ; ce projet sera renommé [[ScicosLab]].

Dans la lignée d'un développement industriel, le Consortium Scilab intègre la [[Fondation de coopération scientifique]] [[Digiteo]] en {{date-|juillet 2008}} pour fournir un environnement propice à la croissance soutenue de l’opération et préparer son transfert progressif vers une structure privée.

Ainsi en {{date-|juin 2010}}, [[Scilab Enterprises]] est créée sur le [[business model|modèle économique]] [[Open Source]] classique pour assurer le développement du logiciel Scilab gratuit basé sur un code ouvert et proposer des services professionnels payants. À partir de {{date-|juillet 2012}}, le logiciel Scilab est hébergé par Scilab Enterprises. 

En 2015, l'Inria et [[OCamlPro]] mettent en place un projet commun d'interpréteur en [[OCaml]] nommé ''Scilint''. Cela donne naissance à ''Sciweb'', un interpréteur expérimental accessible par un [[navigateur web]], bien qu'incomplet et plus lent<ref>{{lien web
 | url = http://sciweb.ocamlpro.com/
 | titre = Sciweb
 | consulté le = 2016-02-09
}}</ref>. Jamais publié, Sciweb est à la base de ''Scilab Cloud'' développé et commercialement  exploité par Scilab Enterprises puis ESI.

En février 2017, [[ESI Group|ESI group]] fait l'acquisition de Scilab Enterprises et intègre son équipe opérationnelle. Depuis février 2019 (Scilab 6.0.2), la version [[MacOS]] de Scilab est construite et distribuée par l'[[Université de technologie de Compiègne|UTC]].

En août 2022, Scilab est acquis par [[Dassault Systèmes]]<ref>{{lien web
 |url=https://www.mail-archive.com/users@lists.scilab.org/msg10926.html
 |titre=[Scilab-users] Scilab is joining 3DS
 |site=The Mail Archive
 |date=2022-08-30
}}.</ref>.

== Licence ==
Distribué gratuitement et avec son [[code source]] via [[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é sous la [[Licence CeCILL|licence CeCILL v2]] à partir de la version 5.0, licence libre compatible [[Licence publique générale GNU|GNU GPL]]<ref>[http://www.scilab.org/changes_5/ Annonce du changement de licence]</ref>. Les versions 6.0 et ultérieures sont distribuées sous licence GNU GPL <ref>[https://www.scilab.org/download/scilab-6.1.1/ Précision des licences applicables]</ref>.

== Présentation succincte de l’utilisation ==
{{Section à synthétiser|date=mars 2023}}
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 exécuter des programmes [[Fortran]] ou [[C (langage)|C]] à partir de Scilab.
Il est également possible d'utiliser le moteur de Scilab depuis une application externe grâce à l'API call_scilab.
Scilab est complété par un environnement graphique Xcos (basé sur [[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>--&gt;</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 :
<syntaxhighlight lang="scilab">
-->a = 1;
-->A = 2;
-->a + A
 ans =
 
 3. </syntaxhighlight>

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 (mathématiques)|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]] {{math|i}}, il faut utiliser <code>%i</code> ; il figure simplement sous la forme « i » dans les résultats. Pour entrer l’infini {{math|∞}}, il faut utiliser <code>%inf</code> ; il figure simplement sous la forme « inf » dans les résultats. La valeur de [[Pi|{{math|π}}]] s’obtient par <code>%pi</code>, et la [[e (nombre)|constante de Neper {{math|e}}]] par <code>%e</code>.

==== Booléens ====
Lorsque l’on assigne une valeur [[Algèbre de Boole (logique)|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
<syntaxhighlight lang="scilab">
-->(%T & %F) | %F
ans =
 
F.
</syntaxhighlight>

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>&lt;&gt;</code> ou <code>~=</code>, et les [[relation d'ordre|relations d’ordre]] <code>&lt;</code>, <code>&lt;=</code>, <code>&gt;</code> et <code>&gt;=</code>.

==== Polynômes et fractions rationnelles ====
Il s’agit ici non pas de [[fonction polynomiale|fonctions polynomiales]] qui ne permettraient que leur évaluation numérique, mais de [[polynôme formel|polynômes 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
<syntaxhighlight lang="scilab">
-->x = poly(0, "x"); p = x ^ 2 + 2 * x + 1
p =
 
          2
1 + 2x + x
</syntaxhighlight>

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''}}.

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
<syntaxhighlight lang="scilab">
-->x = poly(0, "x"); f = (1 + x) / (1 - x)
f = 
 
1 + x
-----
1 - x
 
-->1/f
ans =
 
1 - x
-----
1 + x
</syntaxhighlight>

Pour avoir le numérateur de ƒ, il suffit de taper <code>f.num</code> ; le dénominateur de ƒ 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><ref group=alpha>Le nom de cette fonction, ''horner'', fait référence à la [[Méthode de Ruffini-Horner|méthode de Horner]] utilisée pour calculer numériquement un polynôme, en effectuant le plus petit nombre possible de multiplications : <math>a_0+a_1x+a_2x^2+...+a_nx^n=a0+x\,(a1+x\,(a_2+x\,(...+x\,a_n)...))</math>.</ref> : <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 doubles : <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>, et pour y mettre un guillemet double, il faut également en écrire deux accolés <code>""</code>.

L’addition <code>+</code> sur des chaînes de caractères produit la [[concaténation]]. Une chaîne de caractères 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)|matrices]] ; 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 (logique)|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’une 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 sans encadrement (sauf les matrices de chaînes de caractères qui sont encadrées par des points d’exclamation). Par exemple :
<syntaxhighlight lang="scilab">
-->[1, 2, 3 ; 0, 1, 0 ; 0, 0, 1]
ans =
 
 1. 2. 3. 
 0. 1. 0. 
 0. 0. 1. 
</syntaxhighlight>

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:N'</code> permet de générer une matrice-ligne dont le premier coefficient est N1, le dernier est inférieur ou égal à N', 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
<syntaxhighlight lang="scilab">
-->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
</syntaxhighlight>

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 ƒ est une fonction extérieure (c’est-à-dire 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'' = ƒ(''x'', ''y'')
: <code>z = feval(x, y, f)</code> : on a ''z''(''i'', ''j'') = ƒ(''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 un point suivi d'une apostrophe <code>.’</code> après la matrice ; l'utilisation de l'apostrophe seule <code>'</code> fait la transposition de la matrice [[conjugué]]e ([[opérateur adjoint]]) ;
* 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
: ƒ(''x'') = 2 · ''x''
peut se définir par
<syntaxhighlight lang="scilab">
deff("[y] = f(x)", "y = 2 * x")
</syntaxhighlight>
(voir aussi la section ''[[#Programmation|Programmation]]'').

; Intégration
: <code>integrate("''expression''", "x", x0, x1)</code> calcule numériquement l’intégrale de la fonction décrite par ''expression'' (c’est une chaîne de caractères interprétable par Scilab, comme <code>"sin(x)"</code>), ''x'' étant la variable d’intégration, entre les valeurs ''x''0 et ''x''1.

; Résolution d’équations
: Scilab dispose de plusieurs primitives permettant la résolution d’équations (voir ''[[Solveur d'équations]]''), entre 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 [[équation différentielle ordinaire]] ''({{langue|en|ordinary differential equation}})'' ; si l’équation différentielle est d''y''/d''t'' = ƒ(''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
<syntaxhighlight lang="scilab">
Y = [cos(x), sin(x)]; plot2d(x, Y, style = [-2, -1])
</syntaxhighlight>
On peut utiliser la commande <code>legend()</code> pour inscrire des légendes, par exemple
<syntaxhighlight lang="scilab">
legend("cosinus", "sinus")
</syntaxhighlight>

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'', N''x'', ''ny'', N''y'']</code> où N''x'' 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(theta,r)</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
<syntaxhighlight lang="scilab">grayplot(x, y, z)
</syntaxhighlight>
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
<syntaxhighlight lang="scilab">
xset('colormap', cmap)
</syntaxhighlight>
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>, par exemple <code>graycolormap(''n'')</code> (''n'' [[Niveau de gris|niveaux de gris]] entre le noir et le blanc), <code>jetcolormap(''n'')</code> dégradé entre le bleu et le rouge) ou <code>hotcolormap(''n'')</code> (dégradé 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
<syntaxhighlight lang = "scilab">
cmap = graycolormap(32); cmap(:, 2:3) = 0
</syntaxhighlight>
ou avec
<syntaxhighlight lang="scilab">r = linspace(0, 32, 32)'; cmap = [r zeros(32, 2)]
</syntaxhighlight>
et un dégradé du bleu vers le blanc avec
<syntaxhighlight lang="scilab">
cmap = graycolormap(32); cmap(:, 2:3) = 1
</syntaxhighlight>
ou avec
<syntaxhighlight lang="scilab">r = linspace(0, 32, 32)'; cmap = [r ones(32, 2)]
</syntaxhighlight>
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
<syntaxhighlight lang="scilab">
contour2d(x, y, z, n)
</syntaxhighlight>
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
<syntaxhighlight lang="scilab">
contour2d(x, y, z, [z1, z2, …, zn])
</syntaxhighlight>

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
<syntaxhighlight lang="scilab">
champ(x, y, vx, vy)
</syntaxhighlight>
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
<syntaxhighlight lang="scilab">plot3d(x, y, z)
</syntaxhighlight>
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 (représentation)|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'', "''chaîne''")</code> écrit la chaîne de caractères ''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 ''a''1 × 64° et va jusqu'à l'angle (''a''1 + ''a''2) × 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("''propriété", ''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
<syntaxhighlight lang="text">
xarc(0, 1, 0.5, 0.5, 0, 360*64) // ellipse
set("line_style", 2) // pointillés
</syntaxhighlight>
ou bien
<syntaxhighlight lang="text">
xarc(0, 1, 0.5, 0.5, 0, 360*64) // ellipse
a=get("hdl")
a.line_style=2 // pointillés
</syntaxhighlight>

==== 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)|empattements]] type [[Times New Roman|Times]] (2 pour des lettres 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 nombre de sous-graduations (il faut 4 sous-graduations pour que la graduation principale soit divisée en 5) ;
Exemple :
<syntaxhighlight lang="text">
a = get("current_axes")
a.x_location = "middle"
a.y_location = "middle"
a.isoview = "on"
a.sub_ticks = [4,4]
</syntaxhighlight>

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''{{e}} 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("''nom du graphique''", "''axe des x''", "''axe des y''")</code> met un titre au graphique et aux axes. La fonction <code>titlepage("''titre''")</code> met un titre au milieu du graphique. La fonction <code>clf</code> efface la fenêtre graphique.

==== Exemple ====
[[Fichier:Scilab exemple 3d 2.png|vignette|Exemple de graphique obtenu avec Scilab]]

Voici le graphique que l’on obtient avec les instructions ci-dessous.
<syntaxhighlight lang="scilab">
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)
</syntaxhighlight>

=== Programmation ===
On peut mettre les instructions Scilab dans un [[fichier texte]] portant l'extension de nom de fichier <code>.sce</code>. On parle alors de [[Programme informatique|script]] Scilab.

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) :
<syntaxhighlight lang="scilab">
function [y] = f(x)
  …
endfunction
</syntaxhighlight>
Le paramètre ''x'' est passé à la fonction ƒ ; la valeur retournée par ƒ sera celle qui est attribuée à ''y'' dans la fonction.

Si un fichier ne comporte que des définitions de fonctions, on lui donne alors l'extension <code>.sci</code>. Cela permet de créer des bibliothèques de fonctions communes à plusieurs scripts, ce qui facilite la maintenance logicielle (les améliorations profitent à tous les scripts, une erreur apparaîtra dans tous les scripts et donc sera plus vite détectée et corrigée). Ce fichier <code>.sci</code> est ensuite chargé par le script avec la commande <code>exec("chemin/nomdefichier")</code>.

On peut enregistrer l’environnement, c’est-à-dire l’ensemble des variables, dont notamment les fonctions, avec la commande <code>save("''fichier''")</code>. Ceci crée un [[fichier binaire]] (Scilab n’ajoute pas d’extension). Cet environnement peut être rechargé avec la fonction <code>load("''fichier''")</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 [[Variable locale|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 ''a''1, ''a''2, …, ''an'' dans l’environnement père, avec la syntaxe <code>(''x''1, ''x''2, …, ''xn'') = return(''a''1, ''a''2, …, ''an'')</code>, où ''x''1, ''x''2, …, ''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.

=== Interface avec d’autres langages ===
Scilab s’interface facilement avec le langage de script [[Tool Command Language|Tcl-Tk]] et permet d’afficher des interfaces graphiques. La fonction <code>TCL_EvalFile()</code> évalue des scripts [[Tool Command Language|Tcl-Tk]] qui peuvent faire appel à des fonctions de Scilab en passant des paramètres via <code>ScilabEval</code>.

Exemple :
Calcul d’une distance dont les valeurs x, y ou z peuvent varier grâce au mouvement d’un curseur dans l’interface graphique écrite en [[Tool Command Language|Tcl-Tk]].

On crée trois fichiers (<code>lancement.sce</code>, distance.sci, gui.tcl).

Les deux fichiers Scilab:
<syntaxhighlight lang="scilab">
// lancement.sce - lancement de l’application

exec distance.sci;
TCL_EvalFile("gui.tcl");
</syntaxhighlight>

<syntaxhighlight lang="scilab">
// distance.sci - fonction Scilab

function dist = distance(x, y, z)
   dist = sqrt(x*x + y*y + z*z)
endfunction
</syntaxhighlight>

Et le code Tcl-Tk:
<syntaxhighlight lang="tcl">
# gui.tcl - interface graphique

global x y z dist

set x 10; set y 10; set z 10; set dist " "

toplevel .w
scale .w.scx -from 0 -to 200 -length 200 -resolution 1 -label "X" \
             -orient horiz -bd 1 -showvalue true -variable x \
             -command CalculDistance
scale .w.scy -from 0 -to 200 -length 200 -resolution 1 -label "Y" \
             -orient horiz -bd 1 -showvalue true -variable y \
             -command CalculDistance
scale .w.scz -from 0 -to 200 -length 200 -resolution 1 -label "Z" \
             -orient horiz -bd 1 -showvalue true -variable z \
             -command CalculDistance

label .w.lt -text Distance
label .w.ldist -textvariable dist -bg lightblue
eval pack [winfo children .w]

proc CalculDistance w {
 global x y z dist
 ScilabEval "dist = distance($x,$y,$z) ; TK_SetVar('dist',string(dist));"
}
</syntaxhighlight>

== Notes et références ==
=== Notes ===
{{Références| groupe=alpha}}

=== Références ===
{{Références}}

== Voir aussi ==
{{Autres projets| commons=Category:Scilab| wikibooks=Scilab}}

=== Articles connexes ===
* [[Tool Command Language|Tcl/Tk]]

==== Outil associé ====
[[Xcos]]

==== Logiciels similaires ====
* [[GNU Octave]]
* [[R (langage)|R]]
* [[SciPy]], ''Scientific Computing Tools for Python''
* [[SageMath]]
* [[FreeMat]]
* [[Julia (langage de programmation)]]
* [[MATLAB]]

=== Liens externes ===
{{Liens}}* [https://gitlab.com/scilab/ Hébergement sur Gitlab]
* [https://www.scilab.org/ Site officiel du logiciel]
* [https://help.scilab.org/ Documentation]
* [https://www.mail-archive.com/users@lists.scilab.org/ Liste de diffusion utilisateurs (anglais)]
* [https://atoms.scilab.org/ Modules externes]
* [https://interstices.info/a-propos-du-calcul-numerique/ Interview audio de Claude Gomez, directeur du consortium Scilab]

{{Palette|Logiciels de calcul numérique}}

{{Portail|logiciels libres|mathématiques}}

[[Catégorie:Logiciel de statistiques]]
[[Catégorie:Logiciel libre sous licence CeCILL]]
[[Catégorie:Logiciel de calcul numérique]]
[[Catégorie:Logiciel pour Windows]]
[[Catégorie:Logiciel pour Unix]]
[[Catégorie:Logiciel pour macOS]]
[[Catégorie:Produit lancé en 1984]]