Scilab de la théorie à la pratique

I. Les fondamentaux

par

Philippe Roux

Aperçu général de l'ouvrage

Scilab : De la théorie à la pratique est un ouvrage constitué de plusieurs modules, thématiques ou généraux, portant sur différents aspects de l'emploi de Scilab. I. Les fondamentaux est le premier à paraître. Il vous présente les manipulations de base, dont vous pourrez avoir besoin quel que soit votre domaine. II. Modéliser et simuler avec Xcos et III. Le traitement du signal paraîtront respectivement courant de l'été et de l'automne 2013. Consultez le site des éditions D-BookeR pour les autres modules à venir.

Pratique de Scilab validée par 

I. Les fondamentaux

par Philippe Roux

ISBN (EPUB) : 978-2-8227-0052-8

Copyright © 2013 Éditions D-BookeR

Tous droits réservés

Conformément au Code de la propriété intellectuelle, seules les copies ou reproductions strictement réservées à l'usage privé du copiste et non destinées à une utilisation collective ainsi que les analyses et les courtes citations dans un but d'exemple et d'illustration sont autorisées. Tout autre représentation ou reproduction, qu'elle soit intégrale ou partielle, requiert expressément le consentement de l'éditeur (art L 122-4, L 122-5 2 et 3a).

Publié par les Éditions D-BookeR, 5 rue Delouvain, 75019 Paris

www.d-booker.fr

contact@d-booker.fr

Ce module fait partie de l'ouvrage global intitulé : Scilab de la théorie à la pratique

ISBN (HTML) : 978-2-8227-0018-4

Les exemples (téléchargeables ou non), sauf indication contraire, sont propriété des auteurs.

Validation de la pratique de Scilab : Claude Gomez (Directeur général, Scilab Enterprises)

Date de publication : 2013-06-21

Édition : 1

Version : 1.1

À propos de l'auteur

Philippe Roux

Professeur agrégé de mathématiques à l'IUT de Lannion, titulaire d'une thèse en Mathématiques, il enseigne les mathématiques et leur utilisation pratique aux étudiants du DUT Informatique en utilisant Scilab. L'expérience pédagogique ainsi acquise, depuis 2001, a servi de base à l'élaboration de cette introduction à Scilab.

Vous pouvez le retrouver sur son site personnel http://perso.univ-rennes1.fr/philippe.roux/ ou le contacter à l'adresse philippe.roux@univ-rennes1.fr.

Préface

par Claude Gomez

Directeur général de Scilab Enterprises

Bienvenue dans Scilab : De la théorie à la pratique .

Le logiciel de calcul et de simulation numérique Scilab est aujourd’hui la référence des logiciels libres du domaine. Il comprend plus de 1 600 fonctions mathématiques et graphiques et inclut Xcos pour la simulation des systèmes dynamiques hybrides. C’est dire que, malgré l’aide en ligne, il est souvent difficile pour l’utilisateur d’appréhender toutes ses fonctionnalités sans véritable support. Et comme les domaines concernés couvrent ceux de toutes les mathématiques appliquées, calcul matriciel, simulation, traitement du signal, statistiques, commande, etc., il faudrait un livre pour chacun. C’est ce que vous propose Scilab : De la théorie à la pratique , aborder progressivement tous ces domaines pour vous fournir une vue d’ensemble complète du logiciel Scilab. Le monde logiciel est marqué par les mises à jour régulières et l’obsolescence rapide des supports traditionnels papiers, et l’originalité de D-BookeR est de vous permettre de consulter un livre toujours à jour à partir d’un site web.

Les fondamentaux est la partie par laquelle il vous faut commencer. En effet, de façon exhaustive et progressive, elle propose de vous familiariser avec le langage Scilab et les tracés de courbes. À côté d’une programmation naïve généralement réalisée par l’utilisateur débutant, elle montre comment utiliser de façon efficace toute la puissance du langage Scilab et comment jongler avec les possibilités graphiques, 2D, 3D et animation. Grâce à ce bagage, l’utilisateur sera prêt à aborder de façon efficace les domaines des mathématiques appliquées qui sont traités dans les autres chapitres.

Je vous souhaite une bonne lecture et une bonne pratique de Scilab !

Paris, 31 mai 2013

Avant-propos

Scilab a énormément évolué depuis 2010, si bien qu'une grande part de la documentation existante est désormais obsolète. Ce livre se fonde sur la toute dernière version de Scilab (5.4.1) et nous avons mis un soin tout particulier pour vous transmettre de bonnes pratiques conformes à l'esprit actuel du logiciel.

Initialement conçu au format numérique, il contient des éléments interactifs (hyperliens) et multimédias (animations GIF, vidéos), qui selon votre support de lecture seront plus ou moins intégrés. Nous nous sommes toutefois efforcés que chaque version soit la plus conviviale possible et que vous puissiez aisément accéder aux compléments multimédias par Internet.

1. Public visé et prérequis

Ce livre s'adresse tout aussi bien à des utilisateurs débutants avertis qu'à des personnes familières de Scilab souhaitant actualiser ou approfondir leurs connaissances. Il suppose que le lecteur est un minimum à l'aise avec l'outil informatique et qu'il a quelques notions de ce qu'est la programmation. Des connaissances d'ordre technique, physique ou mathématique, peuvent être requises selon les parties.

Si vous débutez complètement, commencez par vous familiariser avec le logiciel en vous aidant notamment du document Scilab pour les vrais débutants conçu par Scilab Enterprises.

2. Réglage de la largeur de l'écran

Vous trouverez de nombreux exemples de code, formatés dans une police à chasse fixe. Afin d'éviter des retours à la ligne inopportuns à l'intérieur d'une ligne de code, la longueur maximale des lignes de code a été fixée à 65 caractères, une valeur suffisamment basse pour être affichée sur la plupart des supports, tout en étant suffisante pour que le code puisse être correctement formaté.

Toutefois, il est possible que sur votre support la largeur maximale affichable soit inférieure à la limite fixée. Le paragraphe test ci-dessous permet de vérifier votre affichage. Il doit tenir sur deux lignes exactement :

00000000001111111111222222222233333333334444444444555555555566666
01234567890123456789012345678901234567890123456789012345678901234

Si ce n'est pas le cas, regardez si vous pouvez agrandir la taille de la fenêtre, diminuer la taille des marges ou diminuer la taille de la police d'affichage. Sur un téléphone portable, placez-le plutôt en mode paysage. Si vous n'y arrivez pas, ne vous inquiétez pas pour autant, la plupart des lignes de code sont inférieures à 65 caractères.

3. Affichage des équations MathML

Les équations de cet ouvrage ont été codées avec le standard MathML. Si vous lisez ce livre en ligne, assurez-vous de disposer d'un navigateur compatible. Vous pouvez vérifier son support du MathML avec cette page de test. Pour notre part, nous vous recommandons l'emploi de Firefox.

Dans un souci d'accessibilité, la version EPUB par défaut ne contient pas de MathML, les équations étant converties en images. Toutefois, si votre reader supporte le MathML, vous disposez aussi d'une version avec MathML afin de bénéficier d'un rendu optimal.

Note > Reportez-vous à la page de support du site des éditions D-BookeR pour plus d'informations.

4. Code source des exemples

Le code source des exemples est téléchargeable sur la page de présentation du livre sur le site des éditions D-BookeR, à l'onglet Compléments.

5. Accès aux vidéos et animations

La version numérique du livre contient quelques illustrations sous forme de captures vidéo commentées ou d'animations GIF.

Les animations GIF sont embarquées dans les EPUB, cependant nombreuses liseuses ne vous permettront pas de les visionner. Consultez la page support du site des éditions D-BookeR pour plus d'informations à ce sujet. Dans ce cas, ou si vous lisez ce livre en version PDF, cliquez sur le picto accompagnant l'illustration, il vous redirigera vers la galerie en ligne des animations GIF.

Les vidéos, pour leur part, ne sont pas embarquées dans les versions téléchargeables (EPUB, PDF). Un clic sur l'image vous redigera vers la vidéo en ligne au format MP4. Si votre navigateur par défaut ne supporte pas nativement ce format (par exemple Firefox), modifiez à la main l'extension du fichier dans l'url en remplaçant .mp4 par .webm. Et n'oubliez pas d'allumer vos haut-parleurs !

Vous pouvez aussi consulter directement la galerie en ligne des vidéos.

Démarrer

Scilab est un logiciel multiplate-forme dédié au calcul numérique, libre et open-source, doté d'une large communauté d'utilisateurs. Cette première partie a pour but de vous aider à mettre en place et prendre en main l'environnement de travail de Scilab.

1

Aperçu de Scilab

Scilab est un logiciel de calcul numérique libre et multiplate-forme destiné aussi bien au théoricien qu'à l'ingénieur. Il dispose d'un langage de programmation de haut niveau, bien adapté au formalisme mathématique, et de modules complémentaires dédiés à des applications scientifiques telles que le traitement du signal et des images, l'analyse statistique, les simulations de mécanique, de dynamique des fluides, l'optimisation numérique, la modélisation et la simulation de systèmes dynamiques hybrides, etc. Pour vous donner une petite idée de ses capacités, prenons l'exemple d'une comète en orbite autour du Soleil, dont la trajectoire est perturbée par la présence d'une planète évoluant sur une orbite stable autour du Soleil. Malgré la complexité du problème, vous pouvez facilement, avec Scilab, simuler un tel système et obtenir une animation en trois dimensions du mouvement des différents corps, comme sur la vidéo ci-dessous.

Figure 1.1 : Simulation d'une orbite cométaire (vidéo)

Cette animation est obtenue à l'aide d'un programme écrit en langage Scilab et présenté dans Exemple 1.1  suivant.

Exemple 1.1 : Script permettant de visualiser la trajectoire d'une comète autour du Soleil

//********************************************************
// simulation de la trajectoire (perturbée) d'une comète
//********************************************************
//  paramétrisation d'une sphère
function [x,y,z]=sphere(theta,phi)
   A=0.1,B=0.01
   x=A*cos(phi).*cos(theta)
   y=A*cos(phi).*sin(theta)
   z=B*sin(phi)
endfunction
//  fonction pour dessiner une sphère
function plot_sphere(x,y,z)
   phi=[0:0.1:2*3.15];
   theta=[2*3.15:-0.05:0];
   [dx,dy,dz]=eval3dp(sphere,theta,phi);
   surf(x+dx,y+dy,z+dz);
endfunction
//  fonction pour dessiner le plan z=0
function plot_ecliptique(ebox)
   x=[ebox(1);ebox(2)]
   y=[ebox(3);ebox(4)]
   z=zeros(2,2)
   surf(x,y,z)
endfunction

// les fonctions calculant les forces gravitationnelles
function [u2]=force_g(t,u,masse)
   module=-G*masse*((u(1)^2+u(2)^2+u(3)^2)^(-3/2))
   u2=[module*u(1); module*u(2); module*u(3)]
endfunction

function [du]=force(t,u,masse0,masse1)
   u1=[u(1);u(2);u(3)]
   du1=[u(4);u(5);u(6)]
   u2=[u(7);u(8);u(9)]
   du2=[u(10);u(11);u(12)]
   ddu1=force_g(t,u1,masse0)
   ddu2=force_g(t,u2,masse0)+force_g(t,u2-u1,masse1)
   du=[du1;ddu1;du2;ddu2]
endfunction

// constantes
G=0.04;
m0=1000;
m1=1;
dt=0.05;
T=50;
dx=0.5;
dy=0.5;
dz=0.5;
alpha=65;
Beta=150;
//********************************************************
// calcul des trajectoires
//********************************************************
//coordonnées initiales de la planète
x1=5;y1=0;z1=0;vx1=0;vy1=2.5;vz1=0;
//coordonnées initiales de la comète
x2=6;y2=6;z2=0.21;vx2=-2;vy2=-0.5;vz2=-0.1;
//résolution de l'équation différentielle avec ode
t=[0:dt:T];
u0=[x1; y1; z1; vx1; vy1; vz1; x2; y2; z2; vx2; vy2; vz2];
u=ode(u0,0,t,list(force,m0,m1));
//  récupération des résultats
X=[u(1,:)',u(7,:)'];
Y=[u(2,:)',u(8,:)'];
Z=[u(3,:)',u(9,:)'];
//********************************************************
// lancement de la fenêtre graphique
//********************************************************
ebox=[min(X),max(X),min(Y),max(Y),min(Z),max(Z)];
N=length(t);                       // nombre d'étapes
drawlater()
plot_ecliptique(ebox) // tracé du plan de l'écliptique
plot_sphere(0,0,0)                 // soleil
plot_sphere(X(1,1),Y(1,1),Z(1,1))  // planète
plot_sphere(X(1,2),Y(1,2),Z(1,2))  // comète
A=gca();
A.axes_visible=["off" "off" "off"];
A.rotation_angles=[alpha Beta];
A.data_bounds=ebox;
drawnow()
//********************************************************
// boucle principale créant l'animation graphique
//********************************************************
for k=1:5:N
   Beta=Beta+k/300;                      //  angle de vue
   realtimeinit(0.05)                   // unité de temps
   drawlater()           // ouverture du buffer graphique
   clf()                 // on efface le buffer graphique
   plot_ecliptique(ebox) // tracé du plan de l'écliptique
   param3d1(X(1:k,:),Y(1:k,:),...        // affichage des
   list(Z(1:k,:),[5,2]))                  // trajectoires
   plot_sphere(0,0,0)                        // le soleil
   plot_sphere(X(k,1),Y(k,1),Z(k,1))        // la planète
   plot_sphere(X(k,2),Y(k,2),Z(k,2))         // la comète
   title('comet dynamics simulation : t='+msprintf(...
   '%2.2f',t(k))+'/'+string(T)+' years')      // le titre
   xinfo(string(t(k)))              // affichage du temps
   A=gca();  // redimensionnement de la fenêtre graphique
   A.axes_visible=["off" "off" "off"];
   A.rotation_angles=[alpha Beta];  // rotation pt de vue
   A.data_bounds=ebox;
   drawnow()             // affichage du buffer graphique
   realtime(k)// pause pour ajuster le rythme d'affichage
end

Cet exemple donne un petit aperçu des possibilités de Scilab aussi bien en matière graphique qu'au niveau du calcul numérique. Avec un peu de maîtrise, vous pourrez rapidement aller plus loin et créer des programmes permettant à un utilisateur d'interagir avec l'interface graphique de Scilab pour générer ses propres animations, telle que celle présentée sur la vidéo ci-dessous.

Figure 1.2 : Simulation d'un pendule accroché à un ressort (vidéo)

Dans cet exemple, nous simulons la trajectoire d'un pendule accroché à un ressort (de raideur k) que l'on laisse osciller librement après l'avoir lâché sans élan depuis une position donnée. L'évolution du pendule se modélise par un système d'équations différentielles faisant intervenir deux variables :

avec :

a l'angle du pendule par rapport à la verticale ;

r la longueur du ressort constituant le pendule ;

et les conditions initiales : (MathML).

Pour étudier un tel système, très sensible aux conditions initiales, il est important de pouvoir modifier facilement la position de départ du pendule et observer l'influence de chaque paramètre sur le mouvement. Ici Scilab permet de créer une interface graphique qui simplifie la saisie des paramètres et de se concentrer sur l'analyse des résultats. Avec le script de l'Exemple 1.2 , vous pouvez modifier la position initiale du pendule d'un simple clic de souris dans la fenêtre graphique puis étudier son mouvement.

Exemple 1.2 : Script permettant de modifier la position initiale du pendule

//*****************************************************************
// animation d'un pendule élastique
//*****************************************************************
//  fonction pour créer la matrice de rotation
function M=rot(a)
    M=[cos(a),sin(a);-sin(a),cos(a)];
endfunction
//  quelques constantes
n=40;      // nombre de spires du ressort
T=5;       // durée de la simulation
g=9.81;    //  g (gravitation)
k=10;      //  k (raideur du ressort)
dt=0.01;   // dt (pas de temps)
//*****************************************************************
// lancement de l'affichage
//*****************************************************************
//  titre de la fenêtre
xtitle("(clic gauche pour démarrer l''animation, clic droit pour arrêter)")
// page de titre (en LaTeX)
titlepage(["résolution numérique d''une EDO le pendule à ressort : ";" "; "$$\Large r{d^2\over dt^2}a+2{d\over dt}r \times {d\over dt}a=g\times \sin(a)$$";
" "; "$$\Large {d^2\over dt^2}r-{k\over m}(r-r_0)=r\left({d\over dt} a\right)^2+g\times \cos(a)$$";" "; " avec les conditions initiales : "; "$$\Large  a(0)=? \;\;\;\;\;\; {d\over dt}a(0)=0  \;\;\;\;\;\; r(0)=r_0=? \;\;\;\;\;\; {d\over dt}r(0)=0 $$"])
//*****************************************************************
// traitement des interactions avec la fenêtre graphique
//*****************************************************************
// attente d'un clic de souris dans la fenêtre
[c_i,c_x,c_y,c_w]=xclick();
while (c_i<>2)&(c_i<>5)   // tant qu'on n'a pas fait un clic droit
      clf()    //effacer la fenêtre
      //***********************************************************
      // récupération des données initiales de l'animation
      //***********************************************************
      // titre de la fenêtre
      xtitle("(un click pour initialiser la position du pendule, a(0) et r(0) )")
      // paramétrage du handle Axes de la fenêtre
      plot(0,0,'.k');A=gca();A.x_location="origin";
      A.y_location="origin";A.auto_scale="off";A.isoview="on";
      A.data_bounds=[-1 -1; 1,0];xgrid(3)
      // récupération des coordonnées de la position initiale
      // du pendule :
      [c_i,x,y,c_w]=xclick();
      // calcul des données initiales :
      a=sign(x)*abs(atan(x/y));a0=a;da=0;  // calcul de l'angle a(0)
      l=sqrt(x^2+y^2);r=l;,dr=0;           //  calcul de  r(0)
      // adapter la taille de la fenêtre à la taille maximale
      // du pendule :
      A.data_bounds=[-1.5,-max(4*l,4);1.5,max(l,0.5)];
      //***********************************************************
      // boucle créant l'animation
      //***********************************************************
      for t=0:dt:T
           //******************************************************
           // calcul des nouvelles positions
           //******************************************************
           // résolution des équations différentielles sur a et r
           // par la méthode d'Euler
           dda=-(g*sin(a)+2*dr*da)/r;
           ddr=r*(da)^2-k*(r-l)+g*cos(a);
           da=da+dt*dda;
           dr=dr+dt*ddr;
           a=a+dt*da;
           r=r+dt*dr;
           // calcul de la ligne  traçant le ressort
           ressortr=linspace(0,r,n)';        // étirement du ressort
           // coordonnées transversales à l'axe du ressort -> /\/\/\
           ressorta=[0;(-1).^[0:n-3]';0]*(l/10);
           //rotation de l'image du ressort selon l'angle a
           x=[x;r*sin(a)];
           y=[y;-r*cos(a)];
           M=-rot(-a);
           N=[ressortr,ressorta]*M;
           ressorty=N(:,1);ressortx=N(:,2);
           //******************************************************
           // affichage du pendule
           //******************************************************
           drawlater()  // écriture dans le buffer graphique
           clf()        // effacer la fenêtre
           plot(ressortx,ressorty) //affichage du ressort du pendule
           xstring(0,0.1,["t=" string(t)]) // temps écoulé
           // la boule du prendule :
           xfarc(r*sin(a)-0.05,-r*cos(a)+0.05,0.1,0.1,0,360*64)
           // redimensionnement de la fenêtre graphique
           A=gca();A.data_bounds=[-1.5,-max(4*l,4);1.5,max(l,0.5)];
           A.auto_scale="off";A.isoview="on";
           A.axes_visible=["off" "off" "off"];
           drawnow()            // afficher le buffer graphique
           realtime(t);           // delai d'affichage
      end
      //***********************************************************
      // choix d'une nouvelle animation ou d'une sortie du script
      //***********************************************************
      xtitle("(un clic pour continuer )")    // titre de la fenêtre
      plot(x,y,'-r')                       // affichage trajectoire
      A=gca();A.isoview="on";xgrid(3); //afficher une grille (verte)
      // attente d'un clic de souris dans la fenêtre graphique :
      [c_i,x,y,c_w]=xclick();
      clf();                         // choix d'une nouvelle action
      xtitle("(clic gauche pour démarrer l''animation, clic droit pour arrêter)")
      plot(0,0,'.k');A=gca();A.x_location="origin";
      A.y_location="origin";
      // attente d'un clic de souris dans la fenêtre :
      [c_i,x,y,c_w]=xclick();
end

Ces deux exemples font appel à des notions de base d'utilisation de Scilab, que nous allons vous présenter dans la suite de ce livre. À la fin de votre lecture, vous serez à même de les réaliser par vous-même, comme nous vous le montrerons au dernier chapitre Deux études de cas : le pendule et l'orbite cométaire .

Attention > Pour une bonne exécution des scripts ci-dessus, utilisez Scilab 5.4.1 ou +.

2

La console

Le lancement de Scilab déclenche l'ouverture d'une fenêtre composée de plusieurs éléments. À la première ouverture après l'installation, cette fenêtre doit ressembler à celle de la Figure 2.1. La partie centrale de cette fenêtre est la console. Elle permet la saisie d'instructions, à la suite du prompt -->, qui seront interprétées par Scilab après un retour chariot ( ↵ ), le résultat s'affichant dans la console avant un nouveau prompt.

Figure 2.1 : La fenêtre principale de Scilab au premier démarrage

1. S'approprier l'interface

Les différentes parties de cette fenêtre peuvent être redimensionnées ou détachées pour apparaître dans une fenêtre distincte de celle de la console. Dans le même temps, d'autres fenêtres peuvent être ajoutées à la fenêtre principale, comme le montre la vidéo de la Figure 2.2. Cette propriété très pratique de l'interface graphique de Scilab est ce qu'on appelle le docking ou arrimage : elle permet d'adapter l'interface graphique aux habitudes de l'utilisateur.

Figure 2.2 : Docking des fenêtres de Scilab (vidéo)

Astuce > Pour arrimer une fenêtre à la fenêtre principale de Scilab, saisissez-la par sa barre supérieure à l'aide de la souris (lorsque c'est fait cette barre passe du gris au bleu), puis déplacez-la en maintenant enfoncé le bouton droit et déposez-la où vous désirez l'arrimer.

Attention > Lorsque deux fenêtres sont arrimées dans la même zone de la fenêtre principale, elles se superposent et l'on peut passer de l'une à l'autre en cliquant sur un onglet. Sur la figure ci-dessous, vous pouvez voir que le navigateur de fichier et le navigateur de variables ont tous deux été arrimés dans la partie gauche de la fenêtre, et qu'on peut passer de l'un à l'autre par le biais des onglets en bas de la fenêtre.

Depuis Scilab 5.4.0, les préférences de configuration de la fenêtre sont sauvegardées à la fin de chaque session de travail, de sorte qu'il n'est pas nécessaire de reconfigurer la fenêtre à chaque redémarrage de Scilab. Vous pouvez également configurer d'autres aspects de l'interface en utilisant l'éditeur de préférences via le menu Édition/Préférences (Voir Figure 2.3 ). Parmi les différents paramètres disponibles, vous trouverez entre autres les informations sur la localisation (la langue utilisée dans l'interface de Scilab).

Figure 2.3 : Éditeur de préférences

Astuce > Pour découvrir les multiples possibilités de Scilab, n'hésitez pas à parcourir la collection de démonstrations qui sont accessibles depuis le menu ?/Démonstrations de la console. Une fenêtre graphique, visible sur la figure ci-dessous, vous permettra de naviguer entre les différentes démonstrations.

2. Utiliser la console

Parmi les différentes fenêtres de Scilab, la console est la plus importante. Il s'agit d'une fenêtre d'invite de commande comparable à celle d'autres interpréteurs de commande (par exemple cmd sous Windows, xterm sous Linux). On retrouve donc un certain nombre de fonctionnalités classiques pour ce genre d'outil que nous allons énumérer.

À la suite du prompt -->, vous pouvez écrire une ou plusieurs commandes qui seront interprétées après un retour chariot, comme on le ferait sur une calculatrice pour ceux qui ne sont pas habitués à l'utilisation d'un terminal. Si vous voulez écrire plusieurs commandes sur une même ligne, vous devez les séparer par une virgule (,) ou un point-virgule (;). Après un retour chariot( ↵ ), les commandes de la ligne s'exécutent et le résultat s'affiche.

-->2+2
 ans  =

    4.

-->2+2,3*4
 ans  =

    4.
 ans  =

    12.

-->2+2;3*4
 ans  =

    12.

-->2+2,3*4;    //un commentaire
 ans  =

    4.

Astuce > Quand la commande que vous exécutez est suivie d'un point-virgule, le résultat n'est pas affiché dans la console. Le point-virgule est donc très pratique si l'on veut masquer un calcul intermédiaire dont l'affichage du résultat occuperait toute la fenêtre. Chaque fois qu'un résultat s'affiche dans la console, le nom de la variable dans laquelle il a été stocké s'affiche avant le signe égal (=). Si la variable n'a pas été spécifiée, il sera stocké par défaut dans la variable ans, pour answer qui veut dire réponse en anglais (voir aussi Chapitre Variables, constantes et types).

Vous pouvez ajouter des commentaires sur une ligne de commande en utilisant le double slash (//) : tout ce qui suivra sera ignoré. Les commentaires sont surtout utiles lors de l'écriture de programmes, comme nous le verrons dans la Partie Programmer.

La navigation dans l'historique des commandes se fait avec les flèches haut (uparrow) et bas (downarrow) du curseur. Si l'on commence par saisir les premiers caractères d'une commande, la navigation dans l'historique se limite aux lignes commençant par les caractères saisis.

La touche Tabulation ( → ) permet l'autocomplétion des commandes, comme l'illustre la Figure 2.4 . Quand plusieurs commandes commencent par le même identifiant, un menu déroulant permet de choisir la commande recherchée, mais vous pouvez aussi continuer à saisir les caractères jusqu'à ce que la complétion puisse se faire de manière non-ambiguë. L'autocomplétion marche aussi pour compléter un nom de variable ou un nom de fichier/répertoire.

Figure 2.4 : Autocomplétion des commandes avec Scilab

Il est possible d'utiliser le copier/coller, par clic droit, comme à la Figure 2.5 , ou en utilisant les raccourcis clavier (taper help console pour avoir la liste complète des raccourcis clavier disponibles). Le menu contextuel associé au clic droit donne accès à d'autres fonctionnalités.

Figure 2.5 : Copier/coller à partir d'un clic droit

Il est possible d'effacer la console sans effacer le résultat des commandes déjà exécutées en utilisant les fonctions clc ou tohome.

3

L'interface graphique

Outre la console, l'interface graphique de Scilab est composée de différentes fenêtres qui peuvent être insérées/séparées de la fenêtre principale (voir la vidéo de la Figure 2.2 ). Dans ce chapitre, vous allez découvrir les fonctionnalités de base des principales fenêtres associées à Scilab.

1. L'aide en ligne

La première fenêtre à connaître est assurément celle du navigateur d'aide, que vous pouvez appeler de plusieurs manières :

depuis le la barre de menu en cliquant sur ? puis Aide de Scilab ;

en pressant la touche F1 ;

depuis le raccourci dans la barre d'outil (voir Figure 3.1 ) ;

Figure 3.1 : Raccourci pour accéder à l'aide en ligne dans la barre d'outils

depuis la console avec l'une des commandes :

help qui permet de savoir ce que fait une commande et comment l'utiliser ;

apropos qui permet de connaître les commandes en rapport avec un thème ou un mot clé.

-->apropos sinus
-->help sin

Dans tous les cas, la fenêtre de la Figure 3.2  s'ouvrira.

Figure 3.2 : Fenêtre d'aide

Astuce > si vous voulez obtenir de l'aide sur la commande sin, saisissez help sin mais si vous voulez obtenir de l'aide sur la notion mathématique de sinus, préférez apropos sinus. Dans les deux cas, vous devriez obtenir un lien vers, ou directement, la page d'aide de la fonction sin.

Pour chaque commande, l'aide fournie est composée de plusieurs rubriques :

Séquence d'appel

Décrit comment on doit appeler la commande pour effectuer son évaluation dans la console de Scilab. En général la séquence d'appel s'écrit sous la forme :

[sortie1,sortie2,...]=commande(entrée1,entrée2,[option1,[option2]])

Cette écriture signifie que commande prend en entrée deux valeurs, désignées par entrée1 et entrée2, plus une ou deux valeurs optionnelles, option1 et option2, qui sont encadrées par des crochets [ et ]. En sortie, on peut récupérer les valeurs sortie1 et sortie2 en utilisant les crochets. Il y a donc plusieurs manières d'appeler la commande, par exemple :

sortie1=commande(entrée1,entrée2)

[sortie1,sortie2]=commande(entrée1,entrée2)

[sortie1,sortie2]=commande(entrée1,entrée2,option1)

sortie1=commande(entrée1,entrée2,option1,option2)

...

Attention > Quelle que soit la syntaxe utilisée, on ne peut jamais récupérer la valeur sortie2 sans avoir récupéré celle de sortie1. De même, on ne peut pas spécifier option2 sans avoir spécifié option1.

Paramètres

Décrit le type de paramètres attendu des différentes valeurs (entrée1,entrée2,option1,... sortie2) qui apparaissent dans la séquence d'appel (voir Chapitre Variables, constantes et types).

Description

Donne une explication plus détaillée de ce que fait commande.

Exemples

Montre comment utiliser commande dans des cas plus ou moins simples. Le code source affiché dans un cadre grisé peut être directement interprété dans la console ou ouvert dans l'éditeur de texte grâce aux deux boutons en haut à droite du cadre (Voir Figure 3.3 ).

Figure 3.3 : Code source dans l'aide en ligne

Voir aussi

Renvoie vers d'autres pages de l'aide qui peuvent compléter celle de commande.

2. L'éditeur de texte

Scilab intègre un éditeur de texte appelé SciNotes, qui peut être appelé de plusieurs manières :

depuis la barre de menu Applications/Scinotes ;

depuis le bouton dans la barre d'outil ;

depuis la console avec une des commande editor ou scinotes.

Cet éditeur possède toutes les fonctionnalités d'un éditeur de texte destiné à la programmation :

formatage semi-automatisé du texte comme commenter/décommenter des parties de code, indentation des commandes imbriquées ;

coloration syntaxique et complétion des commandes, fermeture des caractères de parenthésage ;

fonction de recherche/remplacement, avec utilisation d'expressions régulières ;

plusieurs modes d'exécution du code de l'éditeur dans Scilab (avec/sans écho) (voir Figure 3.4 ) ;

gestion des formats de fichiers Windows/Linux (fins de lignes CR et/ou LF) et des encodages en entrée et en sortie (UTF-8, Latin1, ASCII, etc.).

Figure 3.4 : L'éditeur de texte SciNotes

Dans la Partie Programmer, nous utiliserons cet éditeur de texte pour écrire des programmes en langage Scilab. Vous trouverez, dans l'interface graphique de l'éditeur et de la console, des fonctionnalités spécifiques pour contrôler le lancement et l'exécution des programmes Scilab. Elles sont accessibles depuis le menu contrôle. Vous pouvez en voir un exemple d'utilisation sur la vidéo suivante.

Figure 3.5 : Contrôle de l'exécution des programmes Scilab (vidéo)

3. Les autres fenêtres

Scilab possède d'autres fenêtres dédiées à des fonctionnalités spécifiques, dont voici un petit aperçu.

Fenêtre graphique

Scilab dispose de nombreuses fonctionnalités graphiques, dont l'utilisation déclenche l'ouverture d'une fenêtre graphique. Par exemple, lancer la commande plot depuis la console ouvrira la fenêtre graphique de la Figure 3.6 .

Figure 3.6 : Fenêtre graphique de Scilab

Nous étudierons en détails les propriétés graphiques de Scilab dans la Partie Créer des graphiques et vous verrez comment réaliser diverses figures à deux mais aussi à trois dimensions ! La fenêtre graphique permet d'interagir facilement avec ces figures, en particulier à l'aide de la souris vous pouvez :

effectuer des zooms, et revenir à l'échelle de départ ;

modifier l'angle de vue pour les figures en trois dimensions.

La vidéo suivante vous montre comment utiliser ces fonctionnalités.

Figure 3.7 : Zooms et modification de l'angle de vue (vidéo)

Les capacités graphiques de Scilab reposent sur une représentation hiérarchique très détaillée des objets graphiques, qui permet non seulement de créer des figures complexes mais aussi de nouvelles interfaces graphiques (voir Section 4, Créer ses propres interfaces graphiques). Un éditeur d'entités graphiques, accessible depuis la barre de menu de la fenêtre graphique (menu Édition puis Propriétés de la figure) permet de naviguer parmi les différents paramètres qui composent un graphique et aussi de les modifier. La fenêtre graphique prend en compte ces modifications en temps réel (voir la vidéo ci-après).

Figure 3.8 : Utilisation de l'éditeur d'entités graphiques (vidéo)

Attention > Actuellement, l'éditeur d'entités graphiques ne fonctionne pas sur les versions de Scilab pour Mac OS.

ATOMS

Le gestionnaire de modules externes ATOMS permet d'installer ou de désinstaller des modules complémentaires associés à Scilab. Ces modules ajoutent au logiciel des fonctionnalités de haut niveau, tels que SIVP pour le traitement d'images ou Metanet pour la gestion des graphes (voir aussi Section 4, Les modules complémentaires sur Forge).

Figure 3.9 : Choix du module complémentaire SIVP dans la fenêtre ATOMS

Xcos

L'éditeur de bloc-diagrammes Xcos, équivalent Scilab de la boîte à outils Simulink de Matlab, permet de simuler des systèmes dynamiques. Pour plus d'informations sur Xcos, se reporter au manuel qui lui est consacré.

Figure 3.10 : Schéma Xcos d'une suspension d'automobile

Gestionnaires divers

Plusieurs gestionnaires ont été ajoutés à Scilab depuis la version 5 : un gestionnaire d'historique, un éditeur de variables et un navigateur de fichiers. Ils sont lancés par défaut lors du premier démarrage de Scilab (voir Figure 2.1). Vous pouvez aussi les lancer depuis la console avec les commandes : filebrowser, browsevar, editvar et browsehistory.

4

Les entrées/sorties

Dans ce chapitre, vous allez voir comment Scilab s'intègre avec son environnement informatique. De plus, vous trouverez ici des exemples simples de lignes de commandes exécutées dans la console de Scilab, qui vous permettront de vous habituer à l'utilisation de la console.

1. Système de fichiers

La première notion à comprendre pour bien travailler avec Scilab est celle de répertoire courant. À chaque instant, un répertoire de votre système de fichiers est associé à votre espace de travail dans Scilab. Par défaut, c'est dans ce répertoire que Scilab ira chercher des informations annexes lors de certaines opérations (ouverture ou écriture de fichiers par exemple). Vous pouvez intervenir sur le système de fichier de plusieurs manières :

récupérer le nom du répertoire courant, par le menu Fichier de la console ou par la commande pwd ;

changer de répertoire courant, par le menu Fichier de la console ou en utilisant les commandes cd ou chdir ;

créer un nouveau répertoire avec mkdir et détruire un répertoire avec rmdir ;

déplacer, copier ou détruire des fichiers directement depuis la console à l'aide des commandes copyfile, movefile et mdelete.

Le chemin de certains répertoires spécifiques à Scilab sont accessibles dans la console à l'aide des commandes suivantes :

Le répertoire d'installation de Scilab s'obtient avec SCI (voir aussi Section 2, Installation).

Le répertoire contenant les données de session d'un utilisateur (historique, préférences, etc.) s'obtient avec SCIHOME. Ce répertoire varie selon le système d'exploitation et la manière dont sont gérés les comptes utilisateurs. Par exemple, ce répertoire sera en général :

C:/Users/<User>/AppData/Roaming/Scilab/<Scilab-Version> sur Windows ;

/home/<User>/.Scilab/<Scilab-Version> sur les systèmes de type Unix ;

/Users/<User>/.Scilab/<Scilab-Version> sur Mac OS.

Un répertoire temporaire est aussi associé à chaque session de travail avec Scilab. Il est créé au début de chaque session, puis détruit à la fin. Son chemin s'obtient dans la console avec TMPDIR. Son nom est de la forme SCI_TMP_* et son emplacement dépend du système d'exploitation.

Voici quelques exemples de manipulations sur les répertoires que vous pouvez effectuer depuis la console :

-->path=pwd();  // répertoire courant

-->cd SCI  // aller dans le répertoire d'installation de Scilab
 ans  =

 C:\Program Files\scilab-5.4.1

-->pwd  // valeur du répertoire courant
 ans  =

 C:\Program Files\scilab-5.4.1

-->cd contrib  // aller dans le répertoire SCI/contrib/
 ans  =

 C:\Program Files\scilab-5.4.1\contrib

-->cd '../'  // "remonter" dans le répertoire SCI
 ans  =

 C:\Program Files\scilab-5.4.1

-->chdir('contrib')  // aller dans le répertoire SCI/contrib/
 ans  =

  T

-->pwd  // valeur du répertoire courant
 ans  =

 C:\Program Files\scilab-5.4.1\contrib

-->chdir(TMPDIR)  // aller dans le répertoire temporaire
 ans  =

  T

-->mkdir('essai')  //créer le répertoire essai/
 ans  =

    1.

-->ls('ess*') //lister les éléments commençant par "ess"
 ans  =

 essai

-->rmdir('essai')  //détruire le répertoire essai/
 ans  =

    1.

-->dir('ess*') //c'est le contenu du répertoire courant qui est vide []
 ans  =

[]

-->chdir(path)  // retour au répertoire courant de départ
 ans  =

  T

Toutes ces opérations peuvent également être réalisées via une interface graphique à l'aide du navigateur de fichiers (voir Figure 4.1 ). Ce navigateur peut être appelé depuis le menu Applications de la console ou avec la commande filebrowser.

Figure 4.1 : Le navigateur de fichiers

Astuce > Quand on lance Scilab depuis un raccourci, on peut paramétrer ce raccourci pour spécifier le répertoire courant de démarrage. Par défaut, ce répertoire est en général le répertoire racine de l'utilisateur qui lance Scilab ou le répertoire d'installation de Scilab (SCI) sous Windows.

2. Commandes système

Vous pouvez appeler des commandes système depuis Scilab. Selon le système d'exploitation sur lequel vous travaillez, vous utiliserez plutôt la commande dos ou unix, mais les deux commandes fonctionnent de la même manière ! Quatre variantes de la commande unix traitent différemment le résultat renvoyé par le système :

unix_g : permet de rediriger la sortie vers une variable Scilab ;

unix_w : permet de rediriger la sortie vers la console ;

unix_x : permet de rediriger la sortie vers une fenêtre popup (voir Figure 4.2 ) ;

unix_s : ne renvoie rien.

Voici quelques exemples de résultats affichés dans la console :

-->path=pwd();    // répertoire courant

-->cd SCI    // aller dans le répertoire d'installation de Scilab
 ans  =

 C:\Program Files\scilab-5.4.1

-->cd contrib    // aller dans le répertoire contrib
 ans  =

 C:\Program Files\scilab-5.4.1\contrib

-->unix('dir')    // code retour
 ans  =

    1.

-->unix_s('dir')    //  aucune sortie

-->unix_g('dir')    // sortie vers variable
 ans  =

! Le volume dans le lecteur C s'appelle OS              !
!                                                       !
! Le numéro de série du volume est 26ED-FED0            !
!                                                       !
!                                                       !
!                                                       !
! Répertoire de C:\Program Files\scilab-5.4.1\contrib   !
!                                                       !
!                                                       !
!                                                       !
!05/06/2013  17:38    <REP>          .                  !
!                                                       !
!05/06/2013  17:38    <REP>          ..                 !
!                                                       !
!29/03/2013  00:20               123 loader.sce         !
!                                                       !
!               1 fichier(s)              123 octets    !
!                                                       !
!               2 Rép(s)  44 358 574 080 octets libres  !

-->unix_w('dir')    // sortie vers console
 Le volume dans le lecteur C s'appelle OS
 Le numéro de série du volume est 26ED-FED0

 Répertoire de C:\Program Files\scilab-5.4.1\contrib

05/06/2013  17:38    <REP>          .
05/06/2013  17:38    <REP>          ..
29/03/2013  00:20               123 loader.sce
               1 fichier(s)              123 octets
               2 Rép(s)  44 358 574 080 octets libres

-->unix_x('dir')    // sortie vers fenêtre

-->cd(path);

Attention > La commande unix, pour sa part, renvoie un code entier selon le résultat obtenu.

Figure 4.2 : Exemple de fenêtre popup renvoyée par unix_x

Pour récupérer les informations concernant le système d'exploitation sur lequel s'exécute Scilab, vous utiliserez la commande getos. De même, la commande getversion vous permettra de connaître le numéro de la version de Scilab utilisée. Plus généralement, il est possible de récupérer une variable d'environnement du système avec la commande getenv.

-->getversion()       // version Scilab
 ans  =

 scilab-5.4.1

-->getos()           // os windows
 ans  =

 Windows

-->getenv('TZ')      // récupérer la variable d'environnement TZ
 ans  =

 Europe/Paris

En outre, vous pouvez interagir avec le presse-papier en utilisant clipboard.

-->clipboard("copy","essai")     // CTRL+C sur le texte "essai"
 ans  =

     []

-->clipboard("paste")           // CTRL+V
 ans  =

 essai

3. Dates et temps CPU

Pour certaines applications, vous pouvez avoir besoin d'accéder à des informations temporelles. Différentes commandes permettent d'évaluer des durées. Vous pouvez ainsi :

calculer le temps CPU (= nombre de cycle du processeur) écoulé entre deux actions avec timer ;

calculer le temps réel écoulé en millisecondes entre deux actions avec tic/toc, qui démarre/arrête le chronomètre de Scilab ;

mettre en pause Scilab pendant un temps donné avec sleep(temps en millisecondes) ou xpause(temps en microsecondes);

réaliser des simulations en temps réel avec realtimeinit (qui permet de fixer l'unité de temps) et realtime. Le premier appel à realtime fixe l'origine des dates, les appels suivants obligent Scilab à attendre qu'une date soit passée pour continuer.

Testez ces différentes commandes avec les exemples suivants :

-->// chronométrage avec tic() et toc()

-->tic()

-->sleep(1000)    //1000ms=1seconde

-->toc()
 ans  =

    1.061

-->tic()

-->xpause(200000)    //200000micros=0.2 secondes

-->toc()
 ans  =

    0.203

-->// temps CPU avec timer

-->timer();

-->sleep(1000)    //1000ms=1seconde

-->timer()
 ans  =

    0.0156001

-->timer();

-->xpause(1000000)    //1000000micros=1 seconde

-->timer()
 ans  =

    0.0156001

-->//temps réel

-->realtimeinit(1)    // unité de temps 1 seconde

-->realtime(0)    // date fixée à t=0

-->tic()

-->realtime(2)    //attendre date t=2

-->toc()    //le chronomètre affichera 2 secondes
 ans  =

    2.001

Vous pouvez effectuer des calculs sur les dates, mais prenez garde qu'il existe plusieurs formats pour gérer les dates et autant de fonctions pour les manipuler.

clock récupère la date sous la forme d'une liste à six paramètres [année, mois, jour, heure, minute, seconde] ;

datenum récupère la date sous la forme du nombre de jours écoulés depuis le 1er janvier de l'an zéro ;

getdate récupère la date sous forme d'un timestamp (nombre de secondes écoulées depuis le 1er janvier 1970) ou d'une liste à dix paramètres [année, mois, semaine, jour Julien, jour de la semaine, jour du mois, heure, minute, seconde, millisecondes] (plus complexe que celle renvoyée par clock !).

Une fois les dates récupérées, vous pouvez les traiter avec d'autres commandes :

datevec qui convertit un timestamp en une liste correspondant à la date en question pour Scilab ;

weekday qui calcule le jour de la semaine correspondant à un timestamp ;

eomday qui calcule le dernier jour du mois d'une année donnée ;

etime qui calcule l'écart (en secondes) entre deux dates données par des listes à six paramètres.

Pour finir, les fonctions suivantes affichent des dates ou des calendriers :

date récupère la date sous forme de chaîne de caractères ;

calendar affiche un calendrier mensuel ou annuel.

Attention > Pour la fonction weekday le premier jour de la semaine est le dimanche, alors que pour la fonction calendar le premier jour de la semaine est le lundi. Sans arguments, ces fonctions renvoient les valeurs correspondant à la date courante, sinon elles renvoient les valeurs correspondant aux dates données en paramètres.

Voici quelques exemples d'utilisation des fonctions précédentes :

-->calendar(1970,1)    //calendrier Jan. 1970
 ans  =

       ans(1)

 Jan. 1970

       ans(2)

    L Ma M Je V Sam Dim

       ans(3)

    0.     0.     0.     1.     2.     3.     4.
    5.     6.     7.     8.     9.     10.    11.
    12.    13.    14.    15.    16.    17.    18.
    19.    20.    21.    22.    23.    24.    25.
    26.    27.    28.    29.    30.    31.    0.
    0.     0.     0.     0.     0.     0.     0.

-->eomday(2012,2)    // dernier jour de Février 2012
 ans  =

    29.

-->d1=[1970 1 1 0 0 0]    // format de date scilab
 d1  =

    1970.    1.    1.    0.    0.    0.

-->t1=datenum(d1)    //numéro de la date d1
 t1  =

    719529.

-->[N,S]=weekday(t1)    // jour de la semaine de la date d1
 S  =

 Jeu.
 N  =

    5.

-->date()    //date actuelle
 ans  =

 26-Mai-2013

-->d2=clock()    //liste scilab de la date actuelle
 d2  =

    2013.    5.    26.    14.    12.    59.000003

-->t2=datenum(d2)    //numéro de la date d2
 t2  =

    735380.59

-->datevec(t2)    // date correspondant à t2
 ans  =

    2013.    5.    26.    14.    12.    59.000003

-->etime(d1,d2)    //écart entre les dates d1 et d2
 ans  =

  - 1.370D+09

-->d=etime(d2,d1)    //écart entre les dates d2 et d1
 d  =

    1.370D+09

-->getdate(d)    // jour situé d secondes après le 1er Jan. 1970
 ans  =

    2013.    5.    21.    146.    1.    26.    15.    12.    59.    0.0000026

4. Historique des commandes

Scilab fournit un système de gestion de l'historique. Il permet d'enregistrer automatiquement les commandes saisies dans la console, ce qui permet de passer plus rapidement des tests à la rédaction d'un script. À l'aide des différentes fonctions, vous pourrez :

effacer l'historique avec resethistory ;

le sauvegarder dans un fichier avec savehistory, le recharger dans l'environnement Scilab avec loadhistory ;

modifier des lignes de l'historique avec addhistory et removelinehistory ;

récupérer l'historique dans une variable avec gethistory ;

l'afficher dans le gestionnaire d'historique avec browserhistory ou dans la console avec displayhistory.

Vous pouvez aussi utiliser le gestionnaire d'historique (voir Figure 4.3 ) si vous préférez utiliser une interface graphique pour effectuer les opérations précédentes.

Figure 4.3 : Le gestionnaire d'historique

Pour finir, la fonction diary permet de stocker dans un fichier texte tout ce qui a été affiché dans la console (les commandes et leur résultat le cas échéant) entre deux appels à la fonction...