![[dangerous l bend]](xsok0c7f.png) Ce document est conçu comme un recueil commenté d’exemples “simples” de
commandes Scilab . Il permet de découvrir l’existence de certaines commandes
Scilab et leur domaine d’utilisation, mais la lecture de ce document ne peut
remplacer la lecture de l’aide en ligne pour une utilisation optimale des commandes
décrites. |
Scilab est un logiciel de calcul numérique, qui permet de manipuler la plupart des
objets mathématiques courants (nombres réels, booléens, matrices, fonctions, polynômes,
graphes,. . .). Scilab est aussi un logiciel libre (depuis la version 5) dont vous pouvez vous
procurer la dernière version sur le site de l’INRIA (Institut National de la Recherche en
Informatique et en Automatique) :
dans la suite les exemples de code Scilab ou de sortie « console » apparaissent dans des cadres gris-bleu alors que les remarques sur les erreurs et les confusions les plus fréquentes apparaissent dans des cadres rouges :
|
erreur fréquente . . . |
Lorsque vous démarrez Scilab la fenêtre principale s’ouvre comme sur la figure FIG.1. Un curseur apparaît juste après l’invite des commandes (-->) c’est à cet endroit que vous pourrez lancer les lignes de commandes qui seront exécutées séquentiellement, de la même manière qu’avec une calculatrice ou que dans une fenêtre xterm sous linux. Pour pouvoir utiliser la console il faut comprendre les quelques règles suivantes :
), ce qui nous limite à une commande par ligne,
Vous pouvez aussi accéder à l’aide en ligne de Scilab directement depuis la console. Pour cela il y a deux commandes différentes suivant le type de recherche qu’on veut faire dans l’aide en ligne :
Pour comprendre observez la différence de résultat entre les deux commandes :
la première commande va trouver la page d’aide de la fonction sinus (sin en Scilab ) alors que la deuxième va renvoyer la liste des commande ayant un rapport avec la fonction sinus (en fait la liste des fonctions trigonométriques comme sur la figure FIG.2).
Une dernière chose importante qu’il faut comprendre pour bien travailler avec Scilab c’est la notion derépertoire courant. On a souvent besoin avec Scilab d’importer des informations, ou au contraire d’en exporter, et ceci à l’aide de fichiers. Lorsque c’est le cas, Scilab va chercher à effectuer ces opérations avec les fichiers présents dans son répertoire courant. Au démarrage de Scilab ce répertoire est le répertoire depuis lequel Scilab a été lancé. Par exemple, sous windows™, ça peut être C:\Program Files\Scilab-x.x.x\bin\ si vous démarrez Scilab depuis son répertoire d’installation par défaut. Il existe plusieurs fonctions dédiées à la manipulation des répertoire courant :
Plus généralement, on peut aussi exécuter des commandes systèmes avec la fonction unix() (la sortie pouvant être redirigé vers scilab ou pas).
On peut aussi accéder à certaines fonctionnalités, comme changer ou afficher le répertoire courant, à partir du menu fichier.
Les objets de base du langage Scilab sont les nombres réels. Il sont représentés par des nombres flottant double précision (i.e. avec un exposant signé et une mantisse d’environ 16 décimales), Scilab les affiche dans la console par défaut sous forme décimale avec 8 chiffres significatifs. Les opérations usuelles sur les réels sont codées de manière naturelle, voici leur liste par ordre de priorité croissante :
et on a en plus accès à la plus part des fonctions spéciales :
sin(), asin(), cos(), acos(), tan(), atan(), cotg() |
|
sinh(), asinh(), cosh(), acosh(), tanh(), atanh(), coth() |
|
round(), int(), floor(), ceil() |
|
exp(), log(), log10(), log2() |
|
sqrt()(racine), abs() (valeur absolue), pmodulo() (modulo) |
|
Voici quelques manipulations de base :
Notez qu’un nombre en Scilab contient toujours le caractère “.”, y compris les nombres
entiers (même si le point est facultatif lors de la saisie).
Les constantes, comme e et π, jouent un rôle particulier en mathématiques elles ont donc une place à part dans Scilab et sont stockées dans des variables non modifiables qui commencent par le caractère %. Voici les plus utiles :
Pour simplifier la manipulation des nombres nous allons utiliser des variables. Une
variable est déterminée par un nom composé d’une suite d’au plus 24 caractères d’abord
une lettre éventuellement suivit d’autres lettres, de chiffres, ou de caractères spéciaux
comme _ mais différent des opérateurs déjà définis par Scilab : +*/^[](){}'&|~ .
L’affectation d’une valeur (réelle, complexe, booléenne ou autre) dans une variable se fait
en utilisant =. Si le résultat de la dernière opération n’a pas été stocké dans une variable
spécifique alors il est stocké dans la variable ans :
| Il n’y a donc pas de déclaration préalable des variables en Scilab, celle-ci
sont crées lors de l’affectation. La notion de type d’une variable (constant,
string, function ...) est donc beaucoup moins rigide en Scilab que dans un
langage compilé. En particulier le type d’une variable donné peut changer d’une
affectation à l’autre ! |
Si besoin on peut tester le type d’une variable avec la fonction typeof :
Plusieurs commandes permettent de connaître la liste des variables utilisées dans un session Scilab . La commande who va lister tous les noms des variables de l’environnement Scilab . On pourra ainsi se rendre compte que Scilab travaille avec de nombreuses variables d’environnements (chemins vers des répertoires particuliers, noms de librairies, constantes particulières,. . .). La commande whos -type permet de spécifier le type de variable qu’on veut lister, et donc de clarifier quelque peut l’affichage. Enfin, à partir des versions 5 de Scilab , il existe une fonction who_user qui ne liste que les variables définies par l’utilisateur.
Il s’agit de la structure de données la plus importante dans Scilab , elle sera
constamment utilisée. Scilab permet de construire toutes sortes de matrices, à partir
des réels, mais aussi en utilisant des booléens, des chaînes de caractères . . .on
peut ensuite effectuer toutes les opérations algébriques usuelles définies sur les
matrices.
Il y a plusieurs manières de définir une matrice. La plus simple consiste à saisir la liste des coefficients d’une matrice ligne par ligne, les lignes étant séparées par des points-virgules, en utilisant l’opérateur de concaténation [ ] :
On peut accéder aux valeurs stockées dans une matrice en utilisant l’opérateur d’extraction (). Pour récupérer (resp. modifier) la valeur en position i,j de la matrice A il suffit d’appeler la commande A(i,j) (resp. A(i,j)=) sauf pour la matrice vide [] et éventuellement les matrices à une ligne ou une colonne :
| Il ne faut pas confondre la syntaxe de Scilab avec celle d’autres langages (C
par exemple). Dans la gestion des matrices, en particulier, il ne faut pas confondre
les opérateurs [] et (). Une erreur très fréquente consiste à écrire A[1][2] au lieu
de A(1,2) ou L[2] au lieu de L(2). |
Lorsqu’on modifie un coefficient qui “déborde” de la matrice de départ la matrice est augmenté du nombre de lignes et de colonnes nécessaires et les cases correspondantes sont mises à 0 :
Pour de petites matrices on rentrera tous les coefficients un à un comme ci-dessus mais pour des matrices plus importantes il est utile de pouvoir les construire plus ou moins automatiquement. On peut utiliser pour cela l’opérateur d’incrémentation :. Par exemple pour construire une matrice à une ligne contenant les entiers de a à b on écrira [a :b], si on veut spécifier un pas différent de 1 on pourra écrire [a :pas :b] avec pas adapté (2 pour aller de 2 en 2 ou -1 pour diminuer de 1 à chaque pas) :
On peut ensuite construire d’autres matrices à partir des précédentes par concaténation
Il existe aussi des fonctions permettant de créer des matrices de tailles (p,n) déjà
remplies :
| matrice vide | matrice nulle | matrice identité | matrice de 1 | matrice aléatoire |
| [] | zeros(p,n) | eye(p,n) | ones(p,n) | rand(p,n) |
On peut aussi appliquer ces différentes fonctions à des matrices déjà existante pour obtenir une matrice de même taille (essayer zeros(A), zeros(B)).
La syntaxe des opérations matricielles est plus compliquée que pour les nombres flottants. En effet il faut distinguer
Commençons par les opérations terme à terme (par ordre de priorité croissante) :
à ne pas mélanger avec les opérations purement matricielles (par ordre de priorité croissante) :
il faut donc faire attention à ce que les tailles des matrices soient compatibles entre elles, sinon on obtiendra un message d’erreur :
sauf dans le cas où l’une des matrices est de taille 1 × 1 auquel cas on fera une opération terme à terme entre un nombre et une matrice :
Il faudra faire attention aux confusions possibles entre les différentes opérations matricielles, termes à termes ou scalaire. En particulier le cas des divisions matricielles peuvent conduire à des erreurs complexes :
| lorsqu’on veut faire une division terme à terme d’un réel par une matrice il
faut faire attention à la position du point du ./, s’il touche le réel à diviser le
point sera ignoré : 1./A donne la même chose que 1/A mais pas que (1)./A . Pour
une matrice A carrée 1/A est en fait l’inverse de la matrice (si il existe) qu’on peut
aussi obtenir par inv(A) ou A^(-1) . |
On peut vérifier la différence sur l’exemple suivant :
Pour les calculs d’inverse (qui peut ne pas exister dans certains cas) on obtient le même résultat qu’avec 1/A
Enfin, quand on a une matrice A de taille inconnue on peut récupérer le nombre de lignes et/ou de colonnes par les instructions size(A),size(A,1),size(A,2). On peut aussi utiliser length() quand la matrice a une seule ligne ou une seule colonne pour récupérer sa longueur.
Il existe beaucoup de fonctions Scilab utiles pour les matrices : sum pour faire la somme des coefficients d’une matrice, prod pour le produit , min et max pour trouver le coefficient le plus petit/le plus grand d’une matrice . . .
En général, lorsqu’on applique une fonction de 
dans à une matrice elle est appliquée
à chaque terme de la matrice. cependant certaines fonctions courantes possèdent une
définition matricielle que ne correspond pas simplement à l’application de la fonction à
chaque terme de la matrice. Dans Scilab les versions matricielles des fonctions réelles sont
désignées par le même nom avec un m en plus à la fin. Par exemple pour la fonction
exponentielle :
Scilab permet aussi d’effectuer les principales opérations de comparaisons entre nombres. Le résultat d’une telle opération est un booléen, Scilab reconnaît donc aussi le type Booléen et effectue les opérations élémentaires associées. Les deux valeurs “Vrai” et “Faux” sont deux constantes définies en Scilab par %T et %F (ou %t,%f), le tableau ci-dessous donne les principaux opérateurs associées aux booléens :
| égal | différent | inférieur | supérieur | inférieur | supérieur | ou | et | non |
| strict | strict | ou égal | ou égal | |||||
| == | <> | < | > | <= | >= | | | & | ~ |
| Attention à ne pas confondre avec l’opérateur de comparaison == avec celui
d’affectation =. En particulier si on veut affecter un résultat de comparaison dans
une variable (booléenne) mieux vaut utiliser des parenthèses :
bool_faux=(1==2),bool_vrai=(1==1) |
Voici quelques exemples d’utilisation des booléens avec Scilab :
On peut fabriquer des matrices de Booléens à partir de comparaisons directement entre matrices de réels, la fonction find permet de trouver les cases de valeur vrai dans une matrice Booléens :
Scilab permet de manipuler facilement les chaînes de caractères, pour créer une chaîne de caractères il suffit de la mettre entre apostrophes :
si on veut mettre une apostrophe dans une chaîne de caractères, il faudra la faire précéder elle aussi d’une apostrophe :
| Les fonctions Scilab qui doivent traiter des fichiers externes (lecture/écriture
dans des fichiers textes en général) prennent en entré des noms de fichiers
représentés par des chaînes de caractères. Il faut donc bien penser à encadrer les
noms de fichiers par des apostrophes ! |
La conversion d’un résultat de calcul en chaîne de caractère se fait par la fonction string, attention de ne pas confondre la chaîne affichée et la variable qu’elle représente :
Lors de l’exécution de certains programmes il peut être utile de faire apparaître des informations à l’écran, pour cela on peut utiliser la fonction disp :
On peut aussi fabriquer des matrices de chaînes de caractère dans un fichier avec les commandes write ou mputl et les lire avec read ou mgetl :
Attention mputl permet de récrire sur un fichier ce que ne permet pas write :
Un des concepts mathématique les plus important en informatique est le concept de
fonction. Scilab possède un type de variable function spécifique pour coder les fonctions,
d’ailleurs toutes les commandes que nous avons vu jusqu’ici sont en fait des fonctions
Scilab .
D’un point de vue mathématique, une fonction est une relation qui à un paramètre d’entré associe au plus une valeur en sortie :
dans définie par
f(x) = 1 + x2 sera codée en Scilab par :
|
Maintenant il faut sauver ce code dans un fichier (appelons le mafonction.sci) et le charger dans la session Scilab pour pouvoir ensuite l’utiliser. On peut pour cela utiliser n’importe quel éditeur de texte, mais Scilab possède un éditeur de texte, scipad, parfaitement adapté au langage Scilab (coloration syntaxique, numérotation des lignes, recherche de mots, interfaçage avec Scilab, débogage . . .). Pour lancer Scipad
une nouvelle fenêtre va s’ouvrir : c’est l’éditeur de texte que vous pouvez utiliser pour saisir le code de la fonction f.
| Lorsqu’on veut enregistrer des définitions de fonctions Scilab dans un fichier
on lui donnera un nom de la forme *.sci, c’est à dire avec l’extension sci. Par
contre si on veut sauvegarder dans un fichier une liste de commandes à exécuter
séquentiellement (c’est à dire un script) on utilisera plutôt un nom de fichier avec
l’extension sce. |
On peut écrire plusieurs définitions de fonctions dans un même fichier. Une fois le fichier sauvé on peut le charger dans Scilab depuis le menu execute de scipad (cf figure FIG.4) ou avec la commande exec depuis la console. Une fois chargée, on peut utiliser la fonction comme les autres fonctions Scilab . On peut aussi avoir besoin de définir une fonction en une seule ligne avec la commande, c’est possible avec la commande deff, mais moins maniable qu’avec la commande function (il faut une certaines compréhension des problèmes liés aux chaînes de caractères dans ce cas).
| Scilab est un logiciel de calcul numérique et pas un logiciel de calcul formel,
la commande f(x) n’a aucun sens si x n’est pas une variable définie (x=2 ou une
matrice par exemple). De même les commandes du type f(x)=1+x^2 ne définissent
pas une fonction Scilab . |
Si on veut appliquer cette fonction f à une matrice il faut se méfier des confusions entre opérations terme à terme et opérations matricielles. Par exemple, si x est une matrice carrée x^2 sera interprété comme un produit matriciel et non comme une élévation au carré de chaque terme. pour éviter ce genre de problèmes on utilisera la commande feval pour évaluer une fonction sur chaque valeur d’une matrice :
Cependant, en mathématiques, on peut considérer que les ensembles de départ et d’arrivé d’une fonction sont en fait des produits d’ensembles. Ce point de vue est valable dans Scilab ce qui permet de considérer facilement des fonctions ayant plusieurs variables en entrée et en sortie contrairement à d’autre langages (comme le langage C). Mais il faudra faire attention à bien récupérer les paramètres en sortie :
| lorsqu’une fonction renvoie plusieurs valeurs en sortie, il faut impérativement
récupérer chacune de ces valeurs dans des variables en suivant la syntaxe d’appel
donné dans la première ligne de la fonction :
function [y1,y2,y3]=nomfonction(x1,x2,x3)
sinon seul le résultat y1 sera affiché. les autres résultats du calcul seront perdus ! |
Pour bien utiliser les fonctions Scilab il faut aussi comprendre le problème des variables locales et des variables globales. Le mécanisme d’appel de fonction en conçu pour que les variables définies à l’intérieur du corps de la fonction n’interfèrent pas avec celle définies dans la session Scilab qui appelle la fonction.
| Lors de l’appel à une fonction, si une variable apparaissant dans le corps
de la fonction n’est pas définie dans l’environnement local (entre les commandes
function et endfunction) alors pour évaluer cette variable Scilab va chercher si
cette variable est définie dans la session d’où la fonction a été appelée (ce qu’on
appelle l’environnement global). Si la variable n’est pas définie dans l’environnement
global il y aura une erreur avec le message undefined variable. |
Autant que faire se peut, on évitera d’utiliser dans le corps d’une fonction des variables qui ne sont pas définies dans le corps de la fonction. si toute fois on a besoin d’utiliser des variables globales on pourra utiliser la commande global pour partager des variables entre plusieurs fonctions et l’environnement global.
Toutes les commandes vues depuis le début de ce chapitre forment les instructions de base du langage de programmation de Scilab . Mais pour aller plus loin il nous manque les instructions de base de l’algorithme que sont les branchements conditionnels et les boucles.
| pseudo-code | scilab
| |
|
|
||
|
 |
|
|
|
 |
|
|
|
 |
|
|
|
 |
|
|
|
 |
|
|
|
 |
|
|
|
|
||
|
|
||
|
|
||
|
|
||
|
|
Dans ce qui précède condition représente une expression dont l’évaluation conduit à une valeur booléenne (%t ou %f) et les action* représentent des suites de commandes Scilab à exécuter suivant le cas. La syntaxe de la boucle for mérite une explication particulière. En effet la syntaxe debut:pas:fin est exactement celle pour créer une matrice ligne dont les valeurs partent de debut pour arriver à fin par incrément de pas. On peut donc écrire les boucle for cpt=debut:pas:fin sous la forme :
le compteur cpt prendra alors successivement toutes les valeurs de L (dans l’ordre). Cette remarque est très utile pour réécrire certaines boucles plus simplement, en particulier dans des structure algorithmique de type pour tout , pour chaque .
| Dans une structure conditionnelle l’instruction then peut être omise, mais
si ce n’est pas le cas alors les instructions if et then doivent obligatoirement
être sur la même ligne et il doit y avoir un espace avant le then. |
Pour mieux comprendre prenons l’exemple très simple du calcul d’un factoriel. Si on veut écrire un script pour calculer 10 ! en utilisant la définition n! = n× (n- 1)! et 1! = 1, on écrira un fichier avec le code :
On sauve ce code dans un fichier script.sce que l’on peut exécuter dans Scilab avec la commande exec(’script.sce’) ou en cliquant sur l’onglet execute-->load into scilab de l’éditeur scipad.
| On évitera de lancer de lancer des instructions if, for, while
. . . directement dans la console et on privilégiera l’utilisation de fichiers (scripts).
En particulier lorsqu’une commande if, for ou while est lancée dans la console
aucune commande n’est exécutée tant que le end correspondant n’a pas été exécuté. |
On peut aussi utiliser le langage de programmation Scilab à l’intérieur d’une fonction Scilab . Par exemple pour la fonction définie par factoriel(n) = n! on aura :
On peut aussi utiliser la récursivité
Scilab possède une librairie graphique très puissante, qu’il n’est pas possible de
présenter entièrement ici. Pour pouvoir débuter avec Scilab il faut commencer par
comprendre comment tracer une courbe du plan comme le graphe d’une fonction par
exemple.
Pour tracer une courbe Scilab possède une fonction plot2d(x,y) qui va tracer une ligne brisée en reliant par des segments de droites les points de coordonnées (x(i),y(i)). Pour avoir un affichage convenable du graphe il faut donc avoir suffisamment de points pour que la courbe est un aspect “lisse” et pas celui d’une ligne brisée. La démarche est donc la suivante :
Pour améliorer l’aspect du graphe on pourra utiliser certaines options de la fonction plot2d (voir l’aide en ligne pour plus de détails), par exemple :
deff('y=f(x)','y=x+cos(x)')
x=[-%pi:0.01:%pi]'; y=feval(x,f); plot2d(x,y,5,axesflag=5,frameflag=6) xgrid(3)//grille verte 
|
Quand on a plus besoin du graphe on peut détruire la fenêtre ou utiliser la commande clf() pour effacer le contenu de la fenêtre. On peut aussi superposer des courbes en exécutant plusieurs fois plot2d sans effacer la fenêtre ou en une seule commande comme ci-dessous :
Pour les fonctions à deux variables on peut faire des graphiques en trois dimensions avec plot3d1(x,y,z). Il faudra cette fois découper le domaine en petits rectangles (c’est à dire découper l’intervalle des x et des y puis calculer les valeurs correspondantes de z=f(x,y). Pour faciliter l’interprétation du graphe Scilab permet un affichage des niveaux en couleur à l’aide d’une table des couleurs (colormap en anglais).
