suivant: Calcul numérique monter: CN_ECS précédent: Graphiques Table des matières Index

Sous-sections

Programmation

Types de fichiers

Scilab travaille à partir d'un répertoire de base, qui est donné par la commande 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 $\fbox{Fichier}$ -> $\fbox{Changer de répertoire}$

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 à $\fbox{Applications}$ -> $\fbox{Editor}$ .
Par le menu $\fbox{Execute}$ 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.

$\includegraphics[width=14cm]{scilab_scipad.eps}$

Scilab distingue trois sortes de fichiers.

Les fichiers de sauvegarde.
Ce sont des fichiers binaires, créés par la commande 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.
Les fichiers de commandes.
Ce sont des fichiers texte dont le nom se termine par l'extension .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.
Les fichiers de fonctions.
Comme les fichiers de commandes, ce sont des fichiers texte, mais leur nom se termine par .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 $\fbox{Fichier}$ 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 $\fbox{Execute}$ .

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.

Style de programmation

La philosophie de Scilab est celle d'un langage fonctionnel. Au lieu de créer un logiciel avec programme principal et procédures, on étend le langage par les fonctions dont on a besoin. Le rôle du programme principal est joué par un fichier de commandes contenant essentiellement des appels de fonctions.

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

l'instruction sera exécutée pour 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 $v=(v_i)_{i=1\ldots n}$ et $w=(w_j)_{j=1\ldots m}$ sont deux vecteurs, on souhaite définir la matrice $A=(a_{i,j})$ , où $a_{i,j}=v(i)^{w(j)}$ . 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

suivant: Calcul numérique monter: CN_ECS précédent: Graphiques Table des matières Index

Georges Koepfler 2011-01-19