pwd
. C'est là qu'il va chercher par défaut
les fichiers à charger ou à exécuter. On peut le changer
par la commande chdir
. A défaut, il faut saisir le chemin d'accès
complet du fichier que l'on souhaite charger ou sauvegarder. Le plus
facile est d'utiliser le menu de l'interface
Dès que les calculs à effectuer requièrent plus de quelques lignes
de commande, on a intérêt à saisir ces lignes dans un fichier
exécutable externe. Dans l'interface de Scilab,
les seules commandes qui apparaîtront seront les exécutions ou les
chargements répétés de fichiers externes.
Il est conseillé de maintenir ouvertes deux fenêtres : la fenêtre Scilab,
et une fenêtre d'édition. Emacs sous Linux, WordPad sous Windows.
Le meilleur outil pour créer, modifier les fichiers .sce
et .sci
est l'éditeur de Scilab : SciPad accessible grâce à
->
.
Par le menu
de SciPad, on peut charger (Load) ou évaluer (Evaluate) le contenu.
Cet éditeur affiche les mots clefs de Scilab en couleurs,
ceci permet d'éviter des erreurs de frappe.
Scilab distingue trois sortes de fichiers.
save
et rappelés par load
. Ceci
permet de reprendre un calcul en conservant les valeurs déjà affectées.
On peut aussi enregistrer des variables dans un fichier texte par write
et les rappeler par read
.
.sce
.
Ils contiennent des suites d'instructions Scilab, qui sont exécutées
successivement par exec
. Enregistrez dans le
répertoire courant les trois lignes suivantes sous le nom
losange.sce
.
Attention, la dernière ligne du fichier doit obligatoirement
se terminer par un retour-chariot pour être prise en compte.
x=[0,-1,0,1;-1,0,1,0] y=[-1,0,1,0;0,1,0,-1] plot2d(x,y)
La commande exec("losange.sce")
affichera x
, puis
y
, puis tracera un losange.
On peut écrire une matrice dans un fichier texte à exécuter
(par exemple pour importer des données issues d'un tableur). Dans ce cas,
les lignes du fichier, si elles correspondent aux lignes de la matrice,
ne doivent pas se terminer par deux points. Par exemple le fichier
saisie.txt
peut contenir les trois lignes (terminées par un
retour-chariot) :
A=[1,2,3; 4,5,6; 7,8,9];
La commande exec("saisie.txt")
affectera la matrice A
.
.sci
.
Ils contiennent la définition d'une ou plusieurs
fonctions. Ces fonctions sont disponibles pour Scilab
après les avoir chargées et compilées par getf
ou exec
.
La définition d'une fonction commence obligatoirement
par une ligne qui déclare le nom de la fonction, les variables d'entrée
x1,...,xm
et le vecteur des variables de sortie
[y1,...,yn]
.
function [y1,...,yn] = nom_de_la_fonction(x1,...,xm)endfunction
Là encore, il ne faut pas oublier de terminer la dernière ligne par un
retour-chariot. Enregistrez par
exemple dans le fichier cloche.sci
les lignes suivantes.
function d = cloche(x) // CLOCHE densite de la loi normale N(0,1) coef=1/sqrt(2*%pi) d = coef*exp(-x.^2/2); endfunction
Si ce fichier est placé dans le répertoire courant,
getf("cloche.sci")
charge et compile la nouvelle fonction.
clear getf("cloche.sci") t=[-3:0.1:3]; y=cloche(t); d // erreurs : d variable interne x // x variable interne coef // coef variable interne plot2d(t,y) fplot2d(t,cloche) intg(-5,1.96,cloche)
Le menu
permet d'exécuter le contenu d'un fichier.
Si on utilise l'éditeur SciPad, on exécute les fichiers de commande et on
charge/compile les fonctions en passant le menu
.
Autant pour les fichiers de commande que pour les fichiers de fonctions, une présentation claire et abondamment commentée est vivement recommandée...
Les fichiers les plus couramment utilisés sont les fichiers de commandes
et les fichiers de fonctions.
Un fichier de commandes peut réaliser les mêmes tâches qu'une fonction et
réciproquement. Pour une utilisation courante ou de mise au point,
les fichiers de commandes permettent de suivre le contenu de toutes
les variables. Pour une programmation plus avancée, il est
préférable de définir
des fonctions, car leurs variables internes restent locales.
Un même fichier .sci
peut contenir plusieurs fonctions.
Les fonctions du langage sont regroupées dans des librairies qui
contiennent leur code Scilab (fichiers texte .sci
), et
leur code compilé (fichiers .bin
). On peut transformer
un ensemble de fichiers de fonctions en librairie, en sauvant
les versions compilées et en rajoutant les fichiers d'aide.
Certaines erreurs difficiles à trouver proviennent de confusions entre
noms de variables ou de fonctions. Scilab garde en mémoire tous les
noms introduits tant qu'ils n'ont pas été libérés par clear
.
Il est donc prudent de donner des noms assez explicites aux
variables. Les variables introduites dans la session ou dans les
fichiers de commandes sont globales. Par
défaut, toutes les variables introduites à l'intérieur d'une fonction
sont locales. C'est une des raisons pour lesquelles on a intérêt
à définir de nouvelles fonctions plutôt que d'utiliser des
fichiers de commande exécutables.
Pour comparer l'efficacité des algorithmes, on dispose de timer
qui permet de compter le temps CPU écoulé entre deux appels consécutifs.
A=rand(200,200); b=rand(200,1); timer(); x=A\b; timer() // resout le systeme lineaire timer(); x=inv(A)*b; timer() // inverse la matrice : plus lent A=rand(1000,100); B=rand(1000,100); format("v",25) timer(); C=A.*B; timer() clear C timer(); for i=1:100,for j=1:100, .. C(i,j)=A(i,j)*B(i,j); end, end; timer() format("v",10)
Scilab propose les commandes des langages de programmation classiques.
Commandes principales | ||||
Pour | for |
x=vecteur, |
instruction; |
end |
Tant que | while |
booleen, |
instruction; |
end |
Si | if |
booleen then, |
instruction; |
end |
Sinon | else |
instruction; |
end |
|
Sinon si | elseif |
booleen then, |
instruction; |
end |
Selon | select x |
case 1 ... |
then ... |
end |
La boucle for
peut aussi s'appliquer à une matrice.
Dans :
for x=A, instruction, end
x
prenant successivement comme valeurs les colonnes de la
matrice A
.
Scilab est un outil de calcul. Pour un
problème compliqué, on aura tendance
à utiliser Scilab pour réaliser des maquettes de logiciels et
tester des algorithmes, quitte à lancer ensuite les gros calculs dans un
langage compilé comme C. Cela ne dispense pas de
chercher à optimiser la programmation en Scilab, en utilisant au
mieux la logique du calcul matriciel.
Voici un exemple illustrant cette logique. Si
et
sont deux vecteurs, on souhaite définir la matrice
, où
. Il y a
plusieurs solutions. Dans les commandes qui suivent,
v
est un
vecteur colonne et w
est un vecteur ligne.
for i=1:n, for j=1:m, A(i,j)=v(i)^w(j); end; end // a eviter A=v^w(1); for j=2:m, A=[A,v^w(j)]; end // mieux A=v(1)^w; for i=2:n, A=[A;v(i)^w]; end // equivalent A=(v*ones(w)).^(ones(v)*w) // preferable
Si on doit appeler plusieurs fois ce calcul, on aura intérêt à en faire une fonction.
Scilab offre toutes les facilités pour programmer correctement : protection des saisies, utilitaires de débuggage...
Protection et débuggage | |
disp |
affichage de variables |
type |
type des variables |
typeof |
idem |
argn |
nombre de variables d'entrée |
break |
sortie de boucle |
pause |
attente clavier |
return |
sortie de fonction |
resume |
idem |
error |
message d'erreur |
warning |
message d'avertissement |