Baniere Saphir Control
http://www.saphir-control.fr/

bar
BACK

Scilab: un logiciel libre pour le calcul scientifique
deuxième partie



Tous ces articles en ligne sur Scilab ont été écrits pour LINUX MAGAZINE FRANCE par les développeurs du Scilab Group. Les articles sont sous licence FDL (Free Documentation Licence)

Des centaines de fonctions mathématiques préprogrammées, un langage de programmation de haut niveau, simple et puissant, des fonctionnalités d'imports-exports de données en formats variés et des outils graphiques puissants font de Scilab la super calculatrice incontournable sous Linux.

Dans Scilab, la plupart du temps on manipule des vecteurs et des matrices. Les opérateurs et les fonctions élémentaires sont conçus pour favoriser ce type de manipulation et de manière plus générale, de permettre la vectorisation des programmes. Certes le langage Scilab contient des opérations conditionnelles ( if-then-else-elseif), des boucles (while, for) et la programmation récursive, mais la vectorisation permet de limiter le recours à ces fonctionnalités qui ne sont jamais très efficaces dans le cas d'un langage interprété. Par exemple, pour tracer la fonction cos(2x2) entre 0 et 5, on peut définir sans boucle le vecteur contenant les points à afficher, de la manière suivante : 

-->x=[0:999]*5/1000;
On peut, par la suite, utiliser ce vecteur pour évaluer la fonction et tracer la courbe (Fig. 1) : 

-->y=cos(2*x^2);  
 
-->plot2d(x,y)

Figure 1: Exemple d'un plot2d
L'opérateur <<:>> dans [0:999] permet de définir un vecteur d'entiers allant de 0 à 999.

On peut trouver, sans aucune boucle, les points où la fonction cos(2x2) est extrémale en utilisant le fait que la dérivée aux points extrêmes change de signe. On calcule d'abord le vecteur dy dont les composantes sont yi+1-yi, puis le vecteur p contenant (yi+1-yi)(yi+2-yi+1) et enfin on cherche les composantes négatives de p : 

-->dy=y(2:$)-y(1:$-1);

-->p=dy(1:$-1).*dy(2:$);  
 
-->x_ext=x(find(p<=0)) 
 x_ext  =
         column 1 to 8 
! 1.25  1.765  2.165  2.5  2.795  3.065  3.31  3.54 !
 
         column  9 to 15 
! 3.755  3.96  4.15  4.335  4.515  4.685  4.85 !
L'opérateur <<$>> désigne l'indice du dernier élément (1000 dans le cas de y et 999 dans le cas de dy) et l'opérateur <<.*>> désigne le produit élément par élément. Le résultat de p<=0 est un vecteur de booléens dont les indices correpondant aux éléments ayant la valeur vraie (%t en Scilab) sont determinés par la fonction find .

L'absence de <<;>> à la fin de la dernière instruction actionne l'affichage du résultat.
Les graphiques 3D sont aussi souvent réalisés en utilisant des opérations matricielles. Par exemple pour tracer la surface f(x,y)=10sin(x)cos(y), 0 £ x < p, 0£ y < 2p, on peut faire: 

-->x=[0:99]*%pi/100;y=[0:99]*2*%pi/100;
 
-->M=10*sin(x)'*cos(y);plot3d(x,y,M)
{short description of image}

Figure 2: plot3d de la fonction 10sin(x)cos(y)
L'opérateur <<'>> correspond à la transposition donc sin(x)'*cos(y) est le produit d'un vecteur colonne de taille 100 par un vecteur ligne de taille 100, ce qui est une matrices à 10000 éléments.

Par des opérations de souris et en utilisant les menus de la fenêtre graphique, on peut faire tourner le plot 3D (Fig. 2) dans l'espace pour obtenir un point de vue optimal et sauver le résultat en divers formats (Postscript, xfig, gif, ...).

La programmation
Un programme Scilab correpond à l'enchaînement d'une suite d'instructions. Ces instructions peuvent être placées dans un fichier (qu'on appelle un script) à l'aide d'un éditeur de texte comme emacs ou vi. Si on nomme par exemple le fichier toto.sce , on peut alors exécuter le script avec l'instruction : 

-->exec toto.sce
Le langage Scilab permet aussi de définir de nouvelles fonctions. Le mot-clé function est utilisé pour déclarer le début d'une fonction dans un fichier texte. 

function v=mafonc(v,op)
// cette fonction recoit un vecteur v
// et une chaine de caracteres indiquant
// l'operation a effectuer sur v
if v==[] then return;end
select op
case "aleatoire" then
// dans ce cas on melange de maniere 
// aleatoire les elements de v
  vrand=rand(v);  // rand est un generateur
                  // de nombre aleatoire
  [junk,ind]=sort(vrand);
  v=v(ind);
case "decroissant" then
// dans ce cas on trie les elements de v
// dans l'ordre decroissant
  v=sort(v);
case "croissant" then
  v=-sort(-v);
else
  error("operation non prevue !");
end
Noter l'utilisation de <<//>> pour indiquer les commentaires. La fonction mafonc, définie dans le fichier mafonc.sci peut alors être <<chargée>> et utilisée dans Scilab comme suit : 

-->getf mafonc.sci

-->y=mafonc([2,5,4],"aleatoire")
 y  = 
!   5.    2.    4. !
Il existe aussi la possibilité de définir des fonctions <<en-ligne>>. Par exemple l'instruction sort(x) trie les élements de x dans l'ordre décroissant. On peut alors facilement définir en ligne la fonction trie qui trie dans l'ordre croissant: 

-->deff("y=trie(x)","y=-sort(-x)")
Une fonction est un objet dans Scilab au même titre qu'un vecteur ou une matrice de chaîne de caractères. Dans l'exemple suivant, on passe une fonction comme argument d'une autre fonction : 

function x=bubble(x,fun)
// cette fonction realise un bubble sort
// x est un vecteur de nombres complexes
// fun est une fonction definissant
// la relation d'ordre a utiliser
n=size(x,"*"); // n est le produit des
               // 2 dimensions de x
fini=%f;
while ~fini

  fini=%t
  for i=1:n-1
    if fun(x(i),x(i+1)) then
      tmp=x(i);
      x(i)=x(i+1);
      x(i+1)=tmp;
      fini=%f
    end
  end
end
Pour utiliser cette fonction, il faut d'abord définir une fonction définissant la relation d'ordre choisie, par exemple la relation d'ordre correspondant à la norme : 

function test=cmp_nrm(a,b)
test=norm(a)>norm(b); // test est booleen
Alors pour trier un vecteur de nombres complexes suivant leurs normes, il suffit de charger les deux fonctions et de faire par exemple : 
-->bubble([1+%i,2,4*%i],cmp_nrm)
 ans  =
! 1.+ i   2.  4.i !
La fonction bubble a peu d'intérêt dans ce cas car le tri des vecteurs peut en général se faire de manière plus efficace par vectorisation. Mais si la structure à trier contient des éléments autres que des simples scalaires, elle peut être très utile. Mais pour cela il faut modifier bubble pour qu'il accepte des structures. Une façon de coder des structures dans Scilab est d'utiliser la commande list. Une structure peut contenir des objets hétérogènes : des matrices, des chaînes de caractères, des booléens, des polynômes, et même d'autres structures. Les éléments d'une structure peuvent être manipulés presque comme ceux d'un vecteur, donc les modifications à faire dans bubble sont minimes ; en particulier il suffit de remplacer size(x,"*") par size(x) car contrairement aux vecteurs, qui ne sont que des matrices particulières, les structures n'ont qu'une seule dimension. En utilisant la même fonction cmp_nrm, on peut maintenant (ayant fait la modification dans bubble), trier des matrices selon leur norme comme suit : 

-->ll=list(rand(2,3),[1,2;5,4],eye(2,2));

-->ln=bubble(ll,cmp_nrm)      
 ln  = 
       ln(1)
 
!   1.    0. !
!   0.    1. !
 
       ln(2)
 
!   0.84974    0.87821    0.56084 !
!   0.68573    0.06837    0.66235 !
 
       ln(3)
 
!   1.    2. !
!   5.    4. !

Scilab contient des centaines de fonctions préprogrammées pour résoudre des problèmes mathématiques spécifiques. Mais toutes les fonctions ne sont pas écrites en langage Scilab. Les fonctions très élémentaires et les fonctions pour lesquelles la vitesse d'exécution est un facteur crucial (par exemple l'inversion d'une matrice) sont codées en dur (en C ou fortran). On appelle ces fonctions des primitives.

L'utilisateur peut aussi écrire ses programmes en dur et les interfacer avec Scilab. Cela peut se faire en utilisant les fonctions link ou addinter pour définir de nouvelles primitives.

L'interface utilisateur
Scilab permet de développer des applications interactives complètes. Pour cela, il propose des boîtes de dialogues programmables. Par exemple : 

-->age=x_dialog(["Quel est votre age ?"],"18")
{short description of image}
et d'autres fonctions de ce type comme x_message, x_choose, etc...

On peut aussi, de manière dynamique, rajouter des boutons et des menus aussi bien à la fenêtre principale Scilab qu'aux fenêtres graphiques. Dans les fenêtres graphiques, on a accès aux événements souris (position de la souris, bouton pressé, etc...). Pour mieux comprendre l'étendue de ces fonctionnalités, il suffit de lancer la démo Scicos qui est un éditeur schéma-bloc et un simulateur de systèmes dynamiques dont l'éditeur est écrit entièrement en Scilab.

Il existe aussi une interface Tcl/Tk dans Scilab. Elle permet de développer des GUIs en Tcl/Tk utilisables dans Scilab.

Comment obtenir de l'aide
Scilab contient un manuel en ligne. Pour obtenir de l'aide sur une fonction dont on connaît le nom, par exemple plot2d, il suffit de faire : 

-->help plot2d
La page du manuel correspondant à plot2d s'ouvre alors dans une fenêtre. Si on ne connaît pas le nom de la fonction, on peut faire une recherche par mots-clés, par exemple : 

-->apropos plot
On obtient alors la liste des fonctions contenant plot comme mot-clé (les mots-clés sont bien-entendu en anglais). On peut aussi accéder à ces fonctionnalités en cliquant sur le bouton help de la fenêtre principale de Scilab. Dans ce cas, on obtient, en plus, une liste souvent très utile des fonctions classées par thème. Il existe aussi un ensemble de démos des applications types disponibles depuis les menus de la fenêtre principale.

Il existe aussi des manuels (en anglais) disponibles par ftp anonyme qui décrivent différentes applications de Scilab.

Conclusion
Il est difficile de faire ici une présentation complète de toutes les potentialités de Scilab. Certaines potentialités seront décrites dans des articles futurs, en particulier le prochain article abordera la notion d'objet et de surcharge d'opérateurs.

Ramine NIKOUKHAH.
scilab@inria.fr
http://www-rocq.inria.fr/scilab/
ftp://ftp.inria.fr/INRIA/Projects/Meta2/Scilab/
This document was translated from LATEX by HEVEA.