Introduction à Scilab

par Jean-Marc Steyaert
LIX, Polytechnique

1. Prononcer saïlab pour Sci-{entific} Lab...

2. Logiciel développé à l'INRIA (projet Méta), concurrent (clone?) gratuit de MATLAB

3. Outil de calcul numérique, pas de calcul formel, conçu pour aider à faire des simulations

4. Documentation sur le site Web :
http://www-rocq.inria.fr/scilab

5. Documentation fournie : Une introduction à Scilab, par Bruno Pinçon, E.S.I.A.L., Institut Élie Cartan, orientée « analyse numérique ».

6. Compléments pour les probabilités sont fournis dans les exercices.

==============================================================================

Devenir polyglote informatique:
pourquoi? comment?

1. Historique: les divers formalismes pour le calcul (Pascal, Vaucanson, Babbage, Gödel, Church, Post, Turing, Von Neumann,...

2. Les langages de programmation modernes: plusieurs centaines

3. Au moins une dizaine utilisés couramment

4. Les ancêtres encore actifs: Lisp, Cobol, Fortran

5. Les petits derniers: TI92, Magma, Java, CPL, PVM, etc. avec leurs spécialisations

6. Quel est le meilleur?

==============================================================================

Le principe fondamental...

Thèse de Church: Tout système de calcul non trivial est équivalent à tout autre.

et la dure réalité...

Certains langages vont mieux pour faire certaines choses dans un certain style; aucun ne peut prétendre être la panacée.

Conséquence...

Il faut savoir passer de l'un à l'autre!

... De Java à Scilab .../...

============================================================================

Les objets de base

Le type des objets n'est pas déclaré explicitement; Scilab attribue automatiquement un type aux variables en fonction de leur première affectation :
- nombre
- booléen
- chaîne de caractères

Exemples:
des constantes         %e, %pi, %i. %eps. %inf
des nombres réels    -2, 1.1414, .3183098
les booléens         %t et %f (vrai et faux)
des chaînes       "entrez la valeur de x"
"c''est la vie" -> c'est la vie

============================================================================

Scilab transforme et arrondit les nombres en nombres décimaux et livre ses valeurs avec discrétion

-->f=(sqrt(5)-1)/2
 f  =
    0.6180340  
-->f-0.6180340
 ans  =
  - 1.125E-08  

-->f-.61803398874989
 ans  =
    4.885E-15  
-->f-.6180339887498948
 ans  =
    1.110E-16  
-->f-.6180339887498949
 ans  =
    0.  
-->f-.618033988749894885
 ans  =
    0.  
-->\%eps
 \%eps  =
    4.441E-16

============================================================================

Scilab les assemble en tableaux de dimensions quelconques

-->b=3 
 b  =
    3.  
-->b(2,1)=5
 b  =
!   3. !
!   5. !
-->b(2,2)=7 
 b  =
!   3.    0. !
!   5.    7. !

On note que c'est toujours la m\^eme variable !

c=[1,2,3;4,5,6;..
7,8,9;10,11,12]
 c  =
!   1.     2.     3.  !
!   4.     5.     6.  !
!   7.     8.     9.  !
!   10.    11.    12. !

La matrice identit\'e
-->c=eye(3,3)
 c  =
!   1.    0.    0. !
!   0.    1.    0. !
!   0.    0.    1. !
-->c=eye(2,3)
 c  =
!   1.    0.    0. !
!   0.    1.    0. !
-->c=eye(3)
 c  =
    1.  
-->c=eye(2,2,2)
             !--error    42 
incompatible RHS  (right hand side)

De la place en g\'en\'eral
--> a=[1 2 3;4 5 6]
 a  =
!   1.    2.    3. !
!   4.    5.    6. !
--> matrix(a,1,6)
 ans  =
!   1.    4.    2.    5.    3.    6. !
--> matrix(a,3,2)
 ans  =
!   1.    5. !
!   4.    3. !
!   2.    6. !

Pour voir grand
-->z=zeros(100,100,10); 

-->z=zeros(100,100,100);
 !--error    17 
stack size exceeded! (Use stacksize function 
to increase it)
Memory used for variables :      6439
Intermediate memory needed:   1000007
Total  memory available   :   1000001
at line      11 of function zeros    called by :  
at line    15 of function zeros         called by :  
z=zeros(100,100,100);

=============================================================================

Les expressions arithmétiques

- opérateurs de base : +, -, *, /, ^ sur les réels (comme en Java)

- étendus aux tableaux, dans leur sens usuel des math'ematiciens : A*B produit matriciel, produit scalaire, produit extérieur selon les dimensions de A et B

- variantes pour traiter élément par élément : A.*B

- opérateurs sur les matrices : A' transposition, inv(A) inverse, A\b système linéaire, spec(A) spectre, etc.

Les expressions booléennes

- opérateurs de comparaison : == , < , > , <= , >= , <>

- opérateurs logiques : & , | , ~

============================================================================

Les primitives de contrôle

- conditionnelle :
if condition then
instruction, instruction,... else
instruction, instruction,... end

- conditionnelle en cascade avec elseif

- branchement :
select var_test,
case val1, instruction, instruction,...
case val2, instruction, instruction,...
...
else instruction, instruction,...
end

La suite d'instructions correspondant à la valeur de var_test est sélectionnée et exécutée.

L'usage du end est nécessaire dans les fonctions.

=============================================================================

Exemples

-->if 3<0 then
-->x=3 else   
-->x=5, y=7   
 x  =
    5.  
 y  =
    7.  


-->num=17
 num  =
    17.  
-->select num, case 1, y="",
-->case 17, y="ouf", z=2
 y  =
   ouf   
 z  =
    2.

============================================================================

Les primitives de contrôle : les boucles

- itération bornée :
for var=tableau,
instructions,
...
instructions,
end

Le tableau est fabriqué par un des constructeurs :
var = [1,2,3,5,7,11,13,17,19]
var = 1:.1:2      ([1,1.1,1.2,1.3,...,2])
var = rand(3,3)

La variable var est interne à la boucle : sa valeur est non définie dès la sortie de la boucle.

Dans le cas d'une itération matricielle, varprend successivement les valeurs des colonnes de la matrice.

============================================================================

- itération conditionnelle :
while condition,
instructions,
...
instructions,
end

Exemple (Syracuse):
while x<>1,
if pmodulo(x,2)==0 then x=x/2
else x=floor((3*x+1)/2) end,
disp(x),
end

- de l'usage du break dans les itérations : break fait sortir de la boucle qui le contient ;

while %t,           {%t == vrai}
if pmodulo(x,2)==0 then x=x/2
else x=floor((3*x+1)/2) end,
disp(x),
if x==1 then break end,
end

Idem pour les boucles for

============================================================================

Les fonctions

* Difficiles à utiliser à la console
* À définir sous Emacs puis télécharger

- forme générale de déclaration :
function [y1,y2,...,yk] = nomfonction(x1,x2,...,xl)
.....
corps de la fonction
.....
y1=..., instructions, ..., yk=...,
endfunction

Exemple :
function [y1,y2]=f(x1,x2)
y1=x1-x2
y2=x1+x2
endfunction

function bonjour(x)
for i=1:1:x
disp("Bonjour")
end
endfunction

============================================================================

Fonctions : les variables

- arguments : non modifiables

- résultats : seul moyen de passer de nouvelles valeurs

- variables internes : inconnues de l'extérieur

Exemple :
function [y]=testargs(x)
y=x+g          // g doit être globale
disp(g,"g = ") // pour les curieux
g(5,2)=17      // rien à voir avec l'autre !!
disp(g,"g = ") // bien sûr
endfunction

à essayer avec g=11...

============================================================================

Fonctions utiles en probas

- l'aléatoire :
rand(n,m) -> matrice nxm
rand("loi"), loi=normal, uniform -> loi normale, uniforme
rand("seed",germe) pour changer le point de départ du générateur congruentiel.

la fonction grand permet de traiter encore plus de cas de lois (beta, binomial, chi, gamma, poisson, etc.)

- les affichages :
histplot(n,X,opts) -> n est un entier (nombre de classes) ou le vecteur des valeurs seuils, X est le tableau des valeurs, opts les paramètres comme dans plot2d
plot2d(X,Y,opts) -> X est le tableau des abscisses, Y est le tableau des ordoonnées, opts les paramètres comme dans histplot.

En général, si f est une fonction bien programmée, et si X est un vecteur, Y=f(X) sera le vecteur des ordonnées.

============================================================================

Comment ça s'utilise?

1. Ouvrir une fenêtre xterm, se mettre dans le répertoire désiré (Probas), ouvrir une fenêtre emacs et une fenêtre scilab.

2. Dans la fenêtre scilab lancer la commande
diary(td1.dia)
qui enregistrera le contenu de la session jusqu'à
diary(0)

3. Tester sous scilab le scénario de calcul, le traduire en fonctions dans la fenêtre emacs dans un fichier td1.sci; revenir dans scilab pour lire ce fichier et définir les fonctions qu'il contient
readf(td1.sci).

4. Poursuivre la mise au point, jusqu'à satisfaction...

5. Et pour tout le reste voir la brochure...

============================================================================

Conclusion