Découvrir Scilab/Programmation

Un livre de Wikilivres.
Aller à : navigation, rechercher

Table des matièresIndex



6. Programmation


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 SciNotes ; 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 .sce ou .sci. 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.

Sections

Différence entre les extensions .sce et .sci[modifier | modifier le wikicode]

Les extensions de nom de fichier .sce et .sci 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[1] :

  • les fichiers dont le nom porte l'extension .sci ne devrait contenir que des définitions de fonctions ; ce sont des bibliothèques ; en particulier, seuls les fichiers .sci sont chargés par la commande getd() (voir Syntaxe pour définir une fonction > Fonction définie dans un fichier extérieur) ;
  • les fichiers dont le nom porte l'extension .sce devrait contenir le reste du script, et quelques fonctions locales.

Voir les sections suivantes :

Interaction avec l'utilisateur[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

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.

La fonction input permet à l'utilisateur de rentrer une valeur. la syntaxe est :

x = input("message")

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) :

x = input("message", "string")
x = input("message", "s")

Lorsqu'une variable nom_de_variable existe, alors

editvar nom_de_variable

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

a = x_dialog("message", "a0")

a0 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

a = x_dialog(("Entrez un" ; "nombre entier"], "1")

On peut aussi faire cliquer l'utilisateur et récupérer les coordonnées de l'endroit cliqué :

[bouton, x, y] = xclick

la valeur de bouton correspond à l'action menée par l'utilisateur.

La fonction halt arrête l'exécution du programme jusqu'à ce que l'utilisateur appuie sur une touche.

Sorties[modifier | modifier le wikicode]

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). 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.

La fonction

print(%io(2),a)

affiche le contenu de la variable a à l'écran. On peut aussi utiliser

write(%io(2),a)

La fonction

disp(a)

affiche le contenu de a sans faire figurer « a =  » devant. On peut afficher un message dans la barre d'information située en bas de la fenêtre graphique courante, avec

xinfo("message")

La fonction warning(message) affiche la chaîne de caractère message sous la forme d'un avertissement, c'est-à-dire précédé de « WARNING:  ». La fonction error(message) affiche la chaîne de caractère message sous la forme d'un message d'erreur, c'est-à-dire précédé de « !--error 9999 ».

Pour lancer une impression, on peut utiliser la fonction toprint(), 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 scf() ou récupéré par get(gcf(), "figure_id")[1]) ;

la fonction retourne un booléen indiquant si l'impression a réussi ou pas.

Par exemple :

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");

Pour les figures, on peut aussi utiliser

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

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

printsetupbox

Interaction avec le système d'exploitation[modifier | modifier le wikicode]

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

Déterminer le SE

La commande

SE = getos()

permet de connaître le système d'exploitaiton courant.

Sous Microsoft Windows

La commande

winopen("nom_de_fichier")

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 findfileassociation(), par exemple

findfileassociation(".txt")

Sous les Unix et Microsoft Windows

La commande unix() 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 unix_w(), ou bien vers une variable avec la commande unix_g(), par exemple

if getos() == "Windows" then
    A = unix_g("dir "+SCIHOME);
else
    A = unix_g("ls "+SCIHOME);
end

Structures de contrôle (boucles et branchements conditionnés)[modifier | modifier le wikicode]

Exécution conditionnelle[modifier | modifier le wikicode]

L'exécution conditionnelle se fait de manière classique avec les commandes if condition then, …, else, …, end

if condition1 then
  instructions
  ...
elseif condition2 then
  instructions
  ...
else
  instructions
  ...
end

Si une variable peut prendre plusieurs valeurs, on peut utiliser la structure select … case … else … end :

select nom_variable
  case valeur1 then
    instructions
  case valeur2 then
    instructions
    ...
  case valeurn then
    instructions
else
  instructions
end

Boucle itérative[modifier | modifier le wikicode]

La syntaxe d'une boucle for est la suivante :

for variable=expression
do
  instructions
  …
end

Le mot clef do est optionel. Il est possible d'écrire la boucle sur une seule ligne :

for variable=expression, instruction,, instruction, end

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

Exemples :

  • for i=1:10 ...
    
    la variable i prend successivement les valeurs 1, 2, ..., 10.
  • for i=list (1, 2, "a") ...
    
    la variable i prend successivement les valeurs 1, 2 et "a".

Boucle itérative antéconditionnée[modifier | modifier le wikicode]

while condition
  instructions1
  …
[else
  instructions2
  …]
end
while condition, instructions1,[, else instructions2,], end

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

Interruption d'une boucle[modifier | modifier le wikicode]

Lorsque le mot clé break [2] est rencontré dans une boucle for ou while, 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é end terminant la boucle.

Tri, recherche et sélection[modifier | modifier le wikicode]

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[modifier | modifier le wikicode]

La fonction gsort permet de trier ; elle utilise l'algorithme de tri rapide (quick sort, diviser pour régner). Si V est un vecteur, alors

A = gsort(V)

trie les éléments par ordre décroissant. Pour trier par ordre croissant, il faut ajouter l'option "i" (increasing ordre) : A = gsort(V, "i") Si M est une matrice, alors gsort(M) 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 "r". Et si l'on veut trier les lignes, on utilise l'option "c" (column, les éléments changent de colonne, mais pas de ligne). Par exemple

M = rand(3,3)
A = gsort(M, "r", "i")

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 "lr" ou "lc" :

A = gsort(M, "lr", "i")

Recherche[modifier | modifier le wikicode]

La recherche se fait avec la fonction find.

Par exemple, pour cherche une valeur a au sein d'un vecteur V :

I = find(V == a);

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

A = V(I);

voire les supprimer du vecteur initial

V(I) = [];

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

Avec une matrice booléenne M, la commande

I = find(M);

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

[I, J] = find(M);

alors I(k), J(k) sont les indices du k-ième élément trouvé. La valeur de l'élément est extraite par M(I(k), J(k)).

Dans l'exemple suivant, les deux matrices A et B sont identiques

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]

La commande find() 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).

La commande dsearch() regarde si chaque élément d'une matrice est dans un intervalle donné ; l'intervalle est donné sous forme de matrice. Par exemple

dsearch([1 3 5 7], [2 4])

va regarder quels sont les éléments du vecteur (1 ; 3 ; 5 ; 7) qui sont dans l'intervalle [2 ; 4]. La réponse est

0 1 0 0

car seul le second élément est dans l'intervalle. On peut indiquer des intervalles conjoints, par exemple [2 4 6] correspond aux intervalles I1 = [2 ; 4] et I2 = ]2 ; 6], et l'on a

-->dsearch([1 3 5 7], [2 4 6])
 ans  =
 
    0.    1.    2.    0.

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 "d", dsearch() 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 :

-->dsearch([1 3 5 7], [3 7], "d")
 ans  =
 
    0.    1.    0.    2.

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 :

vectorfind(M, V, "r") // vecteur-ligne
vectorfind(M, V, "c") // vecteur-colonne

la fonction retourne un vecteur d'indices correspondant aux lignes ou colonnes trouvées.

La version 5.5 (encore en test en octobre 2013) propose la fonction members() 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 ne matrice de scalaires, mais aussi une ligne ou une colonne particulière :

nb = members(A, BF)
[nb, pos] = members(A, BF)

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 nb est le nombre d'occurrences et pos les indices de la première position trouvée. On peut ajouter l'option "last" pour avoir la dernière occurrence :

[nb, pos] = members(A, BF, "last")

Si l'on veut chercher une ligne, alors A doit être une matrice ligne, et l'on utilise

members(A, BF, "rows")

on peut aussi chercher les permutations de A avec l'option "shuffle" :

members(A, BF, "rows", "shuffle")

On peut chercher des colonnes avec l'option "cols".

Opérations sur les ensembles[modifier | modifier le wikicode]

Certaines matrices contiennent des éléments dupliqués. La commande unique() 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

unique(M)

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

[N, k] = unique(M)

Par exemple

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.

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 "r" (rows), ou les colonnes uniques, avec l'option "c".

-->unique(A, "r")
ans  =
 
    0.    0.    1.    1.  
    0.    1.    1.    1.  
    0.    2.    2.    2.  
    2.    0.    1.    1.

La matrice A comporte donc quatre lignes originales, et deux lignes qui sont des répétitions.

La commande union() 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 :

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.

On voit donc que la réunion des ensembles est {0 ; 1 ; 2 ; 3 ; 4}. On peut de même utiliser les options "c" ou "r".

Temporisation[modifier | modifier le wikicode]

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 :

  • sleep(n) : suspend le processus en cours pendant n millisecondes ;
  • xpause(n) : suspend Scilab pendant n millisecondes ;
  • realtimeinit(u) ; realtime(t0) ; realtime(t1) : la première commande, realtimeinit(u), indique une unité en nombre de secondes u ;
    la deuxième commande, realtime(t0), indique que l'instant actuel est t0, selon l'unité précédemment définie (habituellement, t0 = 0) ;
    la troisième commande, realtime(t1), met Scilab en attente jusqu'à ce que la date t1 soit atteinte, selon l'unité précédemment définie .

Analyse et construction de chaînes de caractères[modifier | modifier le wikicode]

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 :

  • ascii() (et char()), pour créer une chaîne de caractères à partir de codes ASCII et vice versa ;
  • string(), pour transformer des nombre ou matrices de nombres en chaînes de caractères ;
  • length(), pour déterminer la longueur d'une chaîne ;
  • + et strcat(), pour concaténer des chaînes ;
  • strsubst() qui permet de « rechercher-remplacer » ;
  • evstr() qui permet d'exécuter une commande Scilab contenue dans une chaîne de caractères.


Pour plus de détails voir : Découvrir Scilab/Calculs élémentaires#Chaînes de caractères.

Localiser une sous-chaîne[modifier | modifier le wikicode]

La commande strindex() permet de localiser la position (le n-ième caractère) où se trouve une sous-chaîne :

-->strindex("bonjour Marcel", "r M")
 ans  =
 
    7.

car la sous-chaîne « r M » commence au 7e 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 "r" ; on peut également utiliser la commande regexp() dans ce contexte. Par exemple

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

Couper à des positions données[modifier | modifier le wikicode]

La commande strsplit() 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 :

-->strsplit("abcd")
 ans  =
 
!a  !
!   !
!b  !
!   !
!c  !
!   !
!d  !

Si l'on indique un vecteur de valeurs, il coupe après les endroits indiqués :

-->A = strsplit("aei ou y", [4, 7])
 A  =
 
!aei   !
!      !
!ou    !
!      !
!y     !
 
-->length(A(1))
 ans  =
 
    4.

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[modifier | modifier le wikicode]

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 carcatè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 tokens() 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

t = tokens("a = 5", "=")

crée la matrice ["a " ; "=" ; " 5"]. La commande tokenpos() 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.

-->tokenpos("a = 5", "=")
 ans  =
 
    1.    2.  
    4.    5.  
 
-->tokenpos("a=5", "=")
 ans  =
 
    1.    1.  
    3.    3.

La commande strplit() 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).

-->strsplit("aei ou y", " ")
 ans  =
 
!aei  !
!     !
!ou   !
!     !
!y    !

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 :

-->strsplit("aei    ou y", "/\ +/")
 ans  =
 
!aei  !
!     !
!ou   !
!     !
!y    !

Là encore, les caractères de séparation sont supprimés.

Expressions régulières[modifier | modifier le wikicode]

Une expression régulière est une description d'une chaîne de caractères[2]. C'est elle-même une chaîne, qui commence et finit par une barre de fraction /. Par exemple, l'expression régulière qui décrit « blabla » est /blabla/.

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 /2\+2/, et « /slash » par /\/slash/.

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

Si un caractère est répété, on peut le faire suivre par :

  • un point d'interrogation ? : il est présent au plus une fois (0 ou 1 fois) ; /a?/ décrit «» ou bien « a » ;
  • un astérisque * : il est absent, ou présent un nombre indéterminé de fois ; /a*/ décrit «», « a », « aa », « aaa », … ;
  • un plus + : il est présent au moins une fois : /a+/ décrit « a », « aa », « aaa », … ;
  • une paire d'accolades : /a{5}/ décrit « aaaaa », /a{2,4}/ décrit « aa », « aaa » ou « aaaa », /a{3,} 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 ^ ; si elle doit se trouver en fin de ligne, elle se termine par $. Par exemple, /^bon/ et /jour$/ 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, /[bt]éton/ décrit les chaînes de caractère « béton » et « téton ». L'expression /[0-9a-fA-F]/</code correspond à un chiffre hexadécimal (chifre décimal de à 9, et letre de a à z, en minuscule et en majuscule). On peut aussi interdire une classe en la commençant par l'accent circonflexe : /[^0-9]/ est tout sauf un chiffre décimal.

Enfin, il existe des classes toutes faites :

  • /\d/ est un chiffre, l'équivalent de /[0-9]/ ;
  • /\D/ est tout sauf un chiffre, l'équivalent de /[^0-9]/ ;
  • /\s/ est un caractère d'espacement : blanc, tabulation, nouvelle ligne ou retour-chariot ;
  • \S est la négation de \s ;
  • \w est un caractère alphanumérique (lettre ou chiffre, ainsi que le tiret de soulignement _) ;
  • \W est la négation de \w ;
  • le point . correspond à n'importe quel caractère, sauf une nouvelle ligne \n.

Ainsi, /\s+ décrit un ou plusieurs espaces.

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

Fonctions extérieures[modifier | modifier le wikicode]

Syntaxe pour définir une fonction[modifier | modifier le wikicode]

Comme indiqué dans le chapitre Calcul numérique, la définition d'une fonction commence par le mot clé function et se termine par le mot clé endfunction, selon la syntaxe suivante :

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

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 :

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

Cette fonction peut ensuite être utilisée en mode interactif ou à l'intérieur d'un programme :

-->puissance(2,3)
 ans  =
 
    8.

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 fichier texte, celui-ci peut être chargé au moyen de la commande exec() :

exec("fichier.sci")

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 getd() permet de charger tous les fichiers .sci d'un répertoire, avec la syntaxe :

getd("chemin/")

"chemin/" 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.

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 endfunction sont considérées comme appartenant à la fonction et ne sont pas interprétées immédiatement.

Définition compacte d'une fonction[modifier | modifier le wikicode]

Une fonction peut aussi se définir en une ligne à l'aide de l'instruction deff :

deff ("[y] = f(x)", "y=2*x")

Cette définition est équivalente à :

function [y] = f(x)
  y = 2*x
endfunction

Cette syntaxe permet également de définir des fonctions comportant plusieurs instructions :

deff ("[y] = puissance(x, n)", "y = 1, if n > 0 then, for i = 1:n, y = y*x, end, end")

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 function, le résultat des calculs n'est pas affiché à l'intérieur d'une fonction.

Gérer le nombre de paramètres transmis[modifier | modifier le wikicode]

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 et Recommandations. Il faut alors envisager

  • que certains paramètres soient optionnels ;
  • que le programmeur oublie de transmettre certains paramètres (voir Gestion des erreurs).

Si un paramètre p peut avoir une valeur par défaut, on peut tester son existence avec exists() :

function [y] = monproduit(x, p)
  // paramètre optionnel
  if exists("p", "local") == 0...
    then p = 1; end // valeur par défaut
  y = x*p;
endfunction

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

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

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 varagin(:). 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é :

function [y] = trace_10_premiers(x, y, varargin)
  plot(x(1:10), y(1:10), varargin(:))
endfunction

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 varargout (variable arguments output) dans les paramètres de sortie, et « remplir » la liste varargout dans la fonction. Le nombre total de paramètres de sortie est donné par argn(1).

Informations sur une fonction[modifier | modifier le wikicode]

La commande macrovar(f) donne la liste des paramètres d'entrée et sortie de la fonction f, 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 fun2string(f) renvoie un vecteur de chaînes de caractères contenant la définition de la fonction.

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

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 macrovar(). On peut aussi comparer, avec setdiff(), la liste des variables, obtenue avec who(), avant et après le chargement du script. Par exemple

variables_avant = who("local");
exec("monscript.sce");
variables_du_script = setdiff(variables_avant, who("local"));

Variables locales ou globales[modifier | modifier le wikicode]

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 global() ; 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 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 Parallélisme (informatique) > 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 :

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

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

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()

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

isglobal(a)

Gestion des erreurs[modifier | modifier le wikicode]

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 :

  1. « Blinder » le programme : faire des vérifications de la validité des données à certains instants critiques.
  2. 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.
  3. 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.
  4. 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 %nan et %inf.

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

  1. Si la variable existe.
  2. Si la variable est au bon format.
  3. Si le contenu est dans une plage correcte (est dans l'ensemble de définitoin des fonctions qui s'en servent).

Vérifier l'existence de la variable[modifier | modifier le wikicode]

La commande

exists(nom_de_variable)

nom_de_variable est une chaîne de caractères (par exemple exists("X")), renvoit 1 si la variable existe, 0 sinon. On peut aussi utiliser la fonction

isdef("X")

X est la variable ; cette fonction renvoit un booléen.

Dans une fonction, on peut récupérer le nombre d'arguments d'entrée avec la commande

nb_arg_entree = argn(2)

puis à tester la valeur de nb_arg_entree. On pourra par exemple voir la définition de la fonction sind en tapant edit sind dans la ligne de commande.

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

Vérifier le format de la variable[modifier | modifier le wikicode]

Scilab propose des fonctions de test is... (« est-ce… ? »), c'est-à-dire des fonctions renvoyant des valeurs booléennes %t (vrai) ou %f (faux) :

  • isglobal(X) : vrai si la variable X est une variable globale ;
  • isvector(X) : 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) ;
  • issparse(X) : vrai si X est une matrice creuse ;
  • isnum(X) : vrai si la chaîne de caractères X représente un nombre ;
  • isalphanum(X) : 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 ;
  • isascii(X) : idem, mais vérifie s'il s'agit d'un caractère ASCII 7 bits ;
  • isdigit(X) : idem, mais vérifie s'il s'agit d'un chiffre ;
  • isletter(X) : idem, mais vérifie s'il s'agit d'une lettre ;
  • isreal(X) : vrai si la matrice X ne contient que des nombres réels ;
  • isdir(X) : vrai si la chaîne de caractères X est un chemin d'accès à un répertoire existant ;
  • isfile(X) : vrai si la chaîne de caractères X est un nom de fichier existant ;
  • is_handle_valid(h) : vrai si h est un pointeur vers un objet graphique existant (par exemple obtenu par unget, ou bien généré par un scf) ;
  • iscell(X), iscellstr(X), isstruct(X) : 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) ; isfield(S, nomduchamp) vérifie si le champ nomduchamp (chaîne de caractères) existe dans la structure S, isparam(nomliste, nomparam) vérifie si le paramètre nomparam (chaîne de caractères) existe dans la liste nomliste.

Vérifier le contenu de la variable[modifier | modifier le wikicode]

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

Scilabe propose également les commandes :

  • isempty(X) : vrai si la matrice ou la liste X est vide ;
  • isinf(X), isnan(X) : vérifie si la matrice X a des composantes infinies ou NaN.

Générer un message d'erreur[modifier | modifier le wikicode]

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

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

texte_erreur = "fonction f : valeur de l'argument "+string(X)+" illégale.";
error(texte)

ou bien utiliser les commandes de type « langage C », mais il faut alors être sûr du format de la variable :

texte_erreur = "fonction f : valeur de l'argument %d illégale.";
error(msprintf(texte, X))

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 getext() permet de traduire automatiquement les termes, et d'adapter la typographie (par exemple, mettre une espace[3] devant les deux-points et points-virgules en français).

Dérouter une erreur[modifier | modifier le wikicode]

Pour « dérouter » une erreur, c'est-à-dire éviter que le programme ne s'interrompe, on utilise la fonctions errcatch(-1). La fonction iserror(-1) permet ensuite de tester si une erreur est survenue. On peut ne s'intéresser qu'à un type d'erreur : errcatch(n) et iserror(n) (n > 0) pour l'erreur n (voir la table des erreurs).

On peut indiquer à errcatch une action faire en cas d'erreur :

errcatch(n, "action")

action vaut :

  • pause : s'arrête et reste dans le contexte courant ; on peut utiliser whereami() pour connaître le contexte ; c'est le comportement le plus utile en phas ede développement/déverminage ;
  • continue : l'erreur est ignorée et le programme continue ; il faut effacer l'erreur avec errclear le plus tôt possible (après iserror) ;
  • kill : arrête l'exécution du programme et revient au niveau 0 (comportement normal) ;
  • stop : quitte Scilab.

Enfin, on peut indiquer ce que doit faire Scilab en cas d'erreur de calcul, avec la commande ieee :

  • ieee(0) : génère une erreur (comportement par défaut) ;
  • ieee(1) : renvoit une valeur Inf ou Nan, et génère un avertissement ;
  • ieee(2) : renvoit une valeur Inf ou Nan sans générer d'avertissement.

Encapsuler le code problématique[modifier | modifier le wikicode]

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 try-catch-end :

  • Scilab exécute le code entre les commandes try et catch ; si aucune erreur ne se produit, il va tout de suite après le end ;
  • si une erreur se produit entre le try et le catch, il exécute directement les instructions entre le catch.
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>

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

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

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

Bibliothèque de fonctions[modifier | modifier le wikicode]

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 .sci et l'appeler avec exec() ou getd() comme indiqué précédemment. Mais Scilab fournit également une gestion spécifique des bibliothèques.

Structure d'une bibliothèque[modifier | modifier le wikicode]

Pour Scilab, une bibliothèque est :

  • un répertoire (ou dossier, directory), contenant :
  • un fichier names (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 mputl ;
  • un fichier pour chaque fonction ; le fichier porte le nom de la fonction auquel on ajoute l'extension .bin ; c'est un fichier binaire (compilé) créé par la fonction save de Scilab.

Création d'une bibliothèque[modifier | modifier le wikicode]

Le programme suivant :

  • se place dans le répertoire persolib (déjà existant), les trois petits points désignant le début du chemin d'accès ;
  • définit les fonctions gauss et lorentz, ainsi que la variable unsurpi ;
  • crée les fichiers gauss.bin, lorentz.bin et unsurpi.bin dans ce répertoire, à partir des fonctions définies ;
  • crée le fichier d'index names.
// 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")

Utilisation d'une bibliothèque[modifier | modifier le wikicode]

Le programme suivant :

  • s'assure que toutes les variables sont effacées (clear) ;
  • déclare l'utilisation de la bibliothèque .../persolib/, et l'affecte à la variable mabibliotheque (fonction lib) ;
  • utilise les fonctions et variables de la bibliothèque.
// 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)

Commandes sur les bibliothèques[modifier | modifier le wikicode]

Si l'on tape simplement le nom de la variable dans laquelle on a déclarée la bibliothèque (ici mabibliotheque), Scilab retourne :

  • le chemin d'accès ;
  • la liste des fonctions.

La fonction libraryinfo a le même effet, mais permet de mettre les valeurs retournées dans des variables, par exemple avec

[fcts, chem] = libraryinfo(mabibliotheque)

la variable fcts est une matrice de chaînes de caractères contenant les noms des fonctions, et la variable chem est une chaîne de caractères contenant le chemin d'accès.

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

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

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

La fonction librarieslist indique la liste des bibliothèques chargées.

Lancement d'un programme[modifier | modifier le wikicode]

Un programme (fichier .sce) 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 CTRL+l.

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

Le problème de la précision et de l'exactitude[modifier | modifier le wikicode]

Scilab est destiné à faire du calcul. La précision, l'exactitude des résultats est donc une préoccupation primordiale.

La première chose est bien évidemment d'utiliser des méthodes, des algorithmes corrects, validés, documentés. Mais la mise en code de ces algorithmes doit également être correcte. Bien évidemment, la méthode choisie doit être retranscrite fidèlement et sans erreur, mais il faut aussi prendre en compte certains « effets de bord » dûs à la représentation des nombres.

En effet, Scilab calcule par défaut avec des nombre décimaux codés en virgule flottante à double précision selon la norme IEEE754. Cela permet de représenter des nombres dont la valeur absolue est comprise entre 10-307 et 10308 ; si un calcul donne une valeur inférieure, cela retourne la valeur 0 (erreur de soupassement), et s'il donne une valeur supérieure, cela retourne la valeur Inf ou -Inf (erreur de dépassement). Le nombre de chiffres significatifs est de l'ordre de 16 ; ainsi, si deux nombres diffèrent au 17e chiffre significatif, ils seront considérés comme égaux (erreur d'arrondi), leur différence sera nulle, leur rapport sera de 1.

Il faut donc s'assurer d'une part que le valeur finale est représentable, mais aussi que les résultats des calculs intermédiaires sont eux aussi représentables. Par exemple le calcul de abs(-10^-200) donne bien le résultat 10-200, alors que sqrt((-10^-200)^2) donne 0, puisque le résultat intermédiaire (-10200)2 n'est pas représentable (soupassement). Dans certains cas, un algorithme itératif, cherchant une valeur approchée, peut donner un meilleur résultat qu'un calcul direct utilisant une formule exacte…

Si l'on doit faire des calculs avec des cas « extrêmes » — nombres très proches, ou bien ayant une valeur absolue élevée ou faible —, on s'intéressera à des algorithmes « robustes ». Ceux-ci font fréquemment intervenir une normalisation des données ou une factorisation pertinente. Dans la mesure du possible, si l'on a le choix entre une fonction « fait maison  » et une fonction Scilab faisant le même travail, on favorisera la fonction Scilab, qui est censée être optimisée.

Quoi qu'il en soit, la mise en œuvre d'un algorithme doit toujours s'accompagner de tests avec des valeurs pour lesquelles le résultat est connu. Les résultats de référence peuvent être calculés à la main, obtenus avec un logiciel de référence, ou bien les données peuvent être générées en fonction du résultat attentdu.

Par ailleurs, un résultat de qualité fait figurer la précision du calcul.

On pourra se reporter à Michaël Baudin, [anglaisScilab is not naive], Consortium Scilab (2010).

Optimisation d'un programme[modifier | modifier le wikicode]

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 clock retourne un vecteur ligne de 6 éléments indiquant :

  1. L'année.
  2. Le mois (1–12).
  3. Le jour du mois (1—31).
  4. L'heure (1–24).
  5. Les minutes dans l'heure (0–59).
  6. Les secondes dans la minute (0–59)[4].

Mais cela ne permet d'avoir une précision que de la seconde. On peut avoir les millisecondes avec :

instant = getdate();
instant(9) + instant(10)/1000

en effet, la commande getdate() 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 tic() déclenche le chronomètre ;
  • la commande toc() 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 1re ligne est celle contenant la commande function). Pour chaque ligne, le profil contient 3 colonnes :

  1. Nombre de fois que la ligne exécutée.
  2. Durée d'exécution de la ligne, en seconde.
  3. « Effort » requis par l'interpréteur pour exécuter la ligne.

La commande add_profiling("nom_fonction") « prépare » la fonction : cette commande est nécessaire pour extraire ensuite le profil. La commande profile(nom_fonction) indique le « profile de la fonction ».

La commande showprofile(nom_fonction) met en correspondance ces données et les instructions de la fonctions. La commande plotprofile(nom_fonction) 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 méthode de Horner. 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 tri par tas et le tri rapide.

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 (arbre de décision). Par exemple, pour effectuer une addition A+B, Scilab effectue une dizaine d'opérations préalables[5] :

  1. Allocation de mémoire pour A.
  2. Allocation de mémoire pour B.
  3. Détermination du type de données de A : 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), …
  4. Détermination du type de données de B.
  5. Détermination de la dimension de la matrice A.
  6. Détermination de la dimension de la matrice B.
  7. Si A est une matrice réelle ou complexe, s'agit-i-il de nombre réels ou de nombres complexes ?
  8. Idem pour B.
  9. 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 sur une matrice).

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 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 relentissent l'exécution.

Déverminage[modifier | modifier le wikicode]

Pour déverminer (« débugger ») un programme, on peut :

  • mettre des fonctions halt 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 [entrée] dans l'invite de commande ;
  • lancer le programme en mode 4 : exec('nomprogramme.sce', 4) ; le programme s'arrête à chaque ligne ; on relance le programme en appuyant sur la touche [entrée] dans l'invite de commande.

Recommandations[modifier | modifier le wikicode]

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[6].

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.

Démarche projet[modifier | modifier le wikicode]

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.

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 transmissison d'informations, mais peut mener à un manque de rigueur et donc à des difficultés.

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.

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

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, …).

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.

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 »).

La démarche globale est donc :

  1. 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.
  2. Analyse fonctionnelle : découpage en fonctions. Recherche de solutions (sélection d'algorithmes).
  3. Organisation des modules du programme. Hiérarchisation. Choix de la structure de données.
  4. Codage et test unitaire des fonctions, en suivant l'ordre hiérarchique.
  5. Intégration des fonctions au sein du programme et tests d'intégration (échange de données entre les fonctions)
  6. Test du programme fini avec les données de test. Vérification que le programme répond bien aux besoins (cahier des charges).
  7. Nettoyage du code. Maintenance.

Pour des projets importants et devant être formalisés, on pourra par exemple s'inétresser au modèle en V.

Structure générale du script[modifier | modifier le wikicode]

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

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. clear, clc, imports (input) …
 
Constantes
    définition de variables constantes
 
Fonctions
    définition des fonctions
 
Programme principal
    appel des fonctions

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[7] ; 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 Analyse statique de programmes.

Du code explicite …[modifier | modifier le wikicode]

Il faut utiliser les noms de fonctions et de variable voulant dire quelque chose. On peut utiliser des noms « bidons » (comme toto, foo) pour des variables utilisées sur de petites portions de programme. On utilise aussi fréquemment des noms « standard » : x (abscisse, inconnue d'une équaiton, variable d'une fonction), i (nombre entier évolutif : indice, compteur), n (nombre entier constant : quantité), …

Si l'on travaille en équipe, il est recommandé d'utiliser une nomenclature systématique (voir 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 (maVariableAvecUnNomExplicite). 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 Notation hongroise).

… Aéré …[modifier | modifier le wikicode]

Il faut se limiter à une seule commande par ligne, voire plusieurs lignes pour une commande si la syntaxe est longue (utilisation de trois points ...), 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é ») …[modifier | modifier le wikicode]

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

… Abondamment commenté …[modifier | modifier le wikicode]

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

… Fractionné …[modifier | modifier le wikicode]

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 notation polonaise inverse, mieux adaptée à l'exécution (qui passe par une pile)[5].

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

… Et général[modifier | modifier le wikicode]

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 X = 0:0.01:1; et appliquer directement f(X). 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).


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 » feval(X, f) à la place de f(X).

La manière la plus simple de créer une fonction pouvant agir sur une matrice consiste à faire défiler les indices, par exemple :

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

ainsi, si l'on transmet un vecteur, imax ou jmax vaudra 1, et si l'on transmet un nombre unique (scalaire), les deux vaudront 1. Mais on peut aussi utiliser les versions « pointées » des opérateurs :

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

Rappelons de manière utile que l'inverse peut s'obtenir par .^(1), la racine carrée par .^(0.5) ; les racines n-ièmes par .^(1/n) ou nthroot(x, n) . D'autre part, la plupart des fonctions primitives s'appliquent aux matrices (par exemple exp(), sqrt(), …). Par ailleurs, nous avons vu 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 (:, $), ainsi que la possibilité d'extraire certains indice en utilisant une matrice booléenne. Dans l'exemple suivant[8], nous définissons une fonction ayant une formule différente à gauche et à droite d'une valeur x0 ; 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.

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

On peut ainsi l'utiliser avec un nombre unique

A = [3, 2, 1.5, 2.5];
y = gauss_dissym(A, 2.5)

ou bien avec un vecteur

A = [3, 2, 1.5, 2.5];
X = 0:0.1:6;
plot(X, gauss_dissym(A, X))

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 fg(x, y) et fd(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 :

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)

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

//============================================================================
// 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 ' -> "
//----------------------------------------------------------------------------
// 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
// **********
 
clear;
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")

Relecture de code[modifier | modifier le wikicode]

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 Revue de code). La relecture de code consiste à s'assurer que les règles énoncées — découpage en fonctions demoins 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 cest tout (mais 'cest déjà beaucoup) !

En particulier, il serait illusoire, et contre-productif car décourageant, d'espérer comprendre rapidement un code qui'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[modifier | modifier le wikicode]

Un auteur peut vouloir distribuer un exécutable, par exemple pour avoir une utilisaiton 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 SendScilabJob au sein d'un programme C/C++. Cela fait appel à l'API call_scilab.

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 SendScilabJob. Le programme C/C++ peut ensuite être compilé.

Le module Atoms scetoexe fournit une commande scetoexe_generate() 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 Scilab 2 C 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 [3].

Exemples[modifier | modifier le wikicode]

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

Crible d'Ératosthène[modifier | modifier le wikicode]

Le programme suivant détermine la liste des nombres premiers inférieurs à une valeur donnée, appelée ici maximum, en utilisant l'algorithme du crible d'Ératosthène.

//============================================================================
// 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 ' -> "
//----------------------------------------------------------------------------
// version de Scilab : 5.3.1
// 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); // indices(i) = 1 si i est premier, 0 sinon
    imax = uint32(sqrt(limite));
    for i=2:imax
        if indices(i)=1 then
           jmax = uint32(limite/i);
           for j=2:jmax
               indices(i*j)=0; // élimination des multiples de i
           end
        end
    end
    // constitution de la liste
    j=1;
    for i = 1:limite
        if indices(i)=1 then
            liste(j)=uint32(i);
            j=j+1;
        end
    end
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(lst')

Algorithme d'Euclide[modifier | modifier le wikicode]

Le programme suivant permet de déterminer le PGCD et le PPCM de deux nombres entiers, en utilisant l'algorithme d'Euclide.

//============================================================================
// 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)

Courbe de Koch[modifier | modifier le wikicode]

Courbe de Koch

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

//============================================================================
// 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
//----------------------------------------------------------------------------
// 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
//============================================================================
 
clear;
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
        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
        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)
 
isoview(0, l, 0, l*sin_soixante/3)
 
// enregistrement du fichier
 
nom = "von_koch_"+string(n)+"_etapes.svg" ;
xs2svg(0, nom)

Lancer un programme sans ouvrir directement Scilab[modifier | modifier le wikicode]

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) :

scilab -nw -f monprogramme.sce

Si le système d'exploitation ne trouve pas lui-même Scilab, il faut lui indiquer l'emplacement. Par exemple sous Unix

/bin/scilab -nw -f monprogramme.sce

ou bien sous Microsoft Windows :

"C:\Program Files\scilab-5.3.3\bin\Scilex.exe" -nw -f monprogramme.sce

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

/bin/scilab -nwni < monprogramme.sce
echo "disp('Hello world')" |scilab -nwni

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 :

Voir aussi[modifier | modifier le wikicode]

Dans Wikipédia
Sur le Web

Notes[modifier | modifier le wikicode]

  1. ou bien fig = gcf() ; fig.figure_id
  2. voir anglais Perl regular expressions quick start
  3. En typographie, le terme « espace » est au féminin lorsqu'il désigne un caractère « blanc ».
  4. 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.
  5. 5,0 et 5,1 voir le anglais 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.
  6. Code Conventions for the Java Programming Language, Oracle
  7. le cerveau humain est capable d'appréhender 5 à 9 objets en même temps, selon l'état de fatigue, de concentration, … voir anglais George Armitage Miller, « The magical number seven, plus or minus two: Some limits on our capacity for processing information », dans Psychological Review, vol. 63, no 2, 1956, p. 81–97 [texte intégral] 
  8. le code a été amélioré grâce à Stefan Du Rietz

Graphiques et sons < > Créer une interface graphique GUI