TPN 1:InitiationàSCILAB5 Tabledesmatières...TPN 1:InitiationàSCILAB5 Introduction Ce TP est un...

PCSI 1 - Stanislas - Informatique (2esem.) - TP N◦1 - Initiation à SCILAB 5 A. MARTIN

TP N◦1 : Initiation à SCILAB 5

IntroductionCe TP est un tutoriel d’introduction au logiciel Scilab. Il a pour but de

présenter, en une seule séance, le logiciel grâce à des exemples à saisir dans laconsole, et dont analysera les résultats. Il se termine par quelques exercices dereprésentation graphique.

Scilab est un logiciel libre 1 et gratuit, conçu sur le modèle du logiciel proprié-taire Matlab. Scilab peut être vu dans un premier temps comme une calcula-trice graphique élaborée, même si c’est plus largement un langage de program-mation à part entière. Il repose sur une approche matricielle du calcul : l’objetde base sur lequel on travaille est une matrice (ou un vecteur dans le cas 1D).

Contrairement au langage Python qui est très généraliste et offre un champd’applications très large (mais peut parfois manquer d’ergonomie), Scilab est unoutil dédié au calcul scientifique et optimisé pour cela. Il pourra donc s’avérer d’unabord plus facile et plus confortable lors de vos travaux ultérieurs, notammentpour les TIPE (simulation, représentation graphique). En particulier, la gestiondes figures est probablement plus souple sous Scilab à l’heure actuelle. Toutdépend de vos besoins, et de vos préférences.Toutefois, il faut noter l’avènement récent de Pylab, logiciel libre et gratuit auxprétentions équivalentes à Scilab basé sur Python 2 3. Cela dit, la syntaxe propreà Scilab est très proche de celle propre à Pylab (Numpy / Scipy / Matplotlib),donc l’apprentissage de l’un peut être une introduction à l’autre. Les différencesessentielles résident dans :— la numérotation des éléments des listes / vecteurs... (qui démarre à 0 sous

Python et à 1 sous Scilab) ;— l’écriture des structures de contrôle 4.

1. sous licence CeCILL (compatible GNU, open source)2. Plusieurs raisons peuvent expliquer le choix de Scilab dans le programme officiel : (i)

Scilab est un logiciel français, libre et gratuit développé depuis 25 ans (ENPC et INRIA), (ii)Pylab n’était pas encore au point au moment de la rédaction des nouveaux programmes, etl’ergonomie n’est probablement pas encore aussi dévelopée (à tester...) (iii) Scilab propose uneplateforme spécifique pour la modélisation des systèmes (X-cos).

3. Pylab consiste en une synthèse cohérente des modules préexistant Numpy, Scipy etMatplotlib, qui fournissent un environnement de type Matlab, et ce à travers l’interfaceIPython.

4. Conditionnelle IF ... ELSE, et boucles WHILE et FOR.

Table des matières

I Démarrage 2I.1 L’interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2I.2 Entrer une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . 2I.3 Eléments d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . 2I.4 Commandes de Scilab et variables . . . . . . . . . . . . . . . . . . 2I.5 Obtenir des informations sur l’espace de travail . . . . . . . . . . . 3I.6 Quitter et sauvegarder l’espace de travail . . . . . . . . . . . . . . 3I.7 Nombres, expressions arithmétiques et fonctions usuelles . . . . . . 3

II Les opérations sur les matrices 4II.1 Transposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4II.2 Addition et soustraction . . . . . . . . . . . . . . . . . . . . . . . . 4II.3 Multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4II.4 Inversion d’une matrice et division . . . . . . . . . . . . . . . . . . 5II.5 Opérations élément par élément . . . . . . . . . . . . . . . . . . . . 5II.6 Opérateurs relationnels . . . . . . . . . . . . . . . . . . . . . . . . 5II.7 Opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . 6II.8 Fonctions usuelles appliquées à une matrice . . . . . . . . . . . . . 6

IIIGénérer et manipuler des matrices et des vecteurs 6III.1 Générer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6III.2 Manipuler les éléments d’une matrice . . . . . . . . . . . . . . . . . 6

IVGraphiques 7IV.1 Graphiques à 2 dimensions . . . . . . . . . . . . . . . . . . . . . . 7IV.2 Manipuler plusieurs graphiques . . . . . . . . . . . . . . . . . . . . 8IV.3 Graphiques à 3 dimensions . . . . . . . . . . . . . . . . . . . . . . 8

V Programmer en Scilab 9V.1 Scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9V.2 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10V.3 Structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . 11V.4 Interaction avec l’utilisateur . . . . . . . . . . . . . . . . . . . . . . 11

VIRésolution numérique d’équations différentielles 12

EXERCICES 12

1


I. Démarrage

I.1. L’interfaceCe tutoriel est écrit avec la version 5.4.1. L’interface de Scilab est composéede plusieurs sous-fenêtres :— la console (fenêtre principale pour entrer les instructions ;— le navigateur de variables (permet de connaître à l’instant t l’état de la

mémoire pour ce qui concerne les variables créées par l’utilisateur (Nom,dimension, type...) ;

— l’historique des commandes (permet notamment de répéter une com-mande par double clic) ;

— le navigateur de fichiers (permet d’accéder à des scripts ou fonctions, desfichiers de données... ou enregistrer une session de travail ou des variablesspécifiques).

À cela s’ajoutent des fenêtres supplémentaires que l’on peut ouvrir à la demande :— des fenêtres numérotées dédiées aux figures lorsqu’elles sont créées ;— une fenêtre d’aide munie d’un moteur de recherche, d’un navigateur, et de

liens hypertexte, que l’on peut appeler ainsi :--> help plot

— un éditeur de script (SciNotes) ;— une interface de modélisation des système simplifiée, dénommée XCos.

I.2. Entrer une matriceScilab travaille essentiellement avec un seul type d’objet, les matrices rectangu-laires contenant des nombres réels ou complexes et éventuellement des caractères.Dans certaines situations, une signification particulière est donnée aux matrices1 × 1, qui sont des scalaires, et aux matrices avec une seule ligne ou une seulecolonne, qui sont des vecteurs. Les opérations et commandes de Scilab agissentdonc sur ce type d’objet.Il y a plusieurs façons d’entrer une matrice dans l’espace de travail de Scilab :— Entrer au clavier une liste explicite d’éléments.— Générer cette matrice par une suite de commandes Scilab.— Charger cette matrice à partir d’un fichier de données externe.

Le langage Scilab ne contient pas de déclaration de dimension ou de type (àl’opposé de langages comme le Pascal). La place mémoire nécessaire à une matriceest automatiquement allouée au moment de sa création.La façon la plus simple d’entrer une petite matrice est la suivante, en séparantles lignes par des point-virgules ( ;),

--> A = [1 2 3; 4 5 6; 7 8 9]

ou par des retour-chariots (pratique pour les grandes matrices)

--> A = [1 2 3--> 4 5 6--> 7 8 9]

La matrice A est gardée en mémoire pour un usage ultérieur.

I.3. Eléments d’une matriceLes éléments d’une matrice peuvent être n’importe quelle expression Scilab, parexemple

--> x = [-1.3 sqrt(3) (1+2+3)*4/5]

Les éléments individuels d’une matrice peuvent être référencés avec leur indice,précisé entre deux parenthèses, (). Continuons notre exemple :

--> x(5) = abs(x(1))

On notera que la taille de x a été augmentée automatiquement pour pouvoirajouter le nouvel élément, et que les éléments indéfinis ont par défaut été initia-lisés à zéro.On note aussi que contrairement à Python concernant la numérotation, le pre-mier élément porte le numéro 1.

I.4. Commandes de Scilab et variablesScilab est un langage qui possède une syntaxe simple mais bien définie. Unecommande sera toujours de la forme

variable = expression

ou plus simplement

expression

Une expression peut être composée de matrices séparées par des opérateurs, defonctions et de noms de variables. L’évaluation de l’expression produit une ma-trice qui est affichée à l’écran et qui est affectée à une variable. Si le nom de lavariable ainsi que le signe = sont omis, Scilab crée automatiquement une variableportant le nom ans (pour answer). Par exemple :

2


--> 1900/81--> ans

Une commande se termine par l’appui sur la touche Return (ou Enter). Ce-pendant, si le dernier caractère d’une ligne de commande est ; (un point-virgule),cela supprime l’affichage du résultat, sans toutefois affecter l’exécution de la com-mande. On utilisera cette option par exemple lors de calculs intermédiaires dontle résultat n’a pas besoin d’être affiché. Par exemple :

--> y = sqrt(3)/2;--> y

Un nom de variable doit obligatoirement commencer par une lettre, suivie parun nombre quelconque de chiffres et de lettres. Attention : Scilab ne prend encompte que les 19 premiers caractères 5 du nom d’une variable. Scilab fait aussila différence entre les majuscules et les minuscules :

--> z = log(2);--> Z

I.5. Obtenir des informations sur l’espace de travailLes exemples proposés précédemment ont créé des variables qui sont stockéesdans l’espace de travail de Scilab. Pour obtenir la liste de ces variables, il suffitd’entrer la commande

--> who_user

On retrouve au début de cette liste les 4 variables qui ont été créées dans lesexemples précédents. Pour connaître la taille de ces variables, il suffit d’utiliserla commande

--> whos

Une liste assez longue s’affiche, qui présente à la fois les variables créées parl’utilisateur, mais aussi des variables permanentes 6 spécifiques à Scilab (ex :laconstante π s’appelle %pi), et des variables liées à l’environnement de démarrage(librairies notamment).Chaque élément d’une matrice réelle occupe 8 octets (bytes) de la mémoire, etpour chaque matrice 16 octets supplémentaires sont utilisés pour stocker diversesinformations (taille, etc.). Ceci explique par exemple que la matrice A, qui est detaille 3× 3, occupe 9× 8 + 16 = 88 octets, alors que l’objet z (1× 1) en occupe24.

5. C’est en général suffisant... !6. Une variable permanente ne peut être supprimée de l’espace de travail ni modifiée.

I.6. Quitter et sauvegarder l’espace de travailPour quitter Scilab il suffit de taper quit ou exit dans la console. Lorsqu’unesession Scilab est terminée, toutes les variables présentes dans l’espace de travailsont perdues. Il est possible de sauvegarder l’espace de travail avant de quitteren tapant

--> save work.dat

Cette commande sauve toutes les variables dans un fichier appelé work.dat, lui-même situé dans le répertoire courant 7. Il est alors possible lors d’une sessionultérieure de récupérer le contenu de ce fichier en tapant la commande

--> load work.dat

Il est possible d’utiliser les commandes save et load avec d’autres noms defichiers, ou pour des fichiers hors du répertoire courant, via

--> load(’mon_chemin/mon_travail.dat’)

ou bien de sauvegarder uniquement certaines variables :

--> save(’work.dat’,A,x)

La commande ne sauve alors dans ce même fichier que les variables A et x.

I.7. Nombres, expressions arithmétiques et fonctions usuellesScilab utilise la notation décimale classique, avec un point décimal optionnel (sile nombre est entier), précédée du signe moins pour les nombres négatifs. Il estpossible d’inclure une puissance de dix en facteur. Exemples de nombres légaux :

3 -99 0.0001 9.37821312 1.6023E-20 6.02252e23

La précision relative des nombres est donnée par la variable permanente %eps

--> %eps

Cette valeur signifie que la précision est à peu de choses près de 16 chiffressignificatifs. On peut illustrer ceci par l’exemple suivant

--> 1 - 1 + 1e-16--> 1 + 1e-16 - 1

7. Le répertoire courant est celui affiché dans le navigateur de fichiers. Lorsque Scilab aété lancé en mode console (depuis un terminal), le répertoire courant initial est celui à partirduquel a été lancé Scilab.

3


Il faut donc toujours avoir à l’esprit que l’arithmétique sur ordinateur n’est ja-mais exacte (cf cours sur la représentation des nombres). On peut construire desexpressions avec les opérateurs usuels, qui respectent l’ordre de priorité classique :

ˆ élévation à une puissance/ division à droite\ division à gauche∗ multiplication+ addition− soustraction

Nous verrons dans un prochain paragraphe comment ces opérations sont utili-sables sur les matrices.Scilab dispose en standard des fonctions math ématiques usuelles que l’on trouvesur toute calculatrice moderne, nous ne citons ici que les plus classiques :

sqrt racine carréelog logarithmelog10 logarithme décimalsin sinuscos cosinustan tangenteatan arc tangenteexp exponentiellecosh cosinus hyperboliquefloor partie entièreround arrondi à l’entier le plus procheabs valeur absolue ou module pour les complexesreal partie réelle d’un complexeimag partie imaginaire d’un complexemodulo reste d’une division euclidienne

Ces fonctions agissent bien sûr sur les nombres complexes. Par exemple

--> sqrt(-1)--> exp(%i*%pi/3)

Certaines fonctions renvoient simplement des valeurs spéciales. Par exemple lavariable permanente %pi :

--> %pi

renvoie la valeur de π, précalculée comme étant la valeur de 4 arctan(1).

II. Les opérations sur les matrices

II.1. Transposition

--> A = [1 2 3; 4 5 6; 7 8 0]--> B = A’--> x = [-1 0 2]’

L’opération de transposition transpose les matrices au sens classique. Si Z estune matrice complexe, alors Z ′ désigne la transposée conjuguée de Z.

II.2. Addition et soustractionLes opérateurs + et − agissent sur les matrices. Ces opérations sont valides dèsque les dimensions des matrices sont les mêmes. Par exemple avec les matricesde l’exemple précédent l’addition

--> A + x

n’est pas valide car A est 3× 3 et x est 3× 1. Par contre l’opération suivante estvalide :

--> C = A + B

L’addition et la soustraction sont aussi définies si l’un des opérandes est unscalaire, c’est à dire une matrice 1× 1. Dans ce cas le scalaire est additionné ousoustrait de tous les éléments de l’autre opérande, par exemple :

--> z = x - 1

II.3. MultiplicationLe symbole ∗ désigne l’opérateur de multiplication des matrices. Cette opérationest valide dès que les dimensions des opérandes sont compatibles : le nombre decolonnes de l’opérande de gauche doit être égal au nombre de lignes de l’opérandede droite. Par exemple l’opération suivante n’est pas valide

--> x*z

Par contre la commande suivante

--> x’ * z

donne le produit scalaire de x et z.Une autre commande valide est la suivante :

4


--> b = A*x

La multiplication d’une matrice par un scalaire est bien sûr toujours valide :

--> A*2

II.4. Inversion d’une matrice et divisionOn obtient facilement l’inverse d’une matrice carrée avec la commande inv :

--> B = inv(A)--> C=B*A

On notera au passage les erreurs dues à la précision finie des calculs :

--> C(2,1)

La division de matrice est implantée dans Scilab, et porte la significationsuivante : l’expression A/B donne le résultat de l’opération AB−1. Elle est doncformellement équivalente à la commande A*inv(B). Pour la division à gauche,l’expression A\B donne le résultat de l’opération A−1B. Il faut donc respecter lacompatibilité des dimensions des deux matrices pour que cette division ait unsens.La division à gauche est utilisée classiquement lorsque l’on a besoin de résoudre unsystème linéaire. Par exemple si l’on désire résoudre le système linéaire Ay = x,on écrira

--> y = A\x

Lorsque Scilab interprète cette expression, il n’inverse en fait pas la matrice Aavant de la multiplier à droite par x ; il résout effectivement le système. On peutvérifier l’exactitude des résultats de la facon suivante :

--> A*y - x

On notera comme pour l’exemple précédent la présence d’erreurs de l’ordre de laprécision machine.

II.5. Opérations élément par élémentLes opérations usuelles sur les matrices peuvent être effectuées élément par

élément ; cela revient à considérer les matrices comme des tableaux de chiffres etnon plus comme des objets mathématiques de l’algèbre linéaire. Pour l’addition etla soustraction les deux points de vues sont les mêmes puisque ces deux opérationsagissent déjà élément par élément pour les matrices.

Le symbole .* désigne la multiplication élément par élément. Si A et B ont lesmêmes dimensions, alors A.*B désigne le tableau dont les éléments sont simple-ment les produits des éléments individuels de A et B. Par exemple si on définitx et y de la façon suivante :--> x = [1 2 3]; y = [4 5 6];--> z = x .* y

La division fonctionne de la même manière :--> z = x ./ y

Le symbole .ˆ désigne l’élévation à la puissance élément par élément :--> x .^ y

On notera que pour .ˆ l’un des deux opérandes peut être un scalaire :--> x .^ 2--> 2 .^ x

II.6. Opérateurs relationnelsSix opérateurs relationnels sont disponibles pour comparer deux matrices de di-mensions égales :

< plus petit que<= plus petit ou égal> plus grand>= plus grand ou égal== égal<> différent

Scilab compare les paires d’éléments correspondants. Le résultat est une matricede constantes booléennes, le F (false) représentant la valeur "faux" et le T (true)la valeur "vrai". Par exemple--> 2 + 2 <> 4

Les opérateurs logiques permettent de voir dans une matrice la disposition deséléments vérifiant certaines conditions. Par exemple prenons la matrice--> A = [1 1 2; -2 -4 1; 8 1 -1]

La commande--> P = (A < 0)

renvoie une matrice P indiquant par des T les éléments négatifs de A. Ceci peutpermettre d’exprimer une expression logique dans une instruction conditionnellede façon condensée (cf ci-dessous).

5


II.7. Opérateurs logiquesLes opérateurs &, | et ˜ désignent les opérateurs logiques "et", "ou" et "non". Ilsont utilisés pour élaborer des expressions logiques. Par exemple si l’on prend lamatrice de l’exemple précédent, la commande

--> P = (A < 0) & (modulo(A,2) == 0)

permet de repérer dans A les éléments négatifs et multiples de 2.

II.8. Fonctions usuelles appliquées à une matriceLes fonctions usuelles s’appliquant sur réels et complexes s’appliquent aussi élé-ment par élément sur les matrices. Par exemple :

--> A = [0 1/4; 1/2 3/4]--> cos(%pi*A)

III. Générer et manipuler des matrices et des vec-teurs

III.1. GénérerPour créer et initialiser une matrice, on peut facilement générer une matricenulle de taille quelconque :

--> A = zeros(3,2)

On peut aussi générer une matrice identité :

--> I = eye(3,3)

On peut aussi générer des vecteurs particuliers à l’aide du caractère : (deuxpoints), comme ceci :

--> x = 1:5

Cette commande a permis d’affecter au vecteur x les entiers de 1 à 5. On peutaussi spécifier un incrément particulier autre que 1 :

--> y = 0:%pi/4:%pi

On notera que cette commande produit toujours un vecteur ligne. Il est bien sûrpossible d’utiliser un incrément négatif,

--> y = 6:-1:1

ou de spécifier uniquement les valeurs minimum et maximum et le nombre devaleurs désirés :

--> k = linspace(-%pi,%pi,5)

On peut aisément créer des tables en utilisant ces commandes, ce qui estutile notamment pour créer rapidement des représentations graphiques (sectionsuivante). Par exemple :

--> x = (0:0.2:3)’;--> y=exp(-x).*sin(x);--> [x y]

III.2. Manipuler les éléments d’une matriceOn peut accéder aux éléments individuels d’une matrice en précisant leurs nu-méros de ligne et de colonne dans des parenthèses. Prenons la matrice

--> A = [1 2 3; 4 5 6; 7 8 9]

La commande suivante permet de remplacer a33 par a13 + a31 :

--> A(3,3) = A(1,3) + A(3,1)

On peut extraire une ligne ou une colonne d’une matrice :

--> v = A(:,1)

permet de mettre dans le vecteur v la première colonne de la matrice A, alorsque

--> v = A(1,:)

permettra d’extraire la première ligne de A.De manière générale un indice de ligne ou de colonne peut être un vecteur. Parexemple, avec

--> x = 0:2:8;

on peut effectuer une permutation des éléments de x via

--> v = [3 5 1 2 4];--> x(v)

6


On peut aussi extraire une sous-matrice d’une matrice plus grande. Parexemple

--> B = A( 1:2, : );

sélectionne les deux premières lignes et toutes les colonnes de A et les stocke dansune matrice B.Il est possible de construire une matrice à partir de matrices plus petites. Parexemple, pour ajouter une nouvelle ligne à la matrice A :

--> l = [10 11 12];--> A = [A; l]

On peut aussi facilement modifier les sous-matrices d’une matrice (comme on l’adéjà vu plus haut pour le cas d’une ligne ou d’une colonne) :

--> A(1:2,1:2) = eye(2,2)

Ici on a remplacé la sous-matrice principale d’ordre 2 de A par la matrice identité.

Enfin, on peut obtenir la taille d’une matrice (nombre de lignes et de colonnes),

--> size(A)

et l’injecter dans des variables :

--> [n,m]=size(v)

IV. GraphiquesCette section donne un bref apercu des possibilités graphiques de Scilab. Il estpossible de générer des graphiques à deux et à trois dimensions, et d’agir facile-ment sur les attributs du graphe (couleurs, type de ligne, axes, annotations...).Les commandes présentées ci-dessous sont utiles notamment pour être introduitesdans des scripts et automatiser la production de figure. De plus leur syntaxe al’avantage d’être très proche de celle de Matlab (et Pylab, ou Matplotlib). Tou-tefois, une fois le graphe créé (plot), il est aussi possible de modifier les attributsdu graphe directement à la souris grâce aux menus interactifs de la fenêtre figure.

IV.1. Graphiques à 2 dimensions

IV.1.1. La commande plot

Pour générer un graphe en deux dimensions, la commande générale est plot :

--> t = 0:%pi/4:2*%pi;--> plot(t,sin(t))

La syntaxe est claire : plot(x,y) permet de tracer une courbe reliant les pointsdont les abscisses sont données dans le vecteur x et les ordonnées dans y. Unepremière remarque s’impose : les points sont a priori reliés par des segments dedroite, et plus on prendra de points intermédiaires, plus le tracé sera fidèle àl’allure théorique. Par exemple :

--> t = 0:%pi/16:2*%pi;--> plot(t,sin(t))

Ici on a tracé le graphe d’une fonction de x, mais on peut aussi tracer une courbeparamétrée du type {

x = f(t)y = g(t) pour t ∈ [a, b] .

Par exemple pour un cercle :

--> t = 0:%pi/32:2*%pi;--> plot(cos(t),sin(t))--> set(gca(),"isoview","on")

La commande set(gca(),"isoview","on") permet d’imposer une échelle iden-tique sur les deux axes de coordonnées.

Il est possible de superposer deux courbes sur le même graphique :

--> plot(t,cos(t),t,sin(t))

Il est possible de changer les couleurs et les type de lignes utilisés parScilab :

--> plot(t,cos(t),’g’,t,sin(t),’r’)

On peut aussi ne faire apparaître que les points et ne pas les relier par dessegments de droite. Dans ce cas on peut repérer chaque point par un symbole(point, rond, étoile, croix...) :

--> plot(t,cos(t),’g^-’,t,sin(t),’ro-’)

7


Donc on peut modifier couleur et types de tracé (ligne ou symbole) en faisantsuivre chaque couple x, y d’une chaîne de caractères entourée d’apostrophes (lemême caractère que pour la transposition des matrices) composée de deux sym-boles précisant la couleur et le symbole. Le tableau ci-dessous donne quelquessymboles et couleurs possibles (non exhaustif) :

Symbol Color Marker Linetypey yellow . dot - Solid line (default)m magenta ◦ circle - - Dashed linec cyan × cross : Dotted liner red + plus -. Dash-dotted lineg green ∗ starb blue � diamondw white ∧ upward-pointing trianglek black ∨ downward-pointing triangle

Pour en savoir plus, il suffit de taper

--> help plot

IV.1.2. Titres et légendes

On peut facilement ajouter labels sur les axes, un titre, et une légende pour lescourbes :

--> xlabel(’Abscisse’)--> ylabel(’Ordonnee’)--> title(’Essai du graphique’)--> legend(’Cosinus’,’Sinus’)

IV.2. Manipuler plusieurs graphiquesOn peut aisément disposer de plusieurs fenêtres graphiques. La fenêtre créée lorsdu premier appel à la fonction plot porte le numéro 0. Cette fenêtre reçoit lesnouvelles commandes graphiques (ex : courbe supplémentaire). On peut ouvrirune nouvelle fenêtre en indiquant son numéro :

--> figure(1)

ouvre une fenêtre N◦1. La fenêtre active est la dernière sur laquelle on a cliqué.On peut aussi diriger les sorties de la façon suivante :

--> figure(0); plot(t,sin(t))--> figure(1); plot(t,cos(t))

Une fenêtre peut aussi intégrer plusieurs graphes non superposés grâce à lacommande subplot :

--> subplot(2,1,1)--> plot(t,cos(t))--> subplot(2,1,2)--> plot(t,sin(t))

La commande subplot(n,m,k) permet de subdiviser la fenêtre en n ∗m cases,n colonnes et m lignes (comme pour les matrices). Ces cases sont numérotées degauche à droite et de haut en bas. La valeur de k permet de spécifier dans quellecase on désire faire un graphique.

IV.3. Graphiques à 3 dimensionsIV.3.1. Les courbes

Il est possible de tracer des courbes dans l’espace avec la commande param3d.Par exemple une hélice :

--> clf--> t = 0:%pi/32:8*pi;--> param3d(cos(t),sin(t),t)

La commande clf permet d’effacer la fenêtre graphique.

IV.3.2. Les surfaces

Scilab permet de générer très facilement des graphiques à trois dimensions, parexemple, des graphes de fonctions de deux variables

z = f(x, y) ,

représentés dans l’espace, ou bien des graphes paramétriques x = f(t, s)y = g(t, s)z = h(t, s)

avec (t, s) ∈ [a, b]× [c, d].

Voici un premier exemple permettant de tracer le graphe de la fonction

z = f(x, y) = cos(π√x2 + y2

),

sur le domaine de variation (x, y) ∈ [−1, 1]× [−2, 2]. Comme pour les courbes en2D, il faut échantillonner les variables. Par exemple :

8


--> x = linspace(-1,1,10);--> y = linspace(-2,2,20);

Cependant, à ce stade Scilab ne sait pas évaluer directement toutes les valeursf(xi, yj) pour tous les couples (xi, yj) simplement à partir des vecteurs x ety. Il faudrait construire un objet représentant une "grille" ou un "maillage" (unematrice de taille 20×10 en l’occurence) qui contienne tous les couples (xi, yj). Enpratique cela se fait en construisant deux matrices 20× 10 qui répètent chacuneles valeurs des vecteurs x et y :

--> [X,Y] = meshgrid(x,y);

On peut ensuite calculer en une seule instruction les valeurs de f aux points(xi, yj), ce qui crée aussi par une matrice 20× 10 :

--> Z = cos(%pi*sqrt( X.^2 + Y.^2 ));

Il existe alors deux possibilités pour tracer la surface. Soit on utilise directementx et y (attention à l’ordre) et la commande de base plot3d,

--> plot3d(y,x,Z)

ou alors on utilise X et Y avec la commande mesh :

--> mesh(X,Y,Z)

La surface est ainsi dessinée de façon approchée sous la forme d’une sorte de"grillage" reliant les points voisins par des mailles à quatre côtés.

Il est possible d’obtenir un rendu visuel plus parlant à l’aide de la commandesurf, qui en plus du grillage projette les valeurs de z sur une échelle de cou-leurs 8 :

--> set(gcf(),’color_map’,jetcolormap(128))--> surf(X,Y,Z)--> set(gce(),’color_flag’,3)

La commande set(gcf(),’color_map’,jetcolormap(128)) permet de choisirl’échelle de couleurs (color_map) dénommée jetcolormap, en l’échantillonnantselon un dégradé de 128 couleurs. La commande set(gce(),’color_flag’,3)est un supplément esthétique : elle permet d’interpoler les couleurs dans chaquemaille, et donc de "lisser" plus encore le dégradé, sans avoir à prendre plus depoints pour générer la surface.Enfin, une fois le graphe 3D créé, il est possible de modifier le point-de-vue en

8. Il est aussi possible d’ajouter un échelle de couleur avec la commande plot3d.

"faisant tourner" la figure à l’aide du clic droit de la souris (ou en modifiantmanuellement les valeurs des angles dans l’option Viewpoint du menu ou descommandes).

Pour tracer une surface paramétrée, on ne peut pas de façon générale utiliser lacommande plot3d, qui contraint les vecteurs d’abscisses et d’ordonnées à évoluerde façon monotone. Il faut donc passer par les commandes mesh ou surf (ou parles variantes plot3d2 ou plot3d3 qui fonctionnent de la même façon).

V. Programmer en ScilabLes scripts et les fonctions sont des fichiers texte ordinaires créés à l’aide d’unéditeur de texte quelconque :— un script permet d’exécuter automatiquement une longue suite de com-

mandes amenée à être répétée 9 ;— une fonction permet d’étendre la bibliothèque de fonctions standard de

Scilab.

L’interface Scilab propose un éditeur dédié à cela (menu Applications /SciNotes), proposant notamment la coloration syntaxique et des fonctions d’exé-cution autommatique.

V.1. ScriptsNous allons créer un script qui calcule quelques termes de la suite de Fibonaccidont la définition est la suivante : u0 = 1

u1 = 1uk+2 = uk+1 + uk , k ≥ 0

Pour cela, sélectionner Editeur dans le menu de Scilab. Le fichier créé à pardéfaut le nom Sans Titre. Pour le changer ce nom il suffit de sélectionnerEnregister sous dans le menu fichier et de choisir le nom fibo.sce. Vouspouvez maintenant saisir les lignes suivantes dans la fenêtre de l’éditeur :

9. Le Script est aussi de façon générale un moyen plus léger et plus portable pour sau-vegarder des travaux que la sauvegarde de l’espace de travail (ex : réalisation d’une figure àl’aide de données, calcul long en plusieurs étapes...). En particulier il permet de commenterles instructions, comme dans tout programme. De plus il est au format texte donc lisible parn’importe quel éditeur, et utilisable par d’autres versions de Scilab à condition que la syntaxesoit compatible.

9


// Un script pour calculer les termes de la suite de Fibonacci

n = 10;u = zeros(n,1);u(1:2) = [1;1];

for i = 1:n-2u(i+2) = u(i+1) + u(i);

end

u

Les caractères // permettent d’insérer des commentaires (ce qui les suit n’est pasinterprété par Scilab). L’indentation du code est libre sous Scilab. Nous verronsen détail comment utiliser l’instruction for un peu plus tard. Une fois que letexte est tapé dans la fenêtre, sauvez le fichier (menu Fichier de l’éditeur).Pour exécuter le script fibo.sce, il suffit de taper :

--> exec fibo.sce

ou utiliser le menu Exécuter (raccourci CTRL L).

Il peut parfois être utile de mesurer le temps d’exécution d’un programme :

timer()s=0; for i=1:1000000, s=s+i, end ;temps=timer()

La variable temps contient le temps d’exécution du programme.

Lors d’un calcul, il peut être nécessaire de lire des données stoquées dans unfichier (d’entrée), ou d’écrire les résultats dans un fichier (de sortie) :

a=rand(50,50);write(’truc.dat’,a)a=zeros(1)a=read(’truc.dat’,2,2)

Il faut quelques fois faire la chasse aux erreurs de programmation (débogage).Une méthode consiste à introduire aux endroits stratégiques d’une procéduredes instructions pause. Lors de l’exécution d’une telle procédure, Scilab s’ar-rète quand il rencontre une pause et vous avez la main pour demander à Scilabd’afficher les valeurs des différentes variables à cet instant de l’éxécution du pro-gramme ; vous pouvez ensuite dire à Scilab de repartir avec l’instruction resume.

Il repartira alors jusqu’à la prochaine pause, comme si rien ne s’était passé pen-dant l’interruption.On peut aussi demander à ce que le programme affiche les valeurs de certainesvariables au cours de son exécution, afin de suivre son déroulement. Exemple :

--> for i=1:9, disp(i),end

V.2. FonctionsUne fonction est un programme particulier qui prend des arguments en entrée etproduit un résultat (valeur, graphique...). La fonction peut être écrite directementdans la console (si elle est très courte) ou dans un script à exécuter une fois 10.Une fois définie (chargée), elle est connue par Scilab et présente dans l’espacede travail. On peut alors l’appeler par son nom soit dans la console, soit via unautre programme.La syntaxe pour définir une fonction en langage Scilab peut être résummée ainsi :

function [liste_variables_de_sortie] = nom_fonction(liste_arguments)

// Commentaires : ce que fait la fonction, comment elle le fait,// Auteur, dates de création / mise-à-jour...)

... instructions ...

endfunction

A titre d’exemple, nous allons créer une fonction calculant la factorielle, quin’existe pas dans Scilab. Elle sera sauvegardée dans le script fact.sci :

function [f] = fact(n)

// Cette fonction calcule la factorielle d’un nombre entier

if (n - floor(n) ~= 0) | n < 0error(’erreur dans fact : l’’argument doit etre entier’);

end

if n == 0f = 1;

10. Un usage courant consiste à regrouper ses propres fonctions dans un seul scriptmes_fonctions.sce, ou dans plusieurs scripts thématiques, de façon à constituer des biblio-thèques de fonctions.

10


elsef = prod(1:n);

end

endfunction

Quelques explications sont nécessaires sur les lignes de cette fonction :— La ligne if (n - floor(n) = 0... permet de tester si le nombre passé

en argument est un entier naturel. La structure if ... else ... end seravue à la prochaine section.

— La commande error permet de stopper l’exécution de la fonction tout enrenvoyant un message d’erreur à l’utilisateur, si les conditions d’exécutionde la fonction ne sont pas réunies.

— La fonction prod permet de calculer le produit des éléments du vecteurpassé en argument.

Une fois que le texte tapé dans l’éditeur et sauvegardé, il faut exécuter le scriptpour que Scilab puisse utiliser cette nouvelle fonction :

--> exec fact.sci

Ensuite la fonction est appelée par son nom :

--> fact(5)--> p = fact(7)

Enfin, il existe une syntaxe particulière pour définir une fonction de façon conden-sée, qui peut être utile en mode console :

--> deff(’c=plus(a,b)’,’c=a+b’);--> plus(1,2)

V.3. Structures de contrôleOn retrouve les principales structures de contrôle classiques :• Instruction conditionnelle IF ... ELSE :

if 1ere_condition thenbloc_d_instructions

elseif 2nde_conditionbloc_d_instructions

elsebloc_d_instructions

end

Le mot clé then est facultatif.• Instruction conditionnelle WHILE :

while conditionbloc_d_instructions

end

• Boucle séquentielle FORfor i = vecteur

bloc_d_instructionsend

Contrairement à Python qui impose un format d’écriture via l’indentation, Scilab(comme la plupart des langages de programmation) définit explicitement la find’une structure de contrôle par un mot clé : end, mais n’impose pas d’indenta-tion 11.En pratique (comparons avec Python) :— Les structures de contrôle s’écrivent donc comme sous Python, en suppri-

mant les symboles : (deux points), et en ajoutant un end à la fin.— Les conditions booléennes utilisant des comparateurs s’écrivent de la même

façon qu’en Python, à l’exception de <> ("différent", != en Python).— Le comptage dans la boucle séquentielle s’écrit avec des vecteurs 12 (ou

listes du type m:n ou m:p:n), en remplaçant le in de Python par =.Attention : ne pas oublier qu’une ligne qui ne se termine pas avec un point-virgule va déclencher un affichage du résultat... ce qui peut être ennuyeux sil’opération se répète un grand nombre de fois !Toutes ces structures peuvent s’écrire de façon compacte (mais moins lisible) enune seule ligne, pour être utlisées en mode console : il suffit de remplacer tous lesretour-chariots par des virgules. Exemple :

--> s=0; for i=1:1000, s=s+1/i^2; end--> s

A noter, la récursivité 13 est possible sous Scilab, même si elle n’est en généralpas recommandée compte-tenu du coût en occupation de la mémoire.

V.4. Interaction avec l’utilisateurIl est possible, dans un script ou une fonction, de faire entrer interactivementdes données par l’utilisateur. Par exemple, dans la fonction calculant les premiers11. L’indentation est toutefois très conseillée car fort utile pour la clarté du code.12. On peut aussi utiliser des matrices ; elles sont alors lues colonne par colonne.13. ... l’appel d’une fonction par une instruction de boucle au coeur de cette même fonction.

11


termes de la suite de Fibonacci, il serait intéressant de rentrer interactivementla valeur de n. Cela peut se faire à l’aide de la fonction input. Modifiez le scriptfibo.sce en remplaçant la ligne

n = 10;

par la ligne

n = input(’Nombre de termes desire ? ’);

Après avoir sauvegardé, expérimentez le fonctionnement de cette fonction input :

--> exec fibo.sce

On peut facilement générer un menu lorsque l’on a besoin que l’utilisateurfasse un choix parmi un certain nombre d’options, avec la commande x_choose,qui s’utilise de la façon suivante :

--> choice = x_choose([’French fries’;...’Spaghetti Bolognese’;’kaoya’],’Todays menu’)

Un menu cliquable s’ouvre alors. Le premier argument de x_choose est une ma-trice de chaines de caractères contenant les textes associés aux diverses options.Le deuxième argument est le titre du menu apparaissant au dessus des boutons.Après un clic de souris sur l’une des options, la fonction renvoie le numéro del’option choisie.

VI. Résolution numérique d’équations différentiellesC’est un sujet vaste qui sera exploré plus avant en cours d’année, lorsque lesfondements théoriques auront été posés. Toutefois montrons à l’aide d’un simpleexemple ce que permet le solveur d’Equation Différentielle Ordinaire (EDO) ode.

La théorie montre qu’on peut écrire toute EDO d’ordre n sous la forme de l’équa-tion d’ordre 1 suivante :

dYdx = f(x, Y ) ,

où Y est une fonction vectorielle, à valeurs dans Rn.

Par exemple, dans le cas d’un système linéaire du premier ordre soumis à unéchelon, on souhaite résoudre (sous forme adimensionnée)

dydt = −y + 1 avec y(0) = 0 .

Il se trouve que dans ce cas la solution exacte est déjà connue sous forme analy-tique : y(t) = 1 − e−t. Comparons-la à la solution numérique (donc approchée)trouvée par Scilab :

--> function ydot=f(t, y),ydot=-y+1,endfunction--> y0=0;t0=0;t=0:0.1:5;--> y=ode(y0,t0,t,f);--> plot(t,y,’r’,t,1-exp(-t),’k--’)

Bien sûr, ce solveur trouvera tout son intérêt dans la résolution d’EDO que l’onne sait pas résoudre analytiquement...

EXERCICESCourbes planes

1. Tracer une ellipse sous forme paramétrée par la variable temps :{x(t) = Xm cos(ωt)y(t) = Ym cos(ωt+ ϕ)

Explorer l’influence de la constante ϕ.2. Tracer une ellipse paramétrée sous forme polaire :

r = p

1 + e cos(θ − θ0) avec e > 1

Explorer l’influence de la constante θ. Que se passe-t-il pour e > 1 ?

Surfaces

3. Tracer une sphère paramétrée en coordonnées sphériques : x = R cosϕ sin θy = R sinϕ sin θz = R cos θ

4. Expérimenter des surfaces plus générales où le rayon est une fonction R(ϕ, θ),par exemple

R(ϕ, θ) = 2 + sin(4ϕ+ 4θ) ,

où toute autre fonction issue de votre imagination !

12

TPN 1:InitiationàSCILAB5 Tabledesmatières...TPN 1:InitiationàSCILAB5 Introduction Ce TP est un...

Documents

Transcript of TPN 1:InitiationàSCILAB5 Tabledesmatières...TPN 1:InitiationàSCILAB5 Introduction Ce TP est un...