Voir la source de Découvrir Scilab/Programmation

<noinclude>{{NavTitre|book={{BASEPAGENAME}}|prev=Graphiques et sons|next=Créer une interface graphique GUI}}</noinclude>
{{Scilab}}

<br />
<span style="font-size:25px;">6. Programmation</span>
----

Scilab est un langage de programmation, il accepte un certain nombre d’instructions autres que mathématiques, permettant l'exécution d'algorithmes.

L'écriture de programmes se fait idéalement avec l'éditeur de texte <span id="scinotes2">SciNotes</span> ; celui-ci met en exergue les instructions en couleurs, les parenthésages (correspondance entre les paires de parenthèses et de crochets), et surligne les lignes continuées avec un fond jaune. On peut aussi utiliser un autre éditeur de texte en sauvegardant le fichier avec l'extension <code>.sce</code> ou <code id="sci2">.sci</code>. Lorsque l'environnement le permet, on peut faire du copier-coller depuis l'éditeur de texte externe vers SciNotes ou bien l'éditeur de ligne de commande.

== Différence entre les extensions <code>.sce</code> et <code>.sci</code> ==

Les extensions de nom de fichier <code>.sce</code> et <code>.sci</code> sont toutes deux utilisées pour désigner des fichiers texte contenant des scripts Scilab. D'un point de vue de l'utilisateur, il y a peu de différences fonctionnelles entre les deux. Toutefois, la logique voulue par les concepteurs est la suivante[http://www.equalis.com/forums/posts.asp?group=&topic=160605&DGPCrPg=1&hhSearchTerms=&#Post160909] :
* les fichiers dont le nom porte l'extension <code>.sci</code> ne devraient contenir que des définitions de fonctions ; ce sont des bibliothèques ; en particulier, seuls les fichiers <code>.sci</code> sont chargés par la commande <code>getd()</code> (voir ''[[#Syntaxe pour définir une fonction|Syntaxe pour définir une fonction &gt; Fonction définie dans un fichier extérieur]]'') ;
* les fichiers dont le nom porte l'extension <code>.sce</code> devraient contenir le reste du script, et quelques fonctions locales.

Voir les sections suivantes :
* ''[[#Bibliothèque de fonctions|Bibliothèque de fonctions]]'' ;
* ''[[#Recommandations|Recommandations]]''.

== Interaction avec l'utilisateur ==

Interagir avec l'utilisateur, c'est :
* lui permettre d'entrer des données, par exemple des valeurs, paramètres, faire des choix, indiquer un fichier de données, … ce qui évite d'avoir à modifier le code à chaque utilisation spécifique et rend le script plus « universel » ;
* lui permettre de récupérer les résultats.

=== Entrées ===

Nous nous contentons dans cette section des entrées au clavier par le biais de la console Scilab. Les interactions plus complexes sont présentées dans le chapitre suivant ''[[../Créer une interface graphique GUI|Créer une interface graphique GUI]]''.

La fonction <span id="input1"><code>input</code></span> permet à l'utilisateur de rentrer une valeur. la syntaxe est :
<syntaxhighlight lang="scilab">
x = input("message")
</syntaxhighlight>
où ''message'' est une chaîne de caractères qui s'affiche et ''x'' est la variable dans laquelle sera mise la valeur (ou la matrice) entrée par l'utilisateur. Si l'utilisateur doit entrer une chaîne de caractères, il faut écrire (deux possibilités) :
<syntaxhighlight lang="scilab">
x = input("message", "string")
x = input("message", "s")
</syntaxhighlight>

Lorsqu'une variable ''nom_de_variable'' existe, alors
<syntaxhighlight lang="scilab" id="editvar1">
editvar nom_de_variable
</syntaxhighlight>
ouvre une fenêtre permettant de modifier la contenu de cette variable. On peut également définir la valeur d'une variable en affichant une boîte de dialogue
<syntaxhighlight lang="scilab">
a = x_dialog("message", "a0")
</syntaxhighlight>
où <code>a0</code> est la valeur initiale de ''a''. Si l'on veut un message sur plusieurs lignes, on utilise une matrice de chaînes de caractères, par exemple
<syntaxhighlight lang="scilab">
a = x_dialog(["Entrez un" ; "nombre entier"], "1")
</syntaxhighlight>
On peut aussi faire cliquer l'utilisateur et récupérer les coordonnées de l'endroit cliqué :
<syntaxhighlight lang="scilab">
[bouton, x, y] = xclick
</syntaxhighlight>
la valeur de ''bouton'' correspond à l'action menée par l'utilisateur.

La fonction <span id="halt1"><code>halt</code></span> arrête l'exécution du programme jusqu'à ce que l'utilisateur appuie sur une touche.

=== Sorties ===

Nous avons vu jusqu'ici l'affichage graphique et la génération de fichiers d'image et de son (voir le chapitre précédent ''[[../Graphiques et sons|Graphiques et sons]]''). Nous présentons ici l'affichage dans la console ; d'autres méthodes plus avancées sont présentées dans le chapitre suivant ''[[../Créer une interface graphique GUI|Créer une interface graphique GUI]]''.

==== Afficher un message ====

La fonction 
<syntaxhighlight lang="scilab" id="print1">print(%io(2),a)
</syntaxhighlight>
affiche le contenu de la variable ''a'' à l'écran. On peut aussi utiliser
<syntaxhighlight lang="scilab" id="write1">write(%io(2),a)
</syntaxhighlight>
La fonction
<syntaxhighlight lang="scilab" id="disp1">
disp(a)
</syntaxhighlight>
affiche le contenu de ''a'' sans faire figurer « <code>a = </code> » devant. On peut afficher un message dans la barre d'information située en bas de la fenêtre graphique courante, avec
<syntaxhighlight lang="scilab" id="disp1">
xinfo("message")
</syntaxhighlight>

La fonction <code id="warning1">warning(''message'')</code> affiche la chaîne de caractère ''message'' sous la forme d'un avertissement, c'est-à-dire précédé de « <code>WARNING: </code> ». La fonction <span id="error1"><code>error(''message'')</code></span> affiche la chaîne de caractère ''message'' sous la forme d'un message d'erreur, c'est-à-dire précédé de « <code>!--error 9999</code> ».

On peut utiliser la manière <code>printf()</code> du langage C pour inclure des variables mises en forme :
<syntaxhighlight lang="scilab" id="disp1">
a = 1/6
mprintf("La valeur vaut : %.2f", a)
</syntaxhighlight>
va afficher « La valeur vaut : 0.17 »

==== Lancer une impression ====

Pour lancer une impression, on peut utiliser la fonction <code>toprint()</code>, qui accepte comme paramètre :
* pour imprimer le contenu d'un fichier texte : un nom de fichier (et éventuellement son chemin d'accès) sous la forme d'une chaîne de caractères ;
* pour imprimer des lignes de texte : une matrice de chaînes de caractères (une entrée par ligne de texte), avec éventuellement une chaîne additionnelle pour l'en-tête ;
* pour imprimer une figure : le numéro de la figure (défini par <code>scf()</code> ou récupéré par <code>get(gcf(), "figure_id")</code><ref>ou bien <code>fig = gcf() ; fig.figure_id</code></ref>) ;
la fonction retourne un booléen indiquant si l'impression a réussi ou pas.

Par exemple :
<syntaxhighlight lang="scilab">
status = toprint("monfichiertexte.txt"); // impression du contenu du fichier

scf(0);
plot2d();
toprint(0); // impression de la fenêtre graphique

toprint(["ligne 1", "ligne 2", "ligne 3"], "en-tête");
</syntaxhighlight>
Pour les figures, on peut aussi utiliser
<syntaxhighlight lang="scilab">
scf(0);
plot2d();
printfigure(0); // impression de la fenêtre graphique
</syntaxhighlight>
qui, en outre, ouvre la boîte de dialogue de configuration de l'impression.

On peut ouvrir cette boîte de configuration pour modifier les paramètres par défaut, avec la commande

<syntaxhighlight lang="scilab">
printsetupbox
</syntaxhighlight>

== Interaction avec le système d'exploitation ==

Il est possible de demander au système d'exploitation (SE) d'effectuer des actions.

'''Déterminer le SE'''

La commande
<syntaxhighlight lang="scilab">
SE = getos()
</syntaxhighlight>
permet de connaître le système d'exploitation courant.

'''Sous Microsoft Windows'''

La commande
<syntaxhighlight lang="scilab">
winopen("nom_de_fichier")
</syntaxhighlight>
demande au SE d'ouvrir un fichier.
Pour cela, l'extension de nom de fichier doit être associée à un programme extérieur. On peut connaître ce programme avec la commande <code>findfileassociation()</code>, par exemple
<syntaxhighlight lang="scilab">
findfileassociation(".txt")
</syntaxhighlight>

'''Sous les Unix et Microsoft Windows'''

La commande <code>unix()</code> permet de faire effectuer une commande au SE, que ce soit un unix (dont un Linux, BSD ou MacOS X) ou bien Microsoft Windows. La commande renvoie un entier : si l'exécution est possible, le résultat est le code de l'interpréteur de commande, et si elle est impossible, le résultat est -1.

On peut rediriger le contenu de la sortie standard vers la fenêtre Scilab avec <code>unix_w()</code>, ou bien vers une variable avec la commande <code>unix_g()</code>, par exemple
<syntaxhighlight lang="scilab">
if getos() == "Windows" then
    A = unix_g("dir "+SCIHOME);
else
    A = unix_g("ls "+SCIHOME);
end
</syntaxhighlight>

== Structures de contrôle (boucles et branchements conditionnés) ==

=== Exécution conditionnelle ===

<span id="branchement_conditionne1">L'exécution conditionnelle</span> se fait de manière classique avec les commandes <code><span id="if1">if</span> ''condition'' <span id="then1">then</span>, …, <span id="else1">else</span>, …, <span id="end1">end</span></code>

<syntaxhighlight lang="scilab">
if condition1 then
  instructions
  ...
elseif condition2 then
  instructions
  ...
else
  instructions
  ...
end
</syntaxhighlight>
Si une variable peut prendre plusieurs valeurs, on peut utiliser la structure <code>select … case … else … end</code> :
<syntaxhighlight lang="scilab">
select nom_variable
  case valeur1 then
    instructions
  case valeur2 then
    instructions
    ...
  case valeurn then
    instructions
else
  instructions
end
</syntaxhighlight>

=== Boucle itérative ===

La syntaxe d'une <span id="boucle_iterative1">boucle</span> [http://help.scilab.org/docs/5.3.0/fr_FR/for.html <code>for</code>] est la suivante :
<syntaxhighlight lang="scilab">
for variable=expression
do
  instructions
  …
end
</syntaxhighlight>
Le mot clef <code id="do1">do</code> est optionel. Il est possible d'écrire la boucle sur une seule ligne :
<syntaxhighlight lang="scilab">
for variable=expression, instruction, …, instruction, end
</syntaxhighlight>

L'<code>expression</code> est un vecteur ou une liste contenant les différentes valeurs qui seront successivement prises par <code>variable</code>.

''Exemples :''
* <syntaxhighlight lang="scilab">
for i=1:10 ...
</syntaxhighlight> la variable <code>i</code> prend successivement les valeurs 1, 2, ..., 10.
* <syntaxhighlight lang=scilab>
for i=list (1, 2, "a") ...
</syntaxhighlight> la variable <code>i</code> prend successivement les valeurs 1, 2 et "a".

=== Boucle itérative antéconditionnée ===

<syntaxhighlight id="while1" lang="scilab">
while condition
  instructions1
  …
[else
  instructions2
  …]
end
while condition, instructions1, … [, else instructions2, …], end
</syntaxhighlight>

Le bloc d'instructions <code>instructions1</code> est exécuté tant que <code>condition</code> est vraie. Le bloc d'instructions <code>instruction2</code> n'est exécuté qu'une seule fois dès que <code>condition</code> est fausse.

=== Interruption d'une boucle ===

Lorsque le mot clé <code id="break1">break</code> [http://help.scilab.org/docs/5.3.0/fr_FR/break.html] est rencontré dans une boucle <code>for</code> ou <code>while</code>, l'exécution de la boucle est interrompue, et l'exécution du programme se poursuit par les instructions suivants immédiatement le mot clé <code>end</code> terminant la boucle.

== Tri, recherche et sélection ==

Dans un certain nombre de cas, il faut trier les éléments d'un ensemble, ou bien rechercher des éléments répondant à certaines conditions au sein d'un ensemble. Par « ensemble », nous entendons ici un vecteur ou une matrice.

=== Tri ===

La fonction <code>gsort</code> permet de trier ; elle utilise l'algorithme de tri rapide (''quick sort'', diviser pour régner). Si V est un vecteur, alors
<syntaxhighlight lang="scilab">
A = gsort(V)
</syntaxhighlight>
trie les éléments par ordre décroissant. Pour trier par ordre croissant, il faut ajouter l'option <code>"i"</code> ''(increasing ordre)'' :
<code>A = gsort(V, "i")</code>
Si M est une matrice, alors <code>gsort(M)</code> trie la matrice en classant les éléments de haut en bas puis de gauche à droite. Si M est une matrice ''m''×''n'' (''m'' lignes, ''n'' colonnes), alors l'élément M(''i'', ''j'') (''i''-ème ligne, ''j''-ème colonne) donnera l'indice de classement
: I = ''i'' + (''j'' - 1)×''m''
Si l'on veut trier les colonnes, c'est-à-dire que les éléments restent dans la même colonne mais changent de ligne ''(row)'', on utilise l'option <code>"r"</code>. Et si l'on veut trier les lignes, on utilise l'option <code>"c"</code> (''column'', les éléments changent de colonne, mais pas de ligne). Par exemple
<syntaxhighlight lang="scilab">
M = rand(3,3)
A = gsort(M, "r", "i")
</syntaxhighlight>

On peut aussi vouloir conserver les lignes intègres, ou les colonnes intègres. Pour cela, on utilise le tri « lexicographique » (tri par le premier élément, puis en cas d'égalité par le deuxième éléments, …), avec les options <code>"lr"</code> ou <code>"lc"</code> :
<syntaxhighlight lang="scilab">
A = gsort(M, "lr", "i")
</syntaxhighlight>

=== Recherche ===

La recherche se fait avec la fonction <code>find</code>.

Par exemple, pour cherche une valeur ''a'' au sein d'un vecteur V :
<syntaxhighlight lang="scilab">
I = find(V == a);
</syntaxhighlight>
la variable I retournée est alors un vecteur contenant les numéros d'indices ''i'' tels que V(''i'') = ''v''. On peut ensuite extraire les valeurs
<syntaxhighlight lang="scilab">
A = V(I);
</syntaxhighlight>
voire les supprimer du vecteur initial
<syntaxhighlight lang="scilab">
V(I) = [];
</syntaxhighlight>

Pour être un peu plus précis : <code>V == a</code> est un vecteur de booléens. On peut fabriquer un vecteur de booléens avec tous types de conditions, par exemple <code>(V &gt; a & V ~= b)</code>…

Avec une matrice booléenne M, la commande
<syntaxhighlight lang="scilab">
I = find(M);
</syntaxhighlight>
renvoit un vecteur d'indice obtenu en parcourant la matrice par colonnes, de haut en bas, puis de gauche à droite. Comme pour le tri, si M est une matrice ''m''×''n'' (''m'' lignes, ''n'' colonnes), alors l'élément M(''i'', ''j'') (''i''-ème ligne, ''j''-ème colonne) donnera l'indice
: I = ''i'' + (''j'' - 1)×''m''
Si l'on veut des indices « classiques », il faut utiliser la syntaxe
<syntaxhighlight lang="scilab">
[I, J] = find(M);
</syntaxhighlight>
alors I(''k''), J(''k'') sont les indices du ''k''-ième élément trouvé. La valeur de l'élément est extraite par <code>M(I(k), J(k))</code>.

Dans l'exemple suivant, les deux matrices A et B sont identiques
<syntaxhighlight lang="scilab">
M = rand(10, 10);
M > 0.5
[I, J] = find(M > 0.5);
for k = 1:size(I, "*")
    A(k) = M(I(k), J(k));
end

L = find(M > 0.5);
B = M(L);
[A, B]
</syntaxhighlight>

La commande <code>find()</code> travaille uniquement sur des matrices de booléens. Cela explique que la commande ne marche pas avec les listes (voir ''[[../Structures de données avancées|Structures de données avancées]]'').

La commande <code>dsearch()</code> regarde si chaque élément d'une matrice est dans un intervalle donné ; l'intervalle est donné sous forme de matrice. Par exemple
<syntaxhighlight lang="scilab">
dsearch([1 3 5 7], [2 4])
</syntaxhighlight>
va regarder quels sont les éléments du vecteur (1 ; 3 ; 5 ; 7) qui sont dans l'intervalle [2 ; 4]. La réponse est
<syntaxhighlight lang="scilab">
0 1 0 0
</syntaxhighlight>
car seul le second élément est dans l'intervalle. On peut indiquer des intervalles conjoints, par exemple <code>[2 4 6]</code > correspond aux intervalles I<sub>1</sub> = [2 ; 4] et I<sub>2</sub> = ]2 ; 6], et l'on a
<syntaxhighlight lang="scilab">
-->dsearch([1 3 5 7], [2 4 6])
 ans  =
 
    0.    1.    2.    0.  
</syntaxhighlight>
indiquant que le deuxième élément est dans l'intervalle 1, et le troisième éléments est dans l'intervalle 2.

Avec l'option <code>"d"</code>, <code>dsearch()</code> considère que le deuxième argument est un ensemble de nombres disjoints. Il cherche donc si chaque élément du premier argument est un élément du second :
<syntaxhighlight lang="scilab">
-->dsearch([1 3 5 7], [3 7], "d")
 ans  =
 
    0.    1.    0.    2. 
</syntaxhighlight>
indique que le premier élément de (1 ; 3 ; 5 ; 7) est le premier élément de (3 ; 7), et que le quatrième élément de (1 ; 3 ; 5 ; 7) est le second élément de (3 ; 7).

On peut aussi localiser un vecteur-ligne ou un vecteur-colonne V au sein d'une matrice M :
<syntaxhighlight lang="scilab">
vectorfind(M, V, "r") // vecteur-ligne
vectorfind(M, V, "c") // vecteur-colonne
</syntaxhighlight>
la fonction retourne un vecteur d'indices correspondant aux lignes ou colonnes trouvées.

Scilab<ref>À partir de la version 5.5.</ref> propose la fonction <code>members()</code> pour chercher une « aiguille dans un botte de foin » ''(needle in a haystack)'', c'est-à-dire une hypermatrice dans une hypermatrice d'hypermatrices. Bien sûr, on peut s'en servir pour chercher un scalaire dans une matrice de scalaires, mais aussi une ligne ou une colonne particulière :
<syntaxhighlight lang="scilab">
nb = members(A, BF)
[nb, pos] = members(A, BF)
</syntaxhighlight>
cherche l'aiguille A dans la botte de foin BF, qui doit être une matrice ou hypermatrice d'éléments du même type que A ; la variable <code>nb</code> est le nombre d'occurrences et <code>pos</code> les indices de la première position trouvée. Par exemple<ref>Samuel Gougeon, « Re: [Scilab-users] Converting string months to month numbers », '' [http://mailinglists.scilab.org/Scilab-users-Mailing-Lists-Archives-f2602246.html Scilab users mailing list]'' , 21 octobre 2016</ref>
<syntaxhighlight lang="Scilab">
mois  = ["jan", "fév", "mar", "avr", "mai", "jun", "jul", "aou", "sep", "oct", "nov", "déc"]; 
dates = ["déc", "avr" ; "fév", "déc" ; "jun", "jul"];
[tmp, datesnum] = members(dates, mois);
disp(datesnum)

-->12.   4. 
   2.    12.
   6.    7.
</syntaxhighlight>
Ici, le fait d'aller cherche la position des aiguilles dans la botte permet de transformer les noms des mois en numéros.

On peut ajouter l'option <code>"last"</code> pour avoir la dernière occurrence :
<syntaxhighlight lang="scilab">
[nb, pos] = members(A, BF, "last")
</syntaxhighlight>

Si l'on veut chercher une ligne, alors A doit être une matrice ligne, et l'on utilise
<syntaxhighlight lang="scilab">
members(A, BF, "rows")
</syntaxhighlight>
on peut aussi chercher les permutations de A avec l'option <code>"shuffle"</code> :
<syntaxhighlight lang="scilab">
members(A, BF, "rows", "shuffle")
</syntaxhighlight>
On peut chercher des colonnes avec l'option <code>"cols"</code>.

=== Opérations sur les ensembles ===

Certaines matrices contiennent des éléments dupliqués. La commande <code>unique()</code> permet de supprimer les doublons, ou bien, vu d'une autre manière, détermine l'ensemble des valeurs dont est constituée la matrice.

Dans sa syntaxe la plus simple
<syntaxhighlight lang="scilab">
unique(M)
</syntaxhighlight>
renvoie une matrice colonne contenant chacun des éléments, classés par ordre croissant. On peut obtenir l'indice de la première occurrence de chaque éléments avec la syntaxe
<syntaxhighlight lang="scilab">
[N, k] = unique(M)
</syntaxhighlight>
Par exemple
<syntaxhighlight lang="scilab">
A = [0, 0, 1, 1;
     0, 1, 1, 1;
     2, 0, 1, 1;
     0, 2, 2, 2;
     2, 0, 1, 1;
     0, 0, 1, 1];
-->unique(A)
 ans  =
 
    0.  
    1.  
    2.  
 
-->[N, k] = unique(A)
 k  =
 
    1.  
    8.  
    3.  
 N  =
 
    0.  
    1.  
    2. 
</syntaxhighlight>
Nous voyons que la matrice A, de dimension 6×4, comporte les valeurs 0, 1 et 2 — donc qu'elle est construite sur l'ensemble {0 ; 1 ; 2} —, et que la première occurrence de 0 est à l'indice 1, la première occurrence de 1 est à l'indice 8, et la première occurrence de 2 est à l'indice 3 (comptés comme d'habitude de haut en bas, et de gauche à droite).

On peut aussi considérer les lignes uniques, avec l'option <code>"r"</code> ''(rows)'', ou les colonnes uniques, avec l'option <code>"c"</code>.
<syntaxhighlight lang="scilab">
-->unique(A, "r")
ans  =
 
    0.    0.    1.    1.  
    0.    1.    1.    1.  
    0.    2.    2.    2.  
    2.    0.    1.    1.
</syntaxhighlight>
La matrice A comporte donc quatre lignes originales, et deux lignes qui sont des répétitions.

La commande <code>union()</code> fait la même opération, mais sur deux matrices : elle détermine la réunion des ensembles des valeurs des deux matrices, et le cas échéant indique l'indice de première occurrence pour chacune des matrices.

Par exemple :
<syntaxhighlight lang="scilab">
A = [0 1 2
     0 2 1];
B = [3 2 4;
     4 3 2];
-->union(A, B)
 ans  =
 
    0.    1.    2.    3.    4. 
-->[N, ka, kb] = union(A, B)
 kb  =
 
    1.    2.  
 ka  =
 
    1.    3.    4.  
 N  =
 
    0.    1.    2.    3.    4.  
</syntaxhighlight>
On voit donc que la réunion des ensembles est {0 ; 1 ; 2 ; 3 ; 4}. On peut de même utiliser les options <code>"c"</code> ou <code>"r"</code>.

== Temporisation ==

Dans certains cas, il est nécessaire de suspendre l'exécution du script, par exemple pour laisser des opérations extérieures (appels système, …) s'exécuter. On peut utiliser les commandes suivantes :
* <code>sleep(n)</code> : suspend le processus en cours pendant ''n'' millisecondes ;
* <code>xpause(n)</code> : suspend Scilab pendant ''n'' millisecondes ;
* <code>realtimeinit(u) ; realtime(t0) ; realtime(t1)</code> : la première commande, <code>realtimeinit(u)</code>, indique une unité en nombre de secondes ''u'' ;<br /> la deuxième commande, <code>realtime(t0)</code>, indique que l'instant actuel est ''t''<sub>0</sub>, selon l'unité précédemment définie (habituellement, ''t''<sub>0</sub> = 0) ; <br />la troisième commande, <code>realtime(t1)</code>, met Scilab en attente jusqu'à ce que la date ''t''<sub>1</sub> soit atteinte, selon l'unité précédemment définie .

== Analyse et construction de chaînes de caractères ==

Les chaînes de caractères sont un moyen pratique et robuste d'échanger des informations, entre Scilab et l'utilisateur (clavier, écran) ou entre logiciels (fichiers de texte) : les codes ASCII ou UTF-8 sont normalisés et reconnus sous toutes les plateformes par la plupart des logiciels.

Nous avons déjà vu précdemment l'utilisation des commandes :
* <code>ascii()</code> (et <code>char()</code>), pour créer une chaîne de caractères à partir de codes ASCII et ''vice versa'' ;
* <code>string()</code>, pour transformer des nombre ou matrices de nombres en chaînes de caractères ;
* <code>length()</code>, pour déterminer la longueur d'une chaîne ; 
* <code>+</code> et <code>strcat()</code>, pour concaténer des chaînes ;
* <code>strsubst()</code> qui permet de « rechercher-remplacer » ;
* <code>evstr()</code> qui permet d'exécuter une commande Scilab contenue dans une chaîne de caractères.

{{loupe|Découvrir Scilab/Calculs élémentaires#Chaînes de caractères}}

=== Localiser une sous-chaîne ===

La commande <code>strindex()</code> permet de localiser la position (le ''n''-ième caractère) où se trouve une sous-chaîne : 
<syntaxhighlight lang="scilab">
-->strindex("bonjour Marcel", "r M")
 ans  =
 
    7.
</syntaxhighlight>
car la sous-chaîne « r M » commence au 7<sup>e</sup> caractère. La sous-chaîne peut également être décrite par une expression régulière (voir ci-après), il faut alors rajouter le fanion <code>"r"</code> ; on peut également utiliser la commande <code>regexp()</code> dans ce contexte. Par exemple

<syntaxhighlight lang="scilab">
-->strindex("bonjour Marcel", "/r\ M/", "r")
 ans  =
 
    7.  

-->regexp("bonjour Marcel", "/r\ M/")
 ans  =
 
    7.
</syntaxhighlight>

=== Couper à des positions données ===

La commande <code>strsplit()</code> découpe une chaîne et crée un vecteur-colonne des sous-chaînes. Sans autre argument que la chaîne elle-même, elle la découpe en caractère individuels :
<syntaxhighlight lang = "scilab">
-->strsplit("abcd")
 ans  =
 
!a  !
!   !
!b  !
!   !
!c  !
!   !
!d  !
</syntaxhighlight>
Si l'on indique un vecteur de valeurs, il coupe après les endroits indiqués :
<syntaxhighlight lang = "scilab">
-->A = strsplit("aei ou y", [4, 7])
 A  =
 
!aei   !
!      !
!ou    !
!      !
!y     !

-->length(A(1))
 ans  =
 
    4.  
</syntaxhighlight>
La première sous-chaîne fait 4 caractères (l'espace en position 4 est inclus) ; la deuxième sous-chaîne fait trois caractères (l'espace en position 7 est inclus).

=== Couper à des délimiteurs ===

Enfin, on peut indiquer des points de découpe soit sous la forme d'une chaîne de caractères, dite « délimiteur » ; il s'agit typiquement de virgules (le délimiteur décimal étant le point), points-virgules, d'espaces, de tabulations ou d'un caractère qui n'est pas utilisé dans les expressions (point d'exclamation, arobase, …). Les parties de la chaîne de caractère entre les délimiteurs sont appelés « jetons » ''(tokens)''.

Les délimiteurs par défaut sont l'espace et la tabulation, mais on peut définir soi-même le délimiteur. La commande <code>tokens()</code> cherche les délimiteurs dans une chaîne de caractères, découpe la chaîne en ''jeton1 — délimiteur1 — jeton2 — délimiteur2…'' et crée une matrice colonne avec chaque sous-chaîne.

Par exemple, la commande
<syntaxhighlight lang="scilab">
t = tokens("a = 5", "=")
</syntaxhighlight>
crée la matrice <code>["a " ; "=" ; " 5"]</code>. La commande <code>tokenpos()</code> indique la position des jetons, sous la forme d'une matrice : la première colonne indique la position du premier caractère des jetons, la seconde la position du dernier caractère.
<syntaxhighlight lang="scilab">
-->tokenpos("a = 5", "=")
 ans  =
 
    1.    2.  
    4.    5.  

-->tokenpos("a=5", "=")
 ans  =
 
    1.    1.  
    3.    3. 
</syntaxhighlight>

La commande <code>strplit()</code> fait le même travail de découpe, mais avec plus de possibilités ; le point de découpe peut être une chaîne de caractères — on coupe là où se trouve la chaîne —, mais aussi un vecteur de chaînes — on coupe là où se trouve ''un des'' éléments du vecteur —, ou bien une expression régulière (voir ci-après).
<syntaxhighlight lang = "scilab">
-->strsplit("aei ou y", " ")
 ans  =
 
!aei  !
!     !
!ou   !
!     !
!y    !
</syntaxhighlight>
Ici, les caractères de séparation — les espaces — sont supprimés. La première chaîne fait 3 caractères et la deuxième en fait 2.

Les expressions régulières permettent une plus grande souplesse. Par exemple, sil l'on veut couper un nombre indéterminé d'espaces :
<syntaxhighlight lang = "scilab">
-->strsplit("aei    ou y", "/\ +/")
 ans  =
 
!aei  !
!     !
!ou   !
!     !
!y    !
</syntaxhighlight>
Là encore, les caractères de séparation sont supprimés.

Mentionnons encore les commandes :
* <code>strchr()</code>, qui permet d'extraire la fin d'une chaîne à partir d'un délimiteur ;
* <code>strtok()</code>, qui permet d'extraire le début d'une chaîne jusqu'à un délimiteur.
<syntaxhighlight lang = "scilab">
--> strchr("une chaîne ; un délimiteur", ";")
 ans  =

 ; un délimiteur

--> strtok("une chaîne ; un délimiteur", ";")
 ans  =

 une chaîne 
</syntaxhighlight>

=== Expressions régulières ===

Une expression régulière est une description d'une chaîne de caractères<ref>voir {{en}} [http://perldoc.perl.org/perlrequick.html Perl regular expressions quick start]</ref>. C'est elle-même une chaîne, qui commence et finit par une barre de fraction <code>/</code>. Par exemple, l'expression régulière qui décrit « blabla » est <code>/blabla/</code>.

Il existe un certain nombre de caractères réservés, outre la barre de fraction :
 {}[]()^$.|*+?\
On les appelle « métacaractères ». Si l'on veut utiliser un de ces caractères, il faut le faire précéder d'une oblique inversée. Par exemple, la chaîne « 2+2 » est décrite par <code>/2\+2/</code>, et « /slash » par <code>/\/slash/</code>.

L'oblique inversée permet également de représenter des caractères d'échappement. Par exemple, une tabulation est représentée par <code>\t</code>, une nouvelle ligne par <code>\n</code> et un retour-chariot par <code>\r</code>.

Si un caractère est répété, on peut le faire suivre par :
* un point d'interrogation <code>?</code> : il est présent au plus une fois (0 ou 1 fois) ; <code>/a?/</code> décrit «» ou bien « a » ;
* un astérisque <code>*</code> : il est absent, ou présent un nombre indéterminé de fois ; <code>/a*/</code> décrit «», « a », « aa », « aaa », … ;
* un plus <code>+</code> : il est présent au moins une fois : <code>/a+/</code> décrit « a », « aa », « aaa », … ;
* une paire d'accolades : <code>/a{5}/</code> décrit « aaaaa », <code>/a{2,4}/</code> décrit « aa », « aaa » ou « aaaa », <code>/a{3,}</code> décrit « aaa », « aaaa », « aaaaa », …

Si une portion de chaîne doit se trouver en début de ligne, l'expression régulière commence par <code>^</code> ; si elle doit se trouver en fin de ligne, elle se termine par <code>$</code>. Par exemple, <code>/^bon/</code> et <code>/jour$/</code> sont tous les deux vrais pour « bonjour ».

On peut placer plusieurs caractères substituables entre crochets ; on parle de classe de caractères. Par exemple, <code>/[bt]éton/</code> décrit les chaînes de caractère « béton » et « téton ». L'expression <code>/[0-9a-fA-F]/</code> correspond à un chiffre hexadécimal (chiffre décimal de 0 à 9, et lettre de a à f, en minuscule et en majuscule). On peut aussi interdire une classe en la commençant par l'accent circonflexe : <code>/[^0-9]/</code> est tout sauf un chiffre décimal.

Enfin, il existe des classes toutes faites :
* <code>/\d/</code> est un chiffre, l'équivalent de <code>/[0-9]/</code> ;
* <code>/\D/</code> est tout sauf un chiffre, l'équivalent de <code>/[^0-9]/</code> ;
* <code>/\s/</code> est un caractère d'espacement : blanc, tabulation, nouvelle ligne ou retour-chariot ;
* <code>\S</code> est la négation de <code>\s</code> ;
* <code>\w</code> est un caractère alphanumérique (lettre ou chiffre, ainsi que le tiret de soulignement <code>_</code>) ;
* <code>\W</code> est la négation de <code>\w</code> ;
* le point <code>.</code> correspond à n'importe quel caractère, sauf une nouvelle ligne <code>\n</code>.
Ainsi, <code>/\s+</code> décrit un ou plusieurs espaces.

On peut avoir des chaînes alternatives : elles sont séparées par un tube <code>|</code>, et en cas d'ambiguïté, elles sont entre parenthèses : <code>/(bonjour|au\ revoir)\ Marcel/</code> décrit les chaînes « bonjour Marcel » et « au revoir Marcel ».

== Fonctions extérieures ==

=== Syntaxe pour définir une fonction ===

Comme indiqué dans le chapitre  ''[[Découvrir Scilab Calcul numérique#deff2|Calcul numérique]]'', la définition d'une fonction commence par le mot clé <code id = "function5">function</code> et se termine par le mot clé <code>endfunction</code>, selon la syntaxe suivante :

<syntaxhighlight lang=scilab>
function [<arguments de sortie>] = <nom de la fonction>(<arguments d'entrée>)
  <instructions>
endfunction
</syntaxhighlight>

Les instructions pouvant comporter des branchements conditionnels (tests), des boucles, … ce qui recoupe la notion de sous-programme.

Par exemple, la fonction calculant la puissance n-ième peut s'écrire :

<syntaxhighlight lang="scilab">
function [y] = puissance(x,n)
// calcule la puissance n-ieme 
  y = 1 // valeur de y^0, et valeur initiale si n>0
  if n > 0 then 
    for i = 1:n
      y = y*x // on multiplie n fois x par lui-même
    end
  end 
endfunction
</syntaxhighlight>

Cette fonction peut ensuite être utilisée en mode interactif ou à l'intérieur d'un programme : 
<syntaxhighlight lang="scilab">
-->puissance(2,3)
 ans  =
 
    8.  
</syntaxhighlight>

Le résultat d'un calcul à l'intérieur d'une fonction n'est jamais affiché, l'utilisation de virgules ou de points-virgules est donc indifférente.

'''Fonction définie dans un fichier extérieur'''

Lorsque la fonction est définie dans un <span id="fichier1">fichier</span> texte, celui-ci peut être chargé au moyen de la commande <code id="exec1" >exec()</code> :
<syntaxhighlight lang="scilab">
exec("fichier.sci")
</syntaxhighlight>

Un fichier peut contenir plusieurs fonctions. Le nom de fichier peut contenir un chemin d'accès si celui-ci n'est pas dans le répertoire (dossier) courant.

La commande <code>getd()</code> permet de charger tous les fichiers <code>.sci</code> d'un répertoire, avec la syntaxe :
<syntaxhighlight lang="scilab">
getd("chemin/")
</syntaxhighlight>
où <code>"chemin/"</code> est le chemin d'accès au répertoire.

Les commandes permettant de manipuler les répertoires sont décrites au chapitre ''[[../Gestion des fichiers#Manipulation des répertoires|Gestion des fichiers &gt; Manipulation des répertoires]]''.

'''Fonction définie en ligne de commande'''

On peut définir une fonction en mode interactif, en ligne de commande. La syntaxe est identique, il suffit d'entrer les différentes lignes dans l'interpréteur. Toutes les instructions avant le mot clef <code>endfunction</code> sont considérées comme appartenant à la fonction et ne sont pas interprétées immédiatement.

'''Passage d'une fonction en paramètre'''

d'un point de vue de la représentation des données, une fonction est une variable. On peut donc la passer en paramètre. Par exemple :

<syntaxhighlight lang="scilab">
function [y] = ce_que_je_veux(action, parametre)
   y = action(parametre)
endfunction
</syntaxhighlight>
peut ensuite s'utiliser ainsi :
<syntaxhighlight lang="scilab">
-->ce_que_je_veux(sqrt, 2)
 ans  =
 
    1.4142136  
 
-->ce_que_je_veux(max, [2 -1 3 0])
 ans  =
 
    3.  
</syntaxhighlight>
Et l'on peut ainsi renommer des fonctions, par exemple :
<syntaxhighlight lang="scilab">
-->racine_carree = sqrt
 racine_carree  =
 
 
-->racine_carree(2)
ans  =
 
    1.4142136  
</syntaxhighlight>

On voit là l'importance des parenthèses vide lorsque l'on utilise une fonction qui n'a pas de paramètre. Par exemple
<syntaxhighlight lang="scilab">
a = gce
</syntaxhighlight>
crée une copie de la fonction <code>gce()</code>, tandis que
<syntaxhighlight lang="scilab">
a = gce()
</syntaxhighlight>
met dans la variable ''a'' le résultat de la fonction <code>gce()</code> (voir ''[[../Graphiques et sons#Organisation des entités graphiques|Graphiques et sons &gt; Organisation des entités graphiques]]'').

=== Définition compacte d'une fonction ===

Une fonction peut aussi se définir en une ligne à l'aide de l'instruction <code id="deff5">deff</code> :
<syntaxhighlight lang="scilab">
deff ("[y] = f(x)", "y=2*x")
</syntaxhighlight>
Cette définition est équivalente à :
<syntaxhighlight lang="scilab">
function [y] = f(x)
  y = 2*x
endfunction
</syntaxhighlight>

Cette syntaxe permet également de définir des fonctions comportant plusieurs instructions :
<syntaxhighlight lang="scilab">
deff ("[y] = puissance(x, n)", "y = 1, if n > 0 then, for i = 1:n, y = y*x, end, end")
</syntaxhighlight>
Cette écriture, bien que compacte, rend difficile la compréhension de la fonction, et ne devrait être réservé qu'aux fonctions simples.

De même qu'avec le mot clef <code>function</code>, le résultat des calculs n'est pas affiché à l'intérieur d'une fonction.

=== Gérer le nombre de paramètres transmis ===

Lorsqu'une fonction est créée pour un seul programme, on peut facilement gérer le nombre de paramètres : le programmeur sait ce qu'il doit transmettre lors de l'appel de la fonction. Mais une fonction peut être amenée à être utilisée dans d'autres programmes, par d'autre programmeurs, par exemple en étant intégrée à une bibliothèque (voir ''[[#Bibliothèque de fonctions|Bibliothèque de fonctions]]'' et ''[[#Recommandations|Recommandations]]''. Il faut alors envisager
* que certains paramètres soient optionnels ;
* que le programmeur oublie de transmettre certains paramètres (voir ''[[#Gestion des erreurs|Gestion des erreurs]]'').

Si un paramètre <code>p</code> peut avoir une valeur par défaut, on peut tester son existence avec <code>exists()</code> :
<syntaxhighlight lang = "scilab">
function [y] = monproduit(x, p)
  // paramètre optionnel
  if exists("p", "l") == 0...
    then p = 1; end // valeur par défaut
  y = x*p;
endfunction
</syntaxhighlight>

On peut définir une fonction avec un nombre variable d'arguments. Le dernier argument doit alors être <code>varagin</code> ''(variable arguments input)'' ; dans la fonction, <code>varagin</code> est une liste, <code>varagin(i)</code> donne donc le i-ème argument optionnel. Le nombre total d'arguments est donné par la commande <code>argn(2)</code >(le « 2 » est un paramètre imposé). Par exemple

<syntaxhighlight lang = "scilab">
function [y] = produit_multiple(x, varargin)
  // paramètre optionnel
  n = argn(2);
  y = x;
  for i = 1:n - 1
    y = y*varargin(i);
  end
endfunction
</syntaxhighlight>
que l'on peut tester avec
 produit_multiple(5)
 produit_multiple(5, 4)
 produit_multiple(5, 4, 2)

Si l'on veut utiliser la totalité des paramètres, il faut utiliser <code>varagin(:)</code>. Par exemple, si l'on ne désire tracer que les dix premiers points d'un jeu de données mais en permettant de passer des paramètres pour modifier le tracé :
<syntaxhighlight lang = "scilab">
function [y] = trace_10_premiers(x, y, varargin)
  plot(x(1:10), y(1:10), varargin(:))
endfunction
</syntaxhighlight>
que l'on peut tester par exemple avec
 x = rand(1, 100)
 y = rand(1, 100)
 scf(0); plot(x, y)
 scf(1); trace_10_premiers(x, y, "r", "thickness", 2)

De la même manière, on peut utiliser <code>varargout</code> ''(variable arguments output)'' dans les paramètres de sortie, et « remplir » la liste <code>varargout</code> dans la fonction. Le nombre total de paramètres de sortie est donné par <code>argn(1)</code>. Si <code>varargout</code>  est le seul paramètre de sortie, alors les éléments de la liste sont « égrénés », par exemple
<syntaxhighlight lang = "scilab">
function [varargout] = test_varargout()
  varargout = list(1, 2, 3, 4);
endfunction
</syntaxhighlight>
donne :
<syntaxhighlight lang = "scilab">
--> a = test_varargout()
 a  = 

    1.

--> [a, b] = test_varargout()
 b  = 

    2.
 a  = 

    1.
</syntaxhighlight>
S'il y a d'autres arguments de sortie que <code>varargout</code>, alors la liste est transmise comme une variable unique. Par exemple :
<syntaxhighlight lang = "scilab">
function [n, varargout] = test_varargout1()
  varargout = list(1, 2, 3, 4);
  n = argn(1);
endfunction
</syntaxhighlight>
donne :
<syntaxhighlight lang = "scilab">
--> a = test_varargout1()
 a  = 

    1.

--> [N, L] = test_varargout1()
L  = 


       L(1)

    1.

       L(2)

    2.

       L(3)

    3.

       L(4)

    4.
 N  = 

    2.
</syntaxhighlight>
Notons que dans ce cas-là, on a un nombre de paramètres de sortie fixe, pas variable, puisque <code>varargout</code> est ''un'' paramètre unique. On pourrait utiliser n'importe quel nom de liste.

=== Informations sur une fonction ===

La commande <code>macrovar(f)</code> donne la liste des paramètres d'entrée et sortie de la fonction <code>f</code>, sous la forme d'un vecteur :
* première composante : paramètres d'entrée ;
* deuxième composante : paramètres de sortie ;
* troisième composante : variables utilisées mais qui ne sont pas définies à l'intérieur de la fonction ;
* quatrième composante : fonctions appelées à l'intérieur de cette fonction ;
* cinquième composante : variables locales.
La commande <code>fun2string(f)</code> renvoie un vecteur de chaînes de caractères contenant la définition de la fonction.

La commande <code>head_comments f</code> renvoie les commentaires situés au début de la fonction <code>f</code>.

On peut aussi vouloir caractériser un script complet. Une manière de faire consiste à mettre le script dans une fonction et à utiliser la commande <code>macrovar()</code>. On peut aussi comparer, avec <code>setdiff()</code>, la liste des variables, obtenue avec <code>who()</code>, avant et après le chargement du script. Par exemple
<syntaxhighlight lang="scilab">
variables_avant = who("local");
exec("monscript.sce");
variables_du_script = setdiff(variables_avant, who("local"));
</syntaxhighlight>

== Variables locales ou globales ==

Par défaut, toutes les variables sont locales, c'est-à-dire qu'elle sont définie dans un environnement d'exécution ''(workspace)''. Ainsi, une variable dans une fonction peut avoir le même nom qu'une variable dans le programme principal ou dans une autre fonction, ce seront des variables distinctes ; modifier la valeur d'une variable dans une fonction ne modifie pas la valeur de cette variable dans le programme principal.

On peut modifier ce comportement avec la commande <code>global()</code> ; c'est une manière inélégante — voire risquée, car on ne maîtrise pas totalement la valeur de la variable — de gérer une valeur sans avoir à la passer en paramètre à une fonction. Cela peut être utile lorsqu'une valeur est utilisée et modifiée par de nombreuses fonctions — cela allège la syntaxe des fonctions —, mais cela rend le code moins portable (voir la section ''[[#… Et général|Du code… Général]]''), et il faut être sûr de quelle fonction modifie la valeur et quand, voir par exemple sur Wikipédia ''[[w:fr:Parallélisme (informatique)#Dépendance des données|Parallélisme (informatique) &gt; Dépendance des données]]''.

Lorsque l'on veut partager une variable entre plusieurs environnements, il faut déclarer la variable comme globale dans chaque environnement. Par exemple, le script suivant :
<syntaxhighlight lang="scilab">
clear()

// fonctions
function modifie()
   global("a") // déclare la variable comme globale dans l'environnement de la fonction
   a = 5
endfunction

// programme principal

global("a") // déclare la variable comme globale dans l'environnement de base (programme principal)
a = 1;
disp("Valeur initiale : "+string(a)) // affiche la valeur initiale

modifie();

disp("Valeur finale : "+string(a)) // affiche la nouvelle valeur
</syntaxhighlight>
donne
  Valeur initiale : 1   
 
  Valeur finale : 5  
On peut partager une variable entre fonctions sans qu'elle soit partagée avec l'environnement du programme principal, par exemple le script
<syntaxhighlight lang="scilab">
clear()

// fonctions

function initialisation()
   global("a")
   a = 1
   disp("a = "+string(a))
endfunction

function utilisation()
   global("a")
   disp("a = "+string(a))
endfunction

// programme principal

errcatch(4, "continue") // n'interrompt pas le programme lorsqu'une variable
// n'est pas définie

initialisation()

disp("a = "+string(a)) 
errclear(4) // apurement des erreurs de type 4

utilisation()
</syntaxhighlight>
donne
  a = 1   
 disp("a = "+string(a))
                      !--error 4 
 Variable non définie : a
 
 
  a = 1 
ce qui montre que la variable existe dans les environnements d'exécution des fonctions, mais pas dans l'environnement d'exécution du programme principal.

On peut tester si une variable ''a'' est globale avec la commande
<syntaxhighlight lang="scilab">
isglobal(a)
</syntaxhighlight>

== Gestion des erreurs ==

L'exécution d'une fonction, et en particulier un calcul, peut générer une erreur, ce qui va interrompre le déroulement du programme. On peut éviter ceci de plusieurs manières :
# « Blinder » le programme : faire des vérifications de la validité des données à certains instants critiques.
# Prévoir les exceptions : si l'on doit diviser par un nombre, soit on s'assure que ce nombre ne ''peut pas'' être nul, soit on teste la nullité et le programme agit en conséquence.
# Intercepter les erreurs : on peut laisser se produire les erreurs, et éviter l'interruption du programme, avec les risques que cela comporte : résultat incohérent, voire pire, résultat faux mais paraissant cohérent.
# Renvoyer des valeurs particulières : la norme IEEE 754 définit la valeur « NaN » (''not a number'', « ceci n'est pas un nombre ») et « infini », représenté dans Scilab par <code>%nan</code> et <code>%inf</code>.

Blinder un programme, cela consiste essentiellement à vérifier que le contenu des variables est conforme à leur utilisation. C'est en particulier important lorsqu'il y a une entrée de données : lecture d'un fichier ou bien saisie au clavier. Par exemple, lorsque l'on demande à l'utilisateur d'entrer un nombre entier, on vérifie qu'il s'agit bien d'un entier, et si ce n'est pas le cas, on le signale et on redemande une nouvelle saisie.

On peut donc vérifier
# Si la variable existe.
# Si la variable est au bon format.
# Si le contenu est dans une plage correcte (est dans l'ensemble de définition des fonctions qui s'en servent).

=== Vérifier l'existence de la variable ===

La commande
<syntaxhighlight lang="scilab">
exists(nom_de_variable)
</syntaxhighlight>
où <code>nom_de_variable</code> est une chaîne de caractères (par exemple <code>exists("X")</code>), renvoie <code>1</code> si la variable existe, <code>0</code> sinon. Si l'on précise le paramètre <code>"l"</code>, la commande vérifie alors si la variable existe ''en local''. Par exemple : 
<syntaxhighlight lang="scilab">
exists("X", "l")
</syntaxhighlight>
placé au sein d'une fonction permet de vérifier si la variable <code>X</code> existe au sein de cette fonction ; s'il s'agit d'une variable passée en paramètre, cela permet de vérifier que l'appel de la fonction contient bien cette variable (faute de quoi la fonction risquerait d'utiliser la valeur d'une variable globale de même nom).

On peut aussi utiliser la fonction
<syntaxhighlight lang="scilab">
isdef("X")
isdef("X", "l")
</syntaxhighlight>
où <code>X</code> est la variable ; cette fonction renvoie un booléen.

Dans une fonction, on peut récupérer le nombre d'arguments d'entrée avec la commande
<syntaxhighlight lang="scilab">
nb_arg_entree = argn(2)
</syntaxhighlight>
puis à tester la valeur de <code>nb_arg_entree</code>. On pourra par exemple voir la définition de la fonction <code>sind</code> en tapant <code>edit sind</code> dans la ligne de commande.

Une autre manière de faire consiste à initialiser la variable avec un contenu vide — <code>a = []</code> — ou bien particulier — <code>a = %nan</code> —, puis à tester la valeur de la variable avant de l'utiliser (voir plus loin).

=== Vérifier le format de la variable ===

Scilab propose des fonctions de test <code>is...</code> (« est-ce… ? »), c'est-à-dire des fonctions renvoyant des valeurs booléennes <code>%t</code> (vrai) ou <code>%f</code> (faux) :
* <code>isglobal(X)</code> : vrai si la variable X est une variable globale ;
* <code>isvector(X)</code> : vrai si la variable X est un vecteur (faux si c'est un scalaire ou une matrice de plus d'une ligne et une colonne) ;
* <code>issparse(X)</code> : vrai si X est une matrice creuse ;
* <code>isnum(X)</code> : vrai si la chaîne de caractères X représente un nombre ;
* <code>isalphanum(X)</code> : renvoit un vecteur de booléens : la ''i''-ème composante est vraie si le ''i''-ème caractère de la chaîne X est une lettre ou un chiffre ;
* <code>isascii(X)</code> : ''idem'', mais vérifie s'il s'agit d'un caractère ASCII 7 bits ;
* <code>isdigit(X)</code> : ''idem'', mais vérifie s'il s'agit d'un chiffre ; 
* <code>isletter(X)</code> : ''idem'', mais vérifie s'il s'agit d'une lettre ; 
* <code>isreal(X)</code> : vrai si la matrice X ne contient que des nombres réels ;
* <code>isdir(X)</code> : vrai si la chaîne de caractères X est un chemin d'accès à un répertoire existant ;
* <code>isfile(X)</code> : vrai si la chaîne de caractères X est un nom de fichier existant ;
* <code>is_handle_valid(h)</code> : vrai si ''h'' est un pointeur vers un objet graphique existant (par exemple obtenu par un<code>get</code>, ou bien généré par un <code>scf</code>) ;
* <code>iscell(X)</code>, <code>iscellstr(X)</code>, <code>isstruct(X)</code> : vrai si la variable X est respectivement une cellule, une cellule de chaîne de caractères ou une structure (voir ''[[../Structures de données avancées|Structures de données avancées]]'') ; <code>isfield(S, nomduchamp)</code> vérifie si le champ ''nomduchamp'' (chaîne de caractères) existe dans la structure S, <code>isparam(nomliste, nomparam)</code> vérifie si le paramètre ''nomparam'' (chaîne de caractères) existe dans la liste ''nomliste''.

=== Vérifier le contenu de la variable ===

Rappelons les opérations de comparaison de valeurs : <code>==</code>, <code>&lt;</code>, <code>&lt;=</code>, <code>&gt;</code>, <code>&gt;=</code>. La commande <code>isequal(X1, X2, …, Xn)</code> est vraie si les ''n'' valeurs sont toutes égales.

Scilabe propose également les commandes :
* <code>isempty(X)</code> : vrai si la matrice ou la liste X est vide ;
* <code>isinf(X)</code>, <code>isnan(X)</code> : vérifie si la matrice X a des composantes infinies ou NaN.

=== Générer un message d'erreur ===

Lorsque l'on détecte un problème, on peut générer soi-même une erreur, avec la commande <code>error</code> (déjà présentée), ou bien un message d'avertissement, avec <code>warning('message')</code>.

On peut personnaliser le message en indiquant la valeur de la variable illégale. Pour cela, il faut soit composer une chaîne de caractères contenant la variable, par exemple
<syntaxhighlight lang="scilab">
texte_erreur = "fonction f : valeur de l''argument "+string(X)+" illégale.";
error(texte_erreur)
</syntaxhighlight>
ou bien utiliser les commandes de type « langage C », mais il faut alors être sûr du format de la variable :
<syntaxhighlight lang="scilab">
texte_erreur = "fonction f : valeur de l'argument %d illégale.";
error(msprintf(texte, X))
</syntaxhighlight>
Notons qu'un certain nombre de termes standard peuvent être traduits automatiquement selon la langue définie sur le système (paramètres de régionalisation, ''localisation'') ; la commande <code>getext()</code> permet de traduire automatiquement les termes, et d'adapter la typographie (par exemple, mettre une espace<ref>En typographie, le terme « espace » est au féminin lorsqu'il désigne un caractère « blanc ».</ref> devant les deux-points et points-virgules en français).

=== Dérouter une erreur ===

Pour « dérouter » une erreur, c'est-à-dire éviter que le programme ne s'interrompe, on utilise la fonctions <code>errcatch(-1)</code>. La fonction <code>iserror(-1)</code> permet ensuite de tester si une erreur est survenue. On peut ne s'intéresser qu'à un type d'erreur : <code>errcatch(n)</code> et <code>iserror(n)</code> (''n'' &gt; 0) pour l'erreur ''n'' (voir la ''[http://help.scilab.org/docs/5.4.0/fr_FR/error_table.html table des erreurs]'').

On peut indiquer à <code>errcatch</code> une action faire en cas d'erreur :
<syntaxhighlight lang="scilab">
errcatch(n, "action")
</syntaxhighlight>
où ''action'' vaut :
* <code>pause</code> : s'arrête et reste dans le contexte courant ; on peut utiliser <code>whereami()</code> pour connaître le contexte ; c'est le comportement le plus utile en phas ede développement/déverminage ;
* <code>continue</code> : l'erreur est ignorée et le programme continue ; il faut effacer l'erreur avec <code>errclear</code> le plus tôt possible (après <code>iserror</code>) ;
* <code>kill</code> : arrête l'exécution du programme et revient au niveau 0 (comportement normal) ;
* <code>stop</code> : quitte Scilab.

Enfin, on peut indiquer ce que doit faire Scilab en cas d'erreur de calcul, avec la commande <code>ieee</code> :
* <code>ieee(0)</code> : génère une erreur (comportement par défaut) ;
* <code>ieee(1)</code> : renvoit une valeur Inf ou Nan, et génère un avertissement ;
* <code>ieee(2)</code> : renvoit une valeur Inf ou Nan sans générer d'avertissement.

=== Encapsuler le code problématique ===

Certaines partie de code sont plus susceptibles que d'autre de produire des erreurs. C'est par exemple le cas d'une entrée-sortie hasardeuse — saisie au clavier, lecture d'un fichier volumineux —, ou bien de l'utilisation d'une opération instable — valeur pouvant provoquer un dépassement ou un soupassement… Pour gérer cette situation, on peut utiliser une structure <code>try-catch-end</code> :
* Scilab exécute le code entre les commandes <code>try</code> et <code>catch</code> ; si aucune erreur ne se produit, il va tout de suite après le <code>end</code> ;
* si une erreur se produit entre le <code>try</code> et le <code>catch</code>, il exécute directement les instructions entre le <code>catch</code>.

<syntaxhighlight lang="scilab">
try
  <instructions "normales">
catch
  <instructions exécutées en cas d'erreur>
end
[message_erreur, numero_erreur] = lasterror(%t) // enregistrement de l'erreur
<suite du script>
</syntaxhighlight>

Si le code problématique est court, on peut également l'encapsuler dans une comande <code>execstr()></code> avec l'option <code>"errcatch"</code>.

<syntaxhighlight lang="scilab">
numero_erreur = execstr("<instructions normales>", "errcatch", "message d.erreur")
</syntaxhighlight>

S'il n'y a pas d'erreur, le numéro d'erreur est 0.

== Bibliothèque de fonctions ==

Il est possible de créer une bibliothèque de fonctions ''(library)''. Cela permet à plusieurs programmes de partager les mêmes fonctions. L'avantage est double :
* on n'écrit qu'une seule fois les fonctions, ce qui réduit la taille du code source, et donc facilite sa lecture et sa maintenance ;
* lorsque l'on corrige une erreur ou que l'on améliore la fonction, cela profite à tous les programmes.
L'inconvénient est qu'une modification a un impact sur tous les programmes, ce qui peut obliger à une gestion des différentes versions d'une fonction. Cet inconvénient est aussi un avantage : une erreur dans une fonction va avoir un impact sur tous les programmes l'utilisant, donc va être détectée plus rapidement.

La bibliothèque peut aussi contenir des variables.

On peut simplement définir un fichier <code>.sci</code> et l'appeler avec <code>exec()</code> ou <code>getd()</code> comme indiqué précédemment. Mais Scilab fournit également une gestion spécifique des bibliothèques.

Le fait de recourir à une bibliothèque plutôt qu'à un fichier <code>.sci</code> permet entre autres de gérer des fonctions ayant le même nom, par exemple des fonctions réalisant la même chose mais avec un algorithme différent — on peut raisonnablement se demander l'intérêt de la chose, et souligner les problèmes que cela pose (est-on sûr de savoir exactement quelle fonction l'on utilise ?), mais c'est une possibilité. Par exemple, si l'on a une fonction <code>f()</code> définie dans deux bibliothèques <code>bib1</code> et <code>bib2</code>, on peut alors charger les deux bibliothèques et utiliser <code>bib1.f()</code> ou <code>bib2.f()</code> ; si l'on utilise <code>f()</code> tout court, c'est alors ''a priori'' la dernière bibliothèque chargée qui est utilisée.

=== Structure d'une bibliothèque ===

Pour Scilab, une bibliothèque est :
* un répertoire (ou dossier, ''directory''), contenant :
* un fichier <code>names</code> (sans extension de nom de fichier), qui est un fichier texte (ASCII) contenant le nom des différentes fonctions ; c'est en quelques sortes l'index de la bibliothèque ; ce fichier peut être créé par un éditeur de texte, ou bien par Scilab avec la fonction <code>mputl</code> ;
* un fichier pour chaque fonction ; le fichier porte le nom de la fonction auquel on ajoute l'extension <code>.bin</code> ; c'est un fichier binaire (compilé) créé par la fonction <code>save</code> de Scilab.

=== Création d'une bibliothèque ===

Le programme suivant :
* se place dans le répertoire <code>persolib</code> (déjà existant), les trois petits points désignant le début du chemin d'accès ;
* définit les fonctions <code>gauss</code> et <code>lorentz</code>, ainsi que la variable <code>unsurpi</code> ;
* crée les fichiers <code>gauss.bin</code>, <code>lorentz.bin</code> et <code>unsurpi.bin</code> dans ce répertoire, à partir des fonctions définies ;
* crée le fichier d'index <code>names</code>.

<syntaxhighlight lang="scilab">
// Création de la bibliothèque persolib

clear();

// **********
// Paramètres de la bibliothèque
// **********

cheminbiblio = ".../persolib/";

// **********
// Fonctions
// **********

function [y] = gauss(mu, sigma, x)
    // fonction gaussienne
    // mu : espérance
    // sigma : écart type
    y = 1/(sigma * sqrt(2*%pi))*exp(-1/(2*sigma^2)*(x - mu).^2)
endfunction

function [y] = lorentz(x0, Gamma, x)
    // fonction lorentzienne
    // x0 : position du sommet
    // mu : gamma : largeur à mi-hauteur (FWHM)
    HWHM = Gamma/2; // facilite l'expression
    y = ((HWHM)/%pi)*((x - x0).^2 + HWHM^2).^(-1)
endfunction

// **********
// Constantes
// **********

unsurpi = 1/%pi;

// **********
// Création de la bibliothèque
// **********

chdir(cheminbiblio)

// compilation et enregistrement des fonctions
save("gauss.bin", gauss)
save("lorentz.bin", lorentz)
save("unsurpi.bin", unsurpi)

// creation de l'index

mputl(["gauss" ; "lorentz" ; "unsurpi"], "names")
</syntaxhighlight>

=== Utilisation d'une bibliothèque ===

Le programme suivant :
* s'assure que toutes les variables sont effacées (<code>clear()</code>) ;
* déclare l'utilisation de la bibliothèque <code>.../persolib/</code>, et l'affecte à la variable <code>mabibliotheque</code> (fonction <code>lib</code>) ;
* utilise les fonctions et variables de la bibliothèque.

<syntaxhighlight lang="scilab">
// Utilisation de la bibliothèque persolib

clear();

// **********
// Paramètres de la bibliothèque
// **********

cheminbiblio = ".../persolib/";

// **********
// Déclaration et chargement de la bibliothèque
// **********

mabibliotheque = lib(cheminbiblio);

// **********
// Utilisation des fonctions
// **********

X = -3:0.1:3;
Yg = gauss(1,1,X);
Yl = lorentz(1,1,X);
plot(X,Yg)
plot(X,Yl)
disp(unsurpi)
</syntaxhighlight>

=== Commandes sur les bibliothèques ===

Si l'on tape simplement le nom de la variable dans laquelle on a déclarée la bibliothèque (ici <code>mabibliotheque</code>), Scilab retourne :
* le chemin d'accès ;
* la liste des fonctions.
La fonction <code>libraryinfo</code> a le même effet, mais permet de mettre les valeurs retournées dans des variables, par exemple avec
<syntaxhighlight lang="scilab">
[fcts, chem] = libraryinfo(mabibliotheque)
</syntaxhighlight>
la variable <code>fcts</code> est une matrice de chaînes de caractères contenant les noms des fonctions, et la variable <code>chem</code> est une chaîne de caractères contenant le chemin d'accès.

La fonction <code>isdef(mabibliotheque)</code> teste si la bibliothèque est déclarée.

La fonction <code>clear mabibliotheque</code> efface les fonctions et variables définies par la bibliothèque.

La fonction <code>whereis</code> indique dans quelle bibliothèque se trouve une fonction (mais pas une variable). Par exemple, <code>whereis(gauss)</code> retourne <code>mabibliotheque</code>.

La fonction <code>librarieslist</code> indique la liste des bibliothèques chargées.

== Lancement d'un programme ==

Un programme (fichier <code>.sce</code>) peut être lancé depuis Scinotes, en cliquant sur le menu '''Execute''' puis en choisissant '''Load into Scilab'''. On peut aussi utiliser la combinaison de touches <code>CTRL+l</code>.

On peut aussi l'exécuter à partir de l'interpréteur de commandes, avec <code>exec('nomprogramme.sce', -1)</code>. Le paramètre « -1 » permet de ne pas afficher les lignes exécutées.

== Optimisation d'un programme ==

Si un programme est destiné à traiter des données volumineuses, il devient important de s'intéresser à la durée d'exécution. Plusieurs outils permettent de comparer les durées d'exécution et ainsi de faire des choix entre plusieurs solutions possibles pour effectuer une tâche (réaliser une fonction, au sens large de fonctionnalité).

Tout d'abord, Scilab peut lire l'horloge du système. La commande <code>clock</code> retourne un vecteur ligne de 6 éléments indiquant :
# L'année.
# Le mois (1–12).
# Le jour du mois (1—31).
# L'heure (1–24).
# Les minutes dans l'heure (0–59).
# Les secondes dans la minute (0–59)<ref>les secondes sont un nombre entier, mais en raison de la représentation utilisée, il est possible que Scilab affiche un nombre décimal, avec des 9 ou des 0 jusqu'à la cinquième décimale.</ref>.
Mais cela ne permet d'avoir une précision que de la seconde. On peut avoir les millisecondes avec :
<syntaxhighlight lang="scilab">
instant = getdate();
instant(9) + instant(10)/1000
</syntaxhighlight>
en effet, la commande <code>getdate()</code> renvoie un vecteur dont la neuvième composante est la seconde (nombre entier entre 0 et 59) et la dixième composante est la milliseconde (nombre entier entre 0 et 999).

Scilab dispose également d'un chronomètre :
* la commande <code>tic()</code> déclenche le chronomètre ;
* la commande <code>toc()</code> indique la valeur du chronomètre.

L'exécution d'une fonction externe peut être caractérisé par son « profil ». Le profil est une matrice ayant le même nombre de lignes que la fonction (la 1{{re}} ligne est celle contenant la commande <code>function</code>). Pour chaque ligne, le profil contient 3 colonnes :
# Nombre de fois que la ligne exécutée.
# Durée d'exécution de la ligne, en seconde.
# « Effort » requis par l'interpréteur pour exécuter la ligne.
La commande <code>add_profiling("''nom_fonction''")</code> « prépare » la fonction : cette commande est nécessaire pour extraire ensuite le profil. La commande <code>profile(''nom_fonction'')</code> indique le « profile de la fonction ». 

La commande <code>showprofile(''nom_fonction'')</code> met en correspondance ces données et les instructions de la fonctions. La commande <code>plotprofile(''nom_fonction'')</code> synthétise le profil sous la forme d'un histogramme.

'''Conseils'''

Un programme rapide est un programme qui effectue peu d'opérations. Le premier point est donc d'utiliser un algorithme « économe ». Par exemple, pour le calcul de la valeur d'un polynôme, on utilisera la [[w:fr:Méthode de Ruffini-Horner|méthode de Horner]] ; dans le même ordre d'idées, pour calculer les carrés des éléments d'une matrice réelle, il vaut mieux utiliser <code>M.*M</code> que <code>M.^2</code>. L'algorithme le plus économe peut dépendre de la structure des données, c'est le cas notamment des algorithmes de tri — voir par exemple le [[w:fr:Tri par tas|tri par tas]] et le [[w:fr:Tri rapide|tri rapide]].

Certaines opérations sont plus gourmandes que d'autres ; pour de gros volumes de données, il peut être intéressant de ne pas utiliser l'écriture « naïve » de ce que l'on veut calculer. Par exemple, la division utilise plus d'opérations que la multiplication, ainsi, si l'on remplace<ref>voir le chapitre « Optimisation » (transparents 35 et suivants) de {{lien web
 | url = http://www-tech.crihan.fr/calcul/tech/documentation-ibm-cluster-idataplex-antares/formations/Formation_Antares.pdf
 | titre = Utilisation du cluster Antares
 | date = 2016-05 | consulté le = 2016-09-23
 | auteur1 = Patrick Bousquet-Mélou
 | format = pdf
 | site = CRIHAN
}}</ref>
: <math>\begin{cases}e = a/b \\ f = c/d\end{cases}</math>
par
: <math>\begin{cases}dn = 1/(b \times d) \\ e = a \times d \times dn \\ f = c \times b \times dn\end{cases}</math>
on remplace deux divisions par une division et cinq multiplications. Ceci est favorable pour de gros volumes de données, comme le montre l'exemple suivant

<syntaxhighlight lang="scilab">
// Génération des données
n = 9e5;
a = rand(n, 1);
b = rand(n, 1) + 1; // +1 garantit que l'on n'a pas de zéro
c = rand(n, 1);
d = rand(n, 1) + 1;

// Calcul naïf
tic();
e = a./b;
f = c./d;
t1 = toc();

// Calcul optimisé
tic();
dn = 1 ./(b.*d);
E = a.*d.*dn;
F = c.*b.*dn;
t2 = toc();

// Comparaison
disp(t1, t2);
</syntaxhighlight>
Par contre, les erreurs d'arrondis ne sont pas les mêmes, les résultats peuvent donc être légèrement différents, et il faut vérifier que cela ne cause pas d'erreur de dépassement.

Lorsque Scilab effectue un calcul, il commence par vérifier le type de données et les dimensions de la matrice sur laquelle il travaille — rappelons qu'un nombre est une matrice 1×1 —, afin de savoir comment il va mener le calcul ([[w:fr:Arbre de décision|arbre de décision]]). Par exemple, pour effectuer une addition <code>A+B</code>, Scilab effectue une dizaine d'opérations préalables<ref name="steer20130320">voir le {{en}} [http://mailinglists.scilab.org/Scilab-users-Regarding-simple-numerical-operations-result-display-tp4026274p4026307.html message de Serge Steer (INRIA)], 20 mars 2013 à 14h38, sur la discussion ''Regarding simple numerical operations result display'' de la liste de diffusion ''Scilab users''.</ref> :
# Allocation de mémoire pour <code>A</code>.
# Allocation de mémoire pour <code>B</code>.
# Détermination du type de données de <code>A</code> : matrice réelle ou complexe (type 1), matrice polynomiale (2), matrice booléenne (3), matrice creuse (4), matrice creuse booléenne (5), matrice de chaînes de caractères (10), …
# Détermination du type de données de <code>B</code>.
# Détermination de la dimension de la matrice <code>A</code>.
# Détermination de la dimension de la matrice <code>B</code>.
# Si <code>A</code> est une matrice réelle ou complexe, s'agit-il de nombre réels ou de nombres complexes ?
# ''Idem'' pour <code>B</code>.
# La mémoire libre est-elle suffisante pour contenir le résultat ?
Si l'on a des calculs répétitifs à faire, il vaut donc mieux mettre les données dans une matrice et effectuer le calcul sur la matrice : ainsi, les opérations de contrôle et de décision ne seront faites qu'une seule fois.

De manière générale, un calcul est plus long qu'une opération de lecture/écriture en mémoire. Ainsi, si un calcul est répété, on a intérêt à stocker son résultat dans une variable, en particulier s'il s'agit d'un calcul long (par exemple sur une matrice). Si par exemple on utilise plusieurs fois sin(π/3), on a intérêt à créer la variable
<syntaxhighlight lang="scilab">
sinPiSurTrois = sin(%pi/3)
</syntaxhighlight>
et à utiliser cette variable, plutôt que de calculer à chaque fois la valeur.

Dans un tableau (matrice), si l'on s'attend à ce que des valeurs volumineuses (par exemple des nombre à virgule flottante à double précision) soient déplacées plusieurs fois, on peut créer une matrice de correspondance entre indices (donc ne contenant que des entiers), et faire les transferts uniquement à la fin ; ainsi, les opérations de lecture/écriture fréquentes se font sur des données peu volumineuses.

On voit que l'optimisation consiste fréquemment à trouver un équilibre entre volume de données et durée des opérations. Si l'on génère trop de données intermédiaires (dépassant la capacité de la mémoire vive), cela oblige le système d'exploitation à avoir recours à de la mémoire virtuelle ''(swap)'' et donc à faire des opérations de lecture et écriture sur disque dur (ou mémoire flash) qui ralentissent l'exécution.

== Déverminage ==

Pour déverminer (« débugger ») un programme, on peut :
* mettre des fonctions <code>halt</code> dans le code, afin d'interrompre l'exécution à certain endroit pour effectuer des vérifications ; on relance le programme en appuyant sur la touche <code>[entrée]</code> dans l'invite de commande ;
* lancer le programme en mode 4 : <code>exec('nomprogramme.sce', 4)</code> ; le programme s'arrête à chaque ligne ; on relance le programme en appuyant sur la touche <code>[entrée]</code> dans l'invite de commande.

== Recommandations ==

Les « bonnes pratiques de programmation » ont pour but de faciliter la conception et la maintenance des programmes. Cela inclue la possibilité de reprendre des programmes plusieurs années après, de les adapter aux nouvelles versions des logiciels, de réutiliser des bouts de code dans d'autres programme, que d'autres personnes réutilisent le code, l'adapte, … bref créer du code directement réutilisable sans modification ''(boilerplate code)''. Rappelons que 80 % du coût d'un bout de programme réside dans la maintenance et qu'au bout d'un certain temps, cette maintenance n'est en général plus faite par l'auteur original du code<ref>[http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-139411.html#16712 Code Conventions for the Java Programming Language], Oracle</ref>.

Scilab est un langage de calcul ; ces calculs s'appliquent à divers domaines : mécanique, optique, thermique, électronique, traitement du signal, biologie, géophysique, économie, … En général, les utilisateurs sont des spécialistes du domaine d'application (physiciens, biologistes, économistes, …) mais ne sont ''pas'' des informaticiens. Cette section a donc pour but de leur apporter quelques outils simples facilitant la programmation.

{{loupe|Conseils de codage en C}}

'''Exemple'''

Pour illustrer les concepts, nous allons prendre un exemple : vous êtes chargé par une entreprise de mécanique, faisant de l'usinage, d'évaluer les défauts lors de la réalisation d'une forme circulaire. Le client de l'entreprise demande à ce que l'arête d'une pièce forme un cercle, et vous êtes chargé de valider le fait que les imperfections sont dans les tolérances admises. Vous avez pour cela un nuage de points (''x'', ''y'', ''z'') relevé sur la pièce réalisée.

=== Démarche projet ===

Un programme est un projet. On doit donc lui appliquer les outils classiques d'un projet. Cela ne signifie pas nécessairement qu'il faille produire une documentation — notons que les commentaires d'un programme (voir ci après) ''sont'' une documentation, et que certains outils permettent de les extraire —, mais simplement qu'il faut se poser des questions et y répondre avant de commencer.

==== Définir les objectifs ====

Un programme a un but, un objectif : il doit répondre aux attentes d'un utilisateur, qui est souvent le programmeur lui-même. Cette identité utilisateur = programmeur évite les incompréhensions liée à la transmission d'informations, mais peut mener à un manque de rigueur et donc à des difficultés.

[[Fichier:Diagramme APTE programme de calcul.svg|thumb|Définition des fonctions (besoins de l'utilisateur) pour un programme de calcul à l'aide d'un diagramme APTE : le programme doit calculer des résultats à partir de données et avec des options fixées par l'utilisateur. Pour certaines applications, il faut prendre en compte l'environnement (ordinateur, système d'exploitation).]]

La première étape consiste donc à recenser (par écrit ou dans sa tête) les besoins et l'objectif à atteindre. Pour un projet de calcul, c'est essentiellement :
* quelles sont les données d'entrée ;
* quels sont les options possibles ;
* quel est le résultat attendu.
Cette étape doit inclure des données de test permettant de valider le programme : on a des données pour lesquelles on connaît le résultat, ce qui permettra de vérifier que le programme fonctionne bien.

Dans des cas limites — par exemple gros volumes de données, ou bien si le programme doit communiquer avec d'autres dispositifs (comme des capteurs) —, il est nécessaire de prendre en compte l'environnement du programme :
* ordinateur : par exemple parallélisation sur plusieurs processeurs, gestion des limitations de la mémoire ;
* système d'exploitation : par exemple lecture et écriture de fichiers, appel à des fonctions système.

'''Exemple'''

Pour notre exemple, nous avons donc :
* données d'entrée :
** nuage de points (''x'', ''y'', ''z''),
** tolérances, à définir avec le client ;
* options : aucune ''a priori'' ;
* sortie : validation oui/non.
Cette petite étude formelle met une chose en évidence : la demande est incomplète, il faut connaître la nature des tolérances.

Après dialogue avec le chargé d'affaire de l'entreprise et/ou le client, la forme circulaire sert à positionner une pièce mâle de forme cylindrique. Ce qui importe pour le client est que :
* l'axe du cylindre soit « bon », c'est-à-dire que l'angle que fait l'axe du cylindre avec la surface soit « à peu près » {{unité|90|°}}, avec une tolérance d'orientation ε<sub>o</sub> = {{unité|1|'}} ;
* le cylindre soit « bien positionné », c'est-à-dire que la distance entre le centre réel et le centre théorique soit inférieur à une valeur ε<sub>p</sub> = {{unité|0.1|mm}} (tolérance de position) ;
* l'appuis du cylindre sur le cercle « soit bon », c'est-à-dire que la forme ne soit « pas trop éloignée » d'un cercle parfait (quel qu'il soit) afin d'assurer un bon contact ; l'écart entre chaque point et le cercle théorique doit être inférieur à une valeur ε<sub>f</sub> donnée (tolérance de forme) à la fois axialement (écart perpendiculairement au plan) et radialement (écart dans le plan).
Le cahier des charges est validé par les parties (programmeur, chargé d'affaire, client).

Pour les tests, nous prévoyons de créer des données factices correspondant à un cercle parfait auquel on ajoute des défauts maîtrisés. Nous prévoyons un exemple devant passer le test en ayant des défauts justes inférieurs à la limite (mettons à 1 %), trois exemples ayant des défauts justes supérieurs à la limite (1 % également), chacun pour un type de défaut (orientation du plan, position du centre, écart à la circularité) et un exemple ayant les trois défauts.

==== Chercher des solutions ====

La deuxième étape consiste à rechercher les solutions. Cela peut être une recherche bibliographique : trouver un algorithme adapté, ou un programme déjà existant et faisant globalement la même chose. Cela peut aussi être le développement de solutions originales. À l'issue de cette étape, il faut choisir la solution appliquée.

Une méthode consiste à partir du besoin exprimé sous la forme de fonctions, une fonction étant un verbe à la forme active avec un sujet et un complément. Cette fonction peut être découpée en sous-fonctions, et l'on continue ce découpage jusqu'à arriver à des fonctions élémentaires faciles à coder (que l'on sait réaliser d'une ou plusieurs manières). Voir ''[[wikiversity:fr::Introduction à la science des matériaux/Choix d'un matériau#Analyse fonctionnelle|Analyse fonctionnelle]]''.

Le choix de cette solution est critique car il conditionne tout le reste. Il ne peut être pertinent que si les objectifs sont clairs. Notons que l'on peut dans un premier temps retenir une solution peu performante mais facile à programmer, ce qui permet d'avoir rapidement un résultat et avec moins de risques d'erreur ; puis, par la suite, développer une autre solution plus performante, la première solution servant de référence. La programmation modulaire (fractionnement en fonctions) facilite cette démarche : il suffit d'écrire une nouvelle fonction (sous-programme) ayant le même nom que l'ancienne, et de renommer l'ancienne fonction pour se laisser la possibilité de revenir en arrière.

'''Exemple'''

Les fonctions que l'on peut dégager sont :
* f1 : le programme lit les données ;
** f1a : le programme lit les données dans un fichier,
*** f1a.1 : l'utilisateur indique quel fichier lire,
*** f1a.2 : le programme ouvre le fichier et importe les données,
*** f1a.3 : si nécessaire, le programme transforme les données en nombres ;
** f1b : l'utilisateur saisit manuellement les données,
** f1c : le programme lit les données directement de l'appareil de mesure ;
* f2 : le programme prend une décision :
** f2.1 : le programme représente le cercle sous une forme exploitable numériquement,
** f2.2 : le programme traite les données,
*** f2.2.1 : le programme détermine les écarts par rapport à la géométrie idéale,
*** f2.2.2 : le programme détermine si les écarts sont compatibles avec les tolérances ;
* f3 : le programme édite un rapport ;
* f4 : le programme est ergonomique : il est accessible aux connaissance de l'utilisateur,

On s'aperçoit que la fonction f1 peut être réalisée de trois manières très différentes (f1a, f1b et f1c) et que la fonction f4 dépend de qui va être chargé de mettre en œuvre le programme, il faut donc éclaircir ces points avec les personnes responsables des mesures.

Concernant la fonction f2.1 « le programme représente le cercle sous une forme exploitable numériquement » : dans l'espace, une courbe simple peut être définie par une équation ƒ(''x'', ''y'', ''z'') = 0. Il faut donc chercher dans la bibliographie (ou dans ses souvenirs) quel type de fonction décrit un cercle. Deux solutions sont possibles :
* chercher une fonction dans l'espace ;
* décomposer le problème en deux parties, la première consistant à cherche le « plan le plus proche » du nuage de point, et ensuite travailler dans ce plan avec une fonction plane ƒ(''x''{{'}}, ''y''{{'}}).
Concernant la première solution, il apparaît que le cercle est l'intersection d'une sphère et d'un plan, qui dans l'idéal passe par le centre de la sphère, on peut donc définir assez facilement le cercle par un système d'équations : si l'on appelle (''x''<sub>0</sub>, ''y''<sub>0</sub>, ''z''<sub>0</sub>) les cordonnées du centre et R le rayon, alors
: <math>\begin{cases}(x - x_0)^2 + (y - y_0)^2 + (z - z_0)^2 - \mathrm{R}^2 = 0 \\
ax + by + cz + d = 0 \\
ax_0 + by_0 + cz_0 + d = 0 \end{cases}</math>

Pour la deuxième solution, il faut déterminer un plan
: <math>ax + by + cz + d = 0</math>
puis un repère <math>(\mathrm{O}', \vec{\imath}', \vec{\jmath}')</math> dans ce plan, et donc l'équation du cercle
: <math>(x' - x_0')^2 + (y' - y_0') - \mathrm{R}^2 = 0</math>.

Concernant la fonction f2.2.1 « le programme détermine les écarts par rapport à la géométrie idéale », il apparaît que le problème présente deux « échelles » :
* une échelle globale : la forme usinée est « globalement » un cercle, qui impose une position et une direction à l'axe du cylindre ;
* une échelle locale : la forme usinée présente des écarts « locaux » avec un cercle idéal.
On voit donc qu'il faut déterminer dans un premier temps le cercle « parfait » le plus proche possible des points mesurés, et :
* vérifier que les caractéristiques de ce cercle global soient compatibles avec les tolérances d'orientation et de position ;
* vérifier que l'écart entre les points et le cercle global soient compatibles avec la tolérance de forme.
Il faut donc passer par une étape de régression pour déterminer le cercle global. Dans le cas d'une description par l'intersection d'une sphère et d'un plan, la régression consiste à déterminer huit facteurs (''x''<sub>0</sub>, ''y''<sub>0</sub>, ''z''<sub>0</sub>, R, ''a'', ''b'', ''c'', ''d''), mais on a une équation liant trois facteurs, ce qui ramène à sept l nombre de facteurs indépendants. Dans le cas de la seconde description, on n'a que sept facteurs à déterminer (''x''{{'}}<sub>0</sub>, ''y''{{'}}<sub>0</sub>, R, ''a'', ''b'', ''c'', ''d''), mais on rajoute une étape de projection des points sur le plan.

Nous nous orientons vers la seconde description,en deux étapes, qui permet de séparer la résolution en deux étapes élémentaires.

La recherche bibliographique sur la [[w:régression circulaire|régression circulaire]] nous indique qu'il y a deux types d'algorithmes :
* la régression par la méthode des moindres carrés, qui impose une régression non-linéaire et qui est sensible aux points aberrants ;
* des méthodes de régression linéaire, mais qui n'appliquent pas la méthode des moindres carrés.
Il y a peu de risque d'avoir des points aberrants(sauf erreur de mesure), mais les méthodes linéaires sont plus rapides et plus stables : les méthodes non-linéaires sont itératives, donc gourmandes en ressources et peuvent éventuellement diverger. Comme nous ne cherchons pas à déterminer un loi statistique, le fait que l'on ne minimise pas l'écart quadratique (donc l'écart type empirique) n'a pas d'importance. Nous retenons donc une méthode linéaire, celle de Kåsa et Coope.

==== Déterminer la structure du programme ====

La troisième étape consiste à déterminer la structure du programme, son architecture. L'organisation des modules (fonctions) est obtenue à partir de l'analyse fonctionnelle. Il faut également choisir la structure des données (vecteur, matrice, liste, …) et déterminer des test permettant de savoir si chaque module fonctionne.

Les modules doivent être ''hiérarchisés'', ainsi :
* on sait quoi développer en premier, ce qui permet de fournir un programme partiel mais fonctionnel (délais courts, version de test, mode dégradé) ;
* on sait sur quels modules on doit concentrer ses moyens (temps passé en programmation et tests).
Typiquement, l'interface avec l'utilisateur peut être importante, en particulier si le programme doit être utilisé par quelqu'un « n'y connaissant rien », mais doit être développée à la fin, lorsque le programme fonctionne.

Rappelons-le, ces trois étapes ne sont pas nécessairement formalisées. Elles ne se font pas non plus nécessairement d'un bloc avant de commencer à programmer : les besoins exprimés peuvent changer en cours de projet, on peut découvrir de nouvelles solutions, … C'est donc un processus dynamique.

'''Exemple'''

Ici, nous avons une structure assez simple, linéaire :
# chargement des donnée (f1, f4),
#* structure des données :
#** entrée : pour le fichier lu, à voir avec l'utilisateur et en particulier le logiciel générant les données ; dans un premier temps, nous utiliserons un format <code>.csv</code> (format texte facile à manipuler, de nombreux logiciels permettent l'export vers ce format), mais attention au séparateur utilisé ;
#** sortie : en interne, les données sont stockées dans un vecteur de réels codés en [[w:IEEE 754|double précision]],
#* test : créer un fichier afficher les données
# détermination du plan global par régression linéaire (f2.2.1),
#* structure des données :
#** entrée : une matrice de réels ''n'' × 3, la ligne ''i'' correspondant au point ''i'' et la colonne ''j'' à sa coordonnée (1 → ''x'', 2 → ''y'', 3 → ''z''),
#** sortie : le plan est représenté par son équation cartésienne ''ax'' + ''by'' + ''cz'' + ''d'' = 0, donc par un vecteur A = (''a'', ''b'', ''c'', ''d''),
#* test : créer des points suivant un plan connu et en ajoutant des variations (du « bruit ») de faible amplitude, et vérifier que la procédure retrouve des valeurs proches des valeurs initiales pour A ;
# détermination d'un repère orthonormé direct lié au plan (f2.2.1),
#* structure des données :
#** entrée : un vecteur colonne de réels de dimension 3, composantes d'un vecteur normal au plan, N,
#** sortie : le R.O.N.D. est constitué de trois vecteurs colonne réels de dimension 3, X1, X2 et X3, le vecteur X3 étant normal au plan,
#* test : à partir des données précédentes, vérifier que le repère est bien orthonormé direct et que X3 est bien normal au plan ;
# changement de repère des points expérimentaux (f2.2.1) ;
# détermination du cercle global par régression linéaire (méthode de Kåsa et Coope) (f2.1, f2.2.1) ;
# évaluation de l'écart angulaire de l'axe du cercle (f2.2.1) ;
# évaluation de l'écart de la position du centre du cercle (f2.2.1) ;
# évaluation de l'écart des points par rapport au cercle global (f2.2.1) ;
# décision par rapport aux tolérances (f2.2.2) ;
# création du rapport (f3, f4).
Les modules 2 à 8 sont incontournables. Par contre, les modules 1 et 9, correspondant aux interaction avec l'utilisateur, peuvent être réduit au minimum dans une première phase.

==== Écrire le programme, le tester et le maintenir ====

La quatrième étape consiste à faire du codage unitaire : on code chaque fonction, chaque module. On vérifie que chaque fonction remplit bien son rôle, avec des données de test unitaire.

La cinquième étape consiste à intégrer les fonctions, à les mettre dans un même programme. On vérifie que l'on transmet bien les bonnes données aux bonnes fonctions.

La sixième et dernière étape consiste à vérifier que le programme fini fonctionne bien, grâce au données de test établies à la première étape, et qu'il ''remplit bien les besoins'' de l'utilisateur (qu'il suit le cahier des charges).

Là encore, ces trois étapes se font souvent de manière dynamique voire simultanée : au sein du programme, on écrit une nouvelle fonction, on la teste (test unitaire et test d'intégration), puis on passe à la fonction suivante. Mais on n'oubliera pas la hiérarchisation : les premières fonctions développées ne sont pas les premières à être utilisées chronologiquement dans le programme, mais les fonctions les plus importantes (le moteur avant l'interface).

Dernière étape ? En fait non, il reste l'étape la plus longue et la plus difficile : la maintenance, la correction des erreurs qui se révèlent lors des utilisations (déverminage). Cela commence par le nettoyage du code : on retire les morceaux de code obsolètes (« bouts d'essai »).

==== Bilan ====

La démarche globale est donc :
# Définition des besoins de l'utilisateur (cahier des charges) : données d'entrée, option, résultat attendu. Choix de données de test.
# Analyse fonctionnelle : découpage en fonctions. Recherche de solutions (sélection d'algorithmes).
# Organisation des modules du programme. Hiérarchisation. Choix de la structure de données.
# Codage et test unitaire des fonctions, en suivant l'ordre hiérarchique.
# Intégration des fonctions au sein du programme et tests d'intégration (échange de données entre les fonctions)
# Test du programme fini avec les données de test. Vérification que le programme répond bien aux besoins (cahier des charges).
# Nettoyage du code. Maintenance.

Pour des projets importants et devant être formalisés, on pourra par exemple s'intéresser au [[wikipedia:fr:Cycle en V|modèle en V]].

=== Structure générale du script ===

On recommande de mettre la plupart du code dans des fonctions ; le « programme principal », c'est-à-dire ce qui n'est pas dans les fonctions, devrait essentiellement se réduire à la définition des données de base et à l'appel des différentes fonctions. Un script a typiquement la forme suivante

<syntaxhighlight lang="text">
Bloc de commentaires :
    nom du script
    versions du script, dates, auteurs
    version de Scilab utilisée, modules Atoms utilisés
    Objectif du script : fonctions qu'il rempli, son but, son rôle
    entrées et sorties : saisies clavier, affichages, fichiers, formats

Commandes préliminaires
    préparation de l'environnement
    p. ex. clc(), imports (input()) …

Constantes
    définition de variables constantes

Fonctions
    définition des fonctions

Programme principal
    appel des fonctions
</syntaxhighlight>

Par ailleurs, les fonctions ne devraient pas être trop longues, typiquement une page d'écran maximum (environ 80 lignes) ; au-delà, il convient de scinder la fonction en plusieurs sous-fonctions. Elles ne devraient pas utiliser plus de 5 ou 10 variables locales<ref>le cerveau humain est capable d'appréhender 5 à 9 objets en même temps, selon l'état de fatigue, de concentration, … voir {{article
 | prénom1 = George Armitage | nom1 = Miller | lien auteur1 = w:fr:George Armitage Miller
 | titre = [[w:fr:Le nombre magique sept, plus ou moins deux|The magical number seven, plus or minus two]]
 | sous-titre = Some limits on our capacity for processing information
 | langue = en
 | année = 1956
 | périodique = Psychological Review
 | volume = 63
 | numéro = 2
 | passage = 81–97 
 | url texte = http://psychclassics.yorku.ca/Miller/
}}</ref> ; au-delà, il faut repenser la fonction, par exemple la scinder.

Le code doit être
* explicite ;
* aéré ;
* en alinéa ;
* abondamment commenté ;
* fractionné ;
* général.
Voir ''[[wikipedia:fr:Analyse statique de programmes|Analyse statique de programmes]]''.

=== Du code explicite … ===

Il faut utiliser les noms de fonctions et de variable voulant dire quelque chose. '''Les noms ne doivent contenir que des caractères alphanumériques''' (en particulier ''pas'' de tiret de soulignement ''« {{lang|en|underscore}} »''), et si possible même que des lettres non accentuées (les chiffres sont déconseillés) ; '''ils doivent commencer par une lettre en minuscule'''<ref>{{harvsp|ConvScilab|2010}}</ref>.

On peut utiliser des noms « bidons » (comme <code>toto</code>, <code>foo</code>) pour des variables utilisées sur de petites portions de programme. On utilise aussi fréquemment des noms « standard » : <code>x</code> (abscisse, inconnue d'une équation, variable d'une fonction), <code>i</code> (nombre entier évolutif : indice, compteur), <code>n</code> (nombre entier constant : quantité), …

Si l'on travaille en équipe, il est recommandé d'utiliser une nomenclature systématique (voir ''[[w:fr:Convention de nommage|Convention de nommage]]''). D'un point de vue de la forme, on peut par exemple recommander de former les noms de variable à partir de mots ; chaque changement de mot est indiqué par une capitale, les autres lettres étant en minuscules (<code>maVariableAvecUnNomExplicite</code>). Concernant la composition du nom, on peut si nécessaire spécifier le type de variable (« matrice de réels », « vecteur ligne de chaînes de caractères », …) en début ''ou'' en fin de nom (mais toujours au même endroit), selon une convention commune (voir ''[[w:fr:Notation hongroise|Notation hongroise]]'').

=== … Aéré … ===

Il faut se limiter à une seule commande par ligne, voire plusieurs lignes pour une commande si la syntaxe est longue (utilisation de trois points <code>...</code>), la coupure se faisant après une virgule ou avant un opérateur. La longueur d'une ligne ne devrait pas dépasser 80 caractères (l'éditeur SciNotes matérialise d'ailleurs cette limite). Mais l'on peut à l'inverse envisager de mettre deux commandes courtes et s'articulant sur une même ligne.

Par ailleurs, on laisse un ligne vide au sein d'une fonction pour séparer les grands blocs, et on laisse deux lignes vides entre les fonctions.

=== … En alinéa (« indenté ») … ===

Des blancs en début de ligne marquent l'imbrication des commandes, en particulier à l'intérieur des délimiteurs de fonctions (<code>function … endfunction</code>), de boucles (<code>for … end</code>, <code>while … end</code>) et des exécutions conditionelles (<code>if … then … else … end</code>). Par défaut, l'éditeur de Scilab (SciNotes) crée des alinéas de quatre espaces.

=== … Abondamment commenté … ===

Chaque fonction doit comprendre une introduction (commentaires) expliquant ce qu'elle fait, la nature des variables qui lui sont passées et la nature des variable en sortie — ce qu'elles signifient et le type qu'elles doivent avoir (précondition à l'exécution de la fonction, voir ''[[:w:fr:Programmation par contrat|Programmation par contrat]]''). Les grandes étapes de la fonctions doivent être indiquées par des commentaires.

De manière générale, les commentaires doivent donner un aperçu du code, les informations nécessaire à l'utilisation du code ainsi que celle relatives à la lecture et à la compréhension du code, et les raisons du choix d'une solution si son choix n'est pas trivial. Par contre, on évite de commenter ce qui est évident dans le code, ainsi que ce qui risque de devenir obsolète lorsque le code évolue.

Une ligne de commentaire commence par <code>//</code> (deux barres de fraction). Depuis la version 6.0.0, il est possible d'avoir des blocs de commentaire, c'est-à-dire un commentaire écrit sur plusieurs lignes sans avoir à commencer chaque ligne par la double barre de fraction : un bloc de commentaire commence par <code>/*</code>  (barre de fraction-astérisque) et se termine par <code>*/</code> (astérisque-barre de fraction).
<syntaxhighlight lang="scilab">
// Voici une ligne de commentaire

/* Voici un bloc de commentaire
c'est-à-dire un commentaire
écrit sur plusieurs lignes */
</syntaxhighlight>

=== … Fractionné … ===

Comme signalé plus haut, le code doit être découpé en fonction de moins de 80 lignes. Le programmeur doit tant que faire se peut utiliser des variables locales. À l'exception de quelques variables très générales, essentiellement des constantes, toutes les variables utilisées par une fonction doivent être définies dans la fonction, ou bien transmises comme paramètre.

Outre la facilité de maintenance, le fait de mettre du code dans des fonctions accélère l'exécution d'un script. En effet, les fonctions sont compilée en code intermédiaire ''(bytecode)'' ; cette opération — automatique — de compilation consiste d'une part à vérifier que la syntaxe est correcte, et d'autre part réorganise les commandes en [[w:fr:Notation polonaise inverse|notation polonaise inverse]], mieux adaptée à l'exécution (qui passe par une [[w:fr:Pile (informatique)|pile]])<ref name="steer20130320" />.

Si certaines fonctions sont très générales, elle méritent de figurer dans un fichier <code>.sci</code> à part, appelé par la commande <code>exec()</code>, voire dans une bibliothèque (voir ci-dessus).

=== … Et général ===

De manière plus spécifique, pour Scilab, on peut recommander de faire des fonctions les plus générales possibles. Par exemple, une fonction numérique devrait être capable de traiter un nombre, mais aussi une matrice ; on peut ainsi définir un ensemble de définition de type <code>X = 0:0.01:1;</code> et appliquer directement <code>f(X)</code>. Si l'on a une fonction de deux variables X et Y, on peut générer deux matrices « grille » et ainsi avoir une carte de résultats f(X, Y), avec la fonction <code>ndgrid()</code> (grille à ''n'' dimensions) :
<syntaxhighlight lang = "scilab">
X = vx1:pasx:vx2;
Y = vy1:pasy:vy2;

[X_matrice, Y_matrice] = ndgrid(X, Y);


f(X_matrice, Y_matrice)
</syntaxhighlight>
On a ainsi
 X_matrice = [X(1) X(1) … X(1)
              X(2) X(2) … X(2)
               …    …   …  …  
              X(m) X(m) …  X(m)]

 Y_matrice = [Y(1) Y(2) … Y(n)
              Y(1) Y(2) … Y(n)
               …    …   … Y(n)
              Y(1) Y(2) … Y(n)]

 f(X_matrice, Y_matrice) = [f(X(1),Y(1)) f(X(1),Y(2)) … f(X(1),Y(n))
                            f(X(2),Y(1)) f(X(2),Y(2)) … f(X(2),Y(n))
                                  …            …      …       …
                            f(X(m),Y(1)) f(X(m),Y(2)) … f(X(m),Y(n))]

À titre d'exercice, on peut chercher comment soi-même cette fonction.

{{boîte déroulante
 | titre = Génération de grilles
 | contenu =
Considérons que l'on a deux vecteurs ligne X = [X(1), X(2), …] et Y = [Y(1), Y(2), …], obtenus avec la commande <code>linspace()</code> ou la syntaxe <code>v1:p:v2</code>. On peut utiliser le programme suivant :

<syntaxhighlight lang="scilab">
taille_X = size(X, "c");
taille_Y = size(Y, "c");

X_matrice = X'*ones(taille_Y, 1);
Y_matrice = ones(1, taille_X)*Y;

f(X_matrice, Y_matrice)
</syntaxhighlight>
}}


S'il n'est pas possible de créer une fonction gérant les matrices (ou si l'on n'y arrive pas), on peut toujours utiliser « l'évaluation de groupe » <code>feval(X, f)</code> à la place de <code>f(X)</code>.

La manière la plus simple de créer une fonction pouvant agir sur une matrice consiste à faire défiler les indices, par exemple :
<syntaxhighlight lang = "scilab">
function [y]=carre(x)
    // calcule le carré des composantes d'une matrice
    // entrées : x : matrice de nombres
    // sorties : y : matrice de nombres
    [imax, jmax] = size(x);
    for i = 1:imax
        for j = 1:jmax
            y(i,j) = x(i,j)^2;
        end
    end
endfunction
</syntaxhighlight>
ainsi, si l'on transmet un vecteur, <code>imax</code> ou <code>jmax</code> vaudra 1, et si l'on transmet un nombre unique (scalaire), les deux vaudront 1. Mais l'utilisation de boucle ralentit considérablement l'exécution du programme. On peut souvent utiliser le fait que Scilab est fait pour travailler avec des matrices, par exemple  utiliser les versions « pointées » des opérateurs :
<syntaxhighlight lang = "scilab">
function [y]=carre(x)
    // calcule le carré des composantes d'une matrice
    // entrées : x : matrice de nombres
    // sorties : y : matrice de nombres
    y = x.^2;
endfunction
</syntaxhighlight>
Rappelons de manière utile que l'inverse peut s'obtenir par <code>.^(-1)</code> ou par <code>1 ./</code> (bien respecter l'espace entre le 1 et le point), la racine carrée par <code>.^(0.5)</code> ou <code>sqrt()</code> ; les racines n-ièmes par <code>.^(1/n)</code> ou <code>nthroot(x, n)</code>. D'autre part, la plupart des fonctions primitives s'appliquent aux matrices (par exemple <code>exp()</code>, <code>sqrt()</code>, …). Par ailleurs, nous avons vu [[#Optimisation d'un programme|précédemment]] qu'un calcul effectué sur une  matrice est plus rapide qu'un calcul effectué successivement sur chacun de ses éléments (en raison des opérations préliminaires au calcul). Pour une question de rapidité, il vaut donc mieux favoriser les calculs globaux sur des matrices que des calculs en faisant défiler les indices.

On peut utiliser de manière « intelligente » les raccourcis d'indice (<code>:</code>, <code>$</code>), ainsi que la possibilité d'extraire certains indice en utilisant une matrice booléenne. Dans l'exemple suivant<ref>le code a été amélioré grâce à [http://mailinglists.scilab.org/Scilab-users-Conditional-assignments-tp4026572p4026573.html  Stefan Du Rietz]</ref>, nous définissons une fonction ayant une formule différente à gauche et à droite d'une valeur ''x''<sub>0</sub> ; il s'agit d'un pic dissymétrique, formé de deux demies gaussienne de même moyenne et même hauteur, mais de largeurs différentes.

<syntaxhighlight lang="scilab">
function [y] = gauss_dissym(A, x)
    // génère un pic gaussien dissymétrique
    // entrées : A(1) : position du pic
    //     A(2) : hauteur de la courbe
    //     A(3) : largeur de la courbe à gauche
    //     A(4) : largeur de la courbe à droite
    //     x : vecteur de nombres
    // sorties : y : vecteur de nombres
    indice = (x < A(1)); // vecteur de %t à gauche, %f à droite
    y = zeros(x); // initialisation
    y(indice) = A(2)*exp(-(x(indice) - A(1)).^2/A(3)); // profil gauche
    y(~indice) = A(2)*exp(-(x(~indice) - A(1)).^2/A(4)); // profil droit
endfunction
</syntaxhighlight>

On peut ainsi l'utiliser avec un nombre unique
<syntaxhighlight lang="scilab">
A = [3, 2, 1.5, 2.5];
y = gauss_dissym(A, 2.5)
</syntaxhighlight>
ou bien avec un vecteur
<syntaxhighlight lang="scilab">
A = [3, 2, 1.5, 2.5];
X = 0:0.1:6;
plot(X, gauss_dissym(A, X))
</syntaxhighlight>

De manière plus générale, considérons une fonction de deux variables, définie de manière différente à gauche et à droite pour x ; donc concrètement deux fonctions f<sub>g</sub>(''x'', ''y'') et f<sub>d</sub>(''x'', ''y''). Nous voulons l'évaluer sur deux vecteurs à partir desquels on crée deux matrices grille (voir plus haut). On peut utiliser la solution suivante :
<syntaxhighlight lang="scilab">
function [z] = f(A, x, y)

indice = (x < A); // vecteur de %t à gauche, %f à droite
z = zeros(x, y); // initialisation
z = fg(x, y)*bool2s(indice)
z = z + fd(x, y)*bool2s(~indice)
</syntaxhighlight>

Enfin, on peut transmettre une fonction en paramètre à une autre fonction. Dans l'exemple ci-dessous, nous appliquons la fonction <code>derivation</code> à deux fonctions différentes (il existe une fonction <code>derivative()</code> qui remplit parfaitement ce rôle ; le code suivant n'est donné qu'à titre d'illustration).

<syntaxhighlight lang="scilab">
//============================================================================
// nom : carre_inverse_derivee.sce
// auteur : Christophe Dang Ngoc Chan
// date de création : 2012-10-20
// dates de modification : 
//   2013-07-08 : ajout de xtitle dans les tracés
//      guillemets ' -> "
//   2018-05-28 : ajout de scf(0), suppr. de clear
//----------------------------------------------------------------------------
// version de Scilab : 5.3.1
// module Atoms requis : aucun
//----------------------------------------------------------------------------
// Objectif : Tracer les fonction carré et inverse, ainsi que leurs dérivées
// Entrées : aucune (paramètres en dur)
// Sorties : fenêtre graphique avec 4 tracés
//============================================================================

// **********
// Initialisation
// **********

scf(0);
clf;


// **********
// Constantes
// **********

deltax = 1e-6; // précision pour la dérivation


// **********
// Fonctions
// **********

function [y]=carre(x)
    // calcule le carré des composantes d'une matrice
    // entrées : x : matrice de nombres
    // sorties : y : matrice de nombres
    y = x.^2;
endfunction


function [y]=inverse(x)
    // calcule l'inverse des composantes d'une matrice
    // entrées : x : matrice de nombres
    // sorties : y : matrice de nombres
    y = x.^(-1);
endfunction


function [yprime] = derivation (f, x, epsilon)
    // calcule la dérivée aprochée de la fonction f
    // entrées : f : fonction
    //     x : ensemble de définition (matrice de nombres)
    //     epsilon : nombre positif, normalement petit,
    //         mais pas trop pour éviter les erreurs de soupassement
    // sorties : yprime : matrice de nombres
    yprime = 1/(2*epsilon)*(f(x+epsilon) - f(x-epsilon));
endfunction


// **********
// Programme principal
// **********

// Génération des données

X = [1:0.1:10];
Y1 = carre(X);
Yprime1 = derivation(carre, X, deltax);

Y2 = inverse(X);
Yprime2 = derivation(inverse, X, deltax);

// Tracé

subplot(2,2,1)
plot(X, Y1, "b")
xtitle("$f(x) = x^2$", "x", "y")
subplot(2,2,3)
plot(X, Yprime1, "b")
xtitle("$f''(x)$", "x", "y")

subplot(2,2,2)
plot(X, Y2, "r")
xtitle("$y = g(x) = 1/x$", "x", "y")
subplot(2,2,4)
plot(X, Yprime2, "r")
xtitle("$y = g''(x)$", "x", "y")
</syntaxhighlight>

=== Relecture de code ===

Une manière simple de s'assurer de la rigueur dans l'application des règles consiste à relire le code, voire à le faire relire par un tiers (voir ''[[wikipedia:fr:Revue de code|Revue de code]]''). La relecture de code consiste à s'assurer que les règles énoncées — découpage en fonctions de moins de 80 lignes et ayant moins de 10 variables locales, non recours à des variables globales, respect identations, commentation du code, … — sont bien vérifiées ''et c'est tout'' (mais c'est déjà beaucoup) !

En particulier, il serait illusoire, et contre-productif car décourageant, d'espérer comprendre ''rapidement'' un code qu'un auteur a mis plusieurs jours voire semaines à écrire. Par contre, on peut relever les endroits où l'auteur a été peu rigoureux — typiquement, des endroits où il y a eu beaucoup d'essais-erreurs, des modifications vites faites (correction de petites erreurs, petits ajouts).

== Distribuer un exécutable ==

Un auteur peut vouloir distribuer un exécutable, par exemple pour avoir une utilisation transparente de Scilab, ou encore pour masquer un script afin que l'on ne puisse pas le lire, pour garder confidentiel un algorithme. On peut pour cela utiliser la fonction <code>SendScilabJob</code> au sein d'un programme C/C++. Cela fait appel à l'API <code>call_scilab</code>.

Au sein d'un programme C/C++, le code Scilab est alors mis dans une chaîne de caractères, puis envoyé au moteur Scilab par la commande <code>SendScilabJob</code>. Le programme C/C++ peut ensuite être compilé.

On peut également utiliser SWIG<ref>http://swig.org/</ref> ''({{lang|en|Simplified Wrapper and Interface Generator}})'' pour interfacer C/C++ avec Scilab.

Le module Atoms <code>scetoexe</code> fournit une commande <code>scetoexe_generate()</code> permettant d'encapsuler un script Scilab dans un exécutable Microsoft Windows. Cependant, l'exécution fait appel à Scilab, il ne s'agit pas d'un programme indépendant.

Le module Atoms <code>Scilab 2 C</code> permet de convertir le script Scialb en C. Ce code peut ensuite être compilé.

La société Equalis distribue l'extension (payante) WildCruncher pour son logiciel (payant) Pro Plus, qui permet de générer du code C à partir du script Scilab puis de le compiler pour obtenir un exécutable [http://www.equalis.com/?page=CoderAndCompiler].

== Exemples ==

Voici quelques exemples de programmes complets mettant en œuvre des algorithmes simples.

=== Crible d'Ératosthène ===

Le programme suivant détermine la liste des nombres premiers inférieurs à une valeur donnée, appelée ici <code>maximum</code>, en utilisant l'algorithme du [[w:fr:Crible d'Ératosthène|crible d'Ératosthène]].

<syntaxhighlight lang="scilab">
//============================================================================
// nom : crible_eratosthene.sce
// auteur : Christophe Dang Ngoc Chan
// date de création : 2012-10-16
// dates de modification : 
//   2013-07-08 : floor -> uint32 (pour diminuer la taille nécessaire)
//      guillemets ' -> "
//   2014-05-14 : uint8 (pour diminuer la taille nécessaire)
//   2018-01-02 : indices() booléen
//      imax évalué à la volée et non pas par la racine carrée
//         (plus respectueux de l'algorithme initial)
//      élimination d'une boucle
//   2018-02-04 : correction : 1 n'est pas premier
//----------------------------------------------------------------------------
// version de Scilab : 6.0.0
// module Atoms requis : aucun
//----------------------------------------------------------------------------
// Objectif : détermine la liste des nombres premiers inférieurs à un nombre
//   entier donné par le crible d'Ératosthène
// Entrées : nombre entier (scalaire)
// Sorties : vecteur de nombres entiers
//============================================================================

// ***** fonctions et procédures *****

function [liste] = eratosthene(limite)
    // renvoit la liste (vecteur) des nombres premiers inférieurs à la limite
    indices = (ones(limite, 1)==1);
    // indices(i) = %t si i est premier, %f sinon
    indices(1)=%f; // 1 n'est pas premier
    imax = uint32(limite);
    i = uint32(2);
    while i <= imax
        if indices(i) then
           jmax = uint32(limite/i);
           j=uint32(2:jmax);
           indices(i*j)=%f; // élimination des multiples de i
           test = (i*jmax == imax);
           while test // recul de imax si le dernier nombre n'est pas premier
               imax = imax - 1;
               test = ~indices(imax);
           end
        end
        i = i + 1;
    end
    // constitution de la liste
    liste0 = uint32(1:limite);
    liste = liste0(indices);
endfunction

// ***** programme principal *****

// accueil
disp("Crible d''Ératosthène")

// entrer le plus grand nombre que l'on veut tester
maximum=input("nombre entier maximum : ");

// exécuter l'algorithme
lst = eratosthene(maximum);

// afficher le résultat
disp("Liste des nombres premiers entre 1 et "+string(maximum)+" : ");
disp(lst);
</syntaxhighlight>

=== Algorithme d'Euclide ===

Le programme suivant permet de déterminer le PGCD et le PPCM de deux nombres entiers, en utilisant l'[[w:fr:Algorithme d'Euclide|algorithme d'Euclide]].

<syntaxhighlight lang="scilab">
//============================================================================
// nom : pgcd_ppcm_euclide.sce
// auteur : Christophe Dang Ngoc Chan
// date de création : 2012-10-16
// dates de modification : 
//   2013-07-08 : guillemets ' -> "
//----------------------------------------------------------------------------
// version de Scilab : 5.3.1
// module Atoms requis : aucun
//----------------------------------------------------------------------------
// Objectif : détermine le PGCD et le PPCM par l'algorithme d'Euclide
// Entrées : deux nombre entier (scalaires)
// Sorties : deux nombres entiers (scalaires)
//============================================================================

// ***** Fonctions et procédures *****

function [resultat] = euclide(a, b)
    // détermine le PGCD de a et de b (deux entiers)
    r = modulo(a,b); // initialisation du reste
    while r <> 0
        a = b;
        b = r;
        r = modulo(a,b); // calcul du reste
    end
    resultat = b;
endfunction

// ***** Programme principal *****

// accueil

disp("Calcul du PGCD et du PPCM de deux nombres par l''algorithme d''Euclide")

// valeurs

n1 = input("Premier nombre : ");
n2 = input("Second nombre : ");

// exécution de l'algorithme

pgcd = euclide(n1, n2);
ppcm = n1*n2/pgcd;

// affichage du résultat

print(%io(2),pgcd)
print(%io(2),ppcm)
</syntaxhighlight>

=== Courbe de Koch ===

[[Fichier:Von koch 6 etapes.svg|thumb|Courbe de Koch]]

Le programme suivant trace la courbe du flocon de Koch de manière récursive.

<syntaxhighlight lang="scilab">
//============================================================================
// nom : von_koch.sce
// auteur : Christophe Dang Ngoc Chan
// date de création : 2012-10-23
// dates de modification : 
//    2013-07-08 : guillemets ' -> "
//    2013-07-2 : vectorisation du calcul
//    2016-06-21 : ajout de commentaires
//    2018-05028 : ajour de scf, suppr. de clear
//----------------------------------------------------------------------------
// version de Scilab : 5.3.1
// module Atoms requis : aucun
//----------------------------------------------------------------------------
// Objectif : trace la courbe du "flocon de neige" de von Koch
// Entrées : aucun (paramètres codés en dur)
// Sorties : fenêtre graphique avec une courbe ; fichier SVG
//============================================================================

scf(0);
clf;

// **************
// * constantes *
// **************

n = 6; // nombre d'étapes ;
// limité à 9 (262 145 points), sinon il faut changer la taille de la  pile (stacksize)
// 6 etapes (4 097 points) sont suffisantes pour un bon rendu
sin_soixante = sqrt(3)/2; // sin(60°)
l = 1; // longueur du segment initial (unité arbitraire)

// ******************
// * initialisation *
// ******************



// *************
// * fonctions *
// *************

function []=vonkoch(A, B, i)
    u = (B - A)/3 ; // tiers du vecteur AB
    v = [0.5*u(1) - sin_soixante*u(2) ; sin_soixante*u(1) + 0.5*u(2)] ;
    // vecteur tourné de +60°
    C = A + u ;
    D = C + v ;
    E = B - u ;
    if i == 1 then
        // tracé des segments si l'on est au dernier niveau
        x = [A(1) ; C(1) ; D(1) ; E(1) ; B(1)] ;
        y = [A(2) ; C(2) ; D(2) ; E(2) ; B(2)] ;
        xpoly(x, y, "lines")
    else
        // sinon, appel récursif
        j = i - 1 ;
        vonkoch(A, C, j);
        vonkoch(C, D, j);
        vonkoch(D, E, j);
        vonkoch(E, B, j);
    end
endfunction

// ***********************
// * programme principal *
// ***********************

debut = [0;0] ;
fin = [l;0];

vonkoch(debut, fin, n) // tracé du flocon

isoview(0, l, 0, l*sin_soixante/3) // dimensions de l'image

// enregistrement du fichier

nom = "von_koch_"+string(n)+"_etapes.svg" ;
xs2svg(0, nom)
</syntaxhighlight>

== Lancer un programme sans ouvrir directement Scilab ==

Il est possible de lancer un programme Scilab sans ouvrir l'interface graphique Scilab. Cela se comporte comme s'il s'agissait d'un exécutable.

Pour cela, il faut exécuter la commande suivante dans la ligne de commande du système d'exploitation ''(shell)'' :
<syntaxhighlight lang="bash">
scilab -nw -f monprogramme.sce
</syntaxhighlight>
Si le système d'exploitation ne trouve pas lui-même Scilab, il faut lui indiquer l'emplacement. Par exemple 
sous Unix
<syntaxhighlight lang="bash">
/bin/scilab -nw -f monprogramme.sce
</syntaxhighlight>
ou bien sous Microsoft Windows :
<syntaxhighlight lang="dos">
"C:\Program Files\scilab-5.3.3\bin\Scilex.exe" -nw -f monprogramme.sce
</syntaxhighlight>
Si l'on veut rediriger la sortie de Scilab vers la sortie standard (fenêtre système), on peut « tuber » Scilab, par exemple sous Unix
<syntaxhighlight lang="bash">
/bin/scilab -nwni < monprogramme.sce
echo "disp('Hello world')" |scilab -nwni
</syntaxhighlight>

On peut mettre ces commandes de système d'exploitation dans un script.

On peut enfin appeler le moteur Scilab à partir d'un programme écrit dans un autre langage, voir les rubriques d'aide :
* [http://help.scilab.org/docs/5.4.0/fr_FR/call_scilab.html <code>call_scilab</code>] : C/C++ ;
* [http://help.scilab.org/docs/5.4.0/fr_FR/javasci.html <code>javasci</code>] : Java.

== Voir aussi ==

; Dans Wikipédia
* [[w:Algorithmique|Algorithmique]]
* [[w:Structure de contrôle|Structure de contrôle]]

; Sur le Web
* {{lien web
 | url = https://www.scilab.org/programming-scilab
 | titre = Programming in Scilab
 | site = Scilab.org
 | lang = en
 | consulté le = 2019-02-13
}}
* {{lien web
 | id = ConvScilab2010 | libellé = ConvScilab 2010
 | url = http://wiki.scilab.org/Code%20Conventions%20for%20the%20Scilab%20Programming%20Language
 | titre = Code Conventions for the Scilab Programming Language
 | site =  Scilab Wiki
 | langue = en
 | consulté le = 2016-06-21
}}
* {{lien web
 | url = http://cermics.enpc.fr/scilab_new/site/Liens/intro/node86.html
 | titre = Interfacing C or Fortran programs with Scilab
 | site =  Introduction To Scilab User's Guide (Scilab Group, INRIA Metalau Project/ENPC Cermics)
 | langue = en
 | consulté le = 2016-06-21
}}

== Notes ==

{{références}}

----
''[[Découvrir Scilab/Graphiques et sons|Graphiques et sons]]'' &lt; [[Découvrir Scilab|↑]] &gt; ''[[Découvrir Scilab/Créer une interface graphique GUI|Créer une interface graphique GUI]]''

[[Catégorie:Découvrir Scilab (livre)|Programmation]]