Ce résumé est forcément incomplet: aidez-moi à l'améliorer en me faisant part de vos remarques par courrier. La version en ligne sera périodiquement mise à jour en tenant compte de vos suggestions.
Ce résumé doit vous permettre de traduire vos modes de pensée algorithmique (acquis en Java dans le cours de Programmation) dans le langage de programmation Scilab sans pour autant en devenir un expert. Le style qui en résulte n'est souvent pas le meilleur possible, mais il a le mérite d'être sûr, clair et compréhensif. En l'absence d'outils de débogage commodes, mieux vaut déclarer soigneusement les tableaux avec leurs dimensions, ne pas utiliser les raccourcis Scilab qui risquent de vous perdre en cas de débordement ou de généralisation hasardeuse. En conséquence, il sera judicieux de considérer les tableaux comme des tableaux Java et non comme les objets matriciels ou vectoriels complexes de Scilab, sauf quand on on fait de l'algèbre linéaire. On fera juste une exception pour les tableaux mono-dimensionnels (assimilables à des vecteurs ligne ou colonne.
1. Constantes et types de base
Tous les nombres manipulés sont
construits sur les réels; les entiers
ne le sont que par initialisation ou par « hasard »:
->3*(1+1.E-50)-3 = 0.
Les constantes numériques de base sont %e, %pi, %i, %eps ainsi que les constantes boolénnes %t, %f pour vrai et faux. Le calcul sur les nombres complexes se fait de façon usuelle, sous la forme 2+3*%i par exemple. La constante %eps définit la précision relative des calculs: deux nombres qui diffèrent de moins du quart de cette constante (!) sont indiscernables. Elle vaut 4.441E-16.
2. Structures de données
2.1 Tableaux (p. 7-10)
La structure de base est le tableau initialisé et
déclaré par exemple par
tableau=zeros(5,3) pour un tableau de zéros à 5 lignes et
3 colonnes,
tableau=eye(5,5) pour la matrice unité 5 x 5,
tableau=ones(5,1) pour un tableau de uns à 5 lignes et 1 colonne,
tableau=ones(1,5) pour un tableau de uns à 1 ligne et 5 colonnes.
Dans le cas des tableaux T de type (n,1) ou (1,n), on peut utiliser pour l'indexation le raccourci T(k) au lieu de T(k,1) ou T(1,k). Dans tous les autres cas une telle écriture produira des effets scabreux. C'est le seul raccourci que je conseille d'utiliser dans l'utilisation élémentgaire de Scilab.
On peut aussi déclarer des tableaux à trois dimensions et plus.
Scilab permet de manipuler les matrices ligne à ligne ou colonne par colonne. Je déconseille formellement d'utiliser ce genre de raccourci au moins au début.
2.2 Structures de données diverses (p. 32-38)
Les chaînes de caractères (p. 32) se définissent comme il est d'usage entre apostrophes doubles: "vive l''info". Je recommande vivement d'utiliser les apostrophes doubles pour définir les chaînes de caractères et de réserver l'apostrophe au symbole ou à l'opérateur de transposition matricielle.
Une structure de liste, un peu fourre-tout, est disponible, mais qu'on ne devrait pas avoir à utiliser (p. 33-36).
3. Opérations de base
On rencontre les mêmes que dans tous les autres langages de programmation.
Les expressions arithmétiques étendues aux matrices (p. 21-27):
^
étant l'opérateur puissance
A\b
résolution du
système linéaire Ax=b, spec(A) spectre, etc.
Les expressions booléennes:
~
Des fonctions mathématiques usuelles : p. 12
Des fonctions de génération aléatoire :
Des exemples d'opérations sur les tableaux (p. 12-14):
Des exemples de résolution de systèmes linéaires: p. 15-17.
4. Fonctionnelles de calcul
Ce sont les mêmes qu'en Java. Seule la syntaxe change un peu.
Conditionnelles (p. 31):
ou encore mieux, plus lisible et plus sûr:
if (x>5),
y=4,z=5,
else
z=2,y=2,
end
Plus généralement on peut mettre en cascade les conditionnelles
avec des elseif comme par exemple:
if (<condition>)
<liste d'instructions>,
elseif (<condition>),
<liste d'instructions>,
...
elseif (<condition>),
<liste d'instructions>,
else <liste d'instructions>,
end
Attention! Je déconseille l'usage du then car il est source d'ennuis lors de l'exécution s'il est mal placé sur la ligne (les then ne doivent jamais se trouver en début de ligne, il faut les mettre sur la même ligne que la condition).
Aiguillages sur une variable entière (p. 31):
Comme d'habitude on exécute la suite d'instructions qui correspond à la premi`ere expression rencontrée dont la valeur est celle de la variable de test; par défaut on exécute celle du else.
Itération bornée (p. 29):
La variable var, qui doit être une variable scalaire pour ne pas compliquer les choses, prend toutes les valeurs stockées dans l'expression tableau, successivement selon l'ordre induit par les colonnes du tableau. Le tableau le plus couramment utilisé est de type vecteur: (debut:pas:fin) qui en extension donne la suite d, d+p, d+2p,..., f, où d, p, f sont les valeurs respectives des expressions debut, pas et fin. On peut omettre pas lorsqu'il vaut 1.
Attention! La variable de boucle n'est active que pendant
l'exécution de la boucle; elle est ignorée en dehors. Si on veut
récupérer sa valeur, il faut le faire explicitement au moyen d'une
autre variable.
Si par hasard la variable de boucle était de type tableau,
l'exécution se ferait en mode vectoriel: à éviter absolument
pour commencer!
Itération conditionnelle (p. 30):
Cette instruction est, en tous points, semblable à celle de Java. La seule erreur serait d'oublier les virgules nécessaires après la condition et avant le end.
L'instruction break permet de sortir d'une quelconque de ces primitives.
6. Fonctions (p. 38-43)
Elles sont difficiles à définir à la console; il faut les définir sous Emacs ou Nedit puis les importer dans la fenêtre Scilab par getf. Le résultat, s'il y en a un, est indiqué sous la forme d'une liste (au sens de 2.2).
Forme générale de déclaration :
Exemple :
Exemple:
Il est impératif de donner une valeur aux diverses variables qui vont former le résultat. Cependant, il importe aussi de respecter un format de sortie qui est celui d'une liste hétérogène (voir 2.2). Avec le format complexe
-->function [y]= titi(x) -->y=[x,x,x] -->endfunction -->titi(3) ans = ! 3. 3. 3. ! -->function y=tata(x) -->y=[x,x,x] -->endfunction -->tata(3) ans = ! 3. 3. 3. ! -->titi(3)==tata(3) ans = ! T T T ! // pour s'amuser, on fait du boole'en -->function [y1,y2]=tutu(z) -->y1=z+2 -->y2=z-2 -->endfunction -->tutu(3) ans = 5. -->[x1,x2]=tutu(3) x2 = 1. x1 = 5. =======================================
Pour le passage des arguments, c'est un avatar des conventions de Java, et on les trouvera dans les résumés du cours ainsi qu'aux p. 40-41.
Enfin la fonction error(message) permet de sortir proprement d'une fonction en imprimant un message (p. 43).
Attention! L'usage de listes complexes et hétérogènes en sortie conduit à des erreurs d'exécution.
7. Fonctions d'affichage
7.1 Les principes
Très importantes sont les fonctions d'affichage graphique qui permettent représenter des graphes fonctionnels et des histogrammes. Fondamentalement, elles sont de deux types:
Ne pas oublier que les graphiques se superposent dans une même fenêtre et qu'on peut la nettoyer au moyen de la fonction xbasc(). D'autres fonctions de gestion des fenêtres graphiques sont explicitées p. 57.
7.2 Exemples
La fonction 'plot2d2( x, y)' trace une fonction 'en escalier', les vecteurs 'x' et 'y' doivent être de même type (ligne ou colonne) et de même dimension : le graphe est horizontal de 'x(1)' à 'x(2)' d'altitude 'y(1)' et ainsi de suite... mais d'après le célèbre théorème "piquets/intervalles" la dernière valeur de 'y' - à savoir 'y(
$
)' - n'est
représentée que comme une verticale d'abscisse 'x($
)'
de 'y($
-1)' à 'y($
)' et non par un trait horizontal,
la dernière marche manque !
Pour la tracer il faut rajouter
- à droite de 'x' un piquet de plus de valeur appropriée ;
- à droite de 'y' une valeur fictive ( 0 ou 'y($
)').
(remplacer 'a droite' par 'en bas', dans le cas de colonnes)
Exemple:
-->x = 1:4 x = ! 1. 2. 3. 4. ! -->[x,5] ans = ! 1. 2. 3. 4. 5. ! --> y = x; -->y($) ans = 4. -->[y, y($)] ans = ! 1. 2. 3. 4. 4. ! -->xbasc(); plot2d2( x, y, 1, "011", " ", .. [0,0,6,5], [0,6,0,5]) --> // Il manque la dernie`re marche (que le saut) -->xbasc(); plot2d2( [x,5], [y,y($)], 1, "011", .. " ", [0,0,6,5], [0,6,0,5]) --> // Maintenant elle y est (en entier) !
Les arguments optionnels ont été délibérément choisis pour que le cadre déborde largement [de +1] tout autour du graphe.
La fonction 'hisplot( x, data)' a comme arguments principaux deux vecteurs (eventuellement de types distincts) - 'x' est une suite de piquets encadrant des intervalles ; - 'data' des données, aléatoires ou non, en quantité, en général, beaucoup plus grande que la taille de 'x'. 'hisplot' commence par calculer l'histogramme des 'data' en fonction des intervalles déterminés par 'x' comme à la page 18 du polycopié 'Aléatoire' de Francis Comets, puis en trace le graphe 'en rectangle'.
Ces deux fonctions ne font pas le même travail, 'histplot' en fait plus : pour que 'plot2d2' fasse la même chose l'argument 'y' doit être calculé avec la formule des histogrammes (les fréquences normalisées par les longueurs d'intervalle) à partir de données ou de tirages aléatoires.
8. Lecture et écriture sur fichier
Pour charger un fichier de définitions de fonctions on utilise la primitive getf ("nom_de_fichier"); si l'une des fonctions a été modifiée un avertissement le signale:
Pour sauver un ensemble de valeurs, ou en acquérir depuis un fichier, on utilisera les fonctions save et load qui permettent de sauver dans un fichier des variables, ou de les charger depuis une sauvegarde: voir p. 18:
On peut aussi utiliser des mécanismes plus sophistiqués,
inspirés de Fortran comme les fonctions
write et read, dont la
syntaxe type est la suivante:
write(unit,variable,format)
write(unit,nombres,format).
Dans ces expressions:
- unit est un nom de fichier
(éventuellement %io(1)
pour la fenêtre Scilab en lecture et
%io(2)
pour la fenêtre Scilab en écriture);
- variable est une expression Scilab dont la valeur sera
écrite dans le fichier;
- nombres est une suite d'entiers ou de variables entières)
qui indique le nombre de lignes et/ou d'objets à lire dans le fichier;
- format indique comment les valeurs sont codées dans le
fichier (ce paramètre est facultatif).
On trouvera des exemples commentés en section 3.5.7 (p. 48-51).
9. Les bidouilles au niveau exécution (le "toplevel")
Les commandes suivantes ont aussi leur intérêt:
La barre de menus dans la fenêtre d'exécution Scilab comprend plusieurs touches utiles:
10. Les erreurs d'exécution
En voici un petit florilège qui ne manquera pas de prospérer.
error 8 : addition incohérente
error 10 : multiplication incohérente
error 21 : index invalide
error 42 : incompatible RHS (membre droit d'instruction)
error 58 : incorrect number of arguments in function call
error 241 : File exo1.sci does not exist or read access denied