Introduction à Scilab
3. Programmation. Fonctions Scilab

d'aprè s Jean-Philippe Chancelier & Michel de Lara

Date: 30 décembre 2004 (dernière date de mise à jour)

Table des matières

1 Programmation

Ouvrir une fenêtre Scilab

Pour ces travaux pratiques d'introduction à Scilab, il vous faut lancer le logiciel Scilab et disposer ainsi d'une fenêtre permettant de saisir et d'exécuter des instructions.

Dans ces premiers travaux pratiques, vous trouverez une série de lignes de commandes Scilab précédées du signe -->. Pour commencer, il vous suffit de les recopier ou de les saisir par copier-coller (sans -->) pour les exécuter immédiatement dans la fenêtre Scilab.

Charger des instructions Scilab

Quand il y a une succession de lignes de commandes, il est préférable de disposer d'un éditeur (par exemple celui de Scilab), d'ouvrir un fichier (par exemple nom_du_fichier.sci), d'y écrire les lignes de commandes puis de les exécuter en cliquant l'item Exec... sur le menu Fichier. On peut aussi taper sous Scilab l'instruction : exec("nom_du_fichier.sce")

Une bonne pratique à adopter : dè s l'ouverture d'une session Scilab, mettez-vous dans votre répertoire de travail, en cliquant sur l'item Changer... du menu Fichier.

Commentaires

Toute ligne débutant par // est une ligne de commentaires.

1 Programmation

Scilab est un langage interprété où la transmission des arguments se fait par valeur, même pour les objets de type matrices. Il faut donc éviter les boucles qui peuvent être très inefficaces en terme de temps de calcul. Pour cela, il faut utiliser si possible des opérateurs vectoriels qui font la même chose.

Si un fichier ne contient que des fonctions Scilab, alors on lui donne un nom de fichier avec suffixe .sci. Ce fichier peut alors être

soit exécuté dans Scilab par l'instruction exec
soit charger dans l'environnement courant par l'instruction getf.

Scilab est aussi un langage de programmation qui permet d'écrire des scripts (suite d'instructions Scilab dans un fichier) et des fonctions (parfois aussi appelées macros). Un fichier contenant une suite d'instructions Scilab et des définitions de fonction est exécuté par Scilab au moyen de la fonction exec. On notera que cette fonction admet un argument optionnel qui permet de contrôler le niveau d'affichage à l'écran lors de l'exécution du script. On donne aux scripts scilab des noms de fichier qui se terminent par le suffixe .sce. Il est aussi possible au lancement de Scilab d'indiquer un script à exécuter au moyen de l'option scilab -f <nom-de-script>. Si le script se termine par l'instruction quit, ceci permet de lancer des exécutions de Scilab en mode "batch".

L'essentiel d'un programme est une succession des blocs qui réalisent un travail répétitif et entre ces blocs nous avons des instructions d'entrée/sortie. Dans la suite vous trouverez les blocs utilisés dans Scilab. Une présentation plus détaillée se trouve dans le poly, §2.3.1. Les entrées/sorties sont présentées dans le poly, §2.5.

Rè gle générale pour la programmation

Il faut toujours penser

à minimise le temps d'exécution;
à réduire l'espace utilisé;
à faire des programmes trè s modulaires selon le principe "une tâche, une fonction".

1.1 Boucle `for`

La syntaxe de la boucle for est

      for <indice> = <limInf>:<limSup>
        <actions>
      end

Si on veut sortir de la boucle avant qu'<indice> atteigne la valeur <limSup>, il faut utiliser la commande break.

Exemple de boucle for : Calcul de la somme de tous les nombres entre 1 et 500000.

	   stacksize(10000000);  // Faire help stacksize
	   N=500;
	   s = 0.0;
	   for i=1:N
	       s = s + i;
	   end;
	   s

C'est facile, c'est simple, mais ce n'est pas efficace car il consomme du temps. Pour s'en convaincre, exécuter le programme suivant et regarder le temps consommé par les deux algorithmes qui, par ailleurs, font le même calcul.

	   stacksize(10000000);
	   N=500;
	   timer();  // faire  help timer

	       // Premier algorithme
	   s = 0.0;
	   for i=1:N
	       s = s + i;
	   end;
	   t1 = timer()  // sans ";" à la fin, afin d'afficher le temps

	       // Second algorithme
	   s = ones(1,N)*(1:N)';
	   t2 = timer()

Dans le second algorithme on utilise des opérations vectorielles qui sont, en Scilab, beaucoup plus rapides.

1.2 Branchement conditionnel `if ... then`

Il existe trois formes pour l'instruction de branchement conditionnel.

Forme à une branche :

      if <condition(s)> then <action(s)>; end;

Forme à deux branches :

       if
	       <condition(s)>
		then
		    <action(s)>;
	    else
		    <action(s)>;
       end;

Forme multibranche :

       if
	       <condition(s)> then <action(s)>;
		elseif <condition(s)> then <action(s)>;
		..................................
		elseif <condition(s)> then <action(s)>;
	    else <action(s)>;  //Branche par défaut qui est optionnelle
       end;

Exemple de branchement de forme multibranche.

      p=0.4
      y=rand(1)
      if y < p then x=1;
       elseif (y>= p & y < 0.8) then x=0;
       else x=-1;
      end;
      x

1.3 Aiguillage conditionnel `select ... case`

La forme multibranche de if est difficile à manier. On préfè re, quand il possible, d'utiliser l'instruction de l'aiguillage conditionnel select dont la syntaxe est donnée par

       select <expr>
           case <expr1> then <action(s)>
           ................................
           case <expr1> then <action(s)>
           else <action(s)>   // Condition par défaut qui est optionnelle
       end;

1.4 Décrochage conditionnel `while`

Il n'est pas toujours possible de programmer d'avance quand l'exécution d'une boucle doit s'arrêter. dans ce cas l'usage de for n'est pas possible. On utilisera à la place la commande while dont la syntaxe est

      while <condition(s)>
        <action(s)>
      end

Si les <condition(s)> ne sont pas remplies dès le début, les <action(s)> ne s'exécuteront même pas une fois.
Exemple :

	   p=0.2
	   y=rand(1);
	   compteur=1;
	   while y >=p do
	       compteur=compteur+1;
	       y=rand(1);
	   end
	   compteur

2 Fonctions Scilab

On peut définir une fonction Scilab de façon interactive, mais il est souvent plus naturel d'écrire le code d'une fonction dans un fichier au moyen d'un éditeur de texte. (Voir aussi le poly, §2.3.2.)

Quand les définitions d'une ou plusieurs fonctions Scilab sont écrites dans un fichier, on utilise un nom de fichier ayant pour suffixe .sci.

Quand un fichier contient des instructions Scilab, et éventuellement aussi des définitions de fonctions, on utilise un nom de fichier ayant pour suffixe .sce.

Les fonctions sont alors connues et sont utilisables sous Scilab par leur nom. Si on modifie le corps d'une fonction, il faut recharger le fichier dans Scilab pour que les modifications soient prises en compte.

On peut créer de nouvelles fonctions dans Scilab. L'entête de la fonction est constitué de la séquence function [<arguments de retour>]=<nom>(<arguments d'entrée>)
et le corps de la fonction est terminé par le mot clef endfunction.

   function [y]=cube(x), y=x.^3, endfunction;
   // le nom de la fonction est cube
   // elle a pour argument un vecteur x, et retourne le vecteur y=x.^3

   x=0.01:0.01:0.99;y=cube(x);
   xbasc(); plot(x,y);

   function [H] = Heavyside(x)
   // Fonction de Heavyside
   H = bool2s(x>=0)
   // on notera que Heavyside(0)=1
   endfunction

   x=-1:0.2:1; xbasc(); plot2d2(x,Heavyside(x),rect=[-1,-0.1,1,1.2]);

Question 4 Écrire la fonction sinus cardinal ( $\sin x /x$ ). On fera attention au cas où en évaluant la fonction $\sin x /x$ , non pas en x, mais en z=maxi(x,%eps)).

Une fonction dans Scilab peut avoir plusieurs arguments, scalaires ou vectoriels.

   function [y]=Gauss(x,mu,sigma)
   // mu et sigma sont des scalaires
   // x peut être un vecteur de taille quelconque
   y=1 ./(sigma*sqrt(2*%pi))*exp(-((x-mu)/sigma).^2/2)
   endfunction;

   function [Y]=Normal(X,Mu,Sigma)
   // Mu est un vecteur ligne de taille [1,dim]
   // Sigma est une matrice symétrique définie positive de taille [dim,dim]
   // x peut seulement être un vecteur de taille [1,dim]
   [lhs,dim]=size(Mu)
   Y=1/ sqrt( (2*%pi)^dim * det(Sigma) ) * ...
           exp(- (X-Mu)*Sigma*(X-Mu)' / 2 )
   endfunction;

Une fonction dans Scilab peut renvoyer plusieurs valeurs.

   function [H,plus] = Heavyside_plus(x)
   // Fonction de Heavyside
   H = maxi(sign(x),0);
   // on notera que Heavyside(0)=0
   plus=maxi(x,0)
   // Fonction +
   endfunction

   [H,plus] = Heavyside_plus(-1:0.2:1)

function [x]=permutation_lent(n)
// permutation aléatoire de {1,...,n}
// version avec des boucles
  x=ones(1,n);
  for i=2:n,k=0;
    for j=1:1+int(rand(1)*(n-i+2));k=k+1;
      while x(k)>1 do
        k=k+1; 
      end;
    end;
    x(k)=i;
  end;
endfunction

function [x]=permutation_rapide(n)
  // permutation aléatoire de {1,...,n}
  x=grand(1,'prm',[1:n]')
endfunction

// chargement de la fonction permutation_lent :
-->getf("nom_du_fichier.sci") 
// ou 
-->getf nom_du_fichier.sci 
// ou 
-->exec nom_du_fichier.sci 
// la fonction est maintenant connue :
-->permutation_lent
// appel de la fonction permutation_lent :
-->permutation_lent(100)

3 Zéros avec `fsolve`

À titre d'exemple, nous donnons l'utilisation de la fonction Scilab fsolve pour le calcul des zéros d'un polynôme.

-->help fsolve

3.1 Zéros de fonction scalaire

zéro de polynôme
-->function [y]=fct(x) , y=2*x^3-30*x^2-3*x+200, endfunction
-->x=[-3:0.1:15];xbasc();plot(x,fct(x));
--> x1=fsolve(-1,fct)
-->fct(x1)
--> x2=fsolve(1,fct)
-->fct(x2)
--> x3=fsolve(11,fct)
-->fct(x3)

zéro de polynôme, avec gradient
-->function [y]=fct(x) , y=2*x^3-30*x^2-3*x+200, endfunction
-->function [y]=grad_fct(x) , y=6*x^2-60*x-3, endfunction
-->x=[-3:0.1:15];xbasc();plot(x,fct(x));
--> x1=fsolve(-1,fct,grad_fct)
-->fct(x1)
--> x2=fsolve(1,fct,grad_fct)
-->fct(x2)
--> x3=fsolve(11,fct,grad_fct)
-->fct(x3)

3.2 Intersection de coniques

Fonctions de définition des coniques
-->function [z]=conique1(x,y) , z=2*x^2+ 5*y^2-30*x+20, endfunction
-->function [z]=conique2(x,y) , z=2*x^2 -y^2-3*y-20, endfunction

On trace les coniques en dessinant les deux contours de niveau 0 de conique1 et conique2
-->x=-2:10;
-->y=-10:10;
-->xbasc();
-->fcontour2d(x,y,conique1,[0,0],[9,9]) // on trace conique1(x,y)=0
// on superpose le deuxieme contour
-->fcontour2d(x,y,conique2,[0,0],[12,12],"000")

Recherche d'un point d'intersection
-->function [Y]=coniques(X) , Y=[conique1(X(1),X(2)),...
conique2(X(1),X(2))], endfunction
-->rep=fsolve([-1,1],coniques)
-->coniques(rep) // on vérifie le calcul

on rajoute le point sur le dessin
-->xpolys(rep(1),rep(2),-1)

Devoir

Faire les exercices du chapitre 2 du poly.

Introduction à Scilab 3. Programmation. Fonctions Scilab

Rè gle générale pour la programmation

Introduction à Scilab
3. Programmation. Fonctions Scilab