Une introduction `a Scilab

version 0.9999 α
Bruno Pin¸con
Institut Elie Cartan Nancy
E.S.I.A.L.
Universit´e Henri Poincar´e
Email : Bruno.Pincon@iecn.u-nancy.fr
Ce document a ´et´e initialement r´edig´e pour les ´etudiants ing´enieurs de l’E.S.I.A.L. (
´
Ecole Sup´erieure
d’Informatique et Application de Lorraine). Il d´ecrit une petite partie des possibilit´es de Scilab, es-
sentiellement celles qui permettent la mise en pratique de notions d’analyse num´erique et de petites
simulations stochastiques, c’est `a dire :
– la manipulation des matrices et vecteurs de nombres flottants ;
– la programmation en Scilab ;
– quelques primitives graphiques ;
– quelques fonctions importantes pour ces deux domaines (g´en´eration de nombres al´eatoires, r´esolution
d’´equations, ...).
Scilab permet de faire beaucoup d’autres choses, en particulier dans le domaine de l’automatique, du
traitement du signal, de la simulation de syst`emes dynamiques (avec scicos)... Comme je pense compl´eter
progressivement ce document, je suis ouvert `a toutes remarques, suggestions et critiques permettant de
l’am´eliorer (mˆeme sur les fautes d’orthographe...), envoyez les moi par courriel.
Mini historique des versions de ce document :
– version 0.999 : modifications du chapitre sur le graphique et quelques ajouts pour la programmation ;
version relative `a scilab-2.7 ;
– version 0.9999 (ce document) : adaptation du chapitre graphique au “nouveau graphique objet” de
scilab ; version relative `a scilab-4.0.
A force de rajouter quelques paragraphes ici et l`a, ce document n’est plus tr`es synth´etique mais il
existe maintenant d’autres introductions que vous pouvez r´ecup´erer `a partir du site Scilab (voir plus
loin).
Remerciements
– au Doc Scilab qui m’a souvent aid´e via le forum des utilisateurs ;
– `a Bertrand Guiheneuf qui m’a fourni le « patch » magique pour compiler Scilab 2.3.1 sur ma
linuxette (la compilation des versions suivantes ne pose pas de probl`eme sous linux) ;
– `a mes coll`egues et amis, St´ephane Mottelet
1
, Antoine Grall, Christine Bernier-Katzentsev et Didier
Schmitt ;
– un grand merci `a Patrice Moreaux pour sa relecture attentive et les corrections dont il m’a fait
part ;
– `a Helmut Jarausch, qui a traduit ce document en allemand, et qui m’a signal´e quelques erreurs
suppl´ementaires ;
– et `a tous les lecteurs qui m’ont apport´e leurs encouragements, remarques et corrections.
1
merci pour les « trucs » pdf St´ephane !
Table des mati`eres
1 Informations diverses 4
1.1 Scilab en quelques mots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Comment utiliser ce document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.3 Principe de travail sous Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.4 O` u trouver de l’information sur Scilab ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.5 Quel est le statut du logiciel Scilab ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 La manipulation des matrices et vecteurs 7
2.1 Entrer une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Quelques matrices et vecteurs types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 L’instruction d’affectation de Scilab et les expressions scalaires et matricielles . . . . . . . 11
2.3.1 Quelques exemples basiques d’expressions matricielles . . . . . . . . . . . . . . . . 11
2.3.2 Op´erations « ´el´ement par ´el´ement » . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3.3 R´esoudre un syst`eme lin´eaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3.4 R´ef´erencer, extraire, concat´ener matrices et vecteurs . . . . . . . . . . . . . . . . . 15
2.4 Information sur l’espace de travail (*) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.5 Utilisation de l’aide en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.6 Visualiser un graphe simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.7
´
Ecrire et ex´ecuter un script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.8 Compl´ements divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.8.1 Quelques raccourcis d’´ecriture dans les expressions matricielles . . . . . . . . . . . 20
2.8.2 Remarques diverses sur la r´esolution de syst`emes lin´eaires (*) . . . . . . . . . . . . 21
2.8.3 Quelques primitives matricielles suppl´ementaires (*) . . . . . . . . . . . . . . . . . 23
2.8.4 Les fonctions size et length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.9 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3 La programmation en Scilab 30
3.1 Les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.1.1 La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.1.2 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2 Les instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.2.1 La construction if then else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.2.2 La construction select case (*) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3 Autres types de donn´ees . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.3.1 Les chaˆınes de caract`eres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.3.2 Les listes (*) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.3 Quelques expressions avec les vecteurs et matrices de bool´eens (*) . . . . . . . . . 38
3.3.4 les expressions bool´eennes dans les tests (if et while) . . . . . . . . . . . . . . . . . 39
3.4 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.4.1 un premier exemple de fonction : la factorielle en scilab . . . . . . . . . . . . . . . 40
3.4.2 deuxi`eme exemple : l’´equation du second degr´e . . . . . . . . . . . . . . . . . . . . 41
3.4.3 troisi`eme exemple : l’algorithme d’Horner . . . . . . . . . . . . . . . . . . . . . . . 41
3.4.4 quatri`eme exemple : le tri insertion . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.4.5 Passage des param`etres (*) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
1
3.4.6 D´everminage d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.4.7 L’instruction break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.4.8 Quelques primitives utiles dans les fonctions . . . . . . . . . . . . . . . . . . . . . . 46
3.5 Compl´ements divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5.1 Longueur des identificateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5.2 Priorit´e des op´erateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.5.3 R´ecursivit´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.5.4 Une fonction est une variable Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.5.5 Fenˆetres de dialogues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.5.6 Conversion d’une chaˆıne de caract`eres en expression Scilab . . . . . . . . . . . . . 50
3.6 Lecture/´ecriture sur fichiers ou dans la fen`etre Scilab . . . . . . . . . . . . . . . . . . . . . 51
3.6.1 Les entr´ees/sorties `a la fortran . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.6.2 Les entr´ees/sorties `a la C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.7 Remarques sur la rapidit´e . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.8 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4 Les graphiques 61
4.1 G´en´eralit´es sur le nouveau graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.1.1 principes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
4.1.2 les fenˆetres graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.2 l’intruction plot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.3 modifier quelques propri´et´es des graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.4 l’instruction plot2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.5 Des variantes de plot2d : plot2d2, plot2d3 . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.6 Dessiner plusieurs courbes qui n’ont pas le mˆeme nombre de points . . . . . . . . . . . . . 71
4.7 Jouer avec le syst`eme d’axes par d´efaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.8 Dessiner un histogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.9 R´ecup´erer ses graphiques sous plusieurs formats . . . . . . . . . . . . . . . . . . . . . . . . 74
4.10 Animations simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.11 Les surfaces : NOT YET UPDATED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.11.1 Introduction `a plot3d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.11.2 La couleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.11.3 plot3d avec des facettes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.11.4 Dessiner une surface d´efinie par x = x(u, v), y = y(u, v), z = z(u, v) . . . . . . . . 81
4.11.5 plot3d avec interpolation des couleurs . . . . . . . . . . . . . . . . . . . . . . . . . 83
4.12 Les courbes dans l’espace : NOT YET UPDATED . . . . . . . . . . . . . . . . . . . . . . 84
4.13 Divers : NOT YET UPDATED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
4.14 quelques remarques sur le graphique scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
5 Applications et compl´ements : NOT YET UPDATED FOR GRAPHICS 88
5.1
´
Equations diff´erentielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.1.1 Utilisation basique de ode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.1.2 Van der Pol one more time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5.1.3 Un peu plus d’ode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.2 G´en´eration de nombres al´eatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.2.1 La fonction rand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.2.2 La fonction grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
5.3 Les fonctions de r´epartition classiques et leurs inverses . . . . . . . . . . . . . . . . . . . . 96
5.4 Simulations stochastiques simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.4.1 Introduction et notations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.4.2 Intervalles de confiance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.4.3 Dessiner une fonction de r´epartition empirique . . . . . . . . . . . . . . . . . . . . 98
5.4.4 Test du χ
2
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
5.4.5 Test de Kolmogorov-Smirnov . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
2
5.4.6 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6 B´etisier 104
6.1 D´efinition d’un vecteur ou d’une matrice « coefficient par coefficient » . . . . . . . . . . . 104
6.2 Apropos des valeurs renvoy´ees par une fonction . . . . . . . . . . . . . . . . . . . . . . . . 104
6.3 Je viens de modifier ma fonction mais... . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.4 Probl`eme avec rand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.5 Vecteurs lignes, vecteurs colonnes... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.6 Op´erateur de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
6.7 Nombres Complexes et nombres r´eels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
6.8 Primitives et fonctions Scilab : SHOULD BE UPDATED . . . . . . . . . . . . . . . . . . 106
A Correction des exercices du chapitre 2 108
B Correction des exercices du chapitre 3 109
C Correction des exercices du chapitre 5 : NOT YET UPDATED FOR GRAPHICS 113
3
Chapitre 1
Informations diverses
1.1 Scilab en quelques mots
Qu’est-ce que Scilab ? Soit vous connaissez d´ej`a Matlab et alors une r´eponse rapide consiste `a dire
que Scilab en est un pseudo-clone libre (voir un plus loin quelques pr´ecisions `a ce sujet) d´evelopp´e
1
par l’I.N.R.I.A. (Institut National de Recherche en Informatique et Automatique). Il y a quand mˆeme
quelques diff´erences mais la syntaxe est `a peu pr`es la mˆeme (sauf en ce qui concerne les graphiques). Si
vous ne connaissez pas Matlab alors je vais dire bri`evement que Scilab est un environnement agr´eable
pour faire du calcul num´erique car on dispose sous la main des m´ethodes usuelles de cette discipline, par
exemple :
– r´esolution de syst`emes lin´eaires (mˆeme creux),
– calcul de valeurs propres, vecteurs propres,
– d´ecomposition en valeurs singuli`eres, pseudo-inverse
– transform´ee de Fourier rapide,
– plusieurs m´ethodes de r´esolution d’´equations diff´erentielles (raides / non raides),
– plusieurs algorithmes d’optimisation,
– r´esolution d’´equations non-lin´eaires,
– g´en´eration de nombres al´eatoires,
– de nombreuses primitives d’alg`ebre lin´eaire utiles pour l’automatique.
D’autre part, Scilab dispose aussi de toute une batterie d’instructions graphiques, de bas-niveau
(comme tracer un polygone, r´ecuperer les coordonn´ees du pointeur de la souris, etc. . .) et de plus haut
niveau (pour visualiser des courbes, des surfaces) ainsi que d’un langage de programmation assez simple
mais puissant et agr´eable car il int`egre les notations matricielles. Quand vous testez un de vos programmes
´ecrit en langage Scilab, la phase de mise au point est g´en´eralement assez rapide car vous pouvez examiner
facilement vos variables : c’est comme si l’on avait un d´ebogueur. Enfin, si les calculs sont trop longs (le
langage est interpr´et´e. . .) vous pouvez ´ecrire les passages fatidiques comme des sous-programmes C ou
fortran (77) et les lier `a Scilab assez facilement.
1.2 Comment utiliser ce document
Rendez-vous en premier au chapitre deux o` u j’explique comment utiliser Scilab comme une calculette
matricielle : il suffit de suivre les exemples propos´es. Vous pouvez passer les sections ´etoil´ees (*) dans une
premi`ere lecture. Si vous ˆetes int´eress´e(e) par les aspects graphiques vous pouvez alors essayer les premiers
exemples du chapitre quatre. Le chapitre trois explique les rudiments de la programmation en Scilab. J’ai
commenc´e `a ´ecrire un chapitre cinq concernant quelques applications ainsi qu’un « b´etisier » qui essaie
de r´epertorier les erreurs habituelles que l’on peut commettre en Scilab (envoyer moi les votres !). Une
derni`ere chose, l’environnement graphique de Scilab (la fenˆetre principale, les fenˆetres graphiques,...)
est l´eg`erement diff´erent entre les versions Unix
2
et Windows, c-a-d que les boutons et menus ne sont
1
en fait Scilab utilise de nombreuses routines qui proviennent un peu de partout et qui sont souvent accessibles via Netlib
2
Sous Unix il y a en fait 2 interfaces graphiques : l’officielle bas´ee sur les Ath´ena Widgets (Xaw ou Xaw3d) et une interface
d´evelopp´ee par Jean-Philippe Chancelier, bas´ee sur le toolkit gtk avec donc un look plus moderne mais aussi des possibilit´es
d’´edition am´elior´ee via la biblioth`eque readline ; cette version n’est pas officiellement support´ee par le consortium scilab.
4
pas agenc´es exactement de la mˆeme mani`ere. Dans ce document certains d´etails (du genre s´electionner
l’item « truc » du menu « bidule »...) sont relatifs `a la version Unix mais vous trouverez sans probl`eme
la manipulation ´equivalente sous Windows.
1.3 Principe de travail sous Scilab
Au tout d´ebut Scilab peut s’utiliser simplement comme une calculette capable d’effectuer des op´erations
sur des vecteurs et matrices de r´eels et/ou complexes (mais aussi sur de simples scalaires) et de visualiser
graphiquement des courbes et surfaces. Dans ce cas basique d’utilisation, vous avez uniquement besoin
du logiciel Scilab. Cependant, assez rapidement, on est amen´e `a ´ecrire des scripts (suite d’instructions
Scilab), puis des fonctions et il est n´ecessaire de travailler de pair avec un ´editeur de texte comme par
exemple, emacs (sous Unix et Windows), wordpad (sous Windows), ou encore nedit, vi (sous Unix)...
Scilab vient maintenant avec son propre ´editeur int´egr´e (scipad) qui peut aussi rendre des
services lors du d´ebogage de fonctions.
1.4 O` u trouver de l’information sur Scilab ?
La suite du document suppose que vous avez `a votre disposition la version 4.0 du logiciel. Pour tout
renseignement consulter la « Scilab home page » :
http ://scilabsoft.inria.fr
`a partir de laquelle vous avez en particulier acc`es `a diff´erentes documentations, aux contributions des
utilisateurs, etc...
Le « Scilab Group » a ´ecrit (entre fin 1999 et 2001) une vingtaine d’articles dans la revue « Linux
magazine ». Plusieurs aspects de Scilab (dont la plupart ne sont pas ´evoqu´es dans cette introduction) y
sont pr´esent´es, je vous les recommande donc. Ces articles sont consultables `a partir de l’url :
http ://www.saphir-control.fr/articles/
Scilab dispose aussi d’un forum usenet qui est le lieu ad´equat pour poser des questions, faire des
remarques, apporter une solution `a une question pr´ealablement pos´ee, etc. . . :
comp.sys.math.scilab
Tous les messages qui ont ´et´e post´es dans ce forum sont archiv´es
3
et accessibles `a partir de la « home
page » Scilab en cliquant successivement sur l’item Documentation & Support (cadre en haut `a gauche)
puis sur l’item Scilab Newsgroup (cadre en haut `a gauche aussi).
Toujours `a partir de la page Scilab, vous avez acc`es a un certain nombre de documents en choisissant
la rubrique Books, Reports & Articles. En particulier :
– l’introduction de B. Ycart (D´emarrer en Scilab) ;
– l’introduction de J.Ph Chancelier (Scilab : une introduction) ;
– « Scilab Bag Of Tricks » de Lydia E. van Dijk et Christoph L. Spiel qui est plutˆot destin´e aux
personnes connaissant d´ej`a bien Scilab (le d´eveloppement de ce livre s’est h´elas arrˆet´e brutalement
il y a quelques ann´ees) ;
– Travaux Pratiques sur Scilab classes par themes vous permet d’acc´eder `a des projets r´ealis´es avec
Scilab par des ´el`eves de l’ENPC;
– une introduction `a l’informatique en utilisant Scilab (http ://kiwi.emse.fr/SCILAB/).
Mais il y en a bien d’autres, et, selon vos besoins vous trouverez sans doute des documents plus adapt´es
que cette introduction.
1.5 Quel est le statut du logiciel Scilab?
Ceux qui connaissent bien les logiciels libres (g´en´eralement sous licence GPL) peuvent s’interroger
sur le statut
4
de Scilab en tant que logiciel « libre et gratuit ». Voici ce qu’en dit le Doc dans un message
post´e sur le forum :
3
il s’agit en fait, d’un lien sur l’archivage op´er´e par Google.
4
on peut trouver le texte de la licence ` a l’url http ://scilabsoft.inria.fr/legal/licence.html
5
Scilab : is it really free ?
Yes it is. Scilab is not distributed under GPL or other standard free software copyrights
(because of historical reasons), but Scilab is an Open Source Software and is free for academic
and industrial use, without any restrictions. There are of course the usual restrictions concer-
ning its redistribution ; the only specific requirement is that we ask Scilab users to send us a
notice (email is enough). For more details see Notice.ps or Notice.tex in the Scilab package.
Answers to two frequently asked questions : Yes, Scilab can be included a commercial pa-
ckage (provided proper copyright notice is included). Yes, Scilab can be placed on commercial
CD’s (such as various Linux distributions).
N´eanmoins Scilab ne r´epond pas actuellement aux crit`eres de la FSF ou l’OSI pour ˆetre consid´er´e
comme un logiciel libre (en particulier parce que vous ne pouvez pas redistribuer une version modifi´ee
de scilab sans l’autorisation de l’INRIA). Malgr´e tout, d’apr`es ses statuts, Scilab se doit de rester pour
l’avenir un logiciel gratuit avec tous ses fichiers sources fournis. D’autre part, il semble qu’il y ait une
volont´e du consortium scilab
5
de passer `a une licence de type GPL ou LGPL voire CECILL et qu’un
examen des diff´erents copyrights contenus dans le code scilab soit en cours dans ce but. Affaire `a suivre
donc.
5
organisation qui a la charge de d´evelopper et promouvoir Scilab, cf http ://www.scilabsoft.org
6
Chapitre 2
La manipulation des matrices et
vecteurs
Cette premi`ere partie donne des ´el´ements pour commencer `a utiliser Scilab comme une calculette
matricielle
Pour lancer Scilab, il suffit de rentrer la commande :
scilab
dans un terminal
1
. Si tout se passe bien, la fenˆetre Scilab apparaˆıt `a l’´ecran avec en haut un menu
(donnant en particulier acc`es au Help, aux Demos) suivi de la banni`ere scilab et de l’invite (-->) qui
attend vos commandes :
-------------------------------------------
scilab-4.0
Copyright (c) 1989-2006
Consortium Scilab (INRIA, ENPC)
-------------------------------------------
Startup execution:
loading initial environment
-->
2.1 Entrer une matrice
Un des types de base de Scilab est constitu´e par les matrices de nombres r´eels ou complexes (en fait
des nombres « flottants »). La fa¸ con la plus simple de d´efinir une matrice (ou un vecteur, ou un scalaire
qui ne sont que des matrices particuli`eres) dans l’environnement Scilab est d’entrer au clavier la liste de
ses ´el´ements, en adoptant les conventions suivantes :
– les ´el´ements d’une mˆeme ligne sont s´epar´es par des espaces ou des virgules ;
– la liste des ´el´ements doit ˆetre entour´ee de crochets [ ] ;
– chaque ligne, sauf la derni`ere, doit se terminer par un point-virgule.
Par exemple, la commande :
-->A=[1 1 1;2 4 8;3 9 27]
produit la sortie :
1
Ou de cliquer sur un item de menu ou une icˆ one pr´evus pour cet effet !
7
A =
! 1. 1. 1. !
! 2. 4. 8. !
! 3. 9. 27. !
mais la matrice est bien sˆ ur gard´ee en m´emoire pour un usage ult´erieur. En fait si vous terminez l’ins-
truction par un point virgule, le r´esultat n’apparaˆıt pas `a l’´ecran. Essayer par exemple :
-->b=[2 10 44 190];
pour voir le contenu du vecteur ligne b, on tape simplement :
-->b
et la r´eponse de Scilab est la suivante :
b =
! 2. 10. 44. 190. !
Une instruction tr`es longue peut ˆetre ´ecrite sur plusieurs lignes en ´ecrivant trois points `a la fin de chaque
ligne `a poursuivre :
-->T = [ 1 0 0 0 0 0 ;...
--> 1 2 0 0 0 0 ;...
--> 1 2 3 0 0 0 ;...
--> 1 2 3 0 0 0 ;...
--> 1 2 3 4 0 0 ;...
--> 1 2 3 4 5 0 ;...
--> 1 2 3 4 5 6 ]
ce qui donne :
T =
! 1. 0. 0. 0. 0. 0. !
! 1. 2. 0. 0. 0. 0. !
! 1. 2. 3. 0. 0. 0. !
! 1. 2. 3. 4. 0. 0. !
! 1. 2. 3. 4. 5. 0. !
! 1. 2. 3. 4. 5. 6. !
Pour rentrer un nombre complexe, on utilise la syntaxe suivante (on peut se passer des crochets []
pour rentrer un scalaire) :
-->c=1 + 2*%i
c =
1. + 2.i
-->Y = [ 1 + %i , -2 + 3*%i ; -1 , %i]
Y =
! 1. + i - 2. + 3.i !
! - 1. i !
2.2 Quelques matrices et vecteurs types
Il existe des fonctions pour construire des matrices et vecteurs types, dont voici une premi`ere liste (il
y en a bien d’autres dont nous parlerons ult´erieurement ou que vous d´ecouvrirez avec le Help) :
8
matrices identit´es
Pour obtenir une matrice identit´e de dimension (4,4) :
-->I=eye(4,4)
I =
! 1. 0. 0. 0. !
! 0. 1. 0. 0. !
! 0. 0. 1. 0. !
! 0. 0. 0. 1. !
Les arguments de la fonction eye(n,m) sont le nombre de lignes n et le nombre de colonnes m de la
matrice (Rmq : si n < m (resp. n > m) on obtient la matrice de la surjection (resp. injection) canonique
de K
m
vers K
n
.)
matrices diagonales, extraction de la diagonale
Pour obtenir une matrice diagonale, dont les ´el´ements diagonaux sont form´es `a partir d’un vecteur :
-->B=diag(b)
B =
! 2. 0. 0. 0. !
! 0. 10. 0. 0. !
! 0. 0. 44. 0. !
! 0. 0. 0. 190. !
Rmq : cet exemple illustre le fait que Scilab distingue minuscule et majuscule, taper b pour vous
rendre compte que ce vecteur existe toujours dans l’environnement.
Appliqu´ee sur une matrice la fonction diag permet d’en extraire sa diagonale principale sous la forme
d’un vecteur colonne :
-->b=diag(B)
b =
! 2. !
! 10. !
! 44. !
! 190. !
Cette fonction admet aussi un deuxi`eme argument optionnel (cf exercices).
matrices de z´eros et de uns
Les fonctions zeros et ones permettent respectivement de cr´eer des matrices nulles et des matrices
« de 1 ». Comme pour la fonction eye leurs arguments sont le nombre de lignes puis de colonnes d´esir´ees.
Exemple :
-->C = ones(3,4)
C =
! 1. 1. 1. 1. !
! 1. 1. 1. 1. !
! 1. 1. 1. 1. !
Mais on peut aussi utiliser comme argument le nom d’une matrice d´ej`a d´efinie dans l’environnement et
tout se passe comme si l’on avait donn´e les deux dimensions de cette matrice :
-->O = zeros(C)
O =
! 0. 0. 0. 0. !
! 0. 0. 0. 0. !
! 0. 0. 0. 0. !
9
extractions des parties triangulaires sup´erieure et inf´erieure
Les fonctions triu et tril permettent elles d’extraire respectivement la partie triangulaire sup´erieure
(u comme upper) et inf´erieure (l comme lower) d’une matrice, exemple :
-->U = triu(C)
U =
! 1. 1. 1. 1. !
! 0. 1. 1. 1. !
! 0. 0. 1. 1. !
matrices de nombres al´eatoires
La fonction rand (dont nous reparlerons) permet de cr´eer des matrices remplies de nombres pseudo-
al´eatoires (suivants une loi uniforme sur [0, 1[ mais il est possible d’obtenir une loi normale et aussi de
choisir le germe de la suite) :
-->M = rand(2, 6)
M =
! 0.2113249 0.0002211 0.6653811 0.8497452 0.8782165 0.5608486 !
! 0.7560439 0.3303271 0.6283918 0.6857310 0.0683740 0.6623569 !
vecteurs `a incr´ement constant entre 2 composantes
Pour rentrer un vecteur (ligne) x `a n composantes r´eguli`erement r´eparties entre x
1
et x
n
(c-`a-d telles
x
i+1
−x
i
=
x
n
−x
1
n−1
, n « piquets » donc n −1 intervalles. . .), on utilise la fonction linspace :
-->x = linspace(0,1,11)
x =
! 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. !
Une instruction analogue permet, partant d’une valeur initiale pour la premi`ere composante, d’impo-
ser « l’incr´ement » entre deux composantes, et de former ainsi les autres composantes du vecteur jusqu’`a
ne pas d´epasser une certaine limite :
-->y = 0:0.3:1
y =
! 0. 0.3 0.6 0.9 !
La syntaxe est donc : y = valeur_initiale:incr´ement:limite_a_ne_pas_d´epasser. Lorsque l’on
travaille avec des entiers, il n’y pas de probl`eme (sauf entiers tr`es grands...) `a fixer la limite de sorte
qu’elle corresponde `a la derni`ere composante :
-->i = 0:2:12
i =
! 0. 2. 4. 6. 8. 10. 12. !
Pour les r´eels (approch´e par des nombres flottants) c’est beaucoup moins ´evident du fait :
(i) que l’incr´ement peut ne pas « tomber juste » en binaire (par exemple (0.2)
10
= (0.00110011 . . .)
2
) et
il y a donc un arrondi dans la repr´esentation machine,
(ii) et des erreurs d’arrondi num´erique qui s’accumulent au fur et `a mesure du calcul des composantes.
Souvent l’incr´ement est ´egal `a 1 et on peut alors l’omettre :
-->ind = 1:5
ind =
! 1. 2. 3. 4. 5. !
Finalement, si l’incr´ement est positif (resp. n´egatif) et que limite < valeur_initiale (resp. limite
> valeur_initiale) alors on obtient un vecteur sans composantes ( !) qui est un objet Scilab appel´ee
matrice vide (cf section quelques primitives matricielles suppl´ementaires) :
10
-->i=3:-1:4
i =
[]
-->i=1:0
i =
[]
2.3 L’instruction d’affectation de Scilab et les expressions scalaires et
matricielles
Scilab est un langage qui poss`ede une syntaxe simple (cf chapitre suivant) dont l’instruction d’affec-
tation prend la forme :
variable = expression
ou plus simplement
expression
o` u dans ce dernier cas la valeur de expression est affect´ee `a une variable par d´efaut ans. Une expression
Scilab peut ˆetre toute simple en ne mettant en jeu que des quantit´es scalaires comme celles que l’on trouve
dans les langages de programmation courants, mais elle peut aussi ˆetre compos´ee avec des matrices et des
vecteurs ce qui d´eroute souvent le d´ebutant dans l’apprentissage de ce type de langage. Les expressions
« scalaires » suivent les r`egles habituelles : pour des op´erandes num´eriques (r´eels, complexes) on dispose
des 5 op´erateurs +, -, * , / et ^ (´el´evation `a la puissance) et d’un jeu de fonctions classiques (cf table
(2.1) pour une liste non exaustive
2
.
Ainsi pour rentrer une matrice « coefficients par coefficients » on peut utiliser en plus des constantes
(qui sont en fait des expressions basiques) n’importe quelle expression d´elivrant un scalaire (r´eel ou
complexe), par exemple :
-->M = [sin(%pi/3) sqrt(2) 5^(3/2) ; exp(-1) cosh(3.7) (1-sqrt(-3))/2]
M =
! 0.8660254 1.4142136 11.18034 !
! 0.3678794 20.236014 0.5 - 0.8660254i !
(Rmq : cet exemple montre un danger potentiel : on a calcul´e la racine carr´ee d’un nombre n´egatif
mais Scilab consid`ere alors que l’on a affaire `a un nombre complexe et renvoie l’une des deux racines
comme r´esultat).
2.3.1 Quelques exemples basiques d’expressions matricielles
Toutes les op´erations usuelles sur les matrices sont disponibles : somme de deux matrices de mˆemes
dimensions, produit de deux matrices (si leurs dimensions sont compatibles (n, m) (m, p) . . .), produit
d’un scalaire et d’une matrice, etc. . .Voici quelques exemples (pour lesquels on utilise une partie des
matrices pr´ec´edemment rentr´ees). Rmq : tout texte rentr´e sur une ligne apr`es // est un commentaire
pour Scilab : ne les tapez pas, ils sont l`a pour fournir quelques remarques et explications !
-->D = A + ones(A) // taper A au pr´ealable pour revoir le contenu de cette matrice
D =
! 2. 2. 2. !
! 3. 5. 9. !
! 4. 10. 28. !
2
Scilab propose d’autres fonctions math´ematiques comme les fonctions de Legendre, des fonctions de Bessel, des fonctions
elliptiques, etc. . .ainsi que des fonctions li´ees aux lois de probabilit´e usuelles (fonctions de r´epartition et leurs inverses).
11
abs valeur absolue ou module
exp exponentielle
log logarithme n´ep´erien
log10 logarithme base 10
cos cosinus (argument en radian)
sin sinus (argument en radian)
sinc
sin(x)
x
tan tangente (argument en radian)
cotg cotangente (argument en radian)
acos arccos
asin arcsin
atan arctg
cosh ch
sinh sh
tanh th
acosh argch
asinh argsh
atanh argth
sqrt racine carr´ee
floor partie enti`ere E(x) = (¸x|) = n ⇔n ≤ x < n + 1
ceil partie enti`ere sup´erieure ¸x| = n ⇔n −1 < x ≤ n
int partie enti`ere anglaise : int(x) = ¸x| si x > 0 et = ¸x| sinon
erf fonction erreur erf(x) =
2

π
_
x
0
e
−t
2
dt
erfc fonction erreur compl´ementaire ercf(x) = 1 −erf(x) =
2

π
_
+∞
x
e
−t
2
dt
gamma Γ(x) =
_
+∞
0
t
x−1
e
−t
dt
lngamma ln(Γ(x))
dlgamma
d
dx
ln(Γ(x))
Tab. 2.1 – quelques fonctions usuelles de Scilab
-->A + M // somme de matrice impossible (3,3) + (2,6) : que dit Scilab ?
!--error 8
inconsistent addition
-->E = A*C // C est une matrice (3,4) dont les elements sont des 1
E =
! 3. 3. 3. 3. !
! 14. 14. 14. 14. !
! 39. 39. 39. 39. !
--> C*A // produit de matrice impossible (3,4)x(3,3) : que dit Scilab ?
!--error 10
inconsistent multiplication
--> At = A’ // la transposee s’obtient en postfixant la matrice par une apostrophe
At =
! 1. 2. 3. !
! 1. 4. 9. !
! 1. 8. 27. !
--> Ac = A + %i*eye(3,3) // je forme ici une matrice a coef. complexes
Ac =
12
! 1. + i 1. 1. !
! 2. 4. + i 8. !
! 3. 9. 27. + i !
--> Ac_adj = Ac’ // dans le cas complexe ’ donne l’adjointe (transposee conjuguee)
Ac_adj =
! 1. - i 2. 3. !
! 1. 4. - i 9. !
! 1. 8. 27. - i !
-->x = linspace(0,1,5)’ // je forme un vecteur colonne
x =
! 0. !
! 0.25 !
! 0.5 !
! 0.75 !
! 1. !
-->y = (1:5)’ // un autre vecteur colonne
y =
! 1. !
! 2. !
! 3. !
! 4. !
! 5. !
-->p = y’*x // produit scalaire (x | y)
p =
10.
-->Pext = y*x’ // on obtient une matrice (5,5) ((5,1)x(1,5)) de rang 1 : pourquoi ?
Pext =
! 0. 0.25 0.5 0.75 1. !
! 0. 0.5 1. 1.5 2. !
! 0. 0.75 1.5 2.25 3. !
! 0. 1. 2. 3. 4. !
! 0. 1.25 2.5 3.75 5. !
--> Pext / 0.25 // on peut diviser une matrice par un scalaire
ans =
! 0. 1. 2. 3. 4. !
! 0. 2. 4. 6. 8. !
! 0. 3. 6. 9. 12. !
! 0. 4. 8. 12. 16. !
! 0. 5. 10. 15. 20. !
--> A^2 // elevation a la puissance d’une matrice
ans =
! 6. 14. 36. !
! 34. 90. 250. !
! 102. 282. 804. !
--> [0 1 0] * ans // on peut reutiliser la variable ans (qui contient
--> // le dernier resultat non affecte a une variable)
13
ans =
! 34. 90. 250. !
--> Pext*x - y + rand(5,2)*rand(2,5)*ones(x) + triu(Pext)*tril(Pext)*y;
--> // taper ans pour voir le resultat
Une autre caract´eristique tr`es interessante est que les fonctions usuelles (voir table 2.1) s’appliquent
aussi aux matrices « ´el´ement par ´el´ement » : si f d´esigne une telle fonction f(A) est la matrice [f(a
ij
)].
Quelques exemples :
-->sqrt(A)
ans =
! 1. 1. 1. !
! 1.4142136 2. 2.8284271 !
! 1.7320508 3. 5.1961524 !
-->exp(A)
ans =
! 2.7182818 2.7182818 2.7182818 !
! 7.3890561 54.59815 2980.958 !
! 20.085537 8103.0839 5.320D+11 !
Rmq : pour les fonctions qui ont un sens pour les matrices (diff´erent de celui qui consiste `a l’appliquer
sur chaque ´el´ement. . .), par exemple l’exponentielle, le nom de la fonction est suivi par m. Ainsi pour
obtenir l’exponentielle de A, on rentre la commande :
-->expm(A)
ans =
1.0D+11 *
! 0.5247379 1.442794 4.1005925 !
! 3.6104422 9.9270989 28.213997 !
! 11.576923 31.831354 90.468498 !
2.3.2 Op´erations « ´el´ement par ´el´ement »
Pour multiplier et diviser deux matrices A et B de mˆeme dimensions en appliquant ces op´erations
« ´el´ement par ´el´ement » on utilise les op´erateurs .* et ./ : A.*B est la matrice [a
ij
b
ij
] et A./B [a
ij
/b
ij
].
De mˆeme, on peut ´elever `a la puissance chaque coefficient en utilisant l’op´erateur postfix´e .^ : A.^p
permet d’obtenir la matrice [a
p
ij
]. Essayer par exemple :
-->A./A
ans =
! 1. 1. 1. !
! 1. 1. 1. !
! 1. 1. 1. !
Remarques :
– tant que A n’est pas une matrice carr´ee, A^n va fonctionner au sens « ´el´ement par ´el´ement », je
conseille n´eanmoins d’utiliser A.^n car cette ´ecriture est plus claire pour exprimer cette intention ;
– si s est un scalaire et A une matrice, s.^A donnera la matrice [s
a
ij
].
2.3.3 R´esoudre un syst`eme lin´eaire
Pour r´esoudre un syst`eme lin´eaire dont la matrice est carr´ee, Scilab utilise une factorisation LU avec
pivot partiel suivie de la r´esolution des deux syst`emes triangulaires. Cependant ceci est rendu transparent
pour l’utilisateur par l’interm´ediaire de l’op´erateur \, essayer :
14
-->b=(1:3)’ //je cree un second membre b
b =
! 1. !
! 2. !
! 3. !
-->x=A\b // on resout Ax=b
x =
! 1. !
! 0. !
! 0. !
-->A*x - b // je verifie le resultat en calculant le vecteur residu
ans =
! 0. !
! 0. !
! 0. !
Pour se souvenir de cette instruction, il faut avoir en tˆete le syst`eme initial Ax = y puis faire comme
si on multipliait `a gauche par A
−1
, (ce que l’on symbolise par une division `a gauche par A) d’o` u la
syntaxe utilis´ee par Scilab. Ici on a obtenu un r´esultat exact mais en g´en´eral, il y a des erreurs d’arrondi
dues `a l’arithm´etique flottante :
-->R = rand(100,100); // mettre le ; pour ne pas submerger l’ecran de chiffres
-->y = rand(100,1); // meme remarque
-->x=R\y; // resolution de Rx=y
-->norm(R*x-y) // norm permet de calculer la norme de vecteurs (et aussi de matrices)
// (par defaut la norme 2 (euclidienne ou hermitienne))
ans =
1.134D-13
Rmq : vous n’obtiendrez pas forc´ement ce r´esultat si vous n’avez pas jou´e avec la fonction rand
exactement comme moi... Lorsque la r´esolution d’un syst`eme lin´eaire semble douteuse Scilab renvoie
quelques informations permettant de pr´evenir l’utilisateur (cf compl´ements sur la r´esolution des syst`emes
lin´eaires).
2.3.4 R´ef´erencer, extraire, concat´ener matrices et vecteurs
Les coefficients d’une matrice peuvent ˆetre r´ef´erenc´es avec leur(s) indice(s) pr´ecis´es entre parenth`eses,
(). Par exemple :
-->A33=A(3,3)
A33 =
27.
-->x_30 = x(30,1)
x_30 =
- 1.2935412
-->x(1,30)
!--error 21
invalid index
15
-->x(30)
ans =
- 1.2935412
Rmq : si la matrice est un vecteur colonne, on peut se contenter de r´ef´erencer un ´el´ement en pr´ecisant
uniquement son indice de ligne, et inversement pour un vecteur ligne.
Un des avantages d’un langage comme Scilab est que l’on peut extraire des sous-matrices tout aussi
ais´ement. Quelques exemples simples pour commencer :
-->A(:,2) // pour extraire la 2 eme colonne
ans =
! 1. !
! 4. !
! 9. !
-->A(3,:) // la 3 eme ligne
ans =
! 3. 9. 27. !
-->A(1:2,1:2) // la sous matrice principale d’ordre 2
ans =
! 1. 1. !
! 2. 4. !
Passons maintenant `a la syntaxe g´en´erale : si Aest une matrice de taille (n, m), et si v1 = (i
1
, i
2
, . . . , i
p
)
et v2 = (j
1
, j
2
, . . . , j
q
) sont deux vecteurs (ligne ou colonne peut importe) d’indices dont les valeurs sont
telles que 1 ≤ i
k
≤ n et 1 ≤ j
k
≤ m alors A(v1,v2) est la matrice (de dimension (p, q)) form´ee par
l’intersection des lignes i
1
, i
2
, . . . , i
p
et des colonnes j
1
, j
2
, . . . , j
q
. Exemples :
-->A([1 3],[2 3])
ans =
! 1. 1. !
! 9. 27. !
-->A([3 1],[2 1])
ans =
! 9. 3. !
! 1. 1. !
Dans la pratique on utilise g´en´eralement des extractions plus simples, comme celle d’un bloc contigu
ou bien d’une (ou plusieurs) colonne(s) ou ligne(s). Dans ce cas, on utilise l’expression i_debut:incr:i_fin
pour g´en´erer les vecteurs d’indices, ainsi que le caract`ere : pour d´esigner toute l’´etendue dans la dimension
ad´equate (cf premiers exemples). Ainsi pour obtenir la sous-matrice form´ee de la premi`ere et troisi`eme
ligne :
-->A(1:2:3,:) // ou encore A([1 3],:)
ans =
! 1. 1. 1. !
! 3. 9. 27. !
Passons maintenant `a la concat´enation de matrices qui est l’op´eration permettant d’assembler (en les
juxtaposant) plusieurs matrices, pour en obtenir une autre. Voici un exemple : on consid`ere la matrice
16
suivante, avec un d´ecoupage par blocs :
A =
_
_
_
_
1 2 3 4
1 4 9 16
1 8 27 64
1 16 81 256
_
_
_
_
=
_
A
11
A
12
A
21
A
22
_
.
On va d’abord d´efinir les sous-matrices A
11
, A
12
, A
21
, A
22
:
-->A11=1;
-->A12=[2 3 4];
-->A21=[1;1;1];
-->A22=[4 9 16;8 27 64;16 81 256];
enfin on obtient A par concat´enation de ces 4 blocs :
-->A=[A11 A12; A21 A22]
A =
! 1. 2. 3. 4. !
! 1. 4. 9. 16. !
! 1. 8. 27. 64. !
! 1. 16. 81. 256. !
pour la syntaxe tout se passe comme si nos sous-matrices ´etaient de simples scalaires (il faut bien sˆ ur
une certaine compatibilit´e entre le nombre de lignes et de colonnes des diff´erents blocs. . .).
Il existe une syntaxe particuli`ere pour d´etruire un ensemble de lignes ou de colonnes d’une matrice :
si v = (k
1
, k
2
, . . . , k
p
) est un vecteur d’indices rep´erant des num´eros de lignes ou de colonnes d’une
matrice M alors M(v,:) = [] d´etruit les lignes k
1
, k
2
, . . . , k
p
de M et M(:,v) = [] d´etruit les
colonnes k
1
, k
2
, . . . , k
p
. Enfin, pour un vecteur (ligne ou colonne) u, u(v) = [] d´etruit les entr´ees
correspondantes.
A propos de l’ordre des ´el´ements d’une matrice
Les matrices de Scilab sont stock´ees colonne par colonne et cet ordre des ´el´ements intervient dans
plusieurs fonctions (voir par exemple matrix qui permet de reformatter une matrice). En particulier,
pour les op´erations d’extraction et d’insertion, il est possible d’utiliser cet ordre implicite en utilisant
seulement un seul vecteur d’indice (au lieu de deux, l’un d´esignant les colonnes et l’autre les lignes). Voici
quelques exemples `a partir de la matrice A pr´ec´edente :
-->A(5)
ans =
2.
-->A(5:9)
ans =
! 2. !
! 4. !
! 8. !
! 16. !
! 3. !
-->A(5:9) = -1 // il s’agit d’une insertion
A =
17
! 1. - 1. - 1. 4. !
! 1. - 1. 9. 16. !
! 1. - 1. 27. 64. !
! 1. - 1. 81. 256. !
2.4 Information sur l’espace de travail (*)
Il suffit de rentrer la commande :
-->who
your variables are...
Anew A A22 A21 A12 A11 x_30 A33 x
y R b Pext p Ac_adj Ac At E
D cosh ind xx i linspace M U O
zeros C B I Y c T startup ierr
scicos_pal home PWD TMPDIR percentlib fraclablib
soundlib xdesslib utillib tdcslib siglib s2flib roblib optlib metalib
elemlib commlib polylib autolib armalib alglib mtlblib SCI %F
%T %z %s %nan %inf old newstacksize $
%t %f %eps %io %i %e %pi
using 14875 elements out of 1000000.
and 75 variables out of 1023
et l’on voit apparaˆıtre :
– les variables que l’on a rentr´ees sous l’environnement : Anew, A, A22, A21, . . ., b dans l’ordre
inverse de leur cr´eation. En fait la premi`ere variable cr´e´ee ´etait la matrice A mais nous avons « aug-
ment´e »ses dimensions (de (3,3) `a (4,4)) lors de l’exemple concernant la concat´enation de matrice.
Dans un tel cas, la variable initiale est d´etruite pour ˆetre recr´e´ee avec ses nouvelles dimensions.
Ceci est un point important dont nous reparlerons lors de la programmation en Scilab ;
– les noms des biblioth`eques de Scilab (qui se terminent par lib) et un nom de fonction : cosh. En
fait, les fonctions (celles ´ecrites en langage Scilab) et les biblioth`eques sont consid´er´ees comme des
variables par Scilab ; Rmq : les « proc´edures » Scilab programm´ees en Fortran 77 et en C sont
appel´ees « primitives Scilab » et ne sont pas consid´er´ees comme des variables Scilab ; dans la suite
du document j’utilise parfois abusivement le terme « primitives » pour d´esigner des fonctions Scilab
(programm´ees en langage Scilab) qui sont propos´ees par l’environnement standard ;
– des constantes pr´ed´efinies comme π,e, l’unit´e imaginaire i, la pr´ecision machine eps et les deux
autres constantes classiques de l’arithm´etique flottante (nan not a number) et inf (pour ∞) ; ces
variables dont le nom d´ebute n´ecessairement par % ne peuvent pas ˆetre d´etruites ;
– une variable importante newstacksize qui correspond `a la taille (par d´efaut) de la pile (c-`a-d de
la m´emoire disponible).
– ensuite Scilab indique le nombre de mots de 8 octets utilis´es ainsi que la m´emoire totale disponible
(taille de la pile) puis le nombre de variables utilis´ees ainsi que le nombre maximum autoris´e.
On peut changer la taille de la pile `a l’aide de la commande stacksize(nbmots) o` u nbmots d´esigne
la nouvelle taille d´esir´ee, et la mˆeme commande sans argument stacksize() permet d’obtenir la taille
de la pile ainsi que le nombre maximum autoris´e de variables.
Enfin si l’on veut supprimer une variable v1 de l’environnement, (et donc regagner de la place
m´emoire) on utilise la commande : clear v1. La commande clear utilis´ee seule d´etruit toutes vos
variables et si vous voulez simplement d´etruire les variables v1, v2, v3, il faut utiliser clear v1 v2
v3.
18
2.5 Utilisation de l’aide en ligne
Elle s’obtient en cliquant sur le bouton Help de la fenˆetre Scilab... Depuis la version 2.7 les pages
d’aides sont au format html
3
. Si vous rentrez simplement la commande help (ou si vous cliquez sur le
bouton Help) alors la page html affich´ee correspond `a un classement de toutes les pages d’aide en un
certain nombre de rubriques (Scilab Programming, Graphic Library, Utilities and Elementary
functions,...). En cliquant sur une rubrique particuli`ere vous obtenez la liste de toutes les fonctions
class´ees dans cette rubrique, chacune ´etant accompagn´ee d’une br`eve description. En cliquant alors sur
l’une de ces fonctions vous obtenez la page de la fonction en question.
Si vous connaissez le nom de la fonction qui vous int´eresse, vous pouvez rentrer la commande help
nom de la fonction dans la fenˆetre de commande Scilab pour obtenir la page directement.
Enfin la commande apropos mot cl´e vous permet d’obtenir toutes les pages dans lesquelles la chaˆıne
de caract`eres mot cl´e apparaˆıt dans le nom de la fonction ou dans sa br`eve description.
Actuellement il peut ˆetre difficile de se diriger en utilisant les intitul´es des rubriques (par exemple
Elementary functions est un ensemble « fourre-tout » qui m´eriterait d’ˆetre red´ecoup´e), n’h´esitez donc pas
`a utiliser apropos.
2.6 Visualiser un graphe simple
Supposons que l’on veuille visualiser la fonction y = e
−x
sin(4x) pour x ∈ [0, 2π]. On peut tout
d’abord cr´eer un maillage de l’intervalle par la fonction linspace :
-->x=linspace(0,2*%pi,101);
puis, calculer les valeurs de la fonction pour chaque composante du maillage, ce qui, grˆace aux
instructions « vectorielles » ne n´ecessite aucune boucle :
-->y=exp(-x).*sin(4*x);
et enfin :
-->plot(x,y,"b")
-->xtitle("x","y","y=exp(-x)*sin(4x)")
o` u l’instruction plot permet de tracer une courbe passant par les points dont les coordonn´ees sont
donn´ees dans les vecteurs x pour les abscisses et y pour les ordonn´ees. Le troisi`eme argument est une
chaˆıne de caract`eres (contenant ici que le seul caract`ere b) pr´ecisant que l’on veut une courbe bleue (sans
plus de pr´ecision sur le style, les points sont reli´es par des segments de droites, le trac´e sera d’autant
plus fid`ele que les points seront nombreux).
2.7
´
Ecrire et ex´ecuter un script
On peut ´ecrire dans un fichier nomfich une suite de commandes et les faire ex´ecuter par l’instruction :
-->exec(’nomfich’) // ou encore exec nomfich
Une m´ethode plus conviviale est de s´electionner l’item File Operations propos´e par le menu obtenu
en appuyant sur le bouton File de la fenˆetre Scilab. On obtient alors un menu qui permet de s´electionner
son fichier (´eventuellement en changeant le r´epertoire courant) et il ne reste plus qu’`a cliquer sur le bouton
Exec.
Si vous utilisez l’´editeur int´egr´e scipad
4
vous pouvez faire ex´ecuter votre script en utilisant le menu
Execute ou plus directement avec le raccourci clavier Ctr-l.
Comme exemple de script, reprenons le trac´e de la fonction e
−x
sin(4x) en proposant de plus le choix
de l’intervalle de visualisation [a, b] ainsi que sa discr´etisation. J’´ecris donc dans un fichier intitul´e par
exemple script1.sce les instructions Scilab suivantes :
3
le format de base est en fait du xml ` a partir duquel on obtient le html.
4
Pour lancer scipad il suffit de cliquer sur le bouton Editor, ou encore de rentrer l’ordre -->scipad, voire -->scipad
fichier1 fichier2 ... dans la fenˆetre de commande.
19
0 1 2 3 4 5 6 7
−0.4
−0.2
0.0
0.2
0.4
0.6
0.8
y=exp(−x)*sin(4x)
x
y
Fig. 2.1 – Un graphe simple
// mon premier script Scilab
a = input(" Rentrer la valeur de a : ");
b = input(" Rentrer la valeur de b : ");
n = input(" Nb d’’intervalles n : ");
// calcul des abscisses
x = linspace(a,b,n+1);
// calcul des ordonnees
y = exp(-x).*sin(4*x);
// un petit dessin
clf() // efface le contenu de la fen^etre graphique
plot(x,y,"b")
xtitle("x","y","y=exp(-x)*sin(4x)")
Rmq :
1. pour s’y retrouver dans vos fichiers Scilab, il est recommand´e de suffixer le nom des fichiers scripts
par la terminaison .sce (alors qu’un fichier contenant des fonctions sera suffix´e en .sci) ;
2. certains ´editeurs (autres que scipad) peuvent aussi ˆetre munis d’un mode d’´edition sp´ecifique pour
Scilab (voir la page Scilab). Pour emacs il en existe deux mais le meilleur est de loin celui d’Alexander
Vigodner dont les derni`eres versions sont t´el´echargeables `a partir de l’url :
http://www.geocities.com/avezunchik/scilab.html
2.8 Compl´ements divers
2.8.1 Quelques raccourcis d’´ecriture dans les expressions matricielles
Nous avons vu pr´ec´edemment que la multiplication d’une matrice par un scalaire est reconnue par
Scilab, ce qui est naturel (de mˆeme la division d’une matrice par un scalaire). Par contre Scilab utilise
20
des raccourcis moins ´evidents comme l’addition d’un scalaire et d’une matrice. L’expression M + s o` u M
est une matrice et s un scalaire est un raccourci pour :
M + s*ones(M)
c’est `a dire que le scalaire est ajout´e `a tous les ´el´ements de la matrice.
Autre raccourci : dans une expression du type A./B (qui correspond normalement `a la division
« ´el´ement par ´el´ement » de deux matrices de mˆeme dimension), si A est un scalaire alors l’expression est
un raccourci pour :
A*ones(B)./B
on obtient donc la matrice [a/b
ij
]. Ces raccourcis permettent une ´ecriture plus synth´etique dans de
nombreux cas (cf exercices). Par exemple, si f est une fonction d´efinie dans l’environnement, x un vecteur
et s une variable scalaire alors :
s./f(x)
est un vecteur de mˆeme taille que x dont la i
`eme
composante est ´egale `a s/f(x
i
). Ainsi pour calculer le
vecteur de composante 1/f(x
i
), il semble que l’on puisse utiliser :
1./f(x)
mais comme 1. est syntaxiquement ´egal `a 1, le r´esultat n’est pas celui escompt´e. La bonne mani`ere
d’obtenir ce que l’on cherche est d’entourer le nombre avec des parenth`eses ou de rajouter un blanc entre
le nombre et le point :
(1)./f(x) // ou encore 1 ./f(x) ou 1.0./f(x)
2.8.2 Remarques diverses sur la r´esolution de syst`emes lin´eaires (*)
1. Lorsque l’on a plusieurs seconds membres, on peut proc´eder de la fa¸con suivante :
-->y1 = [1;0;0;0]; y2 = [1;2;3;4]; // voici 2 seconds membres (on peut mettre
--> // plusieurs instructions sur une seule ligne)
-->X=A\[y1,y2] // concat´enation de y1 et y2
X =
! 4. - 0.8333333 !
! - 3. 1.5 !
! 1.3333333 - 0.5 !
! - 0.25 0.0833333 !
la premi`ere colonne de la matrice X est la solution du syst`eme lin´eaire Ax
1
= y
1
, alors que la
deuxi`eme correspond `a la solution de Ax
2
= y
2
.
2. Nous avons vu pr´ec´edemment que si A est une matrice carr´ee (n,n) et b un vecteur colonne `a n
composantes (donc une matrice (n,1)) alors :
x = A\b
nous donne la solution du syst`eme lin´eaire Ax = b. Si la matrice A est d´etect´ee comme ´etant
singuli`ere, Scilab renvoie un message d’erreur. Par exemple :
-->A=[1 2;1 2];
-->b=[1;1];
-->A\b
!--error 19
singular matrix
21
Cependant si la matrice Aest consid´er´ee comme mal conditionn´ee (ou ´eventuellement mal ´equilibr´ee)
une r´eponse est fournie mais elle est accompagn´ee d’un message de mise en garde avec une estima-
tion de l’inverse du conditionnement (cond(A) = [[A[[ [[A
−1
[[) :
-->A=[1 2;1 2+3*%eps];
-->A\b
warning
matrix is close to singular or badly scaled.
results may be inaccurate. rcond = 7.4015D-17
ans =
! 1. !
! 0. !
Par contre si votre matrice n’est pas carr´ee, tout en ayant le mˆeme nombre de lignes que le se-
cond membre, Scilab va vous renvoyer une solution (un vecteur colonne de dimension le nombre
de colonnes de A) sans s’´emouvoir (sans afficher en g´en´eral de message d’erreur). En effet, si
dans ce cas l’´equation Ax = b n’a g´en´eralement pas une solution unique
5
, on peut toujours
s´electionner un vecteur unique x qui v´erifie certaines propri´et´es (x de norme minimale et solution
de min [[Ax −b[[). Dans ce cas, la r´esolution est confi´ee `a d’autres algorithmes qui vont permettre
d’obtenir (´eventuellement) cette pseudo-solution
6
. L’inconv´enient est que si vous avez fait une er-
reur dans la d´efinition de votre matrice (par exemple vous avez d´efini une colonne suppl´ementaire,
et votre matrice est de taille (n,n+1)) vous risquez de ne pas vous en apercevoir imm´ediatement.
En reprenant l’exemple pr´ec´edent :
-->A(2,3)=1 // ´etourderie
A =
! 1. 2. 0. !
! 1. 2. 1. !
-->A\b
ans =
! 0. !
! 0.5 !
! - 3.140D-16 !
-->A*ans - b
ans =
1.0D-15 *
! - 0.1110223 !
! - 0.1110223 !
En dehors de vous mettre en garde sur les cons´equences de ce type d’´etourderie, l’exemple est
instructif sur les points suivants :
– x = A\y permet donc de r´esoudre aussi un probl`eme de moindres carr´es (lorsque la matrice n´est
pas de rang maximum, il vaut mieux utiliser x = pinv(A)*b, la pseudo-inverse ´etant calcul´ee via
la d´ecomposition en valeurs singuli`eres de A (cette d´ecomposition peut s’obtenir avec la fonction
svd) ;
– l’instruction A(2,3)=1 (l’ erreur d’´etourderie. . .) est en fait un raccourci pour :
A = [A,[0;1]]
5
soit (m, n) les dimensions de A (telles que n = m), on a une solution unique si et seulement si m > n, KerA = {0} et
enfin b ∈ ImA cette derni`ere condition ´etant exceptionnelle si b est pris au hasard dans K
m
; dans tous les autres cas, on a
soit aucune solution, soit une infinit´e de solutions
6
dans les cas difficiles, c-` a-d lorsque la matrice n’est pas de rang maximum (rg(A) < min(n, m) o` u n et m sont les 2
dimensions) il vaut mieux calculer cette solution en passant par la pseudo-inverse de A (x = pinv(A)*b).
22
c’est `a dire que Scilab d´etecte que vous voulez compl´eter la matrice A (par une troisi`eme colonne)
mais il lui manque un ´el´ement. Dans ce cas, il compl`ete par des z´eros.
– l’´el´ement en position (2,2) est normalement ´egal `a 2+3
m
aux erreurs d’arrondi num´erique pr`es.
Or le epsilon machine (
m
) peut ˆetre d´efini comme le plus grand nombre pour lequel 1⊕
m
= 1 en
arithm´etique flottante
7
. Par cons´equent on devrait avoir 2 ⊕3
m
> 2 alors que la fenˆetre affiche
2. Ceci vient du format utilis´e par d´efaut mais on peut le modifier par l’instruction format :
-->format(’v’,19)
-->A(2,2)
ans =
2.0000000000000009
alors que l’affichage par d´efaut correspond `a format(’v’,10) (voir le Help pour la signification
des arguments).
– Lorque l’on a calcul´e la « solution » de Ax = b on ne l’a pas affect´e `a une variable particuli`ere et
Scilab s’est donc servi de ans que j’ai ensuite utilis´e pour calculer le r´esidu Ax −b.
3. Avec Scilab on peut aussi directement r´esoudre un syst`eme lin´eaire du type xA = b o` u x et b sont
des vecteurs lignes et A une matrice carr´ee (en transposant on se ram`ene `a un syst`eme lin´eaire
classique A

x

= b

), il suffit de faire comme si l’on multipliait `a droite par A
−1
(en symbolisant
cette op´eration par une division `a droite par A) :
x = b/A
et de mˆeme que pr´ec´edemment, si A est une matrice rectangulaire (dont le nombre de colonnes est
´egal `a celui de b) Scilab renvoie une solution, il faut donc, l`a aussi, faire attention.
2.8.3 Quelques primitives matricielles suppl´ementaires (*)
Somme, produit des coefficients d’ une matrice, matrice vide
Pour faire la somme des coefficients d’une matrice, on utilise sum :
-->sum(1:6) // 1:6 = [1 2 3 4 5 6] : on doit donc obtenir 6*7/2 = 21 !!!!!
ans =
21.
Cette fonction admet un argument suppl´ementaire pour effectuer la somme selon les lignes ou les
colonnes :
-->B = [1 2 3; 4 5 6]
B =
! 1. 2. 3. !
! 4. 5. 6. !
-->sum(B,"r") // effectue la somme de chaque colonne -> on obtient une ligne
ans =
! 5. 7. 9. !
-->sum(B,"c") // effectue la somme de chaque ligne -> on obtient une colonne
ans =
! 6. !
! 15. !
En fait sum(B,"r") d´esigne la somme des vecteurs lignes de la matrice B : sum(B, ”r”) =

i
B(i, :),
sum(B,"c") correspondant `a la somme des vecteurs colonnes : sum(B, ”c”) =

j
B(:, j).
Il existe un objet tr`es pratique « la matrice vide » que l’on d´efinit de la fa¸con suivante :
7
en fait tout nombre r´eel x tel que m ≤ |x| ≤ M peut ˆetre cod´e par un nombre flottant fl(x) avec : |x −fl(x)| ≤
m
|x|
o` u m et M sont respectivement le plus petit et le plus grand nombre positif codable en virgule flottante normalis´ee
23
-->C =[]
C =
[]
La matrice vide int´eragit avec d’autres matrices avec les r`egles suivantes : [] + A = A et []*A = [].
Si on applique maintenant la fonction sum sur cette matrice vide, on obtient le r´esultat naturel :
-->sum([])
ans =
0.
identique `a la convention utilis´ee en math´ematique pour les sommations :
S =

i∈E
u
i
=
n

i=1
u
i
si E = ¦1, 2, . . . , n¦
lorsque l’ensemble E est vide, on impose en effet par convention S = 0.
De mani`ere analogue, pour effectuer le produit des ´el´ements d’une matrice, on dispose de la fonction
prod :
-->prod(1:5) // en doit obtenir 5! = 120
ans =
120.
-->prod(B,"r") // taper B pour revoir cette matrice...
ans =
! 4. 10. 18. !
-->prod(B,"c")
ans =
! 6. !
! 120. !
-->prod(B)
ans =
720.
-->prod([])
ans =
1.
et l’on obtient toujours la convention usuelle rencontr´ee en math´ematique :

i∈E
u
i
= 1, si E = ∅.
somme et produit cumul´es
Les fonctions cumsum et cumprod calculent respectivement les sommes et produits cumul´es d’un
vecteur ou d’une matrice :
-->x = 1:6
x =
! 1. 2. 3. 4. 5. 6. !
-->cumsum(x)
ans =
24
! 1. 3. 6. 10. 15. 21. !
-->cumprod(x)
ans =
! 1. 2. 6. 24. 120. 720. !
Pour une matrice l’accumulation se fait simplement selon l’ordre colonne par colonne :
-->x = [1 2 3;4 5 6]
x =
! 1. 2. 3. !
! 4. 5. 6. !
-->cumsum(x)
ans =
! 1. 7. 15. !
! 5. 12. 21. !
Et comme pour les fonctions sum et prod, on peut aussi faire les sommes et produits cumul´es selon
les lignes et les colonnes :
-->cumsum(x,"r") // somme cumul´ee des vecteurs lignes
ans =
! 1. 2. 3. !
! 5. 7. 9. !
-->cumsum(x,"c") // somme cumul´ee des vecteurs colonnes
ans =
! 1. 3. 6. !
! 4. 9. 15. !
Ici il faut toujours faire attention car on peut avoir tendance `a supposer que l’option "r" fait la somme
cumul´ee de chaque ligne mais il s’agit bien de la somme cumul´ee des vecteurs lignes (ce qui correspond
`a faire la somme cumul´ee sur chaque colonne), si on pose y = cumsum(x,"r") alors y est une matrice
de mˆeme dimension que x et :
y(i, :) =
i

k=1
x(k, :)
De mˆeme si y = cumsum(x,"c") alors :
y(:, j) =
j

k=1
x(:, k)
Les fonctions mean, st deviation, min, max admettent aussi ce mˆeme argument optionnel. Comme pour
sum et prod un autre moyen mn´emotechnique
8
pour se souvenir de l’op´eration effectu´ee est de consid´erer
que cette option ("r" ou "c") d´esigne aussi la forme finale obtenue (et donc min(x,"r") correspond `a
prendre le minimun de chaque colonne
minimum et maximum d’un vecteur ou d’une matrice
Les fonctions min et max se chargent de ces op´erations. Elles fonctionnent exactement comme sum et
prod quant `a l’argument suppl´ementaire pour calculer les minima ou maxima de chaque ligne ou colonne.
Elles admettent aussi un argument de sortie suppl´ementaire donnant le premier indice o` u le minimum
ou maximum est atteint (les premiers indices pour les minima maxima selon les lignes ou les colonnes).
Exemples :
8
mais qui ne fonctionne pas pour FIXME
25
-->x = rand(1,5)
x =
! 0.7738714 0.7888738 0.3247241 0.4342711 0.2505764 !
-->min(x)
ans =
0.2505764
-->[xmin, imin] = min(x)
imin =
5. // le min est obtenu en x(5)
xmin =
0.2505764
-->y = rand(2,3)
y =
! 0.1493971 0.475374 0.8269121 !
! 0.1849924 0.1413027 0.7530783 !
-->[ymin, imin] = min(y)
imin =
! 2. 2. ! // le min est obtenu pour y(2,2)
ymin =
0.1413027
-->[ymin, imin] = min(y,"r") // minimum de chaque colonne
imin =
! 1. 2. 2. ! // => les min sont y(1,1) y(2,2) y(2,3)
ymin =
! 0.1493971 0.1413027 0.7530783 !
-->[ymin, imin] = min(y,"c") // minimum de chaque ligne
imin =
! 1. ! // les min sont y(1,1)
! 2. ! // y(2,2)
ymin =
! 0.1493971 !
! 0.1413027 !
moyenne et ´ecart type
Les fonctions mean et st deviation permettent de calculer la moyenne et l’´ecart type des compo-
santes d’un vecteur ou d’une matrice. La formule utilis´ee pour l’´ecart type ´etant :
σ(x) =
_
1
n −1
n

i=1
(x
i
− ¯ x)
2
_
1/2
, ¯ x =
1
n
n

i=1
x
i
-->x = 1:6
x =
! 1. 2. 3. 4. 5. 6. !
-->mean(x)
ans =
3.5
26
-->st_deviation(x)
ans =
1.8708287
De mˆeme on peut calculer la moyenne (et aussi l’´ecart type) des lignes ou des colonnes d’une matrice :
-->x = [1 2 3;4 5 6]
x =
! 1. 2. 3. !
! 4. 5. 6. !
-->mean(x,"r") // la moyenne des vecteurs lignes (=les moyennes de chaque colonne)
ans =
! 2.5 3.5 4.5 !
-->mean(x,"c") // la moyenne des vecteurs colonnes (=les moyennes de chaque ligne)
ans =
! 2. !
! 5. !
Remodeler une matrice
La fonction matrix permet de remodeler une matrice en donnant de nouvelles dimensions (mais avec
le mˆeme nombre de coefficients en tout) .
-->B = [1 2 3; 4 5 6]
B =
! 1. 2. 3. !
! 4. 5. 6. !
-->B_new = matrix(B,3,2)
B_new =
! 1. 5. !
! 4. 3. !
! 2. 6. !
Elle travaille en ordonnant les coefficients colonne par colonne. Une de ses utilisations est de trans-
former un vecteur ligne en vecteur colonne et inversement. Signalons encore un raccourci qui permet
de transformer une matrice A (vecteurs ligne et colonne compris) en un vecteur colonne v : v = A(:),
exemple :
-->A = rand(2,2)
A =
! 0.8782165 0.5608486 !
! 0.0683740 0.6623569 !
-->v=A(:)
v =
! 0.8782165 !
! 0.0683740 !
! 0.5608486 !
! 0.6623569 !
27
Vecteurs avec espacement logarithmique
Parfois on a besoin d’un vecteur avec une incr´ementation logarithmique pour les composantes (c-
`a-d tel que le rapport entre deux composantes successives soit constant : x
i+1
/x
i
= Cte) : on peut
utiliser dans ce cas la fonction logspace : logspace(a,b,n) : permet d’obtenir un tel vecteur avec n
composantes, dont la premi`ere et la derni`ere sont respectivement 10
a
et 10
b
, exemple :
-->logspace(-2,5,8)
ans =
! 0.01 0.1 1. 10. 100. 1000. 10000. 100000. !
Valeurs et vecteurs propres
La fonction spec permet de calculer les valeurs propres d’une matrice (carr´ee !) :
-->A = rand(5,5)
A =
! 0.2113249 0.6283918 0.5608486 0.2320748 0.3076091 !
! 0.7560439 0.8497452 0.6623569 0.2312237 0.9329616 !
! 0.0002211 0.6857310 0.7263507 0.2164633 0.2146008 !
! 0.3303271 0.8782165 0.1985144 0.8833888 0.312642 !
! 0.6653811 0.0683740 0.5442573 0.6525135 0.3616361 !
-->spec(A)
ans =
! 2.4777836 !
! - 0.0245759 + 0.5208514i !
! - 0.0245759 - 0.5208514i !
! 0.0696540 !
! 0.5341598 !
et renvoie le r´esultat sous forme d’un vecteur colonne (Scilab utilise la m´ethode QR qui consiste `a obtenir
it´erativement une d´ecomposition de Schur de la matrice). Les vecteurs propres peuvent s’obtenir avec
bdiag. Pour un probl`eme de valeurs propres g´en´eralis´e, vous pouvez utiliser la fonction gspec.
2.8.4 Les fonctions size et length
size permet de r´ecup´erer les deux dimensions (nombre de lignes puis de colonnes) d’une matrice :
-->[nl,nc]=size(B) // B est la matrice (2,3) de l’exemple precedent
nc =
3.
nl =
2.
-->x=5:-1:1
x =
! 5. 4. 3. 2. 1. !
-->size(x)
ans =
! 1. 5. !
alors que length fournit le nombre d’´el´ements d’une matrice (r´eelle ou complexe). Ainsi pour un
vecteur ligne ou colonne, on obtient directement son nombre de composantes :
-->length(x)
ans =
28
5.
-->length(B)
ans =
6.
En fait ces deux primitives seront surtout utiles `a l’int´erieur de fonctions pour r´ecup´erer les tailles des
matrices et vecteurs, ce qui ´evitera de les faire passer comme arguments. Noter aussi que size(A,’r’)
(ou size(A,1)) et size(A,’c’) (ou size(A,2)) permettent d’obtenir le nombre de lignes (rows) et de
colonnes (columns) de la matrice A.
2.9 Exercices
1. D´efinir la matrice d’ordre n suivante (voir le d´etail de la fonction diag `a l’aide du Help) :
A =
_
_
_
_
_
_
_
_
_
2 −1 0 0
−1
.
.
.
.
.
.
.
.
.
.
.
.
0
.
.
.
.
.
.
.
.
.
0
.
.
.
.
.
.
.
.
.
.
.
.
−1
0 0 −1 2
_
_
_
_
_
_
_
_
_
2. Soit A une matrice carr´ee ; que vaut diag(diag(A)) ?
3. La fonction tril permet d’extraire la partie triangulaire inf´erieure d’une matrice (triu pour la
partie triangulaire sup´erieure). D´efinir une matrice carr´ee A quelconque (par exemple avec rand)
et construire en une seule instruction, une matrice triangulaire inf´erieure T telle que t
ij
= a
ij
pour
i > j (les parties strictement triangulaires inf´erieures de A et T sont ´egales) et telle que t
ii
= 1 (T
est `a diagonale unit´e).
4. Soit X une matrice (ou un vecteur. . .) que l’on a d´efinie dans l’environnement.
´
Ecrire l’instruction
qui permet de calculer la matrice Y (de mˆeme taille que X) dont l’´el´ement en position (i, j) est ´egal
`a f(X
ij
) dans les cas suivants :
(a) f(x) = 2x
2
−3x + 1
(b) f(x) = [2x
2
−3x + 1[
(c) f(x) = (x −1)(x + 4)
(d) f(x) =
1
1+x
2
5. Tracer le graphe de la fonction f(x) =
sin x
x
pour x ∈ [0, 4π] (´ecrire un script).
6. Une petite illustration de la loi des grands nombres : obtenir avec la fonction rand n r´ealisations
de la loi uniforme sous la forme d’un vecteur x, calculer la moyenne cumul´ee de ce vecteur, c-a-d le
vecteur ¯ x dont les n composantes sont : ¯ x
k
=
1
k

k
i=1
x
i
et tracer la courbe de la suite ainsi obtenue.
Tester avec des valeurs de n de plus en plus grandes.
29
Chapitre 3
La programmation en Scilab
Scilab, en dehors des primitives toutes prˆetes (qui permettent avec les instructions matricielles, une
programmation tr`es synth´etique proche du langage math´ematique, du moins matriciel) dispose d’un
langage de programmation simple mais assez complet. La diff´erence essentielle par rapport aux langages
habituels (C, C++, Pascal, ...) est que les variables ne sont pas d´eclar´ees : lors des manipulations
pr´ec´edentes nous n’avons `a aucun moment pr´ecis´e la taille des matrices, ni mˆeme leurs types (r´eelles,
complexes, ...). C’est l’interpr`eteur de Scilab qui, lorsqu’il rencontre un nouvel objet, se charge de ce
travail. Cette caract´eristique est souvent d´econsid´er´ee (avec raison, cf l’ancien fortran) d’un point de
vue g´enie logiciel car cela peut conduire `a des erreurs difficilement rep´erables. Dans le cas de langage
comme Scilab (ou Matlab) cela ne pose pas trop de probl`emes, car la notation vectorielle/matricielle
et les primitives toutes prˆetes, permettent de restreindre consid´erablement le nombre de variables et de
lignes d’un programme (par exemple, les instructions matricielles permettent d’´eviter un maximum de
boucles). Un autre avantage de ce type de langage, est de disposer d’instructions graphiques (ce qui ´evite
d’avoir `a jongler avec un programme ou une biblioth`eque graphique) et d’ˆetre interprˆet´e (ce qui permet
de chasser les erreurs assez facilement, sans l’aide d’un d´ebogueur). Par contre l’inconv´enient est qu’un
programme ´ecrit en Scilab est plus lent (voire beaucoup plus lent) que si vous l’aviez ´ecrit en C (mais le
programme en C a demand´e 50 fois plus de temps d’´ecriture et de mise au point...). D’autre part, pour
les applications o` u le nombre de donn´ees est vraiment important (par exemple des matrices 10001000)
il vaut mieux revenir `a un langage compil´e. Un point important concernant la rapidit´e d’ex´ecution est
qu’il faut programmer en utilisant au maximum les primitives disponibles et les instructions matricielles
(c’est `a dire : limiter le nombre de boucles au maximum)
1
. En effet, dans ce cas, Scilab appelle alors
une routine (fortran) compil´ee, et donc son interpr`eteur travaille moins. . .Pour b´en´eficier du meilleur des
deux mondes (c’est dire de la rapidit´e d’un langage compil´e et du confort d’un environnement comme
celui de Scilab), vous avez des facilit´es pour lier `a Scilab des sous-programmes fortran (77) ou C.
3.1 Les boucles
Il existe deux types de boucles : la boucle for et la boucle while.
3.1.1 La boucle for
La boucle for it`ere sur les composantes d’un vecteur ligne :
-->v=[1 -1 1 -1]
-->y=0; for k=v, y=y+k, end
Le nombre d’it´erations est donn´e par le nombre de composantes du vecteur ligne
2
, et `a la i
`eme
it´eration,
la valeur de k est ´egale `a v(i). Pour que les boucles de Scilab ressemblent `a des boucles du type :
pour i := i
deb
`a i
fin
par pas de i
step
faire :
suite d’instructions
fin pour
1
voir la section « Quelques remarques sur la rapidit´e »
2
si le vecteur est une matrice vide alors aucune it´eration n’a lieu
30
il suffit d’utiliser comme vecteur i_deb:i_step:i_fin , et lorsque l’incr´ement i_step est ´egal `a 1 nous
avons vu qu’il peut peut ˆetre omis. La boucle pr´ec´edente peut alors ˆetre ´ecrite plus naturellement de la
fa¸con suivante :
-->y=0; for i=1:4, y=y+v(i), end
Quelques remarques :
– une boucle peut aussi it´erer sur une matrice. Le nombre d’it´erations est ´egal au nombre de colonnes
de la matrice et la variable de la boucle `a la i
`eme
it´eration est ´egale `a la i
`eme
colonne de la matrice.
Voici un exemple :
-->A=rand(3,3);y=zeros(3,1); for k=A, y = y + k, end
– la syntaxe pr´ecise est la suivante :
for variable = matrice, suite d’instructions, end
o` u les instructions sont s´epar´ees par des virgules (ou des points virgules si on ne veut pas voir le
r´esultat des instructions d’affectations `a l’´ecran). Cependant dans un script (ou une fonction), le
passage `a la ligne est ´equivalent `a la virgule, ce qui permet une pr´esentation de la forme :
for variable = matrice
instruction1
instruction2
...........
instruction n
end
o` u les instructions peuvent ˆetre suivies d’un point virgule (toujours pour ´eviter les affichages `a
l’´ecran)
3
.
3.1.2 La boucle while
Elle permet de r´ep´eter une suite d’instructions tant qu’une condition est vraie, par exemple :
-->x=1 ; while x<14,x=2*x, end
Signalons que les op´erateurs de comparaisons sont les suivants :
== ´egal `a
< strictement plus petit que
> strictement plus grand que
<= plus petit ou ´egal
>= plus grand ou ´egal
~= ou <> diff´erent de
et que Scilab poss`ede un type logique ou bool´een : %t ou %T pour vrai et %f ou %F pour faux. On peut
d´efinir des matrices et vecteurs de bool´eens. Les op´erateurs logiques sont :
& et
| ou
~ non
La syntaxe du while est la suivante :
while condition, instruction_1, ... ,instruction_N , end
ou encore (dans un script ou une fonction) :
while condition
instruction_1
.............
instruction_N
end
3
ceci est uniquement valable pour un script car dans une fonction, le r´esultat d’une instruction d’affectation n’est pas
affich´e mˆeme si elle n’est pas suivie d’un point virgule ; ce comportement par d´efaut pouvant ˆetre modifi´e avec l’instruction
mode
31
o` u chaque instruction_k peut ˆetre suivie d’un point virgule et ce qui est appel´e condition est en
fait une expression d´elivrant un scalaire bool´een.
3.2 Les instructions conditionnelles
Il y en a aussi deux : un « if then else » et un « select case ».
3.2.1 La construction if then else
Voici un exemple :
-->if x>0 then, y=-x,else,y=x,end // la variable x doit ^etre d´efinie
De mˆeme dans un script ou une fonction, si vous allez `a la ligne, les virgules de s´eparation ne sont pas
obligatoires. Comme pour les langages habituels, si aucune action n’intervient dans le cas o` u la condition
est fausse, la partie else, instructions est omise. Enfin, si la partie else enchaˆıne sur un autre if then
else, on peut lier les mots cl´es else et if ce qui conduit finalement `a une pr´esentation du type :
if condition_1 then
suite d’instructions 1
elseif condition_2 then
suite d’instructions 2
.........................
elseif condition_N then
suite d’instructions N
else
suite d’instructions N+1
end
o` u, de mˆeme que pour le while, chaque condition est une expression d´elivrant un scalaire bool´een.
3.2.2 La construction select case (*)
Voici un exemple (`a tester avec diff´erentes valeurs de la variable num)
4
-->num = 1, select num, case 1, y = ’cas 1’, case 2, y = ’cas 2’,...
-->else, y = ’autre cas’, end
qui dans un script ou une fonction s’´ecrirait plutˆot :
// ici on suppose que la variable num est bien definie
select num
case 1 y = ’cas 1’
case 2 y = ’cas 2’
else y = ’autre cas’
end
Ici, Scilab teste successivement l’´egalit´e de la variable num avec les diff´erents cas possibles (1 puis 2),
et d`es que l’´egalit´e est vraie, les instructions correspondantes (au cas) sont effectu´ees puis on sort de la
construction. Le else, qui est facultatif, permet de r´ealiser une suite d’instructions dans le cas o` u tous
les pr´ec´edents tests ont ´echou´es. La syntaxe de cette construction est la suivante :
select variable_test
case expr_1
suite d’instructions 1
...........................
case expr_N
4
la variable y est du type « chaˆıne de caract`eres », cf prochain paragraphe
32
suite d’instructions N
else
suite d’instructions N+1
end
o` u ce qui est appel´e expr_i est une expression qui d´elivrera une valeur `a comparer avec la valeur de la
variable variable_test (dans la plupart des cas ces expressions seront des constantes ou des variables).
En fait cette construction est ´equivalente `a la construction if suivante :
if variable_test = expr_1 then
suite d’instructions 1
........................
elseif variable_test = expr_N then
suite d’instructions N
else
suite d’instructions N+1
end
3.3 Autres types de donn´ees
Jusqu’`a pr´esent nous avons vu les types de donn´ees suivants :
1. les matrices (et vecteurs et scalaires) de nombres r´eels
5
ou complexes ;
2. les bool´eens (matrices, vecteurs et scalaires) ;
Il en existe d’autres dont les chaˆınes de caract`eres et les listes.
3.3.1 Les chaˆınes de caract`eres
Dans l’exemple sur la construction case, la variable y est du type chaˆıne de caract`eres. Dans le
langage Scilab elles sont d´elimit´ees par des apostrophes ou des guillemets (anglais), et lorsqu’une chaˆıne
contient un tel caract`ere, il faut le doubler. Ainsi pour affecter `a la variable est_ce_si_sur, la chaˆıne :
Scilab c’est "cool" ?
on utilisera :
-->est_ce_si_sur = "Scilab c’’est ""cool"" ?"
ou bien :
-->est_ce_si_sur = ’Scilab c’’est ""cool"" ?’
On peut aussi d´efinir des matrices de chaˆınes de caract`eres :
-->Ms = ["a" "bc" "def"]
Ms =
!a bc def !
-->size(Ms) // pour obtenir les dimensions
ans =
! 1. 3. !
-->length(Ms)
ans =
! 1. 2. 3. !
5
les entiers ´etant vu comme des nombres flottants
33
Noter que length n’a pas le mˆeme comportement que sur une matrice de nombres : pour une matrice
de chaˆınes de caract`eres M, length(M) renvoie une matrice d’entiers de mˆeme format que M o` u le coefficient
en position (i, j) donne le nombre de caract`eres de la chaˆıne en position (i, j).
La concat´enation de chaˆınes de caract`eres utilise simplement l’op´erateur + :
-->s1 = ’abc’; s2 = ’def’; s = s1 + s2
s =
abcdef
et l’extraction se fait via la fonction part :
-->part(s,3)
ans =
c
-->part(s,3:4)
ans =
cd
Le deuxi`eme argument de la fonction part est donc un vecteur d’indices (ou un simple scalaire entier)
d´esignant les num´eros des caract`eres que l’on veut extraire.
3.3.2 Les listes (*)
Une liste est simplement une collection d’objets Scilab (matrices ou scalaires r´eels ou complexes,
matrices ou scalaires « chaˆınes de caract`eres » , bool´eens, listes, fonctions, . . .) num´erot´es. Il y a deux
sortes de listes, les « ordinaires » et les « typ´ees ». Voici un exemple de liste ordinaire :
-->L=list(rand(2,2),["Vivement que je finisse" " cette doc..."],[%t ; %f])
L =
L(1)
! 0.2113249 0.0002211 !
! 0.7560439 0.3303271 !
L(2)
!Vivement que je finisse cette doc... !
L(3)
! T !
! F !
Je viens de d´efinir une liste dont le premier ´el´ement est une matrice (2,2), le 2
`eme
un vecteur de
chaˆınes de caract`eres, et le 3
`eme
un vecteur de bool´eens. Voici quelques op´erations basiques sur les listes :
-->M = L(1) // extraction de la premiere entree
M =
! 0.2113249 0.0002211 !
! 0.7560439 0.3303271 !
-->L(1)(2,2) = 100; // modification dans la premiere entree
34
-->L(1)
ans =
! 0.2113249 0.0002211 !
! 0.7560439 100. !
-->L(2)(4) = " avant les vacances !"; // je modifie la 2 eme entree
-->L(2)
ans =
!Vivement que je finisse cette doc... avant les vacances ! !
-->L(4)=" pour ajouter une 4 eme entree"
L =
L(1)
! 0.2113249 0.0002211 !
! 0.7560439 100. !
L(2)
!Vivement que je finisse cette doc... avant les vacances ! !
L(3)
! T !
! F !
L(4)
pour ajouter une 4 eme entree
-->size(L) // quel est le nombre d’elements de la liste
ans =
4.
-->length(L) // idem
ans =
4.
-->L(2) = null() // destruction de la 2 eme entree
L =
L(1)
! 0.2113249 0.0002211 !
! 0.7560439 100. !
35
L(2)
! T !
! F !
L(3)
pour ajouter une 4 eme entree
-->Lbis=list(1,1:3) // je definis une autre liste
Lbis =
Lbis(1)
1.
Lbis(2)
! 1. 2. 3. !
-->L(3) = Lbis // la 3 eme entree de L est maintenant une liste
L =
L(1)
! 0.2113249 0.0002211 !
! 0.7560439 100. !
L(2)
! T !
! F !
L(3)
L(3)(1)
1.
L(3)(2)
! 1. 2. 3. !
Passons aux listes « typ´ees » . Pour ces listes, le premier ´el´ement est une chaˆıne de caract`eres qui
permet de « typer » la liste (ceci permet de d´efinir un nouveau type de donn´ee puis de d´efinir des
op´erateurs sur ce type), les ´el´ements suivants pouvant ˆetre n’importe quels objets scilab. En fait, ce
premier ´el´ement peut aussi ˆetre un vecteur de chaˆınes de caract`eres, la premi`ere donnant donc le type de
la liste et les autres pouvant servir `a r´ef´erencer les diff´erents ´el´ements de la liste (au lieu de leur num´ero
dans la liste). Voici un exemple : on veut repr´esenter un poly`edre (dont toutes les faces ont le mˆeme
36
nombre d’arˆetes). Pour cela, on stocke les coordonn´ees de tous les sommets dans une matrice (de format
(3,nb sommets)) qui sera r´ef´erenc´ee par la chaˆıne coord. Puis on d´ecrit par une matrice (de format (nb
de sommets par face,nb de faces)) la connectivit´e de chacune des faces : pour chaque face, je donne les
num´eros des sommets qui la constituent de sorte `a orienter la normale vers l’ext´erieur par la r`egle du
tire-bouchon.
z
y
2
7
x
8
4
3
6 5
1
Fig. 3.1 – Num´eros des sommets du cube
Cette entr´ee de la liste sera r´ef´erenc´ee par la chaˆıne face. Pour un cube (cf figure 3.1) cela peut
donner :
P=[ 0 0 1 1 0 0 1 1;... // les coordonnees des sommets
0 1 1 0 0 1 1 0;...
0 0 0 0 1 1 1 1];
connect = [1 5 3 2 1 1;... // la connectivit´e des faces
2 8 7 6 5 4;...
3 7 8 7 6 8;...
4 6 4 3 2 5];
Il me reste `a former ma liste typ´ee qui contiendra donc toute l’information sur mon cube :
-->Cube = tlist(["polyedre","coord","face"],P,connect)
Cube =
Cube(1)
!polyedre coord face !
Cube(2)
! 0. 0. 1. 1. 0. 0. 1. 1. !
! 0. 1. 1. 0. 0. 1. 1. 0. !
! 0. 0. 0. 0. 1. 1. 1. 1. !
Cube(3)
37
! 1. 5. 3. 2. 1. 1. !
! 2. 8. 7. 6. 5. 4. !
! 3. 7. 8. 7. 6. 8. !
! 4. 6. 4. 3. 2. 5. !
Au lieu de d´esigner les ´el´ements constitutifs par leur num´ero, on peut utiliser la chaˆıne de caract`eres
correspondante, exemple :
-->Cube.coord(:,2) // ou encore Cube("coord")(:,2)
ans =
! 0. !
! 1. !
! 0. !
-->Cube.face(:,1)
ans =
! 1. !
! 2. !
! 3. !
! 4. !
En dehors de cette particularit´e, ces listes typ´ees se manipulent exactement comme les autres. Leur
avantage est que l’on peut d´efinir (i.e. surcharger) les op´erateurs +, -, /, *, etc, sur une tlist de type donn´e
(cf une prochaine version de cette doc ou mieux : consulter la doc en ligne sur la home page Scilab).
3.3.3 Quelques expressions avec les vecteurs et matrices de bool´eens (*)
Le type bool´een se prˆete aussi `a des manipulations matricielles dont certaines b´en´eficient de raccourcis
d’´ecriture assez pratiques. Lorsque l’on compare deux matrices r´eelles de mˆeme taille avec l’un des
op´erateurs de comparaison (<, >, <=, >=,==, ~=), on obtient une matrice de bool´eens de mˆeme format, la
comparaison ayant lieu « ´el´ement par ´el´ement », par exemple :
-->A = rand(2,3)
A =
! 0.2113249 0.0002211 0.6653811 !
! 0.7560439 0.3303271 0.6283918 !
-->B = rand(2,3)
B =
! 0.8497452 0.8782165 0.5608486 !
! 0.6857310 0.0683740 0.6623569 !
-->A < B
ans =
! T T F !
! F F T !
mais si l’une des deux matrices est un scalaire, alors A < s est un raccourci pour A < s*one(A) :
-->A < 0.5
ans =
! T T F !
! F T F !
Les op´erateurs bool´eens s’appliquent aussi sur ce type de matrice toujours au sens «´el´ement par ´el´ement » :
38
-->b1 = [%t %f %t]
b1 =
! T F T !
-->b2 = [%f %f %t]
b2 =
! F F T !
-->b1 & b2
ans =
! F F T !
-->b1 | b2
ans =
! T F T !
-->~b1
ans =
! F T F !
D’autre part il y a deux fonctions tr`es pratiques qui permettent de vectoriser des tests :
1. bool2s transforme une matrice de bool´eens en une matrice de mˆeme format o` u la valeur logique
« vraie » est transform´ee en 1, et « faux » en z´ero :
-->bool2s(b1)
ans =
! 1. 0. 1. !
2. La fonction find permet de r´ecup´erer les indices des coefficients « vrais » d’un vecteur ou d’une
matrice de bool´eens :
-->v = rand(1,5)
v =
! 0.5664249 0.4826472 0.3321719 0.5935095 0.5015342 !
-->find(v < 0.5) // v < 0.5 donne un vecteur de booleens
ans =
! 2. 3. !
Une application de ces fonctions est expos´ee plus loin (cf Quelques remarques sur la rapidit´e). Enfin les
fonctions and et or proc`edent respectivement au produit logique (et) et `a l’addition logique (ou) de tous
les ´el´ements d’une matrice bool´eenne. On obtient alors un scalaire bool´een. Ces deux fonctions admettent
un argument optionnel pour effectuer l’op´eration selon les lignes ou les colonnes.
3.3.4 les expressions bool´eennes dans les tests (if et while)
Il est tol´er´e dans un test if ou while d’utiliser une expression qui renvoie un vecteur (ou une matrice)
de bool´eens. Dans ce cas c’est le produit logique des ´el´ements du vecteur qui permet de d´eterminer si
le test est vrai ou non. Ainsi pour effectuer un calcul sous la condition que toutes les composantes d’un
vecteur soient strictement positives, on peut utiliser :
if x > 0 then
......
end
D’autre part scilab utilise aussi les raccourcis de certains langages (comme C) lors de l’´evaluation
d’un ou ou d’un et :
39
1. pour a ou b, si a est vraie
6
alors b n’est pas ´evalu´ee ;
2. pour a et b, si a est fausse
7
b n’est pas ´evalu´ee.
Mais, rappelons le, ceci a lieu uniquement dans un test « if »ou « while »(ce comportement a ´et´e introduit
`a partir de la version 3.1).
Un exemple d’utilisation :
while j > 0 & elem < v(j)
v(j+1) = v(j)
j = j-1
end
Dans cette boucle, aucune erreur n’est g´en´er´ee par l’expression elem < v(j) lorsque j = 0 puisqu’elle
n’est pas ´evalu´ee.
3.4 Les fonctions
Pour d´efinir une fonction en Scilab, la m´ethode la plus courante est de l’´ecrire dans un fichier,
dans lequel on pourra d’ailleurs mettre plusieurs fonctions (en regroupant par exemple les fonctions
qui correspondent `a un mˆeme th`eme ou une mˆeme application). Chaque fonction doit commencer par
l’instruction :
function [y1,y2,y3,...,yn]=nomfonction(x1,....,xm)
o` u les xi sont les arguments d’entr´ee, les yj ´etant les arguments de sortie. Vient ensuite le corps de la
fonction (qui permet de calculer les arguments de sortie `a partir des arguments d’entr´ee). La fonction
doit se terminer par le mot cl´e endfunction. Rmq : la tradition est de suffixer les noms des fichiers
contenant des fonctions en .sci.
3.4.1 un premier exemple de fonction : la factorielle en scilab
function [y] = fact1(n)
// la factorielle : il faut ici que n soit bien un entier naturel
y = prod(1:n)
endfunction
Supposons que l’on ait ´ecrit cette fonction dans le fichier facts.sci
8
. Pour que Scilab puisse la
connaˆıtre, il faut charger le fichier par l’instruction :
exec("facts.sci") // ou encore getf("facts.sci")
ce qui peut aussi se faire via le menu File operations comme pour les scripts. Si vous utilisez l’´editeur
int´egr´e scipad, vous pouvez cliquer sur l’item Load into scilab du menu Execute ou mieux sur le
raccourci clavier Ctrl-l.
On peut alors utiliser cette fonction ` a partir de l’invite (mais aussi dans un script ou bien une autre
fonction) :
-->m = fact1(5)
m =
120.
-->n1=2; n2 =3; fact1(n2)
ans =
6.
6
si a renvoie un vecteur de bool´eens il faut que toutes les composantes soient vraies
7
si a renvoie un vecteur de bool´eens il faut qu’au moins une composante soit fausse
8
La tradition est de suffixer les noms des fichiers contenant des fonctions en .sci (et en.sce pour les scripts)
40
-->fact1(n1*n2)
ans =
720.
Avant de vous montrer d’autres exemples, voici quelques pr´ecisions de vocabulaire. Dans l’´ecriture
de la fonction, l’argument de sortie y et l’argument d’entr´ee n sont appel´es arguments formels . Lorsque
j’utilise cette fonction `a partir de l’invite, d’un script ou d’une autre fonction :
arg_s = fact1(arg_e)
les arguments utilis´es sont appel´es arguments effectifs. Dans ma premi`ere utilisation, l’argument effectif
d’entr´ee est une constante (5), dans le deuxi`eme une variable (n2) et dans le troisi`eme une expression
(n1*n2). La correspondance entre arguments effectifs et formels (ce que l’on appelle couramment passage
des param`etres) peut se faire de diverses mani`eres (cf prochain paragraphe pour quelques pr´ecisions en
ce qui concerne Scilab).
3.4.2 deuxi`eme exemple : l’´equation du second degr´e
function [x1,x2] = resoud_equ_2d(a, b, c)
// calcul des racines de a x^2 + b x + c = 0
// a, b et c peuvent etre des reels ou des complexes et a doit etre non nul
delta = b^2 - 4*a*c
x1 = (-b - sqrt(delta))/(2*a)
x2 = (-b + sqrt(delta))/(2*a)
endfunction
Voici trois essais avec cette fonction :
-->[r1, r2] = resoud_equ_2d(1,2,1)
r2 =
- 1.
r1 =
- 1.
-->[r1, r2] = resoud_equ_2d(1,0,1)
r2 =
i
r1 =
- i
-->resoud_equ_2d(1,0,1) // appel sans affectation
ans =
- i
On peut remarquer que le troisi`eme appel ne renvoie qu’une seule racine (la premi`ere). Ceci est normal
car on n’a pas affect´e le resultat de la fonction (qui renvoie 2 objets scalaires) contrairement aux deux
premiers appels. Dans ce cas scilab utilise la variable par d´efaut ans pour stocker le r´esultat mais elle ne
peut que stocker qu’un le premier objet renvoy´e par la fonction (le deuxi`eme ´etant perdu).
3.4.3 troisi`eme exemple : l’algorithme d’Horner
Il s’agit d’´evaluer en un point t un polynˆome ´ecrit dans une base de Newton (Rmq : avec les x
i
= 0
on retrouve la base canonique) :
p(t) = c
1
+c
2
(t −x
1
) +c
3
(t −x
1
)(t −x
2
) +. . . +c
n
(t −x
1
) . . . (t −x
n−1
).
41
En utilisant les facteurs communs et en calculant de la « droite vers la gauche » (ici avec n = 4) :
p(t) = c
1
+ (t −x
1
)(c
2
+ (t −x
2
)(c
3
+ (t −x
3
)(c
4
))),
on obtient l’algorithme d’Horner :
(1) p := c
4
(2) p := c
3
+ (t −x
3
)p
(3) p := c
2
+ (t −x
2
)p
(4) p := c
1
+ (t −x
1
)p.
En g´en´eralisant `a n quelconque et en utilisant une boucle, on obtient donc en Scilab :
function [p]=myhorner(t,x,c)
// evaluation du polynome c(1) + c(2)*(t-x(1)) + c(3)*(t-x(1))*(t-x(2)) +
// ... + c(n)*(t-x(1))*...*(t-x(n-1))
// par l’algorithme d’horner
n=length(c)
p=c(n)
for k=n-1:-1:1
p=c(k)+(t-x(k))*p
end
endfunction
Si les vecteurs coef et xx et le r´eel tt sont bien d´efinis dans l’environnement d’appel de la fonction
(si le vecteur coef a m composantes, il faut que xx en ait au moins m−1, si l’on veut que tout se passe
bien...), l’instruction :
val = myhorner(tt,xx,coef)
affectera `a la variable val la valeur :
coef
1
+coef
2
(tt −xx
1
) + +coef
m
m−1

i=1
(tt −xx
i
)
aux erreurs d’arrondi num´erique pr`es. Petit rappel : l’instruction length renvoie le produit des deux
dimensions d’une matrice (de nombres), et donc dans le cas d’un vecteur (ligne ou colonne) son nombre
de composantes. Cette instruction permet (avec l’instruction size qui renvoie le nombre de lignes et le
nombre de colonnes) de ne pas faire passer la dimension des structures de donn´ees (matrices, listes, ...)
dans les arguments d’une fonction.
3.4.4 quatri`eme exemple : le tri insertion
Voici une fa¸con de coder en scilab, l’algorithme du tri insertion sans sentinelle :
function x = tri_insertion(x)
n = length(x)
for i = 2:n
temp = x(i)
j = i-1
while j > 0 & temp < x(j)
x(j+1) = x(j)
j = j-1
end
x(j+1) = temp
end
endfunction
Noter que ces 4 premi`eres fonctions scilab sont donn´ees `a titre d’exemples simples pour d´ebuter dans
l’´ecriture de fonctions scilab, en particulier si le code pour Horner peut ˆetre rendu rapide par vectorisation
(cf exercices), celui du tri insertion est ` a oublier (utiliser les fonctions sort ou gsort).
42
3.4.5 Passage des param`etres (*)
Le passage d’un param`etre se fait par r´ef´erence si ce param`etre n’est pas modifi´e par la fonction et
par copie sinon (ainsi les param`etres d’entr´ee ne peuvent pas ˆetre modifi´es). Vous pouvez en tenir compte
pour acc´elerer certaines fonctions. Voici un exemple caricatural mais qui met bien en ´evidence le coˆ ut du
passage par copie pour des arguments prenant beaucoup de place :
function [w] = toto(v, k)
w = 2*v(k)
endfunction
function [w] = titi(v, k)
v(k) = 2*v(k)
w = v(k)
endfunction
// script de test
m = 200000;
nb_rep = 2000;
x = rand(m,1);
timer(); for i=1:nb_rep; y = toto(x,300); end; t1=timer()/nb_rep
timer(); for i=1:nb_rep; y = titi(x,300); end; t2=timer()/nb_rep
Sur ma machine j’obtiens :
t1 = 0.00002
t2 = 0.00380
Lors de la sortie de la fonction, toutes les variables internes (donc propres `a la fonction) sont d´etruites.
3.4.6 D´everminage d’une fonction
Pour d´eboguer une fonction vous pouvez utiliser la fonction disp(v1,v2, ...) qui permet de visua-
liser la valeur des variables v1, v2,. . .Attention disp affiche ses arguments dans l’ordre inverse !
Vous pouvez mettre une ou plusieurs instruction(s) pause en des endroits strat´egiques de la fonc-
tion. Lorsque Scilab rencontre cette instruction le d´eroulement du programme s’arrˆete et vous pouvez
examiner la valeur de toutes les variables d´ej`a d´efinies `a partir de la fenˆetre Scilab (l’invite --> de Sci-
lab se transforme en -1->). Lorsque vos observations sont finies, la commande resume fait repartir le
d´eroulement des instructions (jusqu’`a l’´eventuelle prochaine pause).
Comme il est p´enible de rajouter des instructions pause dans toutes les fonctions `a d´eboguer, il existe
un moyen de mettre des points d’arrˆet (break points en anglais) avec l’instruction :
setbpt(nom fonction [, num ligne ])
o` u vous entrez le nom de la fonction comme une chaˆıne de caract`eres et (´eventuellement) le num´ero de
la ligne d’arrˆet (la valeur par d´efaut est 1). Lorsque Scilab rencontre un tel point d’arrˆet tout se passe
comme si vous aviez mis une instruction pause apr`es la ligne mentionn´ee. Apr`es examen des variables,
vous repartez donc avec un resume.
Les points d’arrˆet doivent ˆetre explicitement enlev´es avec :
delbpt(nom fonction [, num ligne ])
Si vous ne pr´ecisez pas le num´ero de ligne, tous les points d’arrˆet install´es dans cette fonction sont
d´etruits. Enfin, vous pouvez voir tous les points d’arrˆet que vous avez d´efinis avec dispbpt().
Voici un petit exemple avec la fonction resoud equ 2d d´efinie pr´ec´edemment :
function [x1,x2] = resoud_equ_2d(a, b, c)
// calcul des racines de a x^2 + b x + c = 0
// a, b et c peuvent etre des reels ou des complexes et a doit etre non nul
delta = b^2 - 4*a*c
x1 = (-b - sqrt(delta))/(2*a)
x2 = (-b + sqrt(delta))/(2*a)
endfunction
43
Je suppose que cette fonction a ´et´e charg´ee dans Scilab, soit avec un getf soit avec un exec :
-->setbpt("resoud_equ_2d") // un premier point d’arr^et
-->[r1,r2] = resoud_equ_2d(1,2,7) // je lance le calcul => arr^et
Stop after row 1 in function resoud_equ_2d :
-1->a // j’examine quelques variables
a =
1.
-1->b
b =
2.
-1->dispbpt() // je visualise mes points d’arr^et
breakpoints of function :resoud_equ_2d
1
-1->setbpt("resoud_equ_2d",5) // je rajoute un point d’arr^et en ligne 5
-1->x1 // x1 n’est pas encore definie !
x1
!--error 4
undefined variable : x1
-1->resume // je red´emarre (jusqu’au prochain point d’arr^et)
Stop after row 5 in function resoud_equ_2d :
-1->x1 // je peux maintenant examiner x1
x1 =
- 1. - 2.4494897i
-1->x2 // x2 n’est tj pas d´efinie (x2 est d´efinie `a la ligne 6 de cette fct)
x2
!--error 4
undefined variable : x2
-1->dispbpt() // je vois mes 2 points d’arr^et
breakpoints of function :resoud_equ_2d
1
5
-1->resume // je red´emarre (et donc je sorts de ma fonction)
r2 =
- 1. + 2.4494897i
r1 =
- 1. - 2.4494897i
-->delbpt("resoud_equ_2d") // je d´etruits tous les points d’arr^et
Notez que ces manipulations peuvent se faire maintenant de mani`ere graphique avec scipad (voir les
items du menu Debug parmi lesquels show watch vous permet de choisir les variables dont vous voulez
observer la valeur et configure execution vous permet de choisir la valeur des param`etres d’entr´ee de
la fonction).
3.4.7 L’instruction break
Elle permet dans une boucle for ou while d’arrˆeter le d´eroulement des it´erations en passant le
contrˆole `a l’instruction qui suit le end marquant la fin de la boucle
9
. Elle peut servir `a simuler les autres
9
si la boucle est imbriqu´ee dans une autre, break permet de sortir uniquement de la boucle interne
44
types de boucles, celles avec le test de sortie `a la fin (genre repeat ... until du Pascal) et celles avec
test de sortie au milieu ou bien `a traiter les cas exceptionnels qui interdisent le d´eroulement normal d’une
boucle for ou while (par exemple un pivot nul dans une m´ethode de Gauss). Supposons que l’on veuille
simuler une boucle avec test de sortie `a la fin :
r´ep´eter
suite d’instructions
jusqu’`a ce que condition
o` u condition est une expression qui d´elivre un scalaire bool´een (on sort lorsque ce test est vrai). On
pourra alors ´ecrire en Scilab :
while %t // d´ebut de la boucle
suite d’instructions
if condition then, break, end
end
Il y a aussi des cas o` u l’utilisation d’un break conduit `a une solution plus naturelle, lisible et compacte.
Voici un exemple : on veut rechercher dans un vecteur de chaˆınes de caract`eres l’indice du premier mot
qui commence par une lettre donn´ee l. Pour cela, on va ´ecrire une fonction (qui renvoie 0 dans le cas o` u
aucune des chaˆınes de caract`eres ne commenceraient par la lettre en question). En utilisant une boucle
while (sans s’autoriser de break), on peut ˆetre conduit `a la solution suivante :
function ind = recherche2(v,l)
n = max(size(v))
i = 1
succes = %f
while ~succes & (i <= n)
succes = part(v(i),1) == l
i = i + 1
end
if succes then
ind = i-1
else
ind = 0
end
endfunction
Si on s’autorise l’utilisation d’un break, on a la solution suivante plus naturelle (mais moins conforme
aux crit`eres purs et durs de la programmation structur´ee) :
function ind = recherche1(v,l)
n = max(size(v))
ind = 0
for i=1:n
if part(v(i),1) == l then
ind = i
break
end
end
endfunction
Rappel : on peut remarquer l’emploi de la fonction size alors que la fonction length semble plus
adapt´ee pour un vecteur
10
; ceci vient du fait que length r´eagit diff´eremment si les composantes de la
matrice ou du vecteur sont des chaˆınes de caract`eres (length renvoie une matrice de taille identique o` u
chaque coefficient donne le nombre de caract`eres de la chaˆıne correspondante).
10
si l’on veut un code qui fonctionne ind´ependamment du fait que v soit ligne ou colonne, on ne peut pas non plus utiliser
size(v,’r’) ou size(v,’l’) d’o` u le max(size(v))
45
3.4.8 Quelques primitives utiles dans les fonctions
En dehors de length et size qui permettent de r´ecup´erer les dimensions des structures de donn´ees,
et de pause, resume, disp qui permettent de d´eboguer, d’autres fonctions peuvent ˆetre utiles comme
error, warning, argn ou encore type et typeof.
La fonction error
Elle permet d’arrˆeter brutalement le d´eroulement d’une fonction tout en affichant un message d’er-
reur ; voici une fonction qui calcule n! en prenant soin de v´erifier que n ∈ N :
function [f] = fact2(n)
// calcul de la factorielle d’un nombre entier positif
if (n - floor(n) ~=0) | n<0 then
error(’erreur dans fact2 : l’’argument doit etre un nombre entier naturel’)
end
f = prod(1:n)
endfunction
et voici le r´esultat sur deux arguments :
-->fact2(3)
ans =
6.
-->fact2(0.56)
!--error 10000 erreur dans fact2 : l’argument doit etre un nombre entier naturel
at line 6 of function fact called by : fact(0.56)
La fonction warning
Elle permet d’afficher un message `a l’´ecran mais n’interrompt pas le d´eroulement de la fonction :
function [f] = fact3(n)
// calcul de la factorielle d’un nombre entier positif
if (n - floor(n) ~=0) | n<0 then
n = floor(abs(n))
warning(’l’’argument n’’est pas un entier naturel: on calcule ’+sprintf("%d",n)+"!")
end
f = prod(1:n)
endfunction
ce qui donnera par exemple :
-->fact3(-4.6)
WARNING:l’argument n’est pas un entier naturel: on calcule 4!
ans =
24.
Comme pour la fonction error, l’argument unique de la fonction warning est une chaˆıne de caract`eres.
J’ai utilis´e ici une concat´enation de 3 chaˆınes dont l’une est obtenue par la fonction sprintf qui permet
de transformer des nombres en chaˆıne de caract`eres selon un certain format.
Les fonctions type et typeof
Celles-ci permettent de connaˆıtre le type d’une variable v. type(v) renvoie un entier alors que
typeof(v) renvoie une chaˆıne de caract`eres Voici un tableau r´ecapitulatif pour les types de donn´ees
que nous avons vus :
46
type de v type(v) typeof(v)
matrice de r´eels ou complexes 1 constant
matrice de bool´eens 4 boolean
matrice de chaˆınes de caract`eres 10 string
liste 15 list
liste typ´ee 16 type de la liste
fonction 13 function
Un exemple d’utilisation : on veut s´ecuriser notre fonction factorielle en cas d’appel avec un mauvais
argument d’entr´ee.
function [f] = fact4(n)
// la fonction factorielle un peu plus blindee
if type(n) ~= 1 then
error(" erreur dans fact4 : l’’argument n’’a pas le bon type...")
end
[nl,nc]=size(n)
if (nl ~= 1) | (nc ~= 1) then
error(" erreur dans fact4 : l’’argument ne doit pas etre une matrice...")
end
if (n - floor(n) ~=0) | n<0 then
n = floor(abs(n))
warning(’l’’argument n’’est pas un entier naturel: on calcule ’+sprintf("%d",n)+"!")
end
f = prod(1:n)
endfunction
La fonction argn et les arguments optionnels
argn permet d’obtenir le nombre d’arguments effectifs d’entr´ee et de sortie d’une fonction lors d’un
appel `a celle-ci. On l’utilise sous la forme :
[lhs,rhs] = argn()
lhs (pour left hand side) donnant le nombre d’arguments de sortie effectifs, et rhs (pour right hand
side) donnant le nombre d’arguments d’entr´ee effectifs.
Elle permet essentiellement d’´ecrire une fonction avec des arguments d’entr´ee et de sortie optionnels
(la fonction type ou typeof pouvant d’ailleurs l’aider dans cette tache). Un exemple d’utilisation est
donn´e plus loin (Une fonction est une variable Scilab).
Cependant pour ´ecrire ais´ement des fonctions avec des arguments optionnels, Scilab poss`ede une
fonctionnalit´e tr`es pratique d’association entre arguments formels et arguments effectifs. Voici un exemple
de fonction pour laquelle je d´esire un argument classique plus deux param`etres optionnels :
function [y] = argopt(x, coef_mult, coef_add)
// pour illustrer l’association entre argument formels et effectifs
[lhs, rhs] = argn()
if rhs < 1 | rhs > 3 then
error("mauvais nombre d’’arguments")
end
if ~exists("coef_mult","local") then
coef_mult = 1
end
if ~exists("coef_add","local") then
coef_add = 0
end
y = coef_mult*x + coef_add
endfunction
47
La fonction exists me permet de tester si les arguments coef mult et coef add ont ´et´e d´efinis
11
lors
de l’appel de la fonction, ce qui permet de leur donner une valeur par d´efaut dans le cas contraire. De
plus avec la syntaxe argument formel = argument effectif, on peut se permettre de mettre les arguments
dans n’importe quel ordre. Exemples :
-->y1 = argopt(5)
y1 =
5.
-->y2 = argopt(5, coef_add=10)
y2 =
15.
-->y3 = argopt(5, coef_mult=2, coef_add=6)
y3 =
16.
-->y4 = argopt(5, coef_add=6, coef_mult=2) // y4 doit ^etre ´egal `a y3
y4 =
16.
3.5 Compl´ements divers
3.5.1 Longueur des identificateurs
Scilab ne prend en compte que des 24 premi`eres lettres de chaque identificateur :
-->a234567890123456789012345 = 1
a23456789012345678901234 =
1.
-->a234567890123456789012345
a23456789012345678901234 =
1.
On peut donc utiliser plus de lettres mais seules les 24 premi`eres sont significatives.
3.5.2 Priorit´e des op´erateurs
Elle est assez naturelle (c’est peut ˆetre la raison pour laquelle ces r`egles n’apparaissent pas dans l’aide
en ligne...). Comme usuellement les op´erateurs num´eriques
12
( + - * .* / ./ \ ^ .^ ’ )
ont une priorit´e plus ´elev´ee que les op´erateurs de comparaisons (< <= > >= == ~=). Voici un tableau
r´ecapitulatif par ordre de priorit´e d´ecroissante pour les op´erateurs num´eriques :

^ .^
* .* / ./ \
+ -
Pour les op´erateurs bool´eens le « non » (~) est prioritaire sur le « et » (&) lui-mˆeme prioritaire sur le
« ou » (|). Lorsque l’on ne souvient plus des priorit´es, on met des parenth`eses ce qui peut d’ailleurs aider
(avec l’ajout de caract`eres blancs) la lecture d’une expression comportant quelques termes... Pour plus
de d´etails voir le « Scilab Bag Of Tricks ». Quelques remarques :
1. Comme dans la plupart des langages, le - unaire n’est autoris´e qu’en d´ebut d’expression, c-`a-d que
les expressions du type (o` u op d´esigne un op´erateur num´erique quelconque) :
11
l’argument suppl´ementaire avec la valeur "local" r´eduit la port´ee de l’interrogation ` a la fonction elle mˆeme ; ceci est
important car des variables de mˆeme nom peuvent ˆetre d´efinies ` a des niveaux sup´erieurs.
12
il y en a d’autres que ceux qui figurent dans cette liste
48
op´erande op - op´erande
sont interdites. Il faut alors mettre des parenth`eses :
op´erande op (- op´erande)
2. Pour une expression du type :
op´erande op1 op´erande op2 op´erande op3 op´erande
o` u les op´erateurs ont une priorit´e identique, l’´evaluation se fait en g´en´eral de la gauche vers la
droite :
((op´erande op1 op´erande) op2 op´erande) op3 op´erande
sauf pour l’op´erateur d’´el´evation `a la puissance :
a^b^c est ´evalu´e de la droite vers la gauche : a^(b^c)
de fa¸con `a avoir la mˆeme convention qu’en math´ematique : a
b
c
.
3.5.3 R´ecursivit´e
Une fonction peut s’appeler elle-mˆeme. Voici deux exemples tr`es basiques (le deuxi`eme illustrant une
mauvaise utilisation de la r´ecursivit´e) :
function f=fact(n)
// la factorielle en recursif
if n <= 1 then
f = 1
else
f = n*fact(n-1)
end
endfunction
function f=fib(n)
// calcul du n ieme terme de la suite de Fibonnaci :
// fib(0) = 1, fib(1) = 1, fib(n+2) = fib(n+1) + fib(n)
if n <= 1 then
f = 1
else
f = fib(n-1) + fib(n-2)
end
endfunction
3.5.4 Une fonction est une variable Scilab
Une fonction programm´ee en langage Scilab
13
est une variable du type « function » , et en particulier,
elle peut ˆetre pass´ee comme argument d’une autre fonction. Voici un petit exemple
14
: ouvrez un fichier
pour ´ecrire les deux fonctions suivantes :
function [y] = f(x)
y = sin(x).*exp(-abs(x))
endfunction
function dessine_fonction(a, b, fonction, n)
// n est un argument optionnel, en cas d’absence de celui-ci on impose n=61
[lhs, rhs] = argn(0)
if rhs == 3 then
n = 61
end
x = linspace(a,b,n)
y = fonction(x)
plot(x,y)
endfunction
13
voir la section « Primitives et fonctions Scilab » du b´etisier
14
qui est inutile en dehors de son aspect p´edagogique : cf fplot2d
49
puis rentrez ces fonctions dans l’environnement et enfin, essayez par exemple :
-->dessine_fonction(-2*%pi,2*%pi,f)
-->dessine_fonction(-2*%pi,2*%pi,f,21)
Une possibilit´e int´eressante de Scilab est que l’on peut d´efinir directement une fonction dans l’envi-
ronnement (sans passer par l’´ecriture d’un fichier puis le chargement par getf) par l’interm´ediaire de la
commande deff dont voici la syntaxe simplifi´ee :
deff(’[y1,y2,...]=nom_de_la_fonction(x1,x2,....)’,text)
o` u text est un vecteur colonne de chaˆınes de caract`eres, constituant les instructions successives de la
fonction. Par exemple, on aurait pu utiliser :
deff(’[y]=f(x)’,’y = sin(x).*exp(-abs(x))’)
pour d´efinir la premi`ere des deux fonctions pr´ec´edentes. En fait cette possibilit´e est int´eressante dans
plusieurs cas :
1. dans un script utilisant une fonction simple qui doit ˆetre modifi´ee assez souvent ; dans ce cas on
peut d´efinir la fonction avec deff dans le script ce qui ´evite de jongler avec un autre fichier dans
lequel on aurait d´efini la fonction comme d’habitude ; cependant depuis la version 2.6 vous
pouvez d´efinir des fonctions dans un script avec la syntaxe habituelle ce qui est plus pratique
qu’avec un deff ; dans votre script vous pouvez donc ´ecrire les fonctions au d´ebut du texte :
// definition des fcts utilis´ees par le script
function
....
endfunction
function
....
endfunction
// debut effectif du script
....
2. la possibilit´e vraiment int´eressante est de pouvoir d´efinir une partie du code de fa¸con dynamique :
on ´elabore une fonction `a partir d’´el´ements divers issus de calculs pr´ec´edents et/ou de l’introduction
de donn´ees (via un fichier ou de fa¸con interactive (cf Fenˆetres de dialogues)) ; dans cet esprit voir
aussi les fonctions evstr et execstr un peu plus loin.
3.5.5 Fenˆetres de dialogues
Dans l’exemple de script donn´e dans le chapitre 2, on a vu la fonction input qui permet de rentrer un
param`etre interactivement via la fenˆetre Scilab. D’autre part la fonction disp permet l’affichage `a l’´ecran
de variables (toujours dans la fenˆetre Scilab). En fait il existe une s´erie de fonctions qui permettent
d’afficher des fenˆetres de dialogues, menus, selection de fichiers : x_choices , x_choose, x_dialog,
x_matrix, x_mdialog, x_message et xgetfile. Voir le Help pour le d´etail de ces fonctions (l’aide sur
une fonction propose toujours au moins un exemple).
3.5.6 Conversion d’une chaˆıne de caract`eres en expression Scilab
Il est souvent utile de pouvoir ´evaluer une expression Scilab mise sous la forme d’une chaˆıne de
caract`eres. Par exemple, la plupart des fonctions pr´ec´edentes renvoient des chaˆınes de caract`eres, ce
qui s’av`ere pratique mˆeme pour rentrer des nombres car on peut alors utiliser des expressions Scilab
(exemples sqrt(3)/2, 2*%pi, . . .). L’instruction qui permet cette conversion est evstr, exemple :
-->c = "sqrt(3)/2"
c =
sqrt(3)/2
50
-->d = evstr(c)
d =
0.8660254
Dans la chaˆıne de caract`eres vous pouvez utiliser des variables Scilab d´ej`a d´efinies :
-->a = 1;
-->b=evstr("2 + a")
b =
3.
et cette fonction s’applique aussi sur une matrice de chaˆınes de caract`eres
15
:
-->evstr(["a" "2" ])
ans =
! 1. 2. !
-->evstr([" a + [1 2]" "[4 , 5]"])
ans =
! 2. 3. 4. 5. !
-->evstr(["""a""" """b"""]) // conversion d’une chaine en une chaine
ans =
!a b !
Il existe aussi la fonction execstr qui permet d’ex´ecuter une instruction Scilab donn´ee sous forme
d’une chaˆıne de caract`eres :
-->execstr("A=rand(2,2)")
-->A
A =
! 0.2113249 0.0002211 !
! 0.7560439 0.3303271 !
3.6 Lecture/´ecriture sur fichiers ou dans la fen`etre Scilab
Scilab poss`ede deux familles d’entr´ees/sorties. Il faut ´eviter de m´elanger les instructions de ces deux
familles surtout si vous ´ecrivez/lisez dans un fichier.
3.6.1 Les entr´ees/sorties `a la fortran
Dans le chapitre deux, nous avons vu comment lire et ´ecrire une matrice de r´eels dans un fichier en
une seule instruction avec read et write. De mˆeme il est possible d’´ecrire et de lire un vecteur colonne
de chaˆınes de caract`eres :
-->v = ["Scilab is free";"Octave is free";"Matlab is ?"];
-->write("toto.dat",v,"(A)") // aller voir le contenu du fichier toto.dat
-->w = read("toto.dat",-1,1,"(A)")
w =
!Scilab is free !
! !
15
et aussi sur une liste, voir le Help
51
!Octave is free !
! !
!Matlab is ? !
Pour l’´ecriture, on rajoute simplement un troisi`eme argument `a write qui correspond `a un format
fortran : c’est une chaˆıne de caract`eres comprenant un (ou plusieurs) descripteur(s) d’´edition (s´epar´es
par des virgules s’il y a en plusieurs) entour´es par des parenth`eses : le A signifie que l’on souhaite ´ecrire une
chaˆıne de caract`eres. Pour la lecture, les deuxi`eme et troisi`eme arguments correspondent respectivement
au nombre de lignes (-1 pour aller jusqu’`a la fin du fichier) et colonne (ici 1). En fait pour les matrices
de r´eels vous pouvez aussi rajouter un format (plutˆot en ´ecriture) de fa¸con `a contrˆoler pr´ecisemment la
fa¸con dont seront ´ecrites les donn´ees.
D’une mani`ere g´en´erale les possibilit´es de Scilab en ce domaine sont exactement celle du fortran 77,
vous pouvez donc lire un livre sur ce langage pour en savoir plus
16
. Dans la suite je vais simplement
donner quelques exemples concernant uniquement les fichiers « texte » `a acc`es s´equentiel.
Ouvrir un fichier
Cela se fait avec l’instruction file dont la syntaxe (simplifi´ee) est :
[unit, [err]]=file(’open’, file-name ,[status])
o` u :
– file-name est une chaˆıne de caract`ere donnant le nom du fichier (´eventuellement pr´ec´ed´ee du
chemin menant au fichier si celui-ci ne se trouve pas dans le r´epertoire point´e par Scilab, ce r´epertoire
se changeant avec l’instruction chdir) ;
– status est l’une des chaˆınes de caract`eres :
– "new" pour ouvrir un nouveau fichier (si celui-ci existe d´ej`a une erreur est g´en´er´ee) ;
– "old" pour ouvrir un fichier existant (si celui-ci n’existe pas une erreur est g´en´er´ee) ;
– "unknow" si le fichier n’existe pas, un nouveau fichier est cr´e´e, et dans le cas contraire le fichier
correspondant est ouvert ;
Dans le cas o` u status n’est pas pr´esent, Scilab utilise "new" (c’est pour cette raison que l’´ecriture
d’un fichier en une seule instruction write ´echoue si le fichier existe d´ej`a).
– unit est un entier qui va permettre d’identifier le fichier par la suite dans les op´erations de lec-
tures/´ecritures (plusieurs fichiers pouvant ˆetre ouverts en mˆeme temps).
– Une erreur `a l’ouverture d’un fichier peut ˆetre d´etect´ee si l’argument err est pr´esent ; dans le cas
contraire, Scilab g`ere l’erreur brutalement. Une absence d’erreur correspond `a la valeur 0 et lorsque
cette valeur est diff´erente, l’instruction error(err) renvoie un message d’erreur permettant d’en
savoir un peu plus : on obtient en g´en´eral err=240 ce qui signifie :
-->error(240)
!--error 240
File error(240) already exists or directory write access denied
Pour permettre de r´ecup´erer un nom de fichier de fa¸con interactive on utilisera xgetfile qui permet
de naviguer dans l’arborescence pour selectionner un fichier.
´
Ecrire et lire dans le fichier ouvert
Supposons donc que l’on ait ouvert un fichier avec succ`es : celui-ci est rep´er´e par l’entier unit qui nous
a ´et´e renvoy´e par file. Si le fichier existait d´ej`a, les lectures/´ecritures ont normalement lieu en d´ebut
de fichier. Si vous voulez ´ecrire `a la fin du fichier, il faut s’y positionner au pr´ealable avec l’instruction
file("last", unit), et si pour une raison quelconque vous voulez revenir en d´ebut de fichier, on utilise
file("rewind", unit).
Voici un premier exemple : on veut ´ecrire un fichier qui permet de d´ecrire une liste d’arˆetes du plan,
c’est `a dire que l’on consid`ere n points P
i
= (x
i
, y
i
) et m arˆetes, chaque arˆete ´etant d´ecrite comme un
16
Vous pouvez r´ecup´erer gratuitement le livre de Clive Page sur le serveur ftp ftp.star.le.ac.uk : se positionner dans
le r´epertoire /pub/fortran et r´ecup´erer le fichier prof77.ps.gz
52
segment
−−→
P
i
P
j
, et l’on donnera simplement le num´ero (dans le tableau des points) du point de d´epart (ici
i) puis celui d’arriv´ee (ici j). On choisit comme format pour ce fichier, la s´equence suivante :
une ligne de texte
n
x_1 y_1
.......
x_n y_n
m
i1 j1
.....
im jm
La ligne de texte permet de mettre quelques informations. On a ensuite un entier donnant le nombre
de points, puis les coordonn´ees de ces points. Vient ensuite le nombre d’arˆetes puis la connectivit´e de
chaque arˆete. Supposons que notre ligne de texte soit contenue dans la variable texte, nos points dans
la matrice P de format (n, 2) et la connectivit´e des arˆetes dans la matrice connect de format (m, 2),
l’´ecriture du fichier s’effectue avec les instructions :
write(unit,texte) // ecriture de la ligne de texte
write(unit,size(P,1)) // ecriture du nombre de points
write(unit,P) // ecriture des coordonnees des points
write(unit,size(connect,1)) // ecriture du nombre d’aretes
write(unit,connect) // ecriture de la connectivite
file("close",unit) // fermeture du fichier
et voici le r´esultat obtenu :
un polygone au hasard
5.0000000000000
0.28553641680628 0.64885628735647
0.86075146449730 0.99231909401715
0.84941016510129 5.0041977781802D-02
0.52570608118549 0.74855065811425
0.99312098976225 0.41040589986369
5.0000000000000
1.0000000000000 2.0000000000000
2.0000000000000 3.0000000000000
3.0000000000000 4.0000000000000
4.0000000000000 5.0000000000000
5.0000000000000 1.0000000000000
qui n’est pas tr`es harmonieux car nous n’avons pas pr´ecis´e de formats d’´edition. Le point n´egatif est
que les entiers ´etant consid´er´es comme des flottants par Scilab
17
, ils sont ´ecrits avec un format relatif
aux flottants. D’autre part, la chaˆıne de caract`eres est pr´ec´ed´ee d’un blanc (non contenu dans la chaˆıne
texte). Pour obtenir quelque chose de mieux, il faut rajouter ces formats fortran :
– pour un entier, on utilise Ix o` u x est un entier strictement positif donnant la longueur du champ
en nombre de caract`eres (le cadrage a lieu `a droite) ;
– pour les flottants, un format passe partout est Ex.y o` u x est la longueur totale du champ et y
la longueur de la mantisse, la sortie prenant la forme : [signe]0.mantisseE[signe]exposant ;
pour les flottants double pr´ecision, la conversion en d´ecimal donne environ 16 chiffres significatifs
et les exposants sont compris (environ) entre -300 et +300, ce qui donne une longueur totale
17
Depuis la version 2.5, il existe cependant les types entiers int8, int16 et int32 voir le Help.
53
de 24 caract`eres. On peut donc utiliser le format E24.16 (selon la magnitude d’un nombre et la
pr´esentation d´esir´ee d’autres formats seraient plus adapt´es) ;
– pour ´eviter le blanc pr´ec´edant la chaˆıne de caract`ere, on peut utiliser le format A.
En reprenant l’exemple pr´ec´edent, une ´ecriture plus harmonieuse est obtenue avec (en supposant moins
de 999 points et arˆetes) :
write(unit,texte,"(A)") // ecriture de la ligne de texte
write(unit,size(P,1),"(I3)") // ecriture du nombre de points
write(unit,P,"(2(X,E24.16))") // ecriture des coordonnees des points
write(unit,size(connect,1),"(I3)") // ecriture du nombre d’aretes
write(unit,connect,"(2(X,I3))") // ecriture de la connectivite
file("close",unit) // fermeture du fichier
(le format X correspond `a l’´ecriture d’un caract`ere blanc et j’utilise aussi un facteur de r´ep´etition,
2(X,E24.16) signifiant que l’on veut ´ecrire sur une mˆeme ligne deux champs comprenant un blanc
suivi d’un flottant ´ecrit sur 24 caract`eres) ce qui donne :
un polygone au hasard
5
0.2855364168062806E+00 0.6488562873564661E+00
0.8607514644972980E+00 0.9923190940171480E+00
0.8494101651012897E+00 0.5004197778180242E-01
0.5257060811854899E+00 0.7485506581142545E+00
0.9931209897622466E+00 0.4104058998636901E+00
5
1 2
2 3
3 4
4 5
5 1
Pour lire ce mˆeme fichier, on pourrait utiliser la s´equence suivante :
texte=read(unit,1,1,"(A)") // lecture de la ligne de texte
n = read(unit,1,1) // lecture du nombre de points
P = read(unit,n,2) // lecture des coordonnees des points
m = read(unit,1,1) // lecture du nombre d’aretes
connect = read(unit,m,2) // lecture de la connectivite
file("close",unit) // fermeture du fichier
Si vous avez bien lu ces quelques exemples, vous avez du remarquer que la fermeture d’un fichier s’obtient
avec l’instruction file("close",unit).
Pour finir, vous pouvez lire et ´ecrire dans la fenˆetre Scilab en utilisant respectivement unit = %io(1)
et unit = %io(2). Pour l’´ecriture, on peut alors obtenir une pr´esentation plus soign´ee que celle obte-
nue avec la fonction disp (voir un exemple dans le B´etisier dans la section « Primitives et fonctions
Scilab » (script d’appel `a la fonction MonteCarlo)).
3.6.2 Les entr´ees/sorties `a la C
Pour l’ouverture et la fermeture des fichiers, il faut utiliser mopen et mclose, les instructions de base
sont :
mprintf, mscanf ecriture, lecture dans la fenˆetre scilab
mfprintf, mfscanf ecriture, lecture dans un fichier
msprintf, msscanf ecriture, lecture dans une chaˆıne de caract`eres
54
Dans la suite, j’explique uniquement l’usage de mprintf. Voici un script pour vous d´ecrire les cas prin-
cipaux :
n = 17;
m = -23;
a = 0.2;
b = 1.23e-02;
c = a + %i*b;
s = "coucou";
mprintf("\n\r n = %d, m = %d", n, m); // %d pour les entiers
mprintf("\n\r a = %g", a); // %g pour les reels
mprintf("\n\r a = %e", a); // %e pour les reels (notation avec exposant)
mprintf("\n\r a = %24.16e", a); // on impose le nombre de "d´ecimales"
mprintf("\n\r c = %g + i %g", real(c), imag(c)); // nb complexe
mprintf("\n\r s = %s", s); // %s pour les chaines de caract`eres
Si vous executez ce script avec un « ; » `a la fin de l’ordre exec (c-a-d exec("demo mprintf.sce") ;
si vous avez appel´e le fichier par ce nom), alors vous allez observer la sortie suivante :
n = 17, m = -23
a = 0.2
a = 2.000000e-01
a = 2.0000000000000001e-01
c = 0.2 + i 0.0123
s = coucou
Quelques explications :
– le \n\r impose un passage `a la ligne (sous Unix le \n doit suffire) : ne pas le mettre si vous ne
voulez pas aller `a la ligne !
– les %x sont des directives de formatage, c’est `a dire qu’elles donnent la fa¸con dont la variable (ou
constante) doit ˆetre ´ecrite :
1. %d pour les entiers ;
2. %e pour les r´eels en notation scientifique (c-a-d avec exposant). La sortie doit prendre la forme :
[−]c
0
.c
1
...c
6
e±d
1
d
2
[d
3
] c’est `a dire avec le signe (si le nombre est n´egatif), 1 chiffre avant la
virgule (le point en fait !), 6 chiffres apr`es, la lettre e puis le signe de l’exposant, et enfin
l’exposant sur deux chiffres, voire 3 si besoin. Pour imposer plus pr´ecisemment la sortie, on
rajoute deux nombres entiers s´epar´es par un point, le premier donnant le nombre de caract`eres
total et le deuxi`eme, le nombre de chiffres apr`es la virgule.
3. %g permet de choisir entre une sortie sans exposant (si c’est possible) ou avec.
4. %5.3f permet d’avoir une sortie sans exposant avec 5 caract`eres en tout dont 3 apr`es la virgule.
5. %s s’utilise pour les chaˆınes de caract`eres.
– `a chaque directive doit correspondre une valeur de sortie (variable, expression ou constante), par
exemple, si on veut afficher 4 valeurs, il faut 4 directives :
mprintf(" %d1 ..... %d4 ", expr1, expr2, expr3, expr4);
Question : la sortie de 0.2 avec le format %24.16e paraˆıt bizarre. R´eponse : c’est parce que 0.2 ne
tombe pas juste en binaire et donc en mettant suffisamment de pr´ecision (pour la conversion binaire vers
d´ecimal) on finit par d´etecter ce probl`eme.
3.7 Remarques sur la rapidit´e
Voici sur deux exemples quelques trucs `a connaˆıtre. On cherche `a calculer une matrice de type
Vandermonde :
A =
_
¸
¸
¸
_
1 t
1
t
2
1
. . . t
n
1
1 t
2
t
2
2
. . . t
n
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1 t
m
t
2
m
. . . t
n
m
_
¸
¸
¸
_
55
Voici un premier code assez naturel :
function A=vandm1(t,n)
// calcul de la matrice de Vandermonde A=[a(i,j)] 1<= i <= m
// 1<= j <= n+1
// ou a(i,j) = ti^(j-1)
// t doit etre un vecteur colonne a m composantes
m=size(t,’r’)
for i = 1:m
for j = 1:n+1
A(i,j) = t(i)^(j-1)
end
end
endfunction
Comme a priori on ne d´eclare pas les tailles des matrices et autres objets en Scilab nul besoin de lui
dire que le format final de notre matrice A est (m, n+1). Comme au fur et `a mesure du calcul la matrice
grossie, Scilab doit g´erer ce probl`eme (pour i = 1, A est un vecteur ligne `a j composantes, pour i > 1, A
est une matrice (i, n+1), on a donc en tout n+m−1 changements dans les dimensions de A. Par contre
si on fait une pseudo-d´eclaration de la matrice (par la fonction zeros(m,n+1)) :
function A=vandm2(t,n)
// idem a vandm1 sauf que l’on fait une pseudo-declaration pour A
m=size(t,’r’)
A = zeros(m,n+1) // pseudo declaration
for i = 1:m
for j = 1:n+1
A(i,j) = t(i)^(j-1)
end
end
endfunction
il n’y a plus ce probl`eme et l’on gagne un peu de temps : :
-->t = linspace(0,1,1000)’;
-->timer(); A = vandm1(t,200); timer()
ans =
6.04
-->timer(); A = vandm2(t,200); timer()
ans =
1.26
On peut essayer d’optimiser un peu ce code en initialisant A avec ones(m,n+1) (ce qui ´evite le calcul de
la premi`ere colonne), en ne faisant que des multiplications avec a
ij
= a
ij−1
t
i
(ce qui ´evite les calculs
de puissances), voire en inversant les deux boucles, mais l’on gagne peu. La bonne m´ethode est de voir
que la construction de A peut se faire en utilisant une instruction vectorielle :
function A=vandm5(t,n)
// la bonne methode : utiliser l’ecriture matricielle
m=size(t,’r’)
A=ones(m,n+1)
for i=1:n
A(:,i+1)=t.^i
end
endfunction
function A=vandm6(t,n)
// idem a vandm5 avec une petite optimisation
m=size(t,’r’)
56
A=ones(m,n+1)
for i=1:n
A(:,i+1)=A(:,i).*t
end
endfunction
et on am´eliore ainsi la rapidit´e de fa¸con significative :
-->timer(); A = vandm5(t,200); timer()
ans =
0.05
-->timer(); A = vandm6(t,200); timer()
ans =
0.02
Voici un deuxi`eme exemple : il s’agit d’´evaluer en plusieurs points (des scalaires r´eels mis dans un
vecteur ou une matrice) la fonction « chapeau » (cf fig (3.2) :
φ(t) =
_
¸
¸
_
¸
¸
_
0 si t ≤ a
t−a
b−a
si a ≤ t ≤ b
c−t
c−b
si b ≤ t ≤ c
0 si t ≥ c
Du fait de la d´efinition par morceaux de cette fonction, son ´evaluation en un point n´ecessite en g´en´eral
t
1
φ
(t)
a,b,c
a c b
Fig. 3.2 – Fonction « chapeau »
plusieurs tests. Si ce travail doit ˆetre r´ealis´e sur beaucoup de points il faut « vectoriser » ces tests pour
´eviter de faire travailler l’interpr´eteur. Par exemple, ce premier code naturel :
function [y]=phi1(t,a,b,c)
// evalue la fonction chapeau (de parametres a, b et c) sur le vecteur
// (voire la matrice) t au sens ‘‘element par element’’.
// a,b et c doivent verifier a < b < c
[n,m] = size(t)
y = zeros(t)
for j=1:m, for i=1:n
if t(i,j) > a then
if t(i,j) < b then
y(i,j) = (t(i,j) - a)/(b - a)
elseif t(i,j) < c then
y(i,j) = (c - t(i,j))/(c - b)
end
end
end, end
endfunction
57
donne le r´esultat :
-->a = -0.2 ; b=0 ; c=0.15;
-->t = rand(200000,1)-0.5;
-->timer(); y1 = phi1(t,a,b,c); timer()
ans =
2.46
alors que les codes suivants
18
:
function [y]=phi2(t,a,b,c)
// evalue la fonction chapeau (de parametres a, b et c) sur le scalaire t
// ou le vecteur (voire la matrice) t au sens \og element par element \fg.
// a,b et c doivent verifier a < b < c
Indicatrice_a_b = bool2s( (a < t) & (t <= b) )
Indicatrice_b_c = bool2s( (b < t) & (t < c ) )
y = Indicatrice_a_b .* (t - a)/(b - a) + Indicatrice_b_c .* (c - t)/(c - b)
endfunction
function [y]=phi3(t,a,b,c)
// idem a phi2 avec une petite optimisation
t_le_b = ( t <= b )
Indicatrice_a_b = bool2s( (a < t) & t_le_b )
Indicatrice_b_c = bool2s( ~t_le_b & (t < c) )
y = Indicatrice_a_b .* (t - a)/(b - a) + Indicatrice_b_c .* (c - t)/(c - b)
endfunction
sont plus rapides :
-->timer(); y2 = phi2(t,a,b,c); timer()
ans =
0.12
-->timer(); y3 = phi3(t,a,b,c); timer()
ans =
0.12
-->timer(); y4 = phi4(t,a,b,c); timer() // voir plus loin la d´efinition de phi4
ans =
0.1
Remarques :
– ma petite optimisation pour phi2 ne donne aucun gain (alors que c’´etait le cas pour une version
pr´ec´edente de scilab sur une autre machine) ;
– le code de phi4 utilise la fonction find qui est sans doute plus naturelle et plus simple `a utiliser :
sur un vecteur de bool´eens b elle renvoie un vecteur contenant les indices i tels que b(i)=%t (la
matrice vide si toutes les composantes sont fausses). Exemple :
-->x = rand(1,6)
x =
! 0.8497452 0.6857310 0.8782165 0.0683740 0.5608486 0.6623569 !
-->ind = find( 0.3<x & x<0.7 )
ind =
! 2. 5. 6. !
Sur une matrice bool´eenne A vous obtenez la mˆeme liste en consid´erant que la matrice est un
« grand » vecteur o` u les ´el´ements de A ont ´et´e r´eordonn´es « colonne par colonne ». Il est cependant
possible avec un deuxi`eme argument de sortie de r´ecup´erer la liste des indices de ligne et de colonne :
18
dans lesquels la fonction bool2s permet de convertir une matrice de bool´eens en matrice de r´eels (vrai donnant 1 et
faux 0)
58
-->A = rand(2,2)
A =
! 0.7263507 0.5442573 !
! 0.1985144 0.2320748 !
-->[il,ic]=find(A<0.5)
ic = ! 1. 2. !
il = ! 2. 2. !
Voici maintenant le code de la fonction phi4 :
function [y]=phi4(t,a,b,c)
// on utilise la fonction find plus naturelle
t_le_b = ( t <= b )
indices_a_b = find( a<t & t_le_b )
indices_b_c = find( ~t_le_b & t<c )
y = zeros(t)
y(indices_a_b) = (t(indices_a_b) - a)/(b - a)
y(indices_b_c) = (c - t(indices_b_c))/(c - b)
endfunction
Conclusion : si vos calculs commencent `a ˆetre trop longs, essayer de les « vectoriser ». Si cette vecto-
risation est impossible ou insuffisante il ne reste plus qu’`a ´ecrire les parties cruciales en C ou en fortran
77.
3.8 Exercices
1.
´
Ecrire une fonction pour r´esoudre un syst`eme lin´eaire o` u la matrice est triangulaire sup´erieure. On
pourra utiliser l’instruction size qui permet de r´ecup´erer les deux dimensions d’une matrice :
[n,m]=size(A)
Dans un premier temps, on programmera l’algorithme classique utilisant deux boucles, puis on es-
saiera de remplacer la boucle interne par une instruction matricielle. Pour tester votre fonction, vous
pourrez g´en´erer une matrice de nombres pseudo-al´eatoires et n’en garder que la partie triangulaire
sup´erieure avec l’instruction triu :
A=triu(rand(4,4))
2. La solution du syst`eme d’´equations diff´erentielles du 1
er
ordre :
dx
dt
(t) = Ax(t), x(0) = x
0
∈ R
n
, x(t) ∈ R
n
, A ∈ /
nn
(R)
peut ˆetre obtenue en utilisant l’exponentielle de matrice (cf votre cours d’analyse de 1
`ere
ann´ee) :
x(t) = e
At
x
0
Comme Scilab dispose d’une fonction qui calcule l’exponentielle de matrice (expm), il y a sans
doute quelque chose `a faire. On d´esire obtenir la solution pour t ∈ [0, T]. Pour cela, on peut la
calculer en un nombre n suffisamment grand d’instants uniform´ement r´epartis dans cet intervalle
t
k
= kδt, δt = T/n et l’on peut utiliser les propri´et´es de l’exponentielle pour all´eger les calculs :
x(t
k
) = e
Akδt
x
0
= e
k(Aδt)
x
0
= (e
Aδt
)
k
x
0
= e
Aδt
x(t
k−1
)
ainsi il suffit uniquement de calculer l’exponentielle de la matrice Aδt puis de faire n multiplications
« matrice vecteur » pour obtenir x(t
1
), x(t
2
), . . . , x(t
n
).
´
Ecrire un script pour r´esoudre l’´equation
diff´erentielle (un oscillateur avec amortissement) :
x

+αx

+kx = 0, avec par exemple α = 0.1, k = 1, x(0) = x

(0) = 1
59
que l’on mettra ´evidemment sous la forme d’un syst`eme de deux ´equations du premier ordre.
`
A la fin
on pourra visualiser la variation de x en fonction du temps, puis la trajectoire dans le plan de phase.
On peut passer d’une fenˆetre graphique `a une autre avec l’instruction xset("window",window-number).
Par exemple :
--> //fin des calculs
--> xset(‘‘window’’,0) // on selectionne la fenetre numero 0
--> instruction pour le premier graphe (qui s’affichera sur la fenetre 0)
--> xset(‘‘window’’,1) // on selectionne la fenetre numero 1
--> instruction pour le deuxieme graphe (qui s’affichera sur la fenetre 1)
3.
´
Ecrire une fonction [i,info]=intervalle_de(t,x) pour d´eterminer l’intervalle i tel que x
i
≤ t ≤
x
i+1
par la m´ethode de la dichotomie (les composantes du vecteur x ´etant telles que x
i
< x
i+1
). Si
t / ∈ [x
1
, x
n
], la variable bool´eenne info devra ˆetre ´egale `a %f (et %t dans le cas inverse).
4. R´ecrire la fonction myhorner pour quelle s’adapte au cas o` u l’argument t est une matrice (la fonction
devant renvoyer une matrice p (de mˆeme taille que t) o` u chaque coefficient (i, j) correspond `a
l’´evaluation du polynˆome en t(i,j)).
5.
´
Ecrire une fonction [y] = signal_fourier(t,T,cs) qui renvoie un d´ebut de s´erie de Fourier en
utilisant les fonctions :
f
1
(t, T) = 1, f
2
(t, T) = sin(
2πt
T
t), f
3
(t, T) = cos(
2πt
T
), f
4
(t, T) = sin(
4πt
T
), f
5
(t, T) = cos(
4πt
T
),
au lieu des exponentielles. T est un param`etre (la p´eriode) et le signal sera caract´eris´e (en dehors
de sa p´eriode) par le vecteur cs de ces composantes dans la base f
1
, f
2
, f
3
, . On r´ecup`erera le
nombre de fonctions `a utiliser `a l’aide de l’instruction length appliqu´ee sur cs. Il est recommand´e
d’utiliser une fonction auxiliaire [y]=f(t,T,k) pour calculer f
k
(t, T). Enfin tout cela doit pouvoir
s’appliquer sur un vecteur (ou une matrice) d’instants t, ce qui permettra de visualiser facilement
un tel signal :
--> T = 1 // une periode ...
--> t = linspace(0,T,101) // les instants ...
--> cs = [0.1 1 0.2 0 0 0.1] // un signal avec une composante continue
--> // du fondamental, pas d’harmonique 1 (periode 2T) mais une harmonique 2
--> [y] = signal_fourier(t,T,cs); // calcul du signal
--> plot(t,y) // et un dessin ...
6. Voici une fonction pour calculer le produit vectoriel de deux vecteurs :
function [v]=prod_vect(v1,v2)
// produit vectoriel v = v1 /\ v2
v(1) = v1(2)*v2(3) - v1(3)*v2(2)
v(2) = v1(3)*v2(1) - v1(1)*v2(3)
v(3) = v1(1)*v2(2) - v1(2)*v2(1)
endfunction
Vectoriser ce code de mani`ere `a calculer dans une mˆeme fonction function [v]=prod_vect_v(v1,v2)
les produits vectoriels v
i
= v
i
1
∧v
i
2
o` u v
i
, v
i
1
et v
i
2
d´esigne la i
`eme
colonne des matrices (3,n) contenant
ces vecteurs.
7. La rencontre : Mr A et Mlle B ont d´ecid´e de se donner rendez-vous entre 17 et 18h. Chacun
arrivera au hasard, uniform´ement et ind´ependamment l’un de l’autre, dans l’intervalle [17, 18]. Mlle
B attendra 5 minutes avant de partir, Mr A 10 minutes.
(a) Quelle est la probabilit´e qu’ils se rencontrent ? (rep 67/288)
(b) Retrouver (approximativement) ce r´esultat par simulation : ´ecrire une fonction [p] = rdv(m)
renvoyant la probabilit´e empirique de la rencontre obtenue avec m r´ealisations.
(c) Exp´erimenter votre fonction avec des valeurs de m de plus en plus grande.
60
Chapitre 4
Les graphiques
Dans ce domaine, Scilab poss`ede de nombreuses possibilit´es qui vont de primitives de bas niveau
1
, `a
des fonctions plus compl`etes qui permettent en une seule instruction de tracer toutes sortes de graphiques
types. Dans la suite, j’explique seulement une petite partie de ces possibilit´es.
4.1 G´en´eralit´es sur le nouveau graphique
Il faut savoir que scilab dispose, depuis la version 3.0, d’un nouveau mode graphique ne fonctionnant
pas de la mˆeme mani`ere que l’ancien mode
2
. Dans ce chapitre on va essayer d’apprendre `a utiliser ce
nouveau syst`eme.
Au passage, ce nouveau mode apporte une petite compatibilit´e avec le graphique Matlab avec les
´emulations des deux fonctions plot et surf. Cependant si vous connaissez le graphique de Matlab vous
pouvez avoir int´erˆet `a utiliser la contribution plotlib de St´ephane Mottelet :
http://www.dma.utc.fr/~mottelet/myplot.html
Dans ce cas vous devrez travailler uniquement avec les instructions offertes par cette contribution et la
suite de ce chapitre n’est pas tr`es utile pour vous.
4.1.1 principes de base
Le nouveau mode graphique repose sur une structure hi´erarchique d’objets dont la racine est la fenˆetre
graphique. Dans une fenˆetre vous pouvez cr´eer plusieurs objets de type syst`eme d’axes de coordonn´ees
(qui sont donc fils de leur fenˆetre) et les axes contiennent `a leur tour les objets graphiques de base comme
des lignes polygonales, des collections de triangles (Fec), des chaˆınes de caract`eres, etc... En g´en´eral les
instructions de haut niveau comme plot ou plot2d rassemblent les objets de base qu’elles cr´eent dans
un seul objet de type composition
3
(cf figure 4.1).
Chaque objet graphique peut ˆetre rep´er´e par un identificateur unique (appel´e handle) qui permet de
modifier les propri´et´es de cet objet (par exemple la couleur d’une ligne polygonale, la fonte utilis´ee pour
une chaˆıne de caract`eres, etc...) et aussi d’acc´eder `a ses fils
4
ainsi qu’`a son p`ere.
Parmi ces objets graphiques, il en existe deux qui ne sont jamais dessin´es mais qui servent de mod`eles
pour le niveau figure et le niveau axes : la fenˆetre par d´efaut et le syst`eme d’axes par d´efaut. En modifiant
ces objets, vous pouvez vous cr´eer un style pr´ecis qui s’appliquera alors automatiquement sur vos dessins
ult´erieurs, vous ´evitant de fastidieuses manipulations avec les handles graphiques
5
. Ce m´ecanisme est
assez pratique, surtout si les valeurs par d´efaut ne vous conviennent pas
6
.
1
exemples : trac´es de rectangles, de polygones (avec ou sans remplissage), r´ecup´erer les coordonn´ees du pointeur de la
souris
2
voir ` a la fin de ce chapitre quelques remarques
3
composition est mon essai traduction en fran¸ cais de “compound” et cet objet s’appelait “agregation” jusqu’` a la version
3.1.1.
4
pour des objets non basiques comme les fenˆetres, les axes et les compositions
5
ces manipulations se faisant alors une seule fois sur ces objets par d´efaut
6
par exemple la taille des titres (une propri´et´e du niveau axes) est par d´efaut assez petite
61
fenêtre
figure
système d’axes
axes
ligne polygonale
polyline
ligne polygonale
polyline
chaîne de caractères
text
ligne polygonale
polyline
surface
surface
chaîne de caractères
text
système d’axes
axes
compound
composition
Fig. 4.1 – Le nouveau graphique `a objets
4.1.2 les fenˆetres graphiques
Comme dans l’ancien mode on peut facilement travailler avec plusieurs fenˆetres graphiques. Noter
que parmi ces fenˆetres il y en a une seule, appel´ee fenˆetre courante ou encore fenˆetre active, qui peut
recevoir les ordres graphiques. Pour jongler avec plusieurs fenˆetres graphiques on utilise les commandes
suivantes :
scf(num) la fenˆetre courante devient la fenˆetre de num´ero num ;
si cette fenˆetre n’existait pas, elle est cr´e´ee par Scilab.
xselect() met en « avant » la fenˆetre courante ;
si aucune fenˆetre graphique n’existe, Scilab en cr´ee une.
clf([num]) efface la fenˆetre graphique num´ero num ;
si num est omis, Scilab efface la fenˆetre courante.
xdel([num]) d´etruit la fenˆetre graphique num´ero num ;
si num est omis, Scilab d´etruit la fenˆetre courante.
Quelques commentaires :
– scf(num) renvoie le handle de la fenˆetre, on peut ainsi ´ecrire hf = scf(num) (rmq : hf = gcf()
permet de r´ecup´erer le handle de la fenˆetre courante) ;
– la syntaxe xdel([num]) est celle de l’ancien mode graphique
7
; pour avoir le mˆeme effet avec une
syntaxe nouveau mode il faut utiliser delete(hf) o` u hf est le handle de la fenˆetre en question.
– quand on lance une commande comme plot, plot2d, plot3d ... alors qu’aucune fenˆetre gra-
phique n’est activ´ee, Scilab choisit de mettre le dessin dans la fenˆetre de num´ero 0.
4.2 l’intruction plot
Cette instruction, qui se veut une ´emulation de la fonction Matlab de mˆeme nom, est assez simple `a
utiliser. Voici quelques exemples :
x=linspace(-1,1,61);
y = x.^2;
plot(x,y)
7
mais fonctionne aussi pour le nouveau mode, au moins pour la version 3.1.1.
62
Rajoutons maintenant une autre courbe :
ybis = 1 - x.^2;
plot(x,ybis)
xtitle("Courbes...") // je rajoute un titre
Continuons avec une troisi`eme courbe qui ne tient pas dans l’´echelle
8
pr´ec´edente :
yter = 2*y;
plot(x,yter)
on remarque que Scilab a chang´e l’´echelle pour s’adapter `a la troisi`eme courbe et que les courbes
pr´ec´edentes ont ´et´e redessin´ees dans cette nouvelle ´echelle.
Il est possible d’afficher les 3 courbes simultan´ement, en pr´ecisant aussi la couleur utilis´ee :
clf() // pour effacer la fen^etre courante
plot(x,y,"b",x,ybis,"r",x,yter,"g")
xtitle("Courbes...","x","y") // un titre plus une l´egende pour les deux axes
legend("x^2","1-x^2","2x^2") // une l´egende pour les courbes
et vous devez obtenir quelque chose qui ressemble `a la figure 4.2.
−1.0 −0.8 −0.6 −0.4 −0.2 0.0 0.2 0.4 0.6 0.8 1.0
0.0
0.2
0.4
0.6
0.8
1.0
1.2
1.4
1.6
1.8
2.0
Courbes...
x
y
x^2
1−x^2
2x^2
Fig. 4.2 – Les fonctions x
2
, 1 −x
2
et 2x
2
Pour afficher simultan´ement plusieurs courbes, l’instruction prend donc la forme :
plot(x1,y1[,style1],x2,y2[,style2], ....)
o` u style est une chaˆıne de caract`eres pr´ecisant la couleur. En rajoutant d’autres caract`eres on peut aussi
sp´ecifier le type du trait (trait plein, traits pointill´es) ou bien encore le symbole utilis´e pour dessiner les
points (x
i
, y
i
), essayer par exemple :
clf() // pour effacer
plot(x,y,"b--",x,ybis,"ro",x,yter,"gx")
Voici les possibilit´es actuelles pour ces caract`eres de style :
8
Par ´echelle on sous-entend le rectangle de visualisation et ´eventuellement des propri´et´es suppl´ementaires.
63
les couleurs
k noir c cyan
b bleu m magenta
r rouge y jaune
g vert w blanc
les types de traits
- trait plein
-- tirets
: pointill´es
-. tiret-point, etc...
les symboles
+ + ^ ´ s
x v _ .
o _ > * ∗
d ♦ < pentagram
Remarques :
– il est possible de tracer simultan´ement une ligne avec des symboles en combinant couleur, style et
symbole, par exemple "b--o" doit donner une ligne tiret´ee avec un cercle pour chaque point ;
– pour obtenir d’autres couleurs, il faudra r´ecup´erer le handle de la ligne et changer sa propri´et´e
foreground.
4.3 modifier quelques propri´et´es des graphiques
Nous allons voir maintenant comment r´egler certains param`etres qui ne peuvent l’ˆetre via la com-
mande plot. En g´en´eral il faudra r´ecup´erer au pr´ealable le handle du syst`eme d’axes contenant le gra-
phique, ce qui s’obtient avec ha = gca() (gca pour get current axes). Notez que toutes les manipulations
qui vont suivre peuvent se faire avec l’´editeur graphique qui se lance `a partir du menu edit de chaque
fenˆetre graphique. Cependant dans de nombreux cas, il est plus pratique de modifier les propri´et´es `a
partir de code scilab mˆeme si l’´editeur reste pratique pour explorer les diverses possibilit´es.
1. choisir le rectangle de visualisation : reprenons l’exercice 6 du chapitre 2, petite illustration
de la loi des grands nombres ; une solution possible est :
m = 1000;
x = rand(1,m);
xm = cumsum(x)./(1:m);
clf();
plot(1:m,xm,"b")
mais le graphe obtenu n’est pas satisfaisant car pour illustrer pleinement le ph´enom`ene, l’intervalle
des ordonn´ees doit ˆetre [0, 1]. Pour cela, il faut donner `a la propri´et´e data bounds de l’objet syst`eme
d’axes la valeur du rectangle de visualisation sous la forme d’une matrice :
_
x
min
y
min
x
max
y
max
_
m = 1000;
x = rand(1,m);
xm = cumsum(x)./(1:m);
clf();
plot(1:m,xm,"b")
a = gca(); // on r´ecup`ere le handle du syst`eme d’axes
a.data_bounds = [1,0;m,1]; // on impose l’´echelle
2. imposer une ´echelle isom´etrique : tr`es pratique pour dessiner des figures g´eom´etriques, elle
s’obtient en positionnant la propri´et´e isoview
9
des axes sur "on". Voici un exemple (cf figure 4.3) :
t = linspace(0,2*%pi,60)’;
x1 = 2*cos(t); y1 = sin(t); // une ellipse
x2 = cos(t); y2 = y1; // un cercle
x3 = linspace(-2,2,60)’; y3 = erf(x3); // la fct erreur
clf();
drawlater()
plot(x1, y1,"b", x2, y2, "r", x3, y3, "m")
9
qui vaut "off" par d´efaut
64
a = gca();
a.isoview = "on"; // l’echelle devient alors isom´etrique
legend("ellipse","cercle","fct erreur")
xtitle("Encore des courbes ...","x","y")
drawnow()
qui utilise aussi deux nouvelles instructions drawlater() et drawnow(). Elles ne sont pas obliga-
toires mais elles ´evitent `a Scilab de redessiner syst´ematiquement le graphique en cours de construc-
tion : sans elles, le graphe serait affich´e une premi`ere fois lors du plot, puis une deuxi`eme lors du
changement de l’´echelle, et finalement une troisi`eme et une quatri`eme fois fois lors du rajout de
la l´egende puis du titre. Dans notre cas leur absence ne serait pas trop p´enalisante mais si vous
dessinez un graphique plus cons´equent, ces r´eaffichages syst´ematiques (et pas tous utiles) sont assez
p´enibles.
−2.0 −1.5 −1.0 −0.5 0.0 0.5 1.0 1.5 2.0
−1.0
−0.5
0.0
0.5
1.0
Encore des courbes ...
x
y
ellipse
cercle
fct erreur
Fig. 4.3 – Ellipse, cercle et erf
3. utiliser une ´echelle logarithmique : cette fois il faut r´egler la propri´et´e log flags de l’objet
syst`eme d’axes. C’est une chaˆıne de deux caract`eres chacun pouvant prendre la valeur ”n” (non
log) ou ”l” (log), le premier caract`ere r`egle le comportement sur l’axe des x, le deuxi`eme celui de
l’axe des y. Voici un exemple (cf figure 4.4) :
x = logspace(0,4,200)’;
y = 1 ./x;
clf()
drawlater()
subplot(1,2,1)
plot(x, y, "b"); a1=gca(); a1.log_flags="ln";
xtitle("log_flags=""ln""")
subplot(1,2,2)
plot(x, y, "b"); a2=gca(); a2.log_flags="ll";
xtitle("log_flags=""ll""")
drawnow()
Cet exemple vous montre aussi comment dessiner plusieurs graphes dans la mˆeme fenˆetre graphique
en utilisant l’instruction subplot(m, n, num). Le param`etre m correspond `a la d´ecoupe verticale (en
65
0
10
1
10
2
10
3
10
4
10
0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
log_flags="ln"
0
10
1
10
2
10
3
10
4
10
−4
10
−3
10
−2
10
−1
10
0
10
log_flags="ll"
Fig. 4.4 – ´echelles semilog et loglog
m parts ´egales), n `a la d´ecoupe horizontale, et num au num´ero de la sous-fenˆetre s´electionn´ee parmi
les mn, les sous-fenˆetres ´etant num´erot´ees de la gauche vers la droite puis de haut en bas (ainsi
la sous-fenˆetre en position (i, j) a le num´ero n (i −1) + j). En fait rien n’interdit de modifier la
grille au fur et `a mesure des subplot pour obtenir ce que l’on cherche. Par exemple, avec :
clf()
subplot(1,2,1)
titlepage("`a gauche")
subplot(3,2,2)
titlepage(["`a droite";"en haut"])
subplot(3,2,4)
titlepage(["`a droite";"au centre"])
subplot(3,2,6)
titlepage(["`a droite";"en bas"])
xselect()
on scinde la fenˆetre verticalement en deux parties (gauche/droite), la sous-fenˆetre de droite ´etant
d´ecoup´ee horizontalement en trois parts. Il faut en fait comprendre subplot comme une directive
qui permet de s´electionner une portion de la fenˆetre graphique.
4. modifier le placement des axes : cela s’obtient en jouant avec les propri´et´es x location et
y location du syst`eme d’axes contenant le graphique :
x location placement obtenu
"bottom" en bas
"top" en haut
"middle" en y = 0 si possible
y location placement obtenu
"left" `a gauche bas
"right" `a droite
"middle" en x = 0 si possible
Voici un exemple (cf figure 4.5) :
x = linspace(-14,14,300)’;
y = sinc(x);
clf()
plot(x, y, "b");
a = gca();
a.x_location = "middle"; a.y_location = "middle";
a.title.text = "La fonction sinus cardinal";
66
Cet exemple vous montre aussi une autre fa¸con de mettre le titre. En fait l’objet syst`eme d’axes
de coordonn´ees contient un grand nombre de propri´et´es qui sont explicit´ees dans la page d’aide
d´enomm´ee axes properties.
−15 −10 −5 0 5 10 15
−0.4
−0.2
0.0
0.2
0.4
0.6
0.8
1.0
La fonction sinus cardinal
Fig. 4.5 – placement des axes en y = 0 et x = 0
5. modifier les propri´et´es d’une courbe : pour cela il faut r´ecup´erer le handle de la courbe
qui vous int´eresse ce qui n’est pas forc´ement ´evident. Une instruction comme plot « enrobe »ses
courbes dans un objet composition dans l’ordre inverse de celui que l’on a donn´e au d´epart. Les
courbes
10
sont donc filles de cette composition. D’autre part, `a l’instar de la fenˆetre courante
11
et
du syst`eme d’axes courant, il existe aussi la notion d’entit´e courante et justement, apr`es un plot,
l’entit´e courante est la composition de nos courbes. Ces quelques explications devraient vous aider
`a comprendre les manipulations suivantes :
x = linspace(0,15,200)’;
y = besselj(1:4,x);
clf()
drawlater()
plot(x,y(:,1),"b", x, y(:,2),"r", x,y(:,3),"g", x,y(:,4),"c")
e = gce(); // l’identificateur de la composition des 4 courbes
// (le handle du compound des 4 courbes)
e.children(1).thickness = 3; // on change l’´epaisseur de la
// courbe en cyan (la 4 eme)
e.children(2).foreground =19; // on change la couleur de la
// courbe initialement verte (la 3 eme)
e.children(3).line_style = 2; // on change le style de la
// courbe en rouge (la 2 eme)
legend("J"+string(1:4));
xtitle("Quelques fonctions de Bessel")
xgrid(12)
drawnow()
10
qui sont des objets de type ligne polygonale
11
on peut r´ecup´erer son handle avec f=gcf()
67
Qui devraient vous permettre d’obtenir la figure 4.6. Quelques remarques :
– Ici chaque enfant (children(1), children(2), ...) est un objet ligne polygonale ; vous trouverez
l’ensemble des propri´et´es `a la page d’aide polyline properties.
– Les couleurs se choisissent avec des num´eros relatifs `a la carte des couleurs courantes (voir un
peu plus loin) ; avec la carte par d´efaut, 19 doit correspondre `a du brun.
– line style doit ˆetre ´egal `a 1 pour une ligne continue et les valeurs sup´erieures donnent diff´erents
style de lignes pointill´ees.
– la fonction xgrid permet de rajouter une grille et son argument (on peut ne pas en mettre) est
le num´ero de sa couleur.
0 5 10 15
−0.4
−0.3
−0.2
−0.1
0.0
0.1
0.2
0.3
0.4
0.5
0.6
Quelques fonctions de Bessel
J1
J2
J3
J4
Fig. 4.6 – Bessels
4.4 l’instruction plot2d
Cette instruction est plus difficile `a utiliser que plot mais elle permet de sp´ecifier certains param`etres
(r´eglages concernant l’´echelle par exemple) sans avoir `a utiliser le handle du syst`eme d’axes du graphique.
La syntaxe g´en´erale a la forme :
plot2d(Mx,My <,opt_arg>*)
o` u :
– Mx et My sont respectivement la matrice des abscisses et celle des ordonn´ees, la k
`eme
courbe ´etant
constitu´ee par les k
`eme
colonnes
12
de Mx et My ; d’autre part, si toutes les courbes ont les mˆemes
abscisses, on a pas `a dupliquer le vecteur des abscisses : par exemple pour afficher x,y1, x,y2, x,y3,
on utilisera plot2d(x,[y1 y2 y3],...) si bien sˆ ur tous ces vecteurs sont des vecteurs colonnes.
– <,opt_arg>* d´esigne l’´eventuelle s´equence des arguments optionnels opt_arg prenant la forme
13
:
mot cl´e=valeur
la s´equence pouvant ˆetre mise dans n’importe quel ordre.
Nous allons exp´erimenter les principales options en essayant de reproduire les graphiques cr´e´es
pr´ec´edemment avec plot, mais auparavant voici quelques remarques :
12
il faut faire attention ` a ce d´etail car avec plot, les vecteurs d’abscisses ou d’ordonn´ees pouvent ˆetre indiff´eremment
des vecteurs lignes ou colonnes ; ainsi lors de la cr´eation du vecteur des abscisses, il sera souvent pratique d’utiliser x =
linspace(a,b,n)’, ou encore x = (a :dx :b)’
13
en fait argument formel=argument effectif
68
– la contrainte de mettre plusieurs courbes dans les matrices Mx et My implique qu’il est impossible de
dessiner des courbes avec des discr´etisations diff´erentes (n points pour l’une et m ,= n pour l’autre)
avec un seul appel `a plot2d ;
– choisir le style pour chaque courbe est plus difficile qu’avec plot ;
– par contre le fait de pouvoir r´egler des param`etres d’´echelle donne, en g´en´eral, un code moins long
14
qu’avec plot ; enfin plot2d s’ex´ecute plus rapidement que plot.
1. choisir les couleurs et ou les symboles : il faut utiliser style=vec o` u vec doit contenir autant
de composantes qu’il y a de courbes et si vec(i) est un entier strictement positif, on obtient une
ligne continue de couleur num´ero i et si i est n´egatif ou nul, il s’agit d’un symbole qui sera dessin´e
dans la couleur courante du syst`eme d’axes.
clf()
x=linspace(-1,1,61)’;
y = x.^2;
ybis = 1 - x.^2;
yter = 2*y;
plot2d(x,[y ybis yter], style=[2 5 3])
xtitle("Courbes...","x","y")
legend("x^2","1-x^2","2x^2")
Voici quelques couleurs de la carte par d´efaut :
1 noir 5 rouge vif 23 violet
2 bleu 6 mauve 26 marron
3 vert clair 13 vert fonc´e 19 brun
4 cyan 16 bleu turquoise 32 jaune orang´e
Pour ´eviter de retenir ces num´eros, il existe la fonction color qui prend en entr´ee, soit une chaˆıne
de caract`eres ("blue","yellow","red", etc
15
...), soit 3 entiers donnant la d´efinition d’une couleur
par ses intensit´es en rouge, en vert et en bleu. Cette fonction retourne l’identificateur de la couleur
dans la carte courante (si la couleur en question manque, elle est rajout´ee dans la carte).
2. sp´ecifier l’´echelle : pour choisir le rectangle de visualisation, on utilise la combinaison rect=val,
mais attention, val est ici le vecteur [x
min
, y
min
, x
max
, y
max
] (ne pas mettre de ; entre y
min
et x
max
comme pour r´egler la propri´et´e data bounds ! ! ! !)
m = 1000;
x = rand(1,m);
xm = cumsum(x)./(1:m);
clf();
plot2d((1:m)’,xm’, style=color("blue"), rect=[1,0,m,1])
Quant `a l’´echelle isom´etrique, on peut l’obtenir avec la combinaison frameflag=val o` u val doit
prendre la valeur 4 (´echelle iso obtenue `a partir des maxima et minima des donn´ees) :
t = linspace(0,2*%pi,60)’;
x1 = 2*cos(t); y1 = sin(t); // une ellipse
x2 = cos(t); y2 = y1; // un cercle
x3 = linspace(-2,2,60)’; y3 = erf(x3); // la fct erreur
clf();
plot2d([x1 x2 x3],[y1 y2 y3],style=[2 5 6], frameflag=4)
legend("ellipse","cercle","fct erreur")
xtitle("Encore des courbes ...","x","y")
14
cf les exemples suivants, mais souvent le code pour plot2d est plus difficile ` a ´ecrire : il faut aller voir la documentation
pour se souvenir des valeurs des param`etres...)
15
La page d’aide color list vous donnera toutes les couleurs reconnues.
69
Voici les valeurs possibles pour ce param`etre (dans certains cas frameflag peut ˆetre accompagn´e du
param`etre rect) :
frameflag=0 on utilise l’´echelle pr´ec´edente (ou par d´efaut)
frameflag=1 ´echelle donn´ee par rect
frameflag=2 ´echelle calcul´ee via les les max et min de Mx et My
frameflag=3 ´echelle isom´etrique calcul´ee en fonction de rect
frameflag=4 ´echelle isom´etrique calcul´ee via les max et min de Mx et My
frameflag=5 idem `a 1 mais avec adaptation eventuelle pour graduation
frameflag=6 idem `a 2 mais avec adaptation eventuelle pour la graduation
frameflag=7 idem `a 1 mais les courbes pr´ec´edentes sont redessin´ees
frameflag=8 idem `a 2 mais les courbes pr´ec´edentes sont redessin´ees
3. le placement des axes s’obtient avec la combinaison axesflag=val :
x = linspace(-14,14,300)’;
y = sinc(x);
clf()
plot2d(x, y, style=2, axesflag=5)
xtitle("La fonction sinc")
Voici le tableau donnant les diverses possibilit´es :
axesflag=0 pas de boite, ni d’axes et de graduations
axesflag=1 avec boite, axes et graduations (les x en bas, les y `a gauche)
axesflag=2 avec boite mais sans axes ni graduations
axesflag=3 avec boite, axes et graduations (les x en bas, les y `a droite)
axesflag=4 sans boite mais avec axes et graduations (trac´es vers le milieu)
axesflag=5 sans boite mais avec axes et graduations (trac´es en y = 0 et x = 0)
4. utiliser une ´echelle logarithmique : la s´equence correspondante est logflag=str o` u str est la
mˆeme chaˆıne de deux caract`eres chacun pouvant prendre la valeur ”n” (non log) ou ”l” (log) :
x = logspace(0,4,200)’;
y = 1 ./x;
clf()
subplot(1,2,1)
plot2d(x, y, style=2, logflag= "ln")
xtitle("logflag=""ln""")
subplot(1,2,2)
plot2d(x, y, style=2, logflag= "ll")
xtitle("logflag=""ll""")
5. le mot cl´e strf : il permet de remplacer `a la fois frameflag et axesflag, et, pour des raisons
de compatibilit´e avec l’ancienne fa¸con d’utiliser plot2d, il contient aussi un drapeau (flag) pour
l’utilisation de la l´egende ou non. La valeur `a donner est une chaˆıne de trois caract`eres "xyz" avec :
x ´egal `a 0 (pas de l´egende) ou 1 (l´egende `a fournir avec la combinaison leg=val) ;
y entre 0 et 9, correspond `a la valeur `a donner pour frameflag ;
z entre 0 et 5, correspond `a la valeur `a donner pour axesflag.
En fait il faut savoir l’utiliser car les s´equences optionnelles de nombreuses primitives de dessin
ne disposent pas encore des mots cl´es frameflag et axesflag. De plus il reste tr`es pratique lorsque
vous voulez rajouter un dessin sur un autre sans modifier l’´echelle et le cadre ce qui s’obtient avec
strf="000" (et ´evite donc d’´ecrire frameflag=0, axesflag=0).
70
4.5 Des variantes de plot2d : plot2d2, plot2d3
Elles s’utilisent exactement comme plot2d : mˆeme syntaxe avec les mˆemes arguments optionnels.
1. plot2d2 permet de dessiner des fonctions en escalier : au lieu de tracer un segment de droite entre
les points (x
i
, y
i
) et (x
i+1
, y
i+1
), plot2d2 trace un segment horizontal (entre (x
i
, y
i
) et (x
i+1
, y
i
))
puis un segment vertical (entre (x
i+1
, y
i
) et (x
i+1
, y
i+1
)). Voici un exemple (cf figure (4.7)) :
n = 10;
x = (0:n)’;
y = x;
clf()
plot2d2(x,y, style=2, frameflag=5, rect=[0,-1,n+1,n+1])
xtitle("plot2d2")
0 2 4 6 8 10 12
−2
0
2
4
6
8
10
12
plot2d2
Fig. 4.7 – illustration pour plot2d2
2. plot2d3 dessine des diagrammes en bˆatons : pour chaque point (x
i
, y
i
) plot2d3 trace un segment
vertical entre (x
i
, 0) et (x
i
, y
i
) ; voici un exemple (cf figure (4.8)) :
n = 6;
x = (0:n)’;
y = binomial(0.5,n)’;
clf()
drawlater()
plot2d3(x,y, style=2, frameflag=5, rect=[-1,0,n+1,0.32])
e = gce();
e.children(1).thickness = 4;
xtitle("Probabilit´es pour la loi binomiale B(6,1/2)")
drawnow()
4.6 Dessiner plusieurs courbes qui n’ont pas le mˆeme nombre de
points
Contrairement `a plot, avec plot2d et ses variantes, on ne peut pas dessiner en une seule fois plusieurs
courbes qui n’ont pas ´et´e discr´etis´ees avec le mˆeme nombre d’intervalles et l’on est oblig´e d’utiliser
71
−1 0 1 2 3 4 5 6 7
0.00
0.05
0.10
0.15
0.20
0.25
0.30
0.35
Probabilités pour la loi binomiale B(6,1/2)
Fig. 4.8 – illustration pour plot2d3
plusieurs appels successifs. Depuis la version 2-6, on peut se passer de sp´ecifier l’´echelle sans mauvaise
surprise puisque, par d´efaut (frameflag=8) les courbes pr´ec´edentes sont redessin´ees en cas de changement
d’´echelle. Cependant si on veut maˆıtriser l’´echelle, il faut la fixer lors du premier appel puis utiliser
frameflag=0 pour les appels suivants
16
. Voici un exemple (cf figure (4.9)) :
x1 = linspace(0,1,61)’;
x2 = linspace(0,1,31)’;
x3 = linspace(0.1,0.9,12)’;
y1 = x1.*(1-x1).*cos(2*%pi*x1);
y2 = x2.*(1-x2);
y3 = x3.*(1-x3) + 0.1*(rand(x3)-0.5); // idem a y2 avec une perturbation
ymin = min([y1 ; y2 ; y3]); ymax = max([y1 ; y2 ; y3]);
dy = (ymax - ymin)*0.05; // pour se donner une marge
rect = [0,ymin - dy,1,ymax+dy]; // fenetre de visualisation
clf() // effacement des graphiques precedents
drawlater()
plot2d(x1, y1, style=5, frameflag=5, rect=rect) // 1er appel qui impose l’´echelle
plot2d(x2, y2, style=2, frameflag=0) // 2eme et 3 eme appel :
plot2d(x3, y3, style=-1,frameflag=0) // on utilise l’echelle precedente
xtitle("Des courbes...","x","y")
legend("x(1-x)*cos(pi x)","x(1-x)","x(1-x) + bruit");
drawnow()
Rmq : essayer cet exemple avec frameflag=1 au lieu de 5.
16
cette m´ethode est obligatoire si on veut une ´echelle isom´etrique.
72
0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1.0
−0.3
−0.2
−0.1
0.0
0.1
0.2
0.3
0.4
Des courbes...
x
y
x(1−x)*cos(pi x)
x(1−x)
x(1−x) + bruit
Fig. 4.9 – Encore des courbes...
4.7 Jouer avec le syst`eme d’axes par d´efaut
Dans l’introduction sur le nouveau syst`eme graphique de scilab, on a parl´e d’une figure par d´efaut
et d’un syst`eme d’axes par d´efaut, mais `a quoi peuvent-ils bien servir ? En fait il contiennent toutes les
valeurs par d´efaut des diff´erentes propri´et´es de toute figure et de tout syst`eme d’axes. Ainsi en modifiant
le syst`eme d’axes par d´efaut vous pouvez r´egler les propri´et´es de tous les axes qui seront cr´e´es par la suite.
Il est ainsi assez facile de se cr´eer son propre style graphique. Avant de donner un exemple, regardons
les fontes dont scilab dispose, les styles et les tailles se rep`erent avec des entiers :
nom de la fonte identificateur
Courier 0
Symbol 1
Times 2
Times-Italic 3
Times-Bold 4
Times-Bold-Italic 5
Helvetica 6
Helvetica-Italic 7
Helvetica-Bold 8
Helvetica-Bold-Italic 9
taille de la fonte identificateur
8 points 0
10 points 1
12 points 2
14 points 3
18 points 4
24 points 5
Pour se rep´erer, rien n’interdit de se cr´eer des variables avec des noms un peu plus parlant, variables
que l’on peut mettre dans son fichier .scilab, par exemple :
%symbol = 1;
%times = 2;
%times_italic = 3;
%times_bold = 4;
%helvetica = 6;
%helvetica_italic = 7;
%helvetica_bold = 8;
%helvetica_bold_italique = 9;
%8pts = 0; %10pts = 1; %12pts = 2;
%14pts = 3; %18pts = 4; %24pts = 5;
Voici un exemple de fonction qui change les propri´et´es par d´efaut :
73
function style1()
sda() // remet `a plat les propri´et´es des axes par d´efaut
a = gda(); // a est le handle sur ces axes par d´efaut
a.title.font_size = %18pts;
a.title.font_style = %helvetica_bold;
a.x_label.font_size = %14pts;
a.x_label.font_style = %helvetica_italic;
a.y_label.font_size = %14pts;
a.y_label.font_style = %helvetica_italic;
a.z_label.font_size = %14pts;
a.z_label.font_style = %helvetica_italic;
a.font_size = %14pts;
endfunction
4.8 Dessiner un histogramme
La fonction scilab ad´equate s’appelle histplot et sa syntaxe est la suivante :
histplot(n, X, <,opt_arg>*)
o` u :
– n est soit un entier, soit un vecteur ligne (avec n
i
< n
i+1
) :
1. dans le cas o` u n est un vecteur ligne, les donn´ees sont comptabilis´ees selon les k classes
C
i
= [n
i
, n
i+1
[ (le vecteur n `a donc k + 1 composantes) ;
2. dans le cas o` u n est un entier, les donn´ees sont comptabilis´ees dans les n classes ´equidistantes :
C
1
= [c
1
, c
2
], C
i
=]c
i
, c
i+1
], i = 2, ..., n, avec
_
_
_
c
1
= min(X), c
n+1
= max(X)
c
i+1
= c
i
+ ∆C
∆C = (c
n+1
−c
1
)/n
– X le vecteur (ligne ou colonne) des donn´ees `a examiner ;
– <,opt arg>* la s´equence des arguments optionnels comme pour plot2d avec cependant la com-
binaison suppl´ementaire normalization = val o` u val est une constante (ou variable ou expression)
bool´eenne (par d´efaut vrai). Lorsque l’histogramme est normalis´e, son int´egrale vaut 1 et approche
donc une densit´e (dans le cas contraire, la valeur d’une plage correspond au nombre de composantes
de X tombant dans cette plage). Plus pr´ecisemment, la plage de l’histogramme correspondant `a
l’intervalle C
i
vaut donc (m ´etant le nombre de donn´ees, et ∆C
i
= n
i+1
−n
i
) :
_
card {X
j
∈C
i
}
m∆C
i
si normalization = vrai
card ¦X
j
∈ C
i
¦ si normalization = faux
Voici un petit exemple, toujours avec la loi normale (cf figure (4.10)) :
X = rand(100000,1,"normal"); classes = linspace(-5,5,21);
clf()
histplot(classes,X)
// on lui superpose le trac´e de la densit´e de N(0,1)
x = linspace(-5,5,60)’; y = exp(-x.^2/2)/sqrt(2*%pi);
plot2d(x,y, style=2, frameflag=0, axesflag=0)
4.9 R´ecup´erer ses graphiques sous plusieurs formats
Ceci est tr`es facile `a partir du menu File de la fenˆetre graphique, en choisissant l’item Export, un
autre menu vous propose diff´erents choix tournant autour du langage postscript ainsi que le format fig
qui permet lui de retravailler son graphique avec le logiciel de dessin vectoriel xfig. Depuis la version 2.5
vous pouvez aussi exporter en gif.
74
−5 −4 −3 −2 −1 0 1 2 3 4 5
0
0.04
0.08
0.12
0.16
0.20
0.24
0.28
0.32
0.36
0.40
Fig. 4.10 – Histogramme d’un ´echantillon de nombres al´eatoires suivants N(0, 1)
4.10 Animations simples
Il est facile de r´ealiser des petites animations avec Scilab qui permet l’utilisation de la technique du
double buffer ´evitant les scintillements ainsi que celle des masques pour faire ´evoluer un objet sur un
fond fixe.
Avec le double buffer, chacun des dessins successifs de l’animation se constitue d’abord dans une
m´emoire (appel´ee pixmap), puis, une fois termin´e, la « pixmap » est bascul´ee `a l’´ecran. Voici le canevas
le plus simple pour une animation en Scilab :
f = gcf(); // on r´ecup`ere le handle de la fen^etre graphique
f.pixmap = "on"; // on met la fen^etre en mode double buffer
for i=1:nb_dessins
clf() // destruction des objets graphiques pr´ec´edents
.......
....... // fabrication du (i eme) dessin dans la pixmap
.......
show_pixmap() // basculement de la pixmap `a l’´ecran
end
f.pixmap = "off"; // on remet la fen^etre en mode usuel
Souvent l’animation se compose de plusieurs ´el´ements graphiques dont certains sont invariables au
cours du temps. Dans ce cas :
– on omet l’instruction clf() ;
– on r´ecup`ere les handles des objets graphiques variables ;
– `a chaque it´eration, on met `a jour le champ data de ces objets ;
– puis on appelle show pixmap().
Notre canevas graphique ressemble alors `a :
f = gcf(); // on r´ecup`ere le handle de la fen^etre graphique
f.pixmap = "on"; // on met la fen^etre en mode double buffer
........... // construction du premier dessin (on r´ecup`ere
e1 = ...... // les handles des objets graphiques variables,
e2 = ...... // ici e1 et e2)
show_pixmap() // basculement de la pixmap `a l’´ecran (pour le premier dessin)
for i=2:nb_dessins
75
e1.data = ..... // modifications des donn´ees de l’objet graphique e1
e2.data = ..... // modifications des donn´ees de l’objet graphique e2
show_pixmap() // basculement de la pixmap `a l’´ecran
end
f.pixmap = "off"; // on remet la fen^etre en mode usuel
Voici un exemple d’animation o` u l’on d´eplace un rectangle (de longueur L et de largeur l) sur un
cercle de rayon r et de centre (0, 0), le rectangle ´etant aussi anim´e d’un mouvement de rotation autour
de son centre de gravit´e. Voici quelques d´etails suppl´ementaires pour vous aider `a comprendre ce script :
– l’´echelle est r´egl´ee uniquement via le handle a du syst`eme d’axes : on passe en mode isom´etrique
et on assure un rectangle de visualisation d’au moins [−1, 1] [−1, 1] ;
– pour vous montrer quelques possibilit´es, je modifie un certain nombre de propri´et´es dont les couleurs
d’arri`ere plan (background) de la figure et du syst`eme d’axes ;
– le rectangle est dessin´e via xfpoly et lorsqu’on r´ecup`ere son handle ep, on en profite pour modifier :
– l’´epaisseur de son contour avec ep.thickness = 5 ;
– la couleur du contour avec ep.foreground = ... ;
– la couleur int´erieure avec ep.background = ... ;
– le cercle est dessin´e via xarc.
n = 4000;
L = 0.6; l = 0.3; r = 0.7;
nb_tours = 4;
t = linspace(0,nb_tours*2*%pi,n)’;
xg = r*cos(t); yg = r*sin(t);
xy = [-L/2 L/2 L/2 -L/2;... // les 4 points du bord
-l/2 -l/2 l/2 l/2];
xselect()
clf(); f = gcf();
f.pixmap = "on";
f.background = color("black");
f.foreground = color("white");;
a = gca();
a.isoview = "on"; a.data_bounds = [-1,-1;1,1];
a.title.text = "Animation simple";
a.title.font_size = 4;
a.title.foreground = color("green");;
a.background = color("grey");
xarc(-0.7,0.7,1.4,1.4,0,360*64); ea = gce();
ea.thickness = 4; ea.foreground = color("yellow");
xfpoly(xy(1,:)+1, xy(2,:)); ep = gce();
ep.thickness = 5;
ep.foreground = color("blue");
ep.background = color("red");
show_pixmap();
for i=2:n
theta = 3*t(i);
xyr = [cos(theta) -sin(theta);...
sin(theta) cos(theta)]*xy;
ep.data = [ xyr(1,:)+xg(i) ;...
xyr(2,:)+yg(i) ]’;
show_pixmap();
end
f.pixmap = "off";
Pour utiliser la technique des masques, vous devez changer la fonction logique d’affichage grˆace `a la
propri´et´e pixel drawing mode, voir la page d’aide figure properties.
76
4.11 Les surfaces : NOT YET UPDATED
L’instruction g´en´erique pour dessiner des surfaces est plot3d
17
. Avec une repr´esentation de votre
surface par facettes, on peut d´efinir une couleur pour chaque facette. Depuis la version 2.6, on peut
aussi, pour des facettes triangulaires ou quadrangulaires, sp´ecifier une couleur par sommet et le rendu
de la facette est obtenu par interpolation des couleurs d´efinies aux sommets.
4.11.1 Introduction `a plot3d
Si votre surface est donn´ee par une ´equation du type z = f(x, y), il est particuli`erement simple de
la repr´esenter pour un domaine rectangulaire des param`etres. Dans l’exemple qui suit je repr´esente la
fonction f(x, y) = cos(x)cos(y) pour (x, y) ∈ [0, 2π] [0, 2π] :
x=linspace(0,2*%pi,31); // la discretisation en x (et aussi en y : c’est la meme)
z=cos(x)’*cos(x); // le jeu des valeurs en z : une matrice z(i,j) = f(x(i),y(j))
plot3d(x,x,z) // le dessin
1
0
−1
Z
0.0
3.1
6.3
Y
6.3
3.1
0.0
X
Fig. 4.11 – la fonction z = cos(x)cos(y)
Vous devez alors obtenir quelque chose qui ressemble `a la figure (4.11)
18
. De fa¸con plus g´en´erale, on
utilise :
plot3d(x,y,z <,opt_arg>*)
plot3d1(x,y,z <,opt_arg>*)
o` u, comme pour plot2d, <,opt arg>* d´esigne la s´equence des arguments optionnels, opt arg prenant
la forme mot cl´e=valeur. Dans la forme la plus simple, x et y sont deux vecteurs lignes ((1, nx) et
(1, ny)) correspondants `a la discr´etisation en x et en y, et z est une matrice (nx, ny) telle que z
i,j
est
« l’altitude » au point (x
i
, y
j
).
Voici les arguments optionnels possibles :
1. theta=val theta et alpha=val alpha sont les deux angles (en degr´e) pr´ecisant le point de vue en
coordonn´ees sph´eriques (si O est le centre de la boite englobante, Oc la direction de la cam´era,
alors α = angle(Oz, Oc) et θ = angle(0x, Oc

) o` u Oc

est la projection de Oc sur le plan Oxy ;
17
plot3d1 qui s’utilise de fa¸ con quasi identique permet de rajouter des couleurs selon la valeur en z.
18
sauf que j’ai utilis´e des couleurs avec plot3d1 (transform´ees en niveau de gris pour ce document) et le point de vue est
un peu diff´erent
77
2. leg=val leg permet d’´ecrire un label pour chacun des axes (exemple leg="x@y@z"), l’argument
effectif val leg est une chaˆıne de caract`eres o` u @ est utilis´e comme s´eparateur de labels ;
3. flag=val flag o` u val flag est un vecteur `a trois composantes [mode type box] permet de pr´eciser
plusieurs choses :
(a) le param`etre mode est relatif au dessin des faces et du maillage :
i. avec mode > 0, les faces cach´ees sont « enlev´ees
19
», le maillage est visible ;
ii. avec mode = 0, on obtient un rendu « fil de fer » (wireframe) de la surface ;
iii. avec mode < 0, les faces cach´ees sont enlev´ees et le maillage n’est pas dessin´e.
De plus le cˆot´e positif d’une face (voir plus loin) sera peint avec la couleur num´ero mode
alors que le cˆot´e oppos´e est peint avec une couleur que l’on peut changer avec l’instruction
xset("hidden3d",colorid) (par d´efaut la couleur 4 de la carte).
(b) le param`etre type permet de d´efinir l’´echelle :
type ´echelle obtenue
0 on utilise l’´echelle pr´ec´edente (ou par d´efaut)
1 ´echelle fournie avec ebox
2 ´echelle obtenue `a partir des minima et maxima des donn´ees
3 comme avec 1 mais l’´echelle est isom´etrique
4 comme avec 2 mais l’´echelle est isom´etrique
5 variante de 3
6 variante de 4
(c) et enfin le param`etre box contrˆole le pourtour du graphe :
box effet obtenu
0 juste le dessin de la surface
2 des axes sous la surface sont dessin´es
3 comme pour 2 avec en plus le dessin de la boite englobante
4 comme pour 3 avec en plus la graduation des axes
4. ebox=val ebox permet de d´efinir la boite englobante, val ebox devant ˆetre un vecteur `a 6 composantes
[x
min
, x
max
, y
min
, y
max
, z
min
, z
max
].
Voici un petit script o` u on utilise presque tous les param`etres de plot3d. C’est une animation qui vous
permettra de comprendre le changement de point de vue avec les param`etres theta et alpha. Dans ce
script j’utilise flag=[2 4 4], c’est `a dire avec :
– mode = 2 la surface sera peinte (cˆ ot´e positif) avec la couleur 2 et le maillage sera apparent ;
– type = 4 on utilise une ´echelle isom´etrique calcul´ee via les donn´ees (ce qui doit ˆetre ´equivalent `a
choisir type = 3 avec un param`etre ebox obtenu en utilisant les minima et maxima des donn´ees) ;
– box = 4 le dessin apparaˆıtra avec une boite et des graduations.
x=linspace(-%pi,%pi,31);
z=sin(x)’*sin(x);
n = 200;
theta = linspace(30,390,n); // un tour complet
alpha = [linspace(60,0,n/2) linspace(0,80,n/2)]; // vers le haut puis
// vers le bas
xselect()
xset("pixmap",1) // pour activer le double buffer
driver("X11")
// on fait varier theta
for i=1:n
xset("wwpc") // effacement du buffer courant
plot3d(x,x,z,theta=theta(i),alpha=alpha(1),leg="x@y@z",flag=[2 4 4])
xtitle("variation du point de vue avec le parametre theta")
xset("wshow")
19
actuellement c’est l’algorithme du peintre qui est utilis´e, c-a-d qu’un tri des facettes est effectu´e et les plus ´eloign´ees de
l’observateur sont dessin´ees en premier.
78
end
// on fait varier alpha
for i=1:n
xset("wwpc") // effacement du buffer courant
plot3d(x,x,z,theta=theta(n),alpha=alpha(i),leg="x@y@z",flag=[2 4 4])
xtitle("variation du point de vue avec le parametre alpha")
xset("wshow")
end
xset("pixmap",0)
driver("Rec")
4.11.2 La couleur
Vous pouvez r´eessayer les exemples pr´ec´edents en rempla¸cant plot3d par plot3d1 qui met des cou-
leurs selon la valeur en z. Votre surface va alors ressembler `a une mosa¨ıque car la carte des couleurs par
d´efaut n’est pas « continue ».
Une carte des couleurs est une matrice de dimensions (nb_couleurs,3), la i
`eme
ligne correspondant
`a l’intensit´e (comprise entre 0 et 1) en rouge, vert et bleu de la i
`eme
couleur.
´
Etant donn´e une telle ma-
trice que nous appellerons C, l’instruction xset("colormap",C) permet de la charger dans le contexte
graphique de la fenˆetre graphique courante. Enfin, deux fonctions, hotcolormap et greycolormap four-
nissent deux cartes avec une variation progressive des couleurs
20
. Petite remarque : si vous changez la
carte des couleurs apr`es avoir dessin´e un graphique, les changements ne se r´epercutent pas imm´ediatement
sur votre dessin (ce qui est normal). Il suffit par exemple de retailler la fenˆetre graphique ou alors d’en-
voyer l’ordre xbasr(numero_fenetre) pour redessiner (et la nouvelle carte est utilis´ee). Voici de nouveau
l’exemple 1
x = linspace(0,2*%pi,31);
z = cos(x)’*cos(x);
C = hotcolormap(32); // la hot colormap avec 32 couleurs
xset("colormap",C)
xset("hidden3d",30) // choix de la couleur 30 pour les faces n´egatives
xbasc()
plot3d1(x,x,z, flag=[1 4 4]) // tester aussi avec flag=[-1 4 4]
Remarque : avec plot3d1, seul le signe du param`etre mode est utilis´e (pour mode ≥ 0 le maillage apparaˆıt
et pour mode < 0 il n’est pas dessin´e).
4.11.3 plot3d avec des facettes
Pour utiliser cette fonction dans un contexte plus g´en´eral, il faut donner une description de votre sur-
face par facettes. Celle-ci est constitu´ee par 3 matrices xf, yf, zf de dimensions (nb sommets par face,
nb faces) o` u xf(j,i),yf(j,i),zf(j,i) sont les coordonn´ees du j
`eme
sommets de la i
`eme
facette. Modulo
ce petit changement, elle s’utilise comme pr´ec´edemment pour les autres arguments :
plot3d(xf,yf,zf <,opt_arg>*)
Attention l’orientation des facettes est diff´erente de la convention habituelle, cf figure (4.12).
Pour d´efinir une couleur pour chaque facette, le troisi`eme argument doit ˆetre une liste : list(zf,colors)
o` u colors est un vecteur de taille nb_faces, colors(i) donnant le num´ero (dans la carte) de la couleur
attribu´ee `a la i
`eme
facette.
Comme premier exemple, visualisons les faces du t´etra`edre de la figure (4.13), pour lequel :
P
1
=
_
_
0
0
0
_
_
, P
2
=
_
_
1
0
0
_
_
, P
3
=
_
_
0
1
0
_
_
, P
4
=
_
_
0
0
1
_
_
,
20
voir aussi la section Contributions sur le site Scilab.
79
P
P
P
P
1
2
3
4
face positive pour Scilab
face négative pour Scilab
Fig. 4.12 – orientation des facettes en scilab
P
4
P
3
P
2
P
1
x
y
z
Fig. 4.13 – un t´etra`edre
et d´efinissons les faces comme suit (de sorte `a obtenir les faces ext´erieures avec l’orientation positive pour
Scilab) :
f
1
= (P
1
, P
2
, P
3
), f
2
= (P
2
, P
4
, P
3
), f
3
= (P
1
, P
3
, P
4
), f
4
= (P
1
, P
4
, P
2
)
On ´ecrira alors :
// f1 f2 f3 f4
xf = [ 0 1 0 0;
1 0 0 0;
0 0 0 1];
yf = [ 0 0 0 0;
0 0 1 0;
1 1 0 0];
zf = [ 0 0 0 0;
0 1 0 1;
0 0 1 0]; // ouf !
xbasc()
plot3d(xf,yf,list(zf,2:5), flag=[1 4 4], leg="x@y@z",alpha=30, theta=230)
xselect()
Avec ces param`etres vous devriez obtenir quelque chose qui ressemble `a la figure 4.14. Vous pouvez
remarquer que plot3d utilise une simple projection orthographique et non une projection perspective
plus r´ealiste.
Pour des besoins courants, le calcul des facettes peut ˆetre effectu´es avec les fonctions suivantes :
– eval3dp et nf3d pour les surfaces d´efinies par x = x(u, v), y = y(u, v), z = z(u, v) (voir 4.11.4) ;
80
Fig. 4.14 – le t´etra`edre dessin´e avec Scilab
– genfac3d pour les surfaces d´efinies par z = f(x, y) (un exemple est propos´e plus loin (4.11.5)).
Si votre surface (poly´edrique) est d´efinie comme mon cube de l’exemple sur les tlists, vous ne pouvez
pas la visualiser directement avec plot3d. Pour obtenir la description attendue par Scilab, vous pouvez
utiliser une fonction comme celle-ci :
function [xf,yf,zf] = facettes_polyedre(P)
// transforme la structure Polyedre de l’exemple
// sur les tlist en description de facettes pour
// visualisation avec plot3d
[ns, nf] = size(P.face) // ns : nb de sommets par facette
// nf : nb de facettes
xf=zeros(P.face); yf=zeros(P.face); zf=zeros(P.face)
for j=1:ns
num = P.face(ns+1-j,:) // pour inverser l’orientation
xf(j,:) = P.coord(1, num)
yf(j,:) = P.coord(2, num)
zf(j,:) = P.coord(3, num)
end
endfunction
En d´efinissant le cube comme pr´ec´edemment, vous obtiendrez alors son dessin avec :
[xf,yf,zf] = facettes_polyedre(Cube);
plot3d(xf,yf,list(zf,2:7), flag=[1 4 0],theta=50,alpha=60)
4.11.4 Dessiner une surface d´efinie par x = x(u, v), y = y(u, v), z = z(u, v)
R´eponse : prendre une discr´etisation du domaine des param`etres et calculer les facettes avec la fonction
(eval3dp). Pour des raisons d’efficacit´e, la fonction qui d´efinit le param`etrage de votre surface doit ˆetre
´ecrite « vectoriellement ». Si (u
1
, u
2
, . . . , u
m
) et (v
1
, v
2
, . . . , v
n
) sont les discr´etisations d’un rectangle du
domaine des param`etres, votre fonction va ˆetre appel´ee une seule fois avec les deux « grands » vecteurs
de longueur mn :
U = (u
1
, u
2
, . . . , u
m
. ¸¸ .
1
, u
1
, u
2
, . . . , u
m
. ¸¸ .
2
, . . . . . . , u
1
, u
2
, . . . , u
m
. ¸¸ .
n
)
V = (v
1
, v
1
, . . . , v
1
. ¸¸ .
m fois v
1
, v
2
, v
2
, . . . , v
2
. ¸¸ .
m fois v
2
, . . . . . . , v
n
, v
n
, . . . , v
n
. ¸¸ .
m fois v
n
)
81
A partir de ces deux vecteurs, votre fonction doit renvoyer 3 vecteurs X, Y et Z de longueur mn tels
que :
X
k
= x(U
k
, V
k
), Y
k
= y(U
k
, V
k
), Z
k
= z(U
k
, V
k
)
Voici quelques exemples de param´etrisation de surfaces, ´ecrite
21
de fa¸con `a pouvoir ˆetre utilis´ee avec
eval3dp :
function [x,y,z] = tore(theta, phi)
// param´etrisation classique d’un tore de rayons R et r et d’axe Oz
R = 1; r = 0.2
x = (R + r*cos(phi)).*cos(theta)
y = (R + r*cos(phi)).*sin(theta)
z = r*sin(phi)
endfunction
function [x,y,z] = helice_torique(theta, phi)
// param´etrisation d’une helice torique
R = 1; r = 0.3
x = (R + r*cos(phi)).*cos(theta)
y = (R + r*cos(phi)).*sin(theta)
z = r*sin(phi) + 0.5*theta
endfunction
function [x,y,z] = moebius(theta, rho)
// param´etrisation d’une bande de Mo¨ebius
R = 1;
x = (R + rho.*sin(theta/2)).*cos(theta)
y = (R + rho.*sin(theta/2)).*sin(theta)
z = rho.*cos(theta/2)
endfunction
function [x,y,z] = tore_bossele(theta, phi)
// param´etrisation d’un tore dont le petit rayon r est variable avec theta
R = 1; r = 0.2*(1+ 0.4*sin(8*theta))
x = (R + r.*cos(phi)).*cos(theta)
y = (R + r.*cos(phi)).*sin(theta)
z = r.*sin(phi)
endfunction
Voici un exemple qui utilise la derni`ere surface :
// script pour dessiner une surface d´efinie par des ´equations param´etriques
theta = linspace(0, 2*%pi, 160);
phi = linspace(0, -2*%pi, 20);
[xf, yf, zf] = eval3dp(tore_bossele, theta, phi); // calcul des facettes
xbasc()
plot3d1(xf,yf,zf)
xselect()
Si vous voulez utiliser des couleurs et que vous ne les obtenez pas, c’est que l’orientation n’est pas
la bonne : il suffit alors d’inverser le sens de l’un des deux vecteurs de la discr´etisation du domaine des
param`etres.
21
en fait vous pouvez ´ecrire ces ´equations naturellement puis remplacer les * et / par des .* et ./ et ¸ ca marchera !
82
Fig. 4.15 – Un tore bossel´e...
La fonction nf3d est un peu analogue `a eval3dp, mais, `a partir d’une discr´etisation de u et v il faut
d´efinir soit-mˆeme des matrices X, Y, Z telles que :
X
i,j
= x(u
i
, v
j
)
Y
i,j
= y(u
i
, v
j
)
Z
i,j
= z(u
i
, v
j
)
et vos facettes s’obtiennent alors avec [xf,yf,zf] = nf3d(X,Y,Z). Comme exemple, voici le ruban de
Mo¨ebius d´efinit juste avant :
nt = 120;
nr = 10;
rho = linspace(-0.5,0.5,nr);
theta = linspace(0,2*%pi,nt);
R = 1;
X = (R + rho’*sin(theta/2)).*(ones(nr,1)*cos(theta));
Y = (R + rho’*sin(theta/2)).*(ones(nr,1)*sin(theta));
Z = rho’*cos(theta/2);
[xf,yf,zf] = nf3d(X,Y,Z);
xbasc()
plot3d(xf,yf,zf, flag=[2 4 6], alpha=60, theta=50)
xselect()
Remarque : pour obtenir les bonnes matrices, j’ai ´et´e oblig´e d’utiliser la fonction ones, ce qui ne rend
pas le code tr`es clair : la fonction eval3dp est plus simple `a utiliser !
4.11.5 plot3d avec interpolation des couleurs
Depuis la version 2.6, il est maintenant possible d’associer une couleur pour chaque sommet d’une
facette. Pour cela il suffit de donner une matrice colors de mˆeme taille que les matrices xf, yf, zf
donnant la description par facette, c-a-d telle que colors(i,j) soit la couleur associ´ee au i
`eme
sommet
de la j
`eme
face, et de l’associer au troisi`eme argument (zf) avec une liste :
plot3d(xf,yf,list(zf,colors) <,opt_arg>*)
Voici l’exemple initial de plot3d avec affichage sans le maillage et avec :
– une couleur par face pour le dessin de gauche,
– une couleur par sommet pour celui de droite.
83
Fig. 4.16 – Le ruban de Mo¨ebius
Pour calculer les couleurs, j’utilise une petite fonction qui me permet d’associer lin´eairement des valeurs
`a la carte graphique courante (j’utilise la fonction dsearch disponible depuis la version 2.7 mais vous
pouvez facilement vous en passer). Vous noterez aussi l’utilisation de la fonction genfac3d qui permet
de calculer les facettes.
// exemple pour illustration de plot3d avec interpolation de couleur
function [col] = associe_couleur(val)
// associe une couleur pour chaque valeur de val
n1 = 1 // numero de la 1 ere couleur
n2 = xget("lastpattern") // num´ero de la derniere couleur
nb_col = n2 - n1 + 1
classes = linspace(min(val),max(val),nb_col)
col = dsearch(val, classes)
endfunction
x=linspace(0,2*%pi,31);
z=cos(x)’*cos(x);
[xf,yf,zf] = genfac3d(x,x,z);
xset("colormap",graycolormap(64))
zmeanf = mean(zf,"r");
zcolf = associe_couleur(zmeanf);
zcols = associe_couleur(zf);
xbasc()
xset("font",6,2) // la fonte 6 (helvetica) n’est disponible
// que dans la version cvs de scilab
subplot(1,2,1)
plot3d(xf,yf,list(zf,zcolf), flag=[-1 4 4])
xtitle("Une couleur par face")
subplot(1,2,2)
plot3d(xf,yf,list(zf,zcols), flag=[-1 4 4])
xtitle("Une couleur par sommet")
xselect()
4.12 Les courbes dans l’espace : NOT YET UPDATED
Pour dessiner une telle courbe l’instruction de base est param3d. Voici l’exemple classique de l’h´elice :
84
Fig. 4.17 – Avec et sans interpolation des couleurs
t = linspace(0,4*%pi,100);
x = cos(t); y = sin(t) ; z = t;
param3d(x,y,z) // effacer eventuellement la fenetre graphique avec xbasc()
mais comme cette derni`ere ne permet que d’affichier une seule courbe nous allons nous concentrer sur
param3d1 qui permet de faire plus de choses. Voici sa syntaxe :
param3d1(x,y,z <,opt_arg>*)
param3d1(x,y,list(z,colors) <,opt_arg>*)
Les matrices x, y et z doivent ˆetre de mˆeme format (np,nc) et le nombre de courbes (nc) est donn´e par
leur nombre de colonnes (comme pour plot2d). Les param`etres optionnels sont les mˆemes que ceux de
l’instruction plot3d, modulo le fait que flag ne ne comporte pas de param`etre mode.
colors est un vecteur donnant le style pour chaque courbe (exactement comme pour plot2d), c’est
`a dire que si colors(i) est un entier strictement positif, la i
`eme
courbe est dessin´ee avec la i
`eme
couleur
de la carte courante (ou avec diff´erents pointill´es sur un terminal noir et blanc) alors que pour une
valeur enti`ere comprise entre -9 et 0, on obtient un affichage des points (non reli´es) avec le symbole
correspondant. Voici un exemple qui doit vous conduire `a la figure (4.18) :
t = linspace(0,4*%pi,100)’;
x1 = cos(t); y1 = sin(t) ; z1 = 0.1*t; // une helice
x2 = x1 + 0.1*(1-rand(x1));
y2 = y1 + 0.1*(1-rand(y1));
z2 = z1 + 0.1*(1-rand(z1));
xbasc();
xset("font",2,3)
param3d1([x1 x2],[y1 y2],list([z1 z2], [1,-9]), flag=[4 4])
xset("font",4,4)
xtitle("Helice avec perles")
Comme pour plot2d on est oblig´e de l’appeler plusieurs fois si les diff´erentes courbes `a afficher n’ont
pas le mˆeme nombre de points. Voici un script qui explique comment dessiner deux groupes de points
avec des marques et des couleurs diff´erentes :
n = 50; // nombre de points
P = rand(n,3); // des points au hasard
// on impose les dimensions de la boite englobante
ebox = [0 1 0 1 0 1];
// ici je separe les points en 2 groupes pour montrer comment mettre des
// symboles et des couleurs differentes pour les points
m = 30;
P1 = P(1:m,:) ; P2 = P(m+1:n,:);
// le dessin
85
Fig. 4.18 – Courbe et points dans l’espace...
xbasc()
// premier groupe de points
xset("color",2) // du bleu avec la carte par defaut
param3d1(P1(:,1),P1(:,2),list(P1(:,3), -9), alpha=60, theta=30,...
leg="x@y@z", flag=[3 4], ebox=ebox)
// flag=[3 4] : 3 -> echelle iso se basant sur ebox
// 4 -> boite + graduation
// pour le deuxieme groupe
xset("color",5) // du rouge avec la carte par defaut
param3d1(P2(:,1),P2(:,2),list(P2(:,3), -5), flag=[0 0])
// -5 pour des triangles inverses
// [0 0] : echelle fix´ee et cadre dessin´e avec l’appel pr´ec´edent
xset("color",1) // pour remettre le noir comme couleur courante
xtitle("Des points...")
xselect()
4.13 Divers : NOT YET UPDATED
Il existe encore beaucoup de primitives graphiques dont :
1. contour2d et contour qui permettent de dessiner des lignes isovaleurs d’une fonction z = f(x, y)
d´efinie sur un rectangle ;
2. grayplot et Sgrayplot qui permettent de repr´esenter les valeurs d’une telle fonction en utilisant
des couleurs ;
3. fec joue le mˆeme rˆole que les deux pr´ec´edentes pour une fonction qui est d´efinie sur une triangulation
plane ;
4. champ qui permet de dessiner un champ de vecteurs en 2D;
5. finalement de nombreuses fonctions graphiques ´evoqu´ees dans ce chapitre admettent des variantes
permettant de faire des graphes de fonctions plus directement si on fournit une fonction scilab
comme argument (le nom de ces fonctions commence par un f fplot2d, fcontour2d, fplot3d,
fplot3d1, fchamp,...).
86
4.14 quelques remarques sur le graphique scilab
– Avant la version 3.0, il ´etait possible de faire un certain nombre de choses avec le graphique de
scilab mais cela pouvait se r´ev´eler parfois compliqu´e ; d’autre part il ´etait impossible de modifier
les propri´et´es des graphiques une fois qu’ils ´etaient affich´es.
– Ainsi (depuis pas mal d’ann´ees) un projet de nouveau graphique a ´et´e mis en route pour essayer de
pallier `a ces d´efauts, ce projet se concr´etisant avec une version b´eta qui a pu ˆetre utilis´e dans scilab-
2.7 (l’ancien graphique restant le standard) ; comme ce nouveau graphique ´etait peu compatible
avec l’ancien, assez bogu´e, peu d´ecrit dans la documentation en ligne, les utilisateurs ne sont pas
pr´ecipit´es pour le tester de mani`ere intensive...
– Lors de la sortie de scilab-3.0 le nouveau graphique est devenu le standard (l’ancien pouvant ˆetre
heureusement toujours utilis´e) et malgr´e des progr`es, il restait toujours de nombreux bogues, une
documentation insuffisante, etc...
– Avec les versions 3.1.1 puis 4.0 cette situation s’est am´elior´ee mais, on ne peut toujours pas dire
que le graphique scilab soit `a la hauteur de ce que nombre d’utilisateurs attendaient (toujours pas
de true color, les possibilit´es 3d et les d´egrad´es de couleurs sont toujours aussi limit´es et je ne parle
mˆeme pas d’acc´el´eration mat´erielle
22
, ni de transparence de surfaces, voire d’antialiasing...).
22
dans beaucoup de cas il semble mˆeme que le nouveau graphique n’utilise pas les primitives 2d sous-jacentes de mani`ere
optimale, par exemple afficher 40000 carr´es avec l’instruction xfpolys prend 1 s en nouveau graphique et 0.25 s avec l’ancien
sur ma machine, soit un facteur de 4
87
Chapitre 5
Applications et compl´ements : NOT
YET UPDATED FOR GRAPHICS
Ce chapitre se propose de vous montrer comment r´esoudre certains probl`emes types d’analyse num´erique
avec Scilab (en fait uniquement des ´equations diff´erentielles actuellement...) et apporte des compl´ements
pour pouvoir ´ecrire des petites simulations stochastiques.
5.1
´
Equations diff´erentielles
Scilab dispose d’une interface tr`es puissante pour r´esoudre num´eriquement (de mani`ere approch´ee)
des ´equations diff´erentielles avec la primitive ode. Soit donc une ´equation diff´erentielle avec une condition
initiale :
_
u

= f(t, u)
u(t
0
) = u
0
o` u u(t) est un vecteur de R
n
, f une fonction de R R
n
−→ R
n
, et u
0
∈ R
n
. On suppose les conditions
remplies pour qu’il y ait existence et unicit´e de la solution jusqu’`a un temps T.
5.1.1 Utilisation basique de ode
Dans son fonctionnement le plus basique elle est tr`es simple `a utiliser : il faut ´ecrire le second membre
f comme une fonction Scilab avec la syntaxe suivante :
function [f] = MonSecondMembre(t,u)
//
ici le code donnant les composantes de f en fonction de t et
des composantes de u.
endfunction
Rmq : Mˆeme si l’´equation est autonome, il faut quand mˆeme mettre t comme premier argument de la
fonction second membre. Par exemple voici un code possible pour le second membre de l’´equation de
Van der Pol :
y

= c(1 −y
2
)y

−y
et que l’on reformule comme un syst`eme de deux ´equations diff´erentielles du premier ordre en posant
u
1
(t) = y(t) et u
2
(t) = y

(t) :
d
dt
_
u
1
(t)
u
2
(t)
_
=
_
u
2
(t)
c(1 −u
2
1
(t))u
2
(t) −u
1
(t)
_
function [f] = VanDerPol(t,u)
// second membre pour Van der Pol (c = 0.4)
f(1) = u(2)
f(2) = 0.4*(1 - u(1)^2)*u(2) - u(1)
endfunction
88
Puis un appel a ode pour r´esoudre l’´equation (l’int´egrer) de t
0
`a T, en partant de u
0
(un vecteur colonne),
et en voulant r´ecup´erer la solution aux instants t(1) = t
0
, t(2), ..., t(m) = T, prendra l’allure suivante :
t = linspace(t0,T,m);
[U] = ode(u0,t0,t,MonSecondMembre)
On r´ecup`ere alors une « matrice » U de format (n, m) telle que U(i,j) est la solution approch´ee de
u
i
(t(j)) (la i
`eme
composante `a l’instant t(j)). Rmq : le nombre de composantes que l’on prend pour t
(les instants pour lesquels on r´ecup`ere la solution), n’a rien `a voir avec la pr´ecision du calcul. Celle-ci
peut se r´egler avec d’autres param`etres (qui ont des valeurs par d´efaut). D’autre part derri`ere ode il y
a plusieurs algorithmes possibles, qui permettent de s’adapter `a diverses situations... Pour s´electionner
une m´ethode particuli`ere, il faut rajouter un param`etre dans l’appel (cf le Help). Par d´efaut (c-a-d sans
s´election explicite d’une des m´ethodes) on a cependant une strat´egie intelligente puisque ode utilise
initialement une m´ethode d’Adams pr´edicteur/correcteur mais est capable de changer cet algorithme par
une m´ethode de Gear dans le cas o` u il d´etecte l’´equation comme « raide
1
».
Voici un exemple complet pour Van der Pol. Comme dans ce cas l’espace des phases est un plan,
on peut d´ej`a obtenir une id´ee de la dynamique en dessinant simplement le champ de vecteur dans un
rectangle [x
min
, x
max
] [y
min
, y
max
] avec l’instruction graphique fchamp dont la syntaxe est :
fchamp(MonSecondMembre,t,x,y)
o` u MonSecondMembre est le nom de la fonction Scilab du second membre de l’´equation diff´erentielle, t est
l’instant pour lequel on veut dessiner le champ (dans le cas le plus courant d’une ´equation autonome on
met une valeur sans signification, par exemple 0) et x et y sont des vecteurs lignes `a nx et ny composantes,
donnant les points de la grille sur lesquels seront dessin´es les fl`eches repr´esentant le champ de vecteur.
// 1/ trace du champs de vecteur issu de l’equation de Van der Pol
n = 30;
delta = 5
x = linspace(-delta,delta,n); // ici y = x
xbasc()
fchamp(VanDerPol,0,x,x)
xselect()
// 2/ resolution de l’equation differentielle
m = 500 ; T = 30 ;
t = linspace(0,T,m); // les instants pour lesquels on recupere la solution
u0 = [-2.5 ; 2.5]; // la condition initiale
[u] = ode(u0, 0, t, VanDerPol);
plot2d(u(1,:)’,u(2,:)’,2,"000")
5.1.2 Van der Pol one more time
Dans cette partie nous allons exploiter une possibilit´e graphique de Scilab pour obtenir autant de
trajectoires voulues sans refaire tourner le script pr´ec´edent avec une autre valeur de u
0
. D’autre part
on va utiliser une ´echelle isom´etrique pour les dessins. Apr`es l’affichage du champ de vecteur, chaque
condition initiale sera donn´ee par un clic du bouton gauche de la souris
2
, le pointeur ´etant positionn´e
sur la condition initiale voulue. Cette possibilit´e graphique s’obtient avec la primitive xclick dont la
syntaxe simplifi´ee est :
[c_i,c_x,c_y]=xclick();
Scilab se met alors `a attendre un «´ev´enement graphique » du type « clic souris », et, lorsque cet ´ev´enement
a lieu, on r´ecup`ere la position du pointeur (dans l’´echelle courante) avec c x et c y ainsi que le num´ero
du bouton avec :
1
pour faire bref on dit qu’une ´equation diff´erentielle est « raide » si celle-ci s’int´egre difficilement avec les m´ethodes (plus
ou moins) explicites...
2
comme sugg´er´e dans l’un des articles sur Scilab paru dans « Linux Magazine »
89
valeur pour c i bouton
0 gauche
1 milieu
2 droit
Dans le script, j’utilise un clic sur le bouton droit pour sortir de la boucle des ´ev´enements.
Enfin, on proc`ede `a quelques fioritures de sorte `a changer de couleur pour chaque trajectoire (le tableau
couleur me permet de s´electionner celles qui m’int´eressent dans la colormap standard. Pour obtenir une
´echelle isom´etrique on utilise fchamp en rajoutant un argument optionnel comme pour plot2d (il faut
utiliser strf=val strf car les param`etres frameflag et axesflag ne sont pas support´es). Derni`ere fioritures :
je dessine un petit rond pour bien marquer chaque condition initiale, et pour exploiter la totalit´e de la
fenˆetre graphique, j’utilise un plan de phase « rectangulaire ». Derni`ere remarque : lorsque le champ de
vecteur apparaˆıt vous pouvez maximiser la fenˆetre graphique ! En cliquant plusieurs fois j’ai obtenu la
figure (5.1) : toutes les trajectoires convergent vers une orbite p´eriodique ce qui est bien le comportement
th´eorique attendu pour cette ´equation.
// 1/ trace du champs de vecteur issu de l’equation de Van der Pol
n = 30;
delta_x = 6
delta_y = 4
x = linspace(-delta_x,delta_x,n);
y = linspace(-delta_y,delta_y,n);
xbasc()
fchamp(VanDerPol,0,x,y, strf="041")
xselect()
// 2/ resolution de l’equation differentielle
m = 500 ; T = 30 ;
t = linspace(0,T,m);
couleurs = [21 2 3 4 5 6 19 28 32 9 13 22 18 21 12 30 27] // 17 couleurs
num = -1
while %t
[c_i,c_x,c_y]=xclick();
if c_i == 0 then
plot2d(c_x, c_y, style=-9, strf="000") // un petit o pour marquer la C.I.
u0 = [c_x;c_y];
[u] = ode(u0, 0, t, VanDerPol);
num = modulo(num+1,length(couleurs));
plot2d(u(1,:)’,u(2,:)’, style=couleurs(num+1), strf="000")
elseif c_i == 2 then
break
end
end
5.1.3 Un peu plus d’ode
Dans ce deuxi`eme exemple, nous allons utiliser la primitive ode avec un second membre qui admet
un param`etre suppl´ementaire et nous allons fixer nous mˆeme les tol´erances pour la gestion du pas de
temps du solveur. Voici notre nouvelle ´equation diff´erentielle (Le Brusselator) :
_
du
1
dt
= 2 −(6 +)u
1
+u
2
1
x
2
du
2
dt
= (5 +)u
1
−u
2
1
u
2
qui admet comme seul point critique P
stat
= (2, (5 + )/2). Lorsque le param`etre passe d’une valeur
strictement n´egative `a une valeur positive, ce point stationnaire change de nature (de stable il devient
instable avec pour = 0 un ph´enom`ene de bifurcation de Hopf). On s’int´eresse aux trajectoires avec des
conditions initiales voisines de ce point. Voici la fonction calculant ce second membre :
90
-6.0 -4.8 -3.6 -2.4 -1.2 0.0 1.2 2.4 3.6 4.8 6.0
-4.24
-3.39
-2.54
-1.70
-0.85
0.00
0.85
1.70
2.54
3.39
4.24
Ο
Ο
Ο
Ο
Ο
Ο
Ο Ο Ο
Ο Ο
Ο
Ο
Ο
Ο
Ο
Ο
Ο
Ο
Ο
Fig. 5.1 – Quelques trajectoires dans le plan de phase pour l’´equation de Van der Pol
function [f] = Brusselator(t,u,eps)
//
f(1) = 2 - (6+eps)*u(1) + u(1)^2*u(2)
f(2) = (5+eps)*u(1) - u(1)^2*u(2)
endfunction
Pour faire « passer » le param`etre suppl´ementaire, on remplace dans l’appel `a ode le nom de la fonction
(ici Brusselator) par une liste constitu´ee du nom de la fonction et du ou des param`etres suppl´ementaires :
[x] = ode(x0,t0,t,list(MonSecondMembre, par1, par2, ...))
Dans notre cas :
[x] = ode(x0,t0,t,list(Brusselator, eps))
et l’on proc`ede de mˆeme pour tracer le champ avec fchamp.
Pour fixer les tol´erances sur l’erreur locale du solveur on rajoute les param`etres rtol et atol,
juste avant le nom de la fonction second membre (ou de la liste form´ee par celui-ci et des param`etres
suppl´ementaires de la fonction).
`
A chaque pas de temps, t
k−1
→ t
k
= t
k−1
+ ∆t
k
, le solveur calcule
une estimation de l’erreur locale e (c-a-d l’erreur sur ce pas de temps en partant de la condition initiale
v(t
k−1
) = U(t
k−1
)) :
e(t
k
) · U(t
k
) −
_
_
t
k
t
k−1
f(t, v(t))dt +U(t
k−1
)
_
(le deuxi`eme terme ´etant la solution exacte partant de la solution num´erique U(t
k−1
) obtenue au pas
pr´ec´edent) et compare cette erreur `a la tol´erance form´ee par les deux param`etres rtol et atol :
tol
i
= rtol
i
∗ [U
i
(t
k
)[ +atol
i
, 1 ≤ i ≤ n
dans le cas o` u l’on donne deux vecteurs de longueur n pour ces param`etres et :
tol
i
= rtol ∗ [U
i
(t
k
)[ +atol, 1 ≤ i ≤ n
91
si on donne deux scalaires. Si [e
i
(t
k
)[ ≤ tol
i
pour chaque composante, le pas est accept´e et le solveur
calcule le nouveau pas de temps de sorte que le crit`ere sur la future erreur ait une certaine chance de
se r´ealiser. Dans le cas contraire, on r´eint`egre `a partir de t
k−1
avec un nouveau pas de temps plus petit
(calcul´e de sorte que le prochain test sur l’erreur locale soit aussi satisfait avec une forte probabilit´e).
Comme les m´ethodes mise en jeu sont des m´ethodes « multipas
3
» le solveur, en plus du pas de temps
variable, joue aussi avec l’ordre de la formule pour obtenir une bonne efficacit´e informatique... Par d´efaut
les valeurs utilis´ees sont rtol = 10
−5
et atol = 10
−7
(sauf lorsque type selectionne une m´ethode de Runge
Kutta). Remarque importante : le solveur peut tr´es bien ´echouer dans l’int´egration...
Voici un script possible, la seule fioriture suppl´ementaire est un marquage du point critique avec un
petit carr´e noir que j’obtiens avec la primitive graphique xfrect :
// Brusselator
eps = -4
P_stat = [2 ; (5+eps)/2];
// limites pour le trace du champ de vecteur
delta_x = 6; delta_y = 4;
x_min = P_stat(1) - delta_x; x_max = P_stat(1) + delta_x;
y_min = P_stat(2) - delta_y; y_max = P_stat(2) + delta_y;
n = 20;
x = linspace(x_min, x_max, n);
y = linspace(y_min, y_max, n);
// 1/ trace du champ de vecteurs
xbasc()
fchamp(list(Brusselator,eps),0,x,y, strf="041")
xfrect(P_stat(1)-0.08,P_stat(2)+0.08,0.16,0.16) // pour marquer le point critique
xselect()
// 2/ resolution de l’equation differentielle
m = 500 ; T = 5 ;
rtol = 1.d-09; atol = 1.d-10; // tolerances pour le solveur
t = linspace(0,T,m);
couleurs = [21 2 3 4 5 6 19 28 32 9 13 22 18 21 12 30 27]
num = -1
while %t
[c_i,c_x,c_y]=xclick();
if c_i == 0 then
plot2d(c_x, c_y, style=-9, strf="000") // un petit o pour marquer la C.I.
u0 = [c_x;c_y];
[u] = ode(u0, 0, t, rtol, atol, list(Brusselator,eps));
num = modulo(num+1,length(couleurs));
plot2d(u(1,:)’,u(2,:)’, style=couleurs(num+1), strf="000")
elseif c_i == 2 then
break
end
end
5.2 G´en´eration de nombres al´eatoires
5.2.1 La fonction rand
Jusqu’`a pr´esent elle nous a essentiellement servi `a remplir nos matrices et vecteurs... Cette fonction
utilise le g´en´erateur congruentiel lin´eaire suivant
4
:
X
n+1
= f(X
n
) = (aX
n
+c) mod m, n ≥ 0, o` u
_
_
_
m = 2
31
a = 843314861
c = 453816693
3
du moins par d´efaut ou lorsque l’on choisit type = adams ou stiff
4
D’apr`es ce que j’ai cru comprendre en regardant le code source.
92
-4.0 -2.8 -1.6 -0.4 0.8 2.0 3.2 4.4 5.6 6.8 8.0
-3.74
-2.89
-2.04
-1.20
-0.35
0.50
1.35
2.20
3.04
3.89
4.74
Ο Ο
Ο
Ο Ο
Ο
Ο
Ο Ο
Ο Ο
Ο
Ο
Ο
Ο
Ο
Ο
Ο
Ο
Fig. 5.2 – Quelques trajectoires dans le plan de phase pour le Brusselator ( = −4)
Sa p´eriode est bien sˆ ur ´egale `a m (ceci signifie que f est une permutation cyclique sur [0, m−1].) Notons
que tous les g´en´erateurs de nombres al´eatoires sur ordinateur sont des suites parfaitement d´eterministes
qui « apparaissent » comme al´eatoires (pour les bons g´en´erateurs) selon un certain nombre de tests
statistiques. Pour se ramener `a des nombres r´eels compris dans l’intervalle [0, 1[, on divise les entiers
obtenus par m (et l’on obtient un g´en´erateur de nombres r´eels qui semblent suivre une loi uniforme sur
[0, 1[). Le terme initial de la suite est souvent appel´e le germe et celui par d´efaut est X
0
= 0. Ainsi
le premier appel `a rand (le premier coefficient obtenu si on r´ecup`ere une matrice ou un vecteur) est
toujours :
u
1
= 453816693/2
31
≈ 0.2113249
Il est cependant possible de changer le germe `a tout moment avec l’instruction :
rand("seed",germe)
o` u germe est un entier compris dans l’intervalle (entier) [0, m−1]. Souvent on ressent le besoin d’initialiser
la suite en choisissant un germe plus ou moins au hasard (histoire de ne pas avoir les mˆemes nombres `a
chaque fois) et une possibilit´e consiste `a r´ecuperer la date et l’heure et de fabriquer le germe avec. Scilab
poss`ede une fonction getdate qui fournit un vecteur de 9 entiers (voir le d´etail avec le Help). Parmi ces
9 entiers :
– le deuxi`eme donne le mois (1-12),
– le sizi`eme, le jour du mois (1-31),
– le septi`eme, l’heure du jour (0-23),
– le huiti`eme, les minutes (0-59),
– et le neuvi`eme, les secondes (0-61 ?).
Pour obtenir un germe on peut par exemple additionner ces nombres entre-eux, ce qui donne :
v = getdate()
rand("seed", sum(v([2 6 7 8 9])))
Noter aussi que l’on peut r´ecup´erer le germe courant avec :
germe = rand("seed")
93
`
A partir de la loi uniforme sur [0, 1[, on peut obtenir d’autres lois et rand fournit aussi une interface
qui permet d’obtenir la loi normale (de moyenne 0 et de variance 1). Pour passer de l’une `a l’autre, on
proc`ede de la fa¸ con suivante :
rand("normal") // pour obtenir la loi normale
rand("uniform") // pour revenir a la loi uniforme
Par d´efaut le g´en´erateur fournit une loi uniforme mais il est judicieux dans toute simulation de s’assurer
que rand donne bien ce que l’on d´esire en utilisant l’une de ces deux instructions. On peut d’ailleurs
r´ecup´erer la loi actuelle avec :
loi=rand("info") // loi est l’une des deux cha^ınes "uniform" ou "normal"
Rappelons que rand peut s’utiliser de plusieurs fa¸cons :
1. A = rand(n,m) remplit la matrice A (n,m) de nombres al´eatoires ;
2. si B est une matrice d´ej`a d´efinie de dimensions (n, m) alors A = rand(B) permet d’obtenir la mˆeme
chose (ce qui permet d’´eviter de r´ecup´erer les dimensions de B) ;
3. enfin, u = rand() fournit un seul nombre al´eatoire.
Pour les deux premi`eres m´ethodes, on peut rajouter un argument suppl´ementaire pour imposer aussi la
loi : A = rand(n,m,loi), A = rand(B,loi), o` u loi est l’une des deux chaˆınes de caract`eres "normal"
ou "uniform".
Quelques petites applications avec rand
`
A partir de la loi uniforme, il est simple d’obtenir une matrice (n,m) de nombres selon :
1. une loi uniforme sur [a, b] :
X = a + (b-a)*rand(n,m)
2. une loi uniforme sur les entiers de l’intervalle [n
1
, n
2
] :
X = floor(n1 + (n2+1-n1)*rand(n,m))
(on tire des r´eels suivants une loi uniforme sur l’intervalle r´eel [n
1
, n
2
+ 1[ et on prend la partie
enti`ere).
Pour simuler une ´epreuve de Bernouilli avec probabilit´e de succ`es p :
succes = rand() < p
ce qui nous conduit `a une m´ethode simple
5
pour simuler une loi binomiale B(N, p) :
X = sum(bool2s(rand(1,N) < p))
(bool2s transforme les succ`es en 1 et il ne reste plus qu’`a les additionner avec sum). Comme les it´erations
sont lentes en Scilab, on peut obtenir directement un vecteur (colonne) contenant m r´ealisations de cette
loi avec :
X = sum(bool2s(rand(m,N) < p),"c")
mais on aura int´erˆet `a utiliser la fonction grand qui utilise une m´ethode plus performante. D’autre part
si vous utilisez ces petits trucs
6
, il est plus clair de les coder comme des fonctions Scilab. Voici une petite
fonction pour simuler la loi g´eom´etrique (nombre d’´epreuves de Bernouilli n´ecessaires pour obtenir un
succ`es)
7
:
5
mais peu efficace pour N grand !
6
d’une mani`ere g´en´erale on utilisera plutˆ ot la fonction grand permet d’obtenir la plupart des lois classiques.
7
cette fonction est peu efficace pour p petit.
94
function [X] = G(p)
// loi geometrique
X = 1
while rand() > p // echec
X = X+1
end
endfunction
Enfin, `a partir de la loi Normale ^(0, 1), on obtient la loi Normale ^(µ, σ
2
) (moyenne µ et ´ecart type
σ) avec :
rand("normal")
X = mu + sigma*rand(n,m) // pour obtenir une matrice (n,m) de tels nombres
// ou encore en une seule instruction : X = mu + sigma*rand(n,m,"normal")
5.2.2 La fonction grand
Pour des simulations lourdes qui utilisent beaucoup de nombres al´eatoires la fonction standard rand
avec sa p´eriode de 2
31
(· 2.147 10
9
) est peut ˆetre un peu juste. Il est alors pr´ef´erable d’utiliser grand qui
permet aussi de simuler toutes les lois classiques. grand s’utilise presque de la mˆeme mani`ere que rand,
c-a-d que l’on peut utiliser l’une des deux syntaxes suivantes (pour la deuxi`eme il faut ´evidemment que
la matrice A soit d´efinie au moment de l’appel) :
grand(n,m,loi, [p1, p2, ...])
grand(A,loi, [p1, p2, ...])
o` u loi est une chaˆıne de caract`eres pr´ecisant la loi, celle-ci ´etant suivie de ses param`etres ´eventuels.
Quelques exemples (pour obtenir un ´echantillon de n r´ealisations, sous la forme d’un vecteur colonne) :
1. une loi uniforme sur les entiers d’un grand intervalle [0, m[ :
X = grand(n,1,"lgi")
o` u m d´epend du g´en´erateur de base (par d´efaut m = 2
32
(voir plus loin)) ;
2. une loi uniforme sur les entiers de l’intervalle [k
1
, k
2
] :
X = grand(n,1,"uin",k1,k2)
(il faut que k
2
−k
1
≤ 2147483561 mais dans le cas contraire ce probl`eme est signal´e par un message
d’erreur) ;
3. pour la loi uniforme sur [0, 1[ :
X = grand(n,1,"def")
4. pour la loi uniforme sur [a, b[ :
X = grand(n,1,"unf",a,b)
5. pour la loi binomiale B(N, p) :
X = grand(n,1,"bin",N,p)
6. pour la loi g´eom´etrique G(p) :
X = grand(n,1,"geom",p)
7. pour la loi de Poisson de moyenne µ :
X = grand(n,1,"poi",mu)
8. pour la loi exponentielle de moyenne λ :
X = grand(n,1,"exp",lambda)
9. pour la loi normale de moyenne µ et d’´ecart type σ :
X = grand(n,1,"nor",mu,sigma)
95
Il y en a d’autres (cf la page d’aide).
Depuis la version 2.7, grand est muni de diff´erents g´en´erateurs de base (qui fournissent des entiers
selon la loi lgi). Par d´efaut grand utilise Mersenne Twister qui poss`ede une p´eriode gigantesque de 2
19937
et il y a en tout 6 g´en´erateurs
8
.
Pour op´erer sur ces g´en´erateurs de base, vous pouvez utiliser les instructions suivantes :
nom gen = grand("getgen") permet de r´ecup´erer le (nom du) g´en´erateur courant
grand("setgen",nom gen) le g´en´erateur nom gen devient le g´en´erateur courant
etat = grand("getsd") permet de r´ecup´erer l’´etat interne du g´en´erateur courant
grand("setsd",e1,e2,..) impose l’´etat interne du g´en´erateur courant
La dimension de l’´etat interne de chaque g´en´erateur d´epend du type du g´en´erateur : de un entier pour
urand `a 624 entiers plus un index pour Mersenne Twister
9
. Si vous voulez refaire exactement la mˆeme
simulation il faut connaˆıtre l’´etat initial (avant la simulation) du g´en´erateur utilis´e et le sauvegarder
d’une fa¸con ou d’une autre. Exemple :
grand("setgen","kiss") // kiss devient le g´en´erateur courant
e = [1 2 3 4]; // etat que je vais imposer pour kiss
// (il lui faut 4 entiers)
grand("setsd",e(1),e(2),e(3),e(4)); // voila c’est fait !
grand("getsd") // doit retourner le vecteur e
X = grand(10,1,"def"); // 10 nombres
s1 = sum(X);
X = grand(10,1,"def"); // encore 10 nombres
s2 = sum(X);
s1 == s2 // en g´en´eral s1 sera different de s2
grand("setsd",e(1),e(2),e(3),e(4)); // retour `a l’´etat initial
X = grand(10,1,"def"); // de nouveau 10 nombres
s3 = sum(X);
s1 == s3 // s1 doit etre egal a s3
5.3 Les fonctions de r´epartition classiques et leurs inverses
Ces fonctions sont souvent utiles pour les tests statistiques (χ
2
r
, ...) car elles permettent de calculer,
soit :
1. la fonction de r´epartition en 1 ou plusieurs points ;
2. son inverse en 1 ou plusieurs points ;
3. l’un des param`etres de la loi, ´etant donn´es les autres et un couple (x, F(x)) ;
Dans le Help, vous les trouverez `a la rubrique « Cumulative Distribution Functions... », toutes ces fonc-
tions commencent par les lettres cdf. Prenons par exemple la loi normale ^(µ, σ
2
), la fonction qui nous
int´eresse s’appelle cdfnor et la syntaxe est alors :
1. [P,Q]=cdfnor("PQ",X,mu,sigma) pour obtenir P = F
µ,σ
(X) et Q = 1−P , X, mu et sigma peuvent
ˆetre des vecteurs (de mˆeme taille) et l’on obtient alors pour P et Q des vecteurs avec P
i
= F
µ
i

i
(X
i
) ;
2. [X]=cdfnor("X",mu,sigma,P,Q) pour obtenir X = F
−1
µ,σ
(P) (de mˆeme que pr´ec´edemment les ar-
guments peuvent ˆetre des vecteurs de mˆeme taille et l’on obtient alors X
i
= F
−1
µ
i

i
(P
i
) ;
3. [mu]=cdfnor("Mean",sigma,P,Q,X) pour obtenir la moyenne ;
4. et finalement [sigma]=cdfnor("Std",P,Q,X,mu) pour obtenir l’´ecart type.
Ces deux derni`eres syntaxes fonctionnant aussi si les arguments sont des vecteurs de mˆeme taille.
Remarques :
– le fait de travailler `a la fois avec p et q = 1 −p permet d’obtenir de la pr´ecision dans les zones o` u p
est proche de 0 ou de 1. Lorsque p est proche de 0 la fonction travaille en interne avec p mais avec
lorsque p est proche de 1 la fonction travaille en interne avec q ;
8
"mt" ,"kiss", "clcg4", "clcg2", "fsultra", et "urand", ce dernier ´etant simplement le g´en´erateur de rand.
9
une proc´edure d’initialisation avec un seul entier existe n´eanmoins pour ce g´en´erateur.
96
– la chaˆıne de caract`eres permettant d’obtenir la fonction inverse n’est pas toujours "X"... voyez les
pages d’aide correspondantes.
5.4 Simulations stochastiques simples
5.4.1 Introduction et notations
Souvent une simulation va consister en premier lieu, `a obtenir un vecteur :
x
m
= (x
1
, ...., x
m
)
dont les composantes sont consid´er´ees comme les r´ealisations de variables al´eatoires ind´ependantes et de
mˆeme loi X
1
, X
2
, ...., X
m
(on notera X une variable al´eatoire g´en´erique suivant la mˆeme loi). Dans la
pratique le vecteur x
m
s’obtient directement ou indirectement `a partir des fonctions rand ou grand
10
.
A partir de l’´echantillon x
m
on cherche `a approcher les caract´eristiques de la loi sous-jacente comme
l’esp´erance, l’´ecart type, la fonction de r´epartition (ou la densit´e) ou, si on emet une hypoth`ese sur la
loi en question, `a d´eterminer son ou ses param`etres, ou encore si les param`etres sont connus, `a v´erifier
via un ou des tests statistiques que notre ´echantillon est (probablement) bien issu de v.a. qui suivent
effectivement la loi en question, etc... Pour les cas qui nous int´eressent (cas d’´ecole) on connaˆıt la plupart
du temps les r´esultats th´eoriques exacts et la simulation sert en fait `a illustrer un r´esultat, un th´eor`eme
(lgn, TCL, etc...), le fonctionnement d’une m´ethode ou d’un algorithme, ....
5.4.2 Intervalles de confiance
Une fois l’esp´erance empirique obtenue `a partir de notre ´echantillon (en scilab avec x bar m =
mean(xm)), on aimerait connaˆıtre un intervalle Ic (souvent centr´e en ¯ x
m
) pour affirmer que :
E[X] ∈ I
c
avec probabilit´e de 1 −α
o` u souvent α = 0.05 ou 0.01 (intervalles de confiance `a respectivement 95 % et 99 %). L’outil de base
pour d´eriver de tels intervalles est le T.C.L.. Si on pose :
¯
X
m
=
1
m
m

i=1
X
i
la variable al´eatoire moyenne (dont ¯ x
m
est une r´ealisation), alors, la loi des grands nombres nous dit que
¯
X
m
« converge » vers E[X] et le T.C.L. (sous certaines conditions...), nous dit que :
lim
m→+∞
P(a <

m(
¯
X
m
−E[X])
σ
≤ b) =
1


_
b
a
e
−t
2
/2
dt
(on a pos´e V ar[X] = σ
2
). Si m est suffisamment grand, on peut approcher cette probabilit´e en consid´erant
la limite « atteinte
11
» :
P(a <

m(
¯
X
m
−E[X])
σ
≤ b) ≈
1


_
b
a
e
−t
2
/2
dt
Si l’on cherche un intervalle de confiance “sym´etrique” :
1


_
a
−a
e
−t
2
/2
dt = F
N(0,1)
(a) −F
N(0,1)
(−a) = 2F
N(0,1)
(a) −1 = 1 −α
10
en fait en statistique l’´echantillon est la plupart du temps obtenu ` a partir de mesures physiques (temp´erature, pression,
...), biom´etriques (tailles, poids), de sondages, etc... les donn´ees obtenues ´etant stock´ees dans des fichiers (ou dans des bases
de donn´ees) ; certains logiciels (comme R) proposent de tels jeux de donn´ees (pour que les ´etudiants puissent se faire la
main !) mais pas scilab ` a l’heure actuelle ; n´eanmoins les cas o` u on utilise de telles simulations sont quand mˆeme nombreux,
par exemple pour ´etudier le comportement de certains syst`emes ` a des entr´ees (ou des perturbations) al´eatoires ou mˆeme pour
r´esoudre des probl`emes purement d´eterministes mais pour lesquels les m´ethodes d’analyse num´erique sont trop compliqu´ees
ou impossible ` a mettre en oeuvre.
11
pour certaines lois on a des crit`eres d’application, par exemple si X ∼ Ber(p) alors l’approximation par la limite est
suffisamment pr´ecise (pour ce que l’on cherche ` a en faire) `a partir du moment o` u min(mp, m(1 −p)) > 10.
97
alors :
a
α
= F
−1
N(0,1)
(1 −
α
2
) ou encore −F
−1
N(0,1)
(
α
2
)
ce qui s’´ecrit en scilab :
a_alpha = cdfnor("X", 0, 1, 1-alpha/2, alpha/2)
On obtient donc finalement
12
:
E[X] ∈ [¯ x
m

a
α
σ

m
, ¯ x
m
+
a
α
σ

m
]
avec probabilit´e 1 −α environ (si l’approximation par la limite est correcte...).
Le probl`eme est que l’on ne connaˆıt g´en´eralement pas l’´ecart type... On utilise alors soit une majo-
ration, ou encore l’estimation donn´ee par :
S
m
=
¸
¸
¸
_
1
m−1
m

i=1
(X
i

¯
X
m
)
2
En rempla¸cant l’´ecart type σ par s
m
(o` u s
m
est la r´ealisation de S
m
), on obtient alors un intervalle de
confiance que l’on qualifie lui aussi d’empirique.
Il existe cependant des cas particuliers :
1. si les X
i
suivent la loi normale N(µ, σ
2
) alors :

m
¯
X
m
−µ
S
m
∼ t(m−1)
o` u t(k) est la loi de Student `a k degr´es de libert´e. Dans ce cas, les diverses approximations
pr´ec´edentes n’existent plus (approximation par la limite et approximation de l’´ecart type) et on
obtient alors :
µ ∈ [¯ x
m

a
α
s
m

m
, ¯ x
m
+
a
α
s
m

m
] avec probabilit´e 1 −α
o` u s
m
est l’´ecart type empirique de l’´echantillon (sm = st deviation(xm) en scilab) et o` u le a
α
est calcul´e `a partir de la loi de Student (au lieu de la loi N(0, 1)) :
a
α
= F
−1
t(m−1)
(1 −
α
2
)
ce qui s’obtient en scilab
13
par :
a_alpha = cdft("T", m-1, 1-alpha/2, alpha/2)
2. lorsque la variance s’exprime en fonction de l’esp´erance (Bernouilli, Poisson, exponentielle,...) on
peut se passer de l’approximation de l’´ecart type et l’intervalle s’obtient alors en r´esolvant une
in´equation.
5.4.3 Dessiner une fonction de r´epartition empirique
La fonction de r´epartition de X est la fonction :
F(x) = Probabilit´e que X ≤ x
La fonction de r´epartition empirique d´efinie `a partir de l’´echantillon x
m
est d´efinie par :
F
x
m(x) = card¦x
i
<= x¦/m
C’est une fonction en escalier qui se calcule facilement si on trie le vecteur x
m
dans l’ordre croissant (on
a alors F
x
m(x) = i/m pour x
i
≤ x < x
i+1
). L’algorithme standard de tri de Scilab est la fonction sort
qui trie dans l’ordre d´ecroissant
14
. Pour trier le vecteur x
m
dans l’ordre croissant, on utilise :
12
Pour un intervalle ` a 95%, on a a
α
1.96 que l’on approche souvent par 2.
13
voir la page d’aide correspondante : en fait les fonctions cdf n’ont pas une syntaxe tr`es r´eguliere et "X" n’est pas toujours
l’indicateur permettant d’obtenir la fonction de r´epartition inverse, ici c’est"T" !
14
voir aussi la fonction gsort qui permet de faire plus de choses
98
xm = - sort(-xm)
La fonction plot2d2 nous permet alors de dessiner cette fonction sans se fatiguer. Voici un code possible :
function repartition_empirique(xm)
// trac´e de la fonction de repartition (empirique)
// associ´ee `a l’´echantillon xm
m = length(xm)
xm = - sort(-xm(:))
ym = (1:m)’/m
plot2d2(xm, ym, leg="repartition empirique")
endfunction
comportant une petite astuce : le xm( :) permet de faire fonctionner le code mˆeme si on utilise la fonction
`a partir d’un vecteur ligne.
Voici maintenant un exemple avec la loi normale ^(0, 1) :
m = 100;
xm = grand(m,1,"nor",0,1);
xbasc()
repartition_empirique(xm); // dessin de la fct de repartition empirique
// les donnees pour tracer la fonction de repartition "exacte"
x = linspace(-4,4,100)’;
y = cdfnor("PQ", x, zeros(x), ones(x));
plot2d(x, y, style=2) // on rajoute la courbe sur le premier dessin
xtitle("Fonctions de r´epartition exacte et empirique")
qui m’a permis d’obtenir la figure (5.3).
−4 −3 −2 −1 0 1 2 3 4
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
repartition empirique
−4 −3 −2 −1 0 1 2 3 4
0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
1.0
Fonctions de répartition exacte et empirique
Fig. 5.3 – Fonctions de r´epartition exacte et empirique pour la loi normale
5.4.4 Test du χ
2
Soit donc x
m
= (x
1
, ..., x
m
) notre ´echantillon `a analyser. Et soit l’hypoth`ese H : « les variables
al´eatoires sous-jacentes (X
1
, ..., X
m
) suivent la loi L ». On a envie de savoir si cette hypoth`ese est r´ealiste
ou pas. Sur cet ´echantillon, on peut sans doute calculer les statistiques ´el´ementaires (moyenne et ´ecart
99
type empirique) et si celles-ci semblent raisonnablement proches de l’esp´erance et de l’´ecart type de L,
on peut alors mettre en oeuvre un test statistique. Le test du χ
2
s’applique sur une loi discr`ete prenant
un nombre fini de valeurs. Par exemple supposons que la loi de L est donn´ee par ¦(v
i
, p
i
), 1 ≤ i ≤ n¦. Le
test consiste `a calculer la quantit´e :
y =

n
i=1
(o
i
−mp
i
)
2
mp
i
o` u o
i
est le nombre de r´esultats x
j
´egaux `a v
i
et `a comparer la valeur obtenue y `a un seuil y
α
, le test
´etant alors positif
15
si y ≤ y
α
.
Si on utilise, dans la formule donnant y, les variables al´eatoires X
1
, ..., X
m
au lieu de l’´echantillon
x
1
, ..., x
m
on d´efinit
16
alors une variable al´eatoire Y qui suit approximativement (pour m suffisamment
grand) la loi du χ
2
`a n −1 degr´es de libert´e. La valeur seuil est alors obtenue par :
y
α
= F
−1
χ
2
n−1
(1 −α)
avec souvent α = 0.05 o` u encore α = 0.01. En Scilab, ce seuil s’obtiendra par :
y_seuil = cdfchi("X", n-1, 1-alpha, alpha)
Pour calculer les occurences o
i
avec scilab, on pourra utiliser la m´ethode suivante :
occ = zeros(n,1);
for i=1:n
occ(i) = sum(bool2s(xm == v(i))); // ou encore length(find(xm==v(i)))
end
if sum(occ) ~= m then, error("probl`eme de comptage"), end
Et pour obtenir la quantit´e y on pourra ´ecrire (en utilisant l’´ecriture vectorielle
17
) :
y = sum( (occ - m*p).^2 ./ (m*p) )
`a la condition que p (le vecteur donnant les probabilit´es de L), soit de mˆeme format que occ (ici un
vecteur colonne vu mon choix pour occ).
Remarques :
– l’approximation par la loi du χ
2
est valable si m est suffisamment grand... on donne souvent la r`egle
mp
min
> 5 (p
min
= min
i
p
i
) comme condition d’application minimale de ce test ; ainsi vous pouvez
v´erifier cette condition et ´ecrire un message pour pr´evenir l’utilisateur si elle n’est pas satisfaite.
– il est facile de regrouper ces calculs dans une fonction ;
– pour une loi continue le test peut s’appliquer en regroupant les valeurs par intervalles, par exemple
pour la loi U
[0,1]
, on utilise n intervalles ´equidistants ; de mˆeme pour une loi discr`ete prenant un
nombre infini de valeurs, on peut regrouper celles en queue de la distribution ; ce mˆeme proc´ed´e
peut s’appliquer aux lois discr`etes finies pour lesquelles la condition d’application du test n’est pas
satisfaite.
– si vous faites le test `a partir d’une loi dont certains param`etres ont ´et´e d´etermin´es avec les donn´ees,
il faut retrancher d’autant le nombre de degr´es de libert´e pour le χ
2
; par exemple si la loi attendue
est B(n − 1, p) et que vous utilisiez p = ¯ x
m
/(n − 1) alors le seuil `a ne pas d´epasser pour un test
positif serait de y
α
= F
−1
χ
2
n−2
(1 −α) au lieu de y
α
= F
−1
χ
2
n−1
(1 −α).
5.4.5 Test de Kolmogorov-Smirnov
Ce test est plus naturel que celui du χ
2
lorsque la loi attendue a une fonction de r´epartition continue.
Soit X une v.a. r´eelle dont la loi a une fonction de r´epartition continue F et X
1
, X
2
,..., X
m
, m copies
ind´ependantes de X. A partir des r´ealisations des X
i
(disons le vecteur x
m
= (x
1
, ...., x
m
)), on peut
construire une fonction de r´epartition empirique qui doit converger lorsque (m → +∞) vers la fonction
15
d’un point de vue intuitif, si l’hypoth`ese est bonne on s’attend ` a ce que o
i
ne soit pas trop loin de mp
i
, donc si l’hypoth`ese
est fausse, on s’attend ` a obtenir une valeur ´elev´ee pour y, d’o` u le rejet de l’hypoth`ese pour y > y
α
...
16
via la variable al´eatoire vectorielle O = (O
1
, ..., O
n
) qui suit une loi multinomiale.
17
exercice : d´ecomposer cette instruction vectorielle pour comprendre comment (et pourquoi) elle fonctionne.
100
de r´epartition exacte. Le test KS consiste justement `a mesurer un ´ecart entre la fonction de r´epartition
exacte et la fonction de r´epartition empirique (obtenue avec notre ´echantillon (x
1
, ...., x
m
)) d´efini par :
k
m
=

m sup
−∞<x<+∞
[F(x) −F
x
m(x)[
et `a le comparer `a une valeur « admissible ». Si on remplace nos r´ealisations par les variables al´eatoires
correspondantes, il est clair que k
m
est en fait une variable al´eatoire (que l’on notera K
m
). La th´eorie
nous dit qu’`a la limite, sa loi a la fonction de r´epartition suivante :
lim
m→+∞
P(K
m
≤ x) = H(x) = 1 −2
+∞

j=1
(−1)
j−1
e
−2j
2
x
2
Comme pour le test du χ
2
, si l’hypoth`ese envisag´ee est fausse, la valeur obtenue pour k
m
aura tendance
`a ˆetre grande, et on va alors rejetter l’hypoth`ese lorsque :
k
m
> H
−1
(1 −α)
avec α = 0.05 ou 0.01 par exemple. Si on utilise l’approximation H(x) · 1 −2e
−2x
2
alors la valeur seuil
`a ne pas d´epasser est :
k
seuil
=
_
1
2
ln(
2
α
)
Le calcul de k
m
ne pose pas de probl`eme si on trie le vecteur (x
1
, x
2
, . . . , x
m
). Supposons ce tri
effectu´e, en remarquant que :
sup
x∈[x
i
,x
i+1
[
F
x
m(x) −F(x) =
i
m
−F(x
i
), et sup
x∈[x
i
,x
i+1
[
F(x) −F
x
m(x) = F(x
i+1
) −
i
m
les deux quantit´es suivantes se calculent facilement :
k
+
m
=

m sup
−∞<x<+∞
(F
x
m(x) −F(x)) =

m max
1≤j≤m
(
j
m
−F(x
j
))
k

m
=

m sup
−∞<x<+∞
(F(x) −F
x
m(x)) =

m max
1≤j≤m
(F(x
j
) −
j −1
m
)
et l’on obtient alors k
m
= max(k
+
m
, k

m
).
5.4.6 Exercices
D´e truqu´e ou non ?
On a effectu´e 200 fois l’exp´erience suivante avec le mˆeme d´e : on le jette autant de fois qu’il le faut
jusqu’`a obtenir un 1 (mais on arrˆete lorsque le 1 n’est pas sorti au bout de 10 lanc´es). On a obtenu les
r´esultats suivants :
nombre de jets 1 2 3 4 5 6 7 8 9 10 ≥ 11
nombre d’exp´eriences 36 25 26 27 12 12 8 7 8 9 30
par exemple il y a 36 exp´eriences o` u le 1 est sorti lors du premier lanc´e, 25 o` u le 1 est sorti au deuxi`eme
lanc´e, etc...
Effectuer un test χ
2
pour essayer de r´epondre `a la question.
Urne de Polya
On effectue N tirages dans l’urne de Polya. Celle-ci contient au d´epart r boules rouges et v boules
vertes et chaque tirage consiste `a tirer une boule au hasard et `a la remettre dans l’urne avec c boules de
la mˆeme couleur. On note X
k
la proportion de boules vertes apr`es k tirages et V
k
le nombre de boules
vertes :
X
0
=
v
v +r
, V
0
= v.
Si l’on choisit v = r = c = 1, on a les r´esultats suivants :
101
1. E(X
N
) = E(X
0
) = X
0
= 1/2 ;
2. X
N
suit une loi uniforme sur ¦
1
N+2
, .....,
N+1
N+2
¦ ;
3. pour N →+∞, X
N
converge p.s. vers la loi uniforme sur [0, 1).
Vous allez mettre en oeuvre une simulation pour illustrer les deux premiers r´esultats.
1. Pour effectuer diff´erentes simulations, on peut programmer une fonction prenant le param`etre N
et qui effectue N tirages successifs. Cette fonction renvoie alors X
N
et V
N
:
function [XN, VN] = Urne_de_Polya(N)
// simulation de N tirages d’une "Urne de Polya" :
VN = 1 ; V_plus_R = 2 ; XN = 0.5
for i=1:N
u = rand() // tirage d’une boule
V_plus_R = V_plus_R + 1 // ca fait une boule de plus
if (u <= XN) then // on a tire une boule verte : on a XN proba de
// tomber sur une verte (et 1 - XN sur une rouge)
VN = VN + 1
end
XN = VN / V_plus_R // on actualise la proportion de boules vertes
end
endfunction
mais pour effectuer des statistiques cons´equentes cette fonction va ˆetre appel´ee tr´es souvent et
comme les it´erations sont lentes en Scilab, vous allez ´ecrire une fonction capable de simuler m
processus en « parall`ele » (il ne s’agit pas de vrai parall´elisme informatique mais simplement
d’exploiter le fait que les op´erations matricielles sont efficaces en Scilab). On pourra utiliser la
fonction find pour rep´erer les urnes o` u l’on a tir´e une boule verte.
2. Ecrire un script pour retrouver par simulation le r´esultat attendu pour l’esp´erance (avec son inter-
valle de s´ecurit´e).
3. Continuer votre script en testant l’hypoth`ese H sur le comportement de la variable al´eatoire X
N
« H : X
N
suit une loi uniforme sur ¦
1
N+2
, .....,
N+1
N+2
¦ » avec un test du χ
2
.
4. Essayer de r´ealiser des illustrations graphiques, par exemple, tracer les probabilit´es empiriques
obtenues et les probabilit´es exactes sur un mˆeme dessin et, sur un autre, tracer la densit´e χ
2
tout
en positionnant la valeur obtenue par le test ainsi que la valeur seuil par des traits verticaux.
Le pont brownien
Le processus stochatisque suivant (o` u U d´esigne la loi uniforme sur [0, 1]) :
X
n
(t) =
1

n
n

i=1
(1
{U
i
≤t}
−t)
est tel que pour t ∈]0, 1[ fix´e, on a :
lim
n→+∞
X
n
(t) = Y (t) ∼ ^(0, t(1 −t))
On cherche `a illustrer ce r´esultat `a l’aide de simulations.
Travail `a r´ealiser :
1. Ecrire une fonction Scilab function [X] = pont_brownien(t,n) permettant d’obtenir une r´ealisation
de X
n
(t) ; dans la suite on appelera cette fonction m fois avec une valeur de n assez grande
18
il faut
donc l’´ecrire sans utiliser de boucle.
2. Ecrire un script scilab mettant en place cette simulation du pont Brownien : effectuer m simulations
de X
n
(t) (avec n grand) et illustrer graphiquement la convergence en loi (en dessinant la fonction de
r´epartition empirique et en lui juxtaposant la fonction de r´epartition exacte de Y (t) puis effectuer
le test de Kolmogorov-Smirnov. On pourra placer la fonction pr´ec´edente en d´ebut du script pour
travailler avec un seul fichier.
18
pour essayer d’approcher Y (t) !
102
Remarque : il n’est pas facile de r´egler de bonnes valeurs pour m et n : lorsque m croit il y a un moment
o` u le test ´echoue car il d´etecte en fait que n n’est pas assez grand (puisque la loi normale est obtenue
`a la limite lorsque n → +∞), il faut alors r´eaugmenter n... Avec t = 0.3, vous pouvez par exemple
tester avec n = 1000 et m = 200, 500, 1000, et le test fonctionne bien (il y a tr`es peu de rejet) mais
avec m = 10000 le test est presque toujours n´egatif. Si on augmente n (avec par exemple n = 10000
mais les calculs commencent `a ˆetre un peu long sur un PC performant de 2003) alors le test redevient
« normalement » positif.
103
Chapitre 6
B´etisier
Cette partie essaie de r´epertorier quelques erreurs fr´equentes que l’on peut commettre en Scilab...
6.1 D´efinition d’un vecteur ou d’une matrice « coefficient par coeffi-
cient »
Cette erreur est l’une des plus fr´equentes. Consid´erons le script suivant :
K = 100 // le seul parametre de mon script
for k=1:K
x(k) = quelque chose
y(k) = autre chose
end
plot(x,y)
Lorsque l’on ex´ecute ce script pour la premi`ere fois, on d´efinit les deux vecteurs x et y de fa¸ con assez
naturelle et tout semble fonctionner... Il y a d´ej`a un petit d´efaut car, `a chaque it´eration, Scilab red´efinit
les dimensions de ces vecteurs (il ne sait pas que leur taille finale sera (K,1)). Notons aussi que, par
d´efaut, il va cr´eer des vecteurs colonnes. Lors de la deuxi`eme ex´ecution (je viens de changer le param`etre
K...) les vecteurs x et y sont connus et tant que k est inf´erieur `a 100 (la valeur initiale de K) il se contente
de changer la valeur des composantes. Par cons´equent si la nouvelle valeur de K est telle que :
– K < 100 alors nos vecteurs x et y ont toujours 100 composantes (seules les K premi`eres ont ´et´e
modifi´ees) et le dessin ne repr´esentera pas ce que l’on veut ;
– K > 100 on a apparemment pas de probl`emes (mis `a part le fait que la taille de vecteurs est de
nouveau `a chaque fois diff´erente `a partir de l’it´eration 101).
La bonne m´ethode est de d´efinir compl`etement les vecteurs x et y avec une initialisation du genre :
x = zeros(K,1) ; y = zeros(K,1)
et l’on ne retrouve plus ces d´efauts. Notre script s’´ecrira donc :
K = 100 // le seul parametre de mon script
x = zeros(K,1); y = zeros(K,1);
for k=1:K
x(k) = quelque chose
y(k) = autre chose
end
plot(x,y)
6.2 Apropos des valeurs renvoy´ees par une fonction
Supposons que l’on ait programm´e une fonction Scilab qui renvoie deux arguments, par exemple :
104
function [x1,x2] = resol(a,b,c)
// resolution de l’equation du second degre a x^2 + b x + c = 0
// formules ameliorees pour plus de robutesse numerique
// (en evitant la soustraction de 2 nombres voisins)
if (a == 0) then
error(" on ne traite pas le cas a=0 !")
else
delta = b^2 - 4*a*c
if (delta < 0) then
error(" on ne traite pas le cas ou delta < 0 ")
else
if (b < 0) then
x1 = (-b + sqrt(delta))/(2*a) ; x2 = c/(a*x1)
else
x2 = (-b - sqrt(delta))/(2*a) ; x1 = c/(a*x2)
end
end
end
endfunction
D’une mani`ere g´en´erale, lorsque l’on invoque une fonction `a partir de la fenˆetre Scilab de la fa¸ con
suivante :
-->resol(1.e-08, 0.8, 1.e-08)
ans =
- 1.250D-08
celui-ci est mis dans la variable ans. Mais ans est toute seule et comme cette fonction renvoie 2 valeurs,
seule la premi`ere est affect´ee dans ans. Pour r´ecup´erer les deux valeurs, on utilise la syntaxe :
-->[x1,x2] = resol(1.e-08, 0.8, 1.e-08)
x2 =
- 80000000.
x1 =
- 1.250D-08
6.3 Je viens de modifier ma fonction mais...
tout semble se passer comme avant la modification ! Vous avez peut ˆetre oubli´e de sauvegarder les
modifications avec votre ´editeur ou, plus certainement, vous avez oubli´e de recharger le fichier qui contient
cette fonction dans Scilab avec l’instruction getf (ou exec) ! Une petite astuce : votre instruction getf
(ou exec) n’est certainement pas tr`es loin dans l’historique des commandes, taper alors sur la touche ↑
jusqu’`a la retrouver.
6.4 Probl`eme avec rand
Par d´efaut rand fournit des nombres al´eatoires selon la loi uniforme sur [0, 1[ mais on peut obtenir la
loi normale ^(0, 1) avec : rand("normal"). Si on veut de nouveau la loi uniforme il ne faut pas oublier
l’instruction rand("uniform"). Un moyen imparable pour ´eviter ce probl`eme est de pr´eciser la loi `a
chaque appel (voir chapitre pr´ec´edent).
6.5 Vecteurs lignes, vecteurs colonnes...
Dans un contexte matriciel ils ont une signification pr´ecise mais pour d’autres applications il semble
naturel de ne pas faire de diff´erence et d’adapter une fonction pour qu’elle marche dans les deux cas.
Cependant pour effectuer les calculs rapidement, il est pr´ef´erable de recourir `a des expressions matricielles
plutˆot qu’`a des it´erations et il faut alors choisir une forme ou l’autre. On peut utiliser alors la fonction
matrix de la fa¸ con suivante :
105
x = matrix(x,1,length(x)) // pour obtenir un vecteur ligne
x = matrix(x,length(x),1) // pour obtenir un vecteur colonne
Si on cherche simplement `a obtenir un vecteur colonne, on peut utiliser le raccourci :
x = x(:)
6.6 Op´erateur de comparaison
Dans certains cas Scilab admet le symbole = comme op´erateur de comparaison :
-->2 = 1
Warning: obsolete use of = instead of ==
!
ans =
F
mais il vaut mieux toujours utiliser le symbole ==.
6.7 Nombres Complexes et nombres r´eels
Tout est fait dans Scilab pour traiter de la mˆeme mani`ere les r´eels et les complexes ! Ceci est assez
pratique mais peut conduire `a certaines surprises, par exemple lorsque vous ´evaluez une fonction r´eelle
hors de son domaine de d´efinition (par exemple

x et log(x) pour x < 0, acos(x) et asin(x) pour
x / ∈ [−1, 1], acosh(x) pour x < 1) car Scilab renvoie alors l’´evaluation de l’extension complexe de la
fonction. Pour savoir si l’on a affaire a une variable r´eelle ou complexe, on peut utiliser la fonction
isreal :
-->x = 1
x =
1.
-->isreal(x)
ans =
T
-->c = 1 + %i
c =
1. + i
-->isreal(c)
ans =
F
-->c = 1 + 0*%i
c =
1.
-->isreal(c)
ans =
F
6.8 Primitives et fonctions Scilab : SHOULD BE UPDATED
Dans ce document j’ai utilis´e plus ou moins indiff´eremment les termes primitive et fonction pour
d´esigner des « proc´edures » offertes par la version courante de Scilab. Il existe cependant une diff´erence
106
fondamentale entre une primitive qui est cod´ee en fortran 77 ou en C et une fonction (appel´ee aussi
macro) qui est cod´ee en langage Scilab : une fonction est consid´er´ee comme une variable Scilab, et, `a ce
titre vous pouvez faire passer une fonction en tant qu’argument d’une autre fonction. Depuis la version
2.7, les primitives sont aussi des sortes de variables Scilab (de type fptr). N´eanmoins il subsiste quelques
probl`emes (actuellement r´esolus dans la version de d´eveloppement).
Voici un exemple de probl`eme que l’on peut rencontrer : la fonction suivante permet d’approcher une
int´egrale par la m´ethode de Monte Carlo :
function [im,sm]=MonteCarlo(a,b,f,m)
// /b
// approx de | f(x) dx par la methode de Monte Carlo
// /a
// on renvoie aussi l’ecart type empirique
xm = grand(m,1,"unf",a,b)
ym = f(xm)
im = (b-a)*mean(ym)
sm = (b-a)*st_deviation(ym)
endfunction
Pour l’argument f, une fonction Scilab est attendue mais ce code devrait aussi fonctionner avec les
fonctions math´ematiques qui sont des primitives Scilab
1
puisqu’elles sont maintenant consid´er´ees comme
des variables. N´eanmoins un test avec une primitive, par exemple exp ´echoue :
-->[I,sigma]=MonteCarlo(0,1,exp,10000) // bug !
Cependant si vous chargez la fonction MonteCarlo avec getf muni de l’option de non compilation :
-->getf("MonteCarlo.sci","n")
ce bug (corrig´e dans le cvs actuel) est alors contourn´e.
That ’s all Folks...
1
par exemple sin, exp et beaucoup d’autres sont des primitives.
107
Annexe A
Correction des exercices du chapitre 2
1. --> n = 5 // pour fixer une valeur a n...
--> A = 2*eye(n,n) - diag(ones(n-1,1),1) - diag(ones(n-1,1),-1)
Un moyen plus rapide consiste `a utiliser la fonction toeplitz :
-->n=5; // pour fixer une valeur a n...
-->toeplitz([2 -1 zeros(1,n-2)])
2. Si A est une matrice (n, n), diag(A) renvoie un vecteur colonne contenant les ´el´ements diagonaux
de A (donc un vecteur colonne de dimension n). diag(diag(A) renvoie alors une matrice carr´ee
diagonale d’ordre n, avec comme ´el´ements diagonaux ceux de la matrice initiale.
3. Voici une possibilit´e :
--> A = rand(5,5)
--> T = tril(A) - diag(diag(A)) + eye(A)
4. (a) --> Y = 2*X.^2 - 3*X + ones(X)
--> Y = 2*X.^2 - 3*X + 1 // en utilisant un raccourci d’ecriture
--> Y = 1 + X.*(-3 + 2*X) // plus un schema a la Horner
(b) --> Y = abs(1 + X.*(-3 + 2*X))
(c) --> Y = (X - 1).*(X + 4) // en utilisant un raccourci d’ecriture
(d) --> Y = ones(X)./(ones(X) + X.^2)
--> Y = (1)./(1 + X.^2) // avec des raccourcis
5. Voici le script :
n = 101; // pour la discretisation
x = linspace(0,4*%pi,n);
y = [1 , sin(x(2:n))./x(2:n)]; // pour eviter la division par zero...
plot(x,y,"x","y","y=sin(x)/x")
6. Un script possible (`a exp´erimenter avec diff´erentes valeurs de n) :
n = 2000;
x = rand(1,n);
xbar = cumsum(x)./(1:n);
plot(1:n, xbar, "n","xbar", ...
"illustration de la lgn : xbar(n) -> 0.5 qd n -> + oo")
108
Annexe B
Correction des exercices du chapitre 3
1. L’algorithme classique a deux boucles :
function [x] = sol_tri_sup1(U,b)
//
// resolution de Ux = b ou U est triangulaire superieure
//
// Remarque : Cet algo fonctionne en cas de seconds membres multiples
// (chaque second membre correspondant a une colonne de b)
//
[n,m] = size(U)
// quelques verifications ....
if n ~= m then
error(’ La matrice n’’est pas carree’)
end
[p,q] = size(b)
if p ~= m then
error(’ Second membre incompatible’)
end
// debut de l’algo
x = zeros(b) // on reserve de la place pour x
for i = n:-1:1
somme = b(i,:)
for j = i+1:n
somme = somme - U(i,j)*x(j,:)
end
if U(i,i) ~= 0 then
x(i,:) = somme/U(i,i)
else
error(’ Matrice non inversible’)
end
end
endfunction
Voici une version utilisant une seule boucle
function [x] = sol_tri_sup2(U,b)
//
// idem a sol_tri_sup1 sauf que l’on utilise un peu
// plus la notation matricielle
//
[n,m] = size(U)
// quelques verifications ....
if n ~= m then
109
error(’ La matrice n’’est pas carree’)
end
[p,q] = size(b)
if p ~= m then
error(’ Second membre incompatible’)
end
// debut de l’algo
x = zeros(b) // on reserve de la place pour x
for i = n:-1:1
somme = b(i,:) - U(i,i+1:n)*x(i+1:n,:) // voir le commentaire final
if U(i,i) ~= 0 then
x(i,:) = somme/U(i,i)
else
error(’ Matrice non inversible’)
end
end
endfunction
Commentaire : lors de la premiere iteration (correspondant `a i = n) les matrices U(i,i+1:n) et
x(i+1:n,:) sont vides. Elles correspondent `a un objet qui est bien defini en Scilab (la matrice vide)
qui se note []. L’addition avec une matrice vide est definie et donne : A = A + []. Donc lors de
cette premiere iteration, on a somme = b(n,:) + [] c’est a dire que somme = b(n,:).
2. //
// script pour resoudre x" + alpha*x’ + k*x = 0
//
// Pour mettre l’equation sous la forme d’un systeme du 1er ordre
// on pose : X(1,t) = x(t) et X(2,t) = x’(t)
//
// On obtient alors : X’(t) = A X(t) avec : A = [0 1;-k -alpha]
//
k = 1;
alpha = 0.1;
T = 20; // instant final
n = 100; // discretisation temporelle : l’intervalle [0,T] va etre
// decoupe en n intervalles
t = linspace(0,T,n+1); // les instants : X(:,i) correspondra a X(:,t(i))
dt = T/n; // pas de temps
A = [0 1;-k -alpha];
X = zeros(2,n+1);
X(:,1) = [1;1]; // les conditions initiales
M = expm(A*dt); // calcul de l’exponentielle de A dt
// le calcul
for i=2:n+1
X(:,i) = M*X(:,i-1);
end
// affichage des resultats
xset("window",0)
xbasc()
xselect()
plot(t,X(1,:),’temps’,’position’,’Courbe x(t)’)
xset("window",1)
xbasc()
xselect()
110
plot(X(1,:),X(2,:),’position’,’vitesse’,’Trajectoire dans le plan de phase’)
3. function [i,info]=intervalle_de(t,x)
// recherche dichotomique de l’intervalle i tel que: x(i)<= t <= x(i+1)
// si t n’est pas dans [x(1),x(n)] on renvoie info = %f
n=length(x)
if t < x(1) | t > x(n) then
info = %f
i = 0 // on met une valeur par defaut
else
info = %t
i_bas=1
i_haut=n
while i_haut - i_bas > 1
itest = floor((i_haut + i_bas)/2 )
if ( t >= x(itest) ) then, i_bas= itest, else, i_haut=itest, end
end
i=i_bas
end
endfunction
4. function [p]=myhorner(t,x,c)
// evaluation du polynome c(1) + c(2)*(t-x(1)) + c(3)*(t-x(1))*(t-x(2)) + ...
// par l’algorithme d’horner
// t est un vecteur d’instants (ou une matrice)
n=length(c)
p=c(n)*ones(t)
for k=n-1:-1:1
p=c(k)+(t-x(k)).*p
end
endfunction
5. Fabrication d’une serie de fourier tronquee :
function [y]=signal_fourier(t,T,cs)
// cette fonction renvoie un signal T-periodique
// t : un vecteur d’instants pour lesquels on calcule
// le signal y ( y(i) correspond a t(i) )
// T : la periode du signal
// cs : est un vecteur qui donne l’amplitude de chaque fonction f(i,t,T)
l=length(cs)
y=zeros(t)
for j=1:l
y=y + cs(j)*f(j,t,T)
end
endfunction
function [y]=f(i,t,T)
// les polynomes trigonometriques pour un signal de periode T :
// si i est pair : f(i)(t)=sin(2*pi*k*t/T) (avec k=i/2)
// si i est impair : f(i)(t)=cos(2*pi*k*t/T) (avec k=floor(i/2))
// d’ou en particulier f(1)(t)=1 que l’on traite ci dessous
// comme un cas particulier bien que se ne soit pas necessaire
111
// t est un vecteur d’instants
if i==1 then
y=ones(t)
else
k=floor(i/2)
if modulo(i,2)==0 then
y=sin(2*%pi*k*t/T)
else
y=cos(2*%pi*k*t/T)
end
end
endfunction
6. La rencontre : soit T
A
et T
B
les temps d’arriv´ee de Mr A et Melle B. Ce sont deux variables al´eatoires
ind´ependantes de loi U([17, 18]) et la rencontre `a lieu si [T
A
, T
A
+1/6] ∩[T
B
, T
B
+1/12] ,= ∅. En fait
une exp´erience de la rencontre correspond `a la r´ealisation de la variable al´eatoire vectorielle R =
(T
A
, T
B
) qui, avec les hypoth`eses, suit une loi uniforme sur le carr´e [17, 18] [17, 18]. La probabilit´e
de la rencontre se calcule donc en faisant le rapport entre la surface de la zone (correspondant `a
une rencontre effective) d´efinie par :
_
_
_
T
A
≤ T
B
+ 1/12
T
B
≤ T
A
+ 1/6
T
A
, T
B
∈ [17, 18]
et la surface du carr´e (1), ce qui permet d’obtenir p = 67/288. Pour calculer cette probabilit´e,
on peut bien sˆ ur faire comme si la rencontre devait avoir lieu entre minuit et une heure :-) ! Par
simulation, on effectue m exp´eriences et la probabilit´e empirique est le nombre de cas o` u la rencontre
a lieu divis´e par m. Voici une solution :
function [p] = rdv(m)
tA = rand(m,1)
tB = rand(m,1)
rencontre = tA+1/6 > tB & tB+1/12 > tA;
p = sum(bool2s(rencontre))/m
endfunction
on peut aussi utiliser la fonction grand d´ecrite dans le chapitre sur les applications :
function [p] = rdv(m)
tA = grand(m,1,"unf",17,18)
tB = grand(m,1,"unf",17,18)
rencontre = tA+1/6 > tB & tB+1/12 > tA;
p = sum(bool2s(rencontre))/m
endfunction
112
Annexe C
Correction des exercices du chapitre 5 :
NOT YET UPDATED FOR
GRAPHICS
D´e truqu´e ou non ?
Si on note J la variable al´eatoire correspondant au r´esultat de l’exp´erience alors J suit la loi
g´eom´etrique G(p) avec p = 1/6 si le d´e est non truqu´e. Avec les donn´ees de l’exp´erience, on agglom`ere
dans une mˆeme classe tous les r´esultats correspondants `a un nombre de lanc´es sup´erieur strictement `a
10. Ce qui nous donne les probabilit´es (notant q = 1 −p = 5/6) :
P(J = 1) = p, P(J = 2) = qp, P(J = 3) = q
2
p, ...., P(J = 10) = q
9
p, P(J > 10) = q
10
D’autre part le tableau donne directement le nombre d’occurence, d’o` u le script :
occ= [36 ; 25 ; 26 ; 27 ; 12 ; 12 ; 8 ; 7 ; 8 ; 9 ; 30];
p = 1/6; q = 5/6;
pr = [p*q.^(0:9) , q^10]’;
y = sum( (occ - m*pr).^2 ./ (m*pr) );
y_seuil = cdfchi("X", 10, 0.95, 0.05);
mprintf("\n\r Test sur le de :")
mprintf("\n\r y = %g, et y_seuil (95 \%) = %g", y, y_seuil)
mprintf("\n\r 200*min(pr) = %g", 200*min(pr))
On obtient y = 7.73915 alors que y
seuil
= 18.307, ce d´e semble donc correct. N´eanmoins on a
200 min(pr) · 6.5 ce qui est tout juste au dessus de la condition d’applicabilit´e du test (on pourrait
donc demander quelques exp´eriences suppl´ementaires).
Urne de Polya
La fonction scilab
function [XN, VN] = Urne_de_Polya_parallele(N,m)
VN = ones(m,1) ; V_plus_R = 2 ; XN = 0.5*ones(m,1)
for i=1:N
u = grand(m,1,"def") // tirage d’une boule (ds chacune des m urnes)
V_plus_R = V_plus_R + 1 // ca fait une boule de plus (qq soit l’urne)
ind = find(u <= XN) // trouve les numeros des urnes dans lesquelles
// on a tire une boule verte
VN(ind) = VN(ind) + 1 // on augmente alors le nb de boules vertes de ces urnes
XN = VN / V_plus_R // on actualise la proportion de boules vertes
end
endfunction
113
Le script Scilab
// polya simulation :
N = 10;
m = 5000;
[XN, VN] = Urne_de_Polya_parallele(N,m);
// 1/ calcul de l’esp´erance et de l’intervalle de securite
EN = mean(XN); // esperance empirique
sigma = st_deviation(XN); // ecart type empirique
delta = 2*sigma/sqrt(m); // increment pour l’intervalle empirique (2 pour 1.9599..)
mprintf("\n\r E exact = 0.5");
mprintf("\n\r E estime = %g",EN);
mprintf("\n\r Intervalle (empirique) de confiance a 95\% : [%g,%g]",EN-delta,EN+delta);
// 2/ test chi2
alpha = 0.05;
p = 1/(N+1); // proba theorique pour chaque resultat (loi uniforme)
occ = zeros(N+1,1);
for i=1:N+1
occ(i) = sum(bool2s(XN == i/(N+2)));
end
if sum(occ) ~= m then, error(" Probleme..."), end // petite verification
Y = sum( (occ - m*p).^2 / (m*p) );
Y_seuil = cdfchi("X",N,1-alpha,alpha);
mprintf("\n\r Test du chi 2 : ")
mprintf("\n\r -------------- ")
mprintf("\n\r valeur obtenue par le test : %g", Y);
mprintf("\n\r valeur seuil a ne pas depasser : %g", Y_seuil);
if (Y > Y_seuil) then
mprintf("\n\r Conclusion provisoire : Hypothese rejetee !")
else
mprintf("\n\r Conclusion provisoire : Hypothese non rejetee !")
end
// 3/ illustrations graphiques
function [d] = densite_chi2(X,N)
d = X.^(N/2 - 1).*exp(-X/2)/(2^(N/2)*gamma(N/2))
endfunction
frequences = occ/m;
ymax = max([frequences ; p]); rect = [0 0 1 ymax*1.05];
xbasc(); xset("font",2,2)
subplot(2,1,1)
plot2d3((1:N+1)’/(N+2), frequences, style=2 , ...
frameflag=1, rect=rect, nax=[0 N+2 0 1])
plot2d((1:N+1)’/(N+2),p*ones(N+1,1), style=-2, strf="000")
xtitle("Frequences empiriques (traits verticaux) et probabilites exactes (croix)")
subplot(2,1,2)
// on trace la densite chi2 a N ddl
X = linspace(0,1.1*max([Y_seuil Y]),50)’;
D = densite_chi2(X,N);
plot2d(X,D, style=1, leg="densite chi2", axesflag=2)
// un trait vertical pour Y
plot2d3(Y, densite_chi2(Y,N), style=2, strf="000")
xstring(Y,-0.01, "Y")
// un trait vertical pour Yseuil
plot2d3(Y_seuil, densite_chi2(Y_seuil,N), style=5, strf="000")
xstring(Y_seuil,-0.01, "Yseuil")
xtitle("Positionnement de Y par rapport a la valeur Yseuil")
Voici un r´esultat obtenu avec N = 10 et m = 5000 (cf figure (C.1)) :
E exact = 0.5
114
E estime = 0.4959167
Intervalle de confiance a 95% : [0.4884901,0.5033433]
Test du chi 2 :
--------------
valeur obtenue par le test : 8.3176
valeur seuil a ne pas depasser : 18.307038
Conclusion provisoire : Hypothese non rejetee !
0.000 0.083 0.167 0.250 0.333 0.417 0.500 0.583 0.667 0.750 0.833 0.917 1.000
0.0
0.1
× × × × × × × × × × ×
Frequences empiriques (traits verticaux) et probabilites exactes (croix)
densite chi2 Y Yseuil
Positionnement de Y par rapport a la valeur Yseuil
Fig. C.1 – Illustrations pour le test du χ
2
de l’urne de Polya...
Le pont brownien
La fonction
function [X] = pont_brownien(t,n)
X = sum(bool2s(grand(n,1,"def") <= t) - t)/sqrt(n)
endfunction
Le script
Ce script effectue m simulations de la variable al´eatoire X
n
(t), affiche le graphe de la fonction de
r´epartition empirique, lui superpose celui de la fonction de r´epartition attendue (pour n = +∞) et
finalement effectue le test KS :
t = 0.3;
sigma = sqrt(t*(1-t)); // l’´ecart type attendu
n = 4000; // n "grand"
m = 2000; // le nb de simulations
X = zeros(m,1); // initialisation du vecteur des realisations
for k=1:m
115
X(k) = pont_brownien(t,n); // la boucle pour calculer les realisations
end
// le dessin de la fonction de repartition empirique
X = - sort(-X); // tri
prcum = (1:m)’/m;
xbasc()
plot2d2(X, prcum)
x = linspace(min(X),max(X),60)’; // les abscisses et
[P,Q]=cdfnor("PQ",x,0*ones(x),sigma*ones(x)); // les ordonnees pour la fonction exacte
plot2d(x,P,style=2, strf="000") // on l’ajoute sur le dessin initial
// mise en place du test KS
alpha = 0.05;
FX = cdfnor("PQ",X,0*ones(X),sigma*ones(X));
Dplus = max( (1:m)’/m - FX );
Dmoins = max( FX - (0:m-1)’/m );
Km = sqrt(m)*max([Dplus ; Dmoins]);
K_seuil = sqrt(0.5*log(2/alpha));
// affichage des resultats
//
mprintf("\n\r Test KS : ")
mprintf("\n\r -------- ")
mprintf("\n\r valeur obtenue par le test : %g", Km);
mprintf("\n\r valeur seuil a ne pas depasser : %g",K_seuil);
if (Km > K_seuil) then
mprintf("\n\r Conclusion provisoire : Hypothese rejetee !")
else
mprintf("\n\r Conclusion provisoire : Hypothese non rejetee !")
end
Voici des r´esultats obtenus avec n = 1000 et m = 4000 :
Test KS :
--------
valeur obtenue par le test : 1.1204036
valeur seuil a ne pas depasser : 1.2212382
Conclusion provisoire : Hypothese non rejetee !
116
Index
chaˆınes de caract`eres, 31
complexes
entrer un complexe, 6
fonctions math´ematiques usuelles, 9
g´en´eration de nombres al´eatoires
grand, 93
rand, 90
listes, 32
listes « typ´ees », 34
matrices
concat´enation et extraction, 13
entrer une matrice, 5
matrice vide [], 21
matrice vide [] , 8
op´erations ´el´ement par ´el´ement, 12
r´esolution d´un syst`eme lin´eaire, 12, 19
remodeler une matrice, 25
somme, produit, transposition, 9
valeurs propres, 26
op´erateurs bool´eens, 29
op´erateurs de comparaisons, 29
primitives scilab
argn, 45
bool2s, 37
cumprod, 22
cumsum, 22
diag, 7
error, 44
evstr, 48
execstr, 49
expm, 12
eye, 7
file, 50
find, 37
input, 17
length, 26
linspace, 8
logspace, 26
matrix, 25
mean, 24
ode, 86
ones, 7
plot, 17
prod, 22
rand, 8
read, 52
size, 26
spec, 26
st deviation, 24
stacksize, 16
sum, 21
timer, 54
triu tril, 8
type et typeof, 44
warning, 44
who, 16
write, 51
zeros, 7
priorit´e des op´erateurs, 46
programmation
affectation, 9
boucle for, 28
boucle while, 29
break, 42
conditionelle : if then else, 30
conditionnelle : select case, 30
continuer une instruction , 6
d´efinir directement une fonction, 48
fonctions, 38
sauvegarde et lecture sur fichier, 49
117

Table des mati`res e
1 Informations diverses 1.1 Scilab en quelques mots . . . . . . . . . 1.2 Comment utiliser ce document . . . . . 1.3 Principe de travail sous Scilab . . . . . . 1.4 O` trouver de l’information sur Scilab ? u 1.5 Quel est le statut du logiciel Scilab ? . . 4 4 4 5 5 5 7 7 8 11 11 14 14 15 18 19 19 19 20 20 21 23 28 29 30 30 30 31 32 32 32 33 33 34 38 39 40 40 41 41 42 43

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

. . . . .

2 La manipulation des matrices et vecteurs 2.1 Entrer une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.2 Quelques matrices et vecteurs types . . . . . . . . . . . . . . . . . . . . . . . 2.3 L’instruction d’affectation de Scilab et les expressions scalaires et matricielles 2.3.1 Quelques exemples basiques d’expressions matricielles . . . . . . . . . 2.3.2 Op´rations « ´l´ment par ´l´ment » . . . . . . . . . . . . . . . . . . . e ee ee 2.3.3 R´soudre un syst`me lin´aire . . . . . . . . . . . . . . . . . . . . . . . e e e 2.3.4 R´f´rencer, extraire, concat´ner matrices et vecteurs . . . . . . . . . . ee e 2.4 Information sur l’espace de travail (*) . . . . . . . . . . . . . . . . . . . . . . 2.5 Utilisation de l’aide en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.6 Visualiser un graphe simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . ´ 2.7 Ecrire et ex´cuter un script . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 2.8 Compl´ments divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 2.8.1 Quelques raccourcis d’´criture dans les expressions matricielles . . . . e 2.8.2 Remarques diverses sur la r´solution de syst`mes lin´aires (*) . . . . . e e e 2.8.3 Quelques primitives matricielles suppl´mentaires (*) . . . . . . . . . . e 2.8.4 Les fonctions size et length . . . . . . . . . . . . . . . . . . . . . . . 2.9 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 La programmation en Scilab 3.1 Les boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.1 La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1.2 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Les instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1 La construction if then else . . . . . . . . . . . . . . . . . . . . . . 3.2.2 La construction select case (*) . . . . . . . . . . . . . . . . . . . . 3.3 Autres types de donn´es . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 3.3.1 Les chaˆ ınes de caract`res . . . . . . . . . . . . . . . . . . . . . . . e 3.3.2 Les listes (*) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.3 Quelques expressions avec les vecteurs et matrices de bool´ens (*) e 3.3.4 les expressions bool´ennes dans les tests (if et while) . . . . . . . . e 3.4 Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4.1 un premier exemple de fonction : la factorielle en scilab . . . . . . 3.4.2 deuxi`me exemple : l’´quation du second degr´ . . . . . . . . . . . e e e 3.4.3 troisi`me exemple : l’algorithme d’Horner . . . . . . . . . . . . . . e 3.4.4 quatri`me exemple : le tri insertion . . . . . . . . . . . . . . . . . . e 3.4.5 Passage des param`tres (*) . . . . . . . . . . . . . . . . . . . . . . e 1

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . .

3.5

3.6

3.7 3.8

3.4.6 D´verminage d’une fonction . . . . . . . . . . . . . . . . . . e 3.4.7 L’instruction break . . . . . . . . . . . . . . . . . . . . . . 3.4.8 Quelques primitives utiles dans les fonctions . . . . . . . . . Compl´ments divers . . . . . . . . . . . . . . . . . . . . . . . . . . e 3.5.1 Longueur des identificateurs . . . . . . . . . . . . . . . . . . 3.5.2 Priorit´ des op´rateurs . . . . . . . . . . . . . . . . . . . . . e e 3.5.3 R´cursivit´ . . . . . . . . . . . . . . . . . . . . . . . . . . . e e 3.5.4 Une fonction est une variable Scilab . . . . . . . . . . . . . 3.5.5 Fenˆtres de dialogues . . . . . . . . . . . . . . . . . . . . . . e 3.5.6 Conversion d’une chaˆ de caract`res en expression Scilab ıne e Lecture/´criture sur fichiers ou dans la fen`tre Scilab . . . . . . . . e e 3.6.1 Les entr´es/sorties ` la fortran . . . . . . . . . . . . . . . . e a 3.6.2 Les entr´es/sorties ` la C . . . . . . . . . . . . . . . . . . . e a Remarques sur la rapidit´ . . . . . . . . . . . . . . . . . . . . . . . e Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

43 44 46 48 48 48 49 49 50 50 51 51 54 55 59 61 61 61 62 62 64 68 71 71 73 74 74 75 77 77 79 79 81 83 84 86 87

4 Les graphiques 4.1 G´n´ralit´s sur le nouveau graphique . . . . . . . . . . . . . . . . . . . . . . e e e 4.1.1 principes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.1.2 les fenˆtres graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . e 4.2 l’intruction plot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 modifier quelques propri´t´s des graphiques . . . . . . . . . . . . . . . . . . ee 4.4 l’instruction plot2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.5 Des variantes de plot2d : plot2d2, plot2d3 . . . . . . . . . . . . . . . . . . . 4.6 Dessiner plusieurs courbes qui n’ont pas le mˆme nombre de points . . . . . e 4.7 Jouer avec le syst`me d’axes par d´faut . . . . . . . . . . . . . . . . . . . . e e 4.8 Dessiner un histogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.9 R´cup´rer ses graphiques sous plusieurs formats . . . . . . . . . . . . . . . . e e 4.10 Animations simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.11 Les surfaces : NOT YET UPDATED . . . . . . . . . . . . . . . . . . . . . . 4.11.1 Introduction ` plot3d . . . . . . . . . . . . . . . . . . . . . . . . . . a 4.11.2 La couleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.11.3 plot3d avec des facettes . . . . . . . . . . . . . . . . . . . . . . . . . 4.11.4 Dessiner une surface d´finie par x = x(u, v), y = y(u, v), z = z(u, v) e 4.11.5 plot3d avec interpolation des couleurs . . . . . . . . . . . . . . . . . 4.12 Les courbes dans l’espace : NOT YET UPDATED . . . . . . . . . . . . . . 4.13 Divers : NOT YET UPDATED . . . . . . . . . . . . . . . . . . . . . . . . . 4.14 quelques remarques sur le graphique scilab . . . . . . . . . . . . . . . . . . . 5 Applications et compl´ments : NOT YET UPDATED e ´ 5.1 Equations diff´rentielles . . . . . . . . . . . . . . . . . . e 5.1.1 Utilisation basique de ode . . . . . . . . . . . . . 5.1.2 Van der Pol one more time . . . . . . . . . . . . 5.1.3 Un peu plus d’ode . . . . . . . . . . . . . . . . . 5.2 G´n´ration de nombres al´atoires . . . . . . . . . . . . . e e e 5.2.1 La fonction rand . . . . . . . . . . . . . . . . . . 5.2.2 La fonction grand . . . . . . . . . . . . . . . . . 5.3 Les fonctions de r´partition classiques et leurs inverses . e 5.4 Simulations stochastiques simples . . . . . . . . . . . . . 5.4.1 Introduction et notations . . . . . . . . . . . . . 5.4.2 Intervalles de confiance . . . . . . . . . . . . . . 5.4.3 Dessiner une fonction de r´partition empirique . e 5.4.4 Test du χ2 . . . . . . . . . . . . . . . . . . . . . 5.4.5 Test de Kolmogorov-Smirnov . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . .

FOR GRAPHICS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

. . . . . . . . . . . . . .

88 . 88 . 88 . 89 . 90 . 92 . 92 . 95 . 96 . 97 . 97 . 97 . 98 . 99 . 100

2

5.4.6

Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 104 104 104 105 105 105 106 106 106 108 109

6 B´tisier e 6.1 D´finition d’un vecteur ou d’une matrice « coefficient par coefficient » e 6.2 Apropos des valeurs renvoy´es par une fonction . . . . . . . . . . . . . e 6.3 Je viens de modifier ma fonction mais... . . . . . . . . . . . . . . . . . 6.4 Probl`me avec rand . . . . . . . . . . . . . . . . . . . . . . . . . . . . e 6.5 Vecteurs lignes, vecteurs colonnes... . . . . . . . . . . . . . . . . . . . . 6.6 Op´rateur de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . e 6.7 Nombres Complexes et nombres r´els . . . . . . . . . . . . . . . . . . . e 6.8 Primitives et fonctions Scilab : SHOULD BE UPDATED . . . . . . . A Correction des exercices du chapitre 2 B Correction des exercices du chapitre 3

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

. . . . . . . .

C Correction des exercices du chapitre 5 : NOT YET UPDATED FOR GRAPHICS 113

3

Chapitre 1

Informations diverses
1.1 Scilab en quelques mots

Qu’est-ce que Scilab ? Soit vous connaissez d´j` Matlab et alors une r´ponse rapide consiste ` dire ea e a que Scilab en est un pseudo-clone libre (voir un plus loin quelques pr´cisions ` ce sujet) d´velopp´1 e a e e par l’I.N.R.I.A. (Institut National de Recherche en Informatique et Automatique). Il y a quand mˆme e quelques diff´rences mais la syntaxe est ` peu pr`s la mˆme (sauf en ce qui concerne les graphiques). Si e a e e vous ne connaissez pas Matlab alors je vais dire bri`vement que Scilab est un environnement agr´able e e pour faire du calcul num´rique car on dispose sous la main des m´thodes usuelles de cette discipline, par e e exemple : – r´solution de syst`mes lin´aires (mˆme creux), e e e e – calcul de valeurs propres, vecteurs propres, – d´composition en valeurs singuli`res, pseudo-inverse e e – transform´e de Fourier rapide, e – plusieurs m´thodes de r´solution d’´quations diff´rentielles (raides / non raides), e e e e – plusieurs algorithmes d’optimisation, – r´solution d’´quations non-lin´aires, e e e – g´n´ration de nombres al´atoires, e e e – de nombreuses primitives d’alg`bre lin´aire utiles pour l’automatique. e e D’autre part, Scilab dispose aussi de toute une batterie d’instructions graphiques, de bas-niveau (comme tracer un polygone, r´cuperer les coordonn´es du pointeur de la souris, etc. . .) et de plus haut e e niveau (pour visualiser des courbes, des surfaces) ainsi que d’un langage de programmation assez simple mais puissant et agr´able car il int`gre les notations matricielles. Quand vous testez un de vos programmes e e ´crit en langage Scilab, la phase de mise au point est g´n´ralement assez rapide car vous pouvez examiner e e e facilement vos variables : c’est comme si l’on avait un d´bogueur. Enfin, si les calculs sont trop longs (le e langage est interpr´t´. . .) vous pouvez ´crire les passages fatidiques comme des sous-programmes C ou ee e fortran (77) et les lier ` Scilab assez facilement. a

1.2

Comment utiliser ce document

Rendez-vous en premier au chapitre deux o` j’explique comment utiliser Scilab comme une calculette u matricielle : il suffit de suivre les exemples propos´s. Vous pouvez passer les sections ´toil´es (*) dans une e e e premi`re lecture. Si vous ˆtes int´ress´(e) par les aspects graphiques vous pouvez alors essayer les premiers e e e e exemples du chapitre quatre. Le chapitre trois explique les rudiments de la programmation en Scilab. J’ai commenc´ ` ´crire un chapitre cinq concernant quelques applications ainsi qu’un « b´tisier » qui essaie eae e de r´pertorier les erreurs habituelles que l’on peut commettre en Scilab (envoyer moi les votres !). Une e derni`re chose, l’environnement graphique de Scilab (la fenˆtre principale, les fenˆtres graphiques,...) e e e est l´g`rement diff´rent entre les versions Unix2 et Windows, c-a-d que les boutons et menus ne sont e e e
en fait Scilab utilise de nombreuses routines qui proviennent un peu de partout et qui sont souvent accessibles via Netlib Sous Unix il y a en fait 2 interfaces graphiques : l’officielle bas´e sur les Ath´na Widgets (Xaw ou Xaw3d) et une interface e e d´velopp´e par Jean-Philippe Chancelier, bas´e sur le toolkit gtk avec donc un look plus moderne mais aussi des possibilit´s e e e e d’´dition am´lior´e via la biblioth`que readline ; cette version n’est pas officiellement support´e par le consortium scilab. e e e e e
2 1

4

pas agenc´s exactement de la mˆme mani`re. Dans ce document certains d´tails (du genre s´lectionner e e e e e l’item « truc » du menu « bidule »...) sont relatifs ` la version Unix mais vous trouverez sans probl`me a e la manipulation ´quivalente sous Windows. e

1.3

Principe de travail sous Scilab

Au tout d´but Scilab peut s’utiliser simplement comme une calculette capable d’effectuer des op´rations e e sur des vecteurs et matrices de r´els et/ou complexes (mais aussi sur de simples scalaires) et de visualiser e graphiquement des courbes et surfaces. Dans ce cas basique d’utilisation, vous avez uniquement besoin du logiciel Scilab. Cependant, assez rapidement, on est amen´ ` ´crire des scripts (suite d’instructions eae Scilab), puis des fonctions et il est n´cessaire de travailler de pair avec un ´diteur de texte comme par e e exemple, emacs (sous Unix et Windows), wordpad (sous Windows), ou encore nedit, vi (sous Unix)... Scilab vient maintenant avec son propre ´diteur int´gr´ (scipad) qui peut aussi rendre des e e e services lors du d´bogage de fonctions. e

1.4

O` trouver de l’information sur Scilab ? u

La suite du document suppose que vous avez ` votre disposition la version 4.0 du logiciel. Pour tout a renseignement consulter la « Scilab home page » : http ://scilabsoft.inria.fr a ` partir de laquelle vous avez en particulier acc`s ` diff´rentes documentations, aux contributions des e a e utilisateurs, etc... Le « Scilab Group » a ´crit (entre fin 1999 et 2001) une vingtaine d’articles dans la revue « Linux e magazine ». Plusieurs aspects de Scilab (dont la plupart ne sont pas ´voqu´s dans cette introduction) y e e sont pr´sent´s, je vous les recommande donc. Ces articles sont consultables ` partir de l’url : e e a http ://www.saphir-control.fr/articles/ Scilab dispose aussi d’un forum usenet qui est le lieu ad´quat pour poser des questions, faire des e remarques, apporter une solution ` une question pr´alablement pos´e, etc. . . : a e e comp.sys.math.scilab Tous les messages qui ont ´t´ post´s dans ce forum sont archiv´s3 et accessibles ` partir de la « home ee e e a page » Scilab en cliquant successivement sur l’item Documentation & Support (cadre en haut ` gauche) a puis sur l’item Scilab Newsgroup (cadre en haut ` gauche aussi). a Toujours ` partir de la page Scilab, vous avez acc`s a un certain nombre de documents en choisissant a e la rubrique Books, Reports & Articles. En particulier : – l’introduction de B. Ycart (D´marrer en Scilab) ; e – l’introduction de J.Ph Chancelier (Scilab : une introduction) ; – « Scilab Bag Of Tricks » de Lydia E. van Dijk et Christoph L. Spiel qui est plutˆt destin´ aux o e personnes connaissant d´j` bien Scilab (le d´veloppement de ce livre s’est h´las arrˆt´ brutalement ea e e ee il y a quelques ann´es) ; e – Travaux Pratiques sur Scilab classes par themes vous permet d’acc´der ` des projets r´alis´s avec e a e e Scilab par des ´l`ves de l’ENPC ; ee – une introduction ` l’informatique en utilisant Scilab (http ://kiwi.emse.fr/SCILAB/). a Mais il y en a bien d’autres, et, selon vos besoins vous trouverez sans doute des documents plus adapt´s e que cette introduction.

1.5

Quel est le statut du logiciel Scilab ?

Ceux qui connaissent bien les logiciels libres (g´n´ralement sous licence GPL) peuvent s’interroger e e 4 de Scilab en tant que logiciel « libre et gratuit ». Voici ce qu’en dit le Doc dans un message sur le statut post´ sur le forum : e
3 4

il s’agit en fait, d’un lien sur l’archivage op´r´ par Google. e e on peut trouver le texte de la licence a l’url http ://scilabsoft.inria.fr/legal/licence.html `

5

without any restrictions. the only specific requirement is that we ask Scilab users to send us a notice (email is enough). cf http ://www. il semble qu’il y ait une volont´ du consortium scilab5 de passer ` une licence de type GPL ou LGPL voire CECILL et qu’un e a examen des diff´rents copyrights contenus dans le code scilab soit en cours dans ce but. Affaire ` suivre e a donc. but Scilab is an Open Source Software and is free for academic and industrial use. For more details see Notice. Scilab can be included a commercial package (provided proper copyright notice is included).ps or Notice.Scilab : is it really free ? Yes it is. Answers to two frequently asked questions : Yes. Yes. N´anmoins Scilab ne r´pond pas actuellement aux crit`res de la FSF ou l’OSI pour ˆtre consid´r´ e e e e ee comme un logiciel libre (en particulier parce que vous ne pouvez pas redistribuer une version modifi´e e de scilab sans l’autorisation de l’INRIA). Malgr´ tout. 5 organisation qui a la charge de d´velopper et promouvoir Scilab. Scilab se doit de rester pour e e l’avenir un logiciel gratuit avec tous ses fichiers sources fournis.scilabsoft. Scilab is not distributed under GPL or other standard free software copyrights (because of historical reasons).org e 6 . There are of course the usual restrictions concerning its redistribution . D’autre part. d’apr`s ses statuts. Scilab can be placed on commercial CD’s (such as various Linux distributions).tex in the Scilab package.

1 Entrer une matrice Un des types de base de Scilab est constitu´ par les matrices de nombres r´els ou complexes (en fait e e des nombres « flottants »).Chapitre 2 La manipulation des matrices et vecteurs Cette premi`re partie donne des ´l´ments pour commencer ` utiliser Scilab comme une calculette e ee a matricielle Pour lancer Scilab. ee e e e – la liste des ´l´ments doit ˆtre entour´e de crochets [ ] . sauf la derni`re. il suffit de rentrer la commande : scilab dans un terminal1 . e Par exemple.2 4 8.0 Copyright (c) 1989-2006 Consortium Scilab (INRIA. aux Demos) suivi de la banni`re scilab et de l’invite (-->) qui e e attend vos commandes : ------------------------------------------scilab-4. la fenˆtre Scilab apparaˆ ` l’´cran avec en haut un menu e ıt a e (donnant en particulier acc`s au Help. la commande : -->A=[1 1 1. Si tout se passe bien.3 9 27] produit la sortie : 1 Ou de cliquer sur un item de menu ou une icˆne pr´vus pour cet effet ! o e 7 . ee e e – chaque ligne. doit se terminer par un point-virgule. ENPC) ------------------------------------------- Startup execution: loading initial environment --> 2. en adoptant les conventions suivantes : ee – les ´l´ments d’une mˆme ligne sont s´par´s par des espaces ou des virgules . La fa¸on la plus simple de d´finir une matrice (ou un vecteur. ou un scalaire c e qui ne sont que des matrices particuli`res) dans l’environnement Scilab est d’entrer au clavier la liste de e ses ´l´ments.

.. 0. 9. 4.. 0.. 2. 4. 2. 0. 5. 2... ! Une instruction tr`s longue peut ˆtre ´crite sur plusieurs lignes en ´crivant trois points ` la fin de chaque e e e e a ligne ` poursuivre : a -->T = [ 1 0 0 0 0 0 --> 1 2 0 0 0 0 --> 1 2 3 0 0 0 --> 1 2 3 0 0 0 --> 1 2 3 4 0 0 --> 1 2 3 4 5 0 --> 1 2 3 4 5 6 ce qui donne : T ! ! ! ! ! ! = 1.A ! ! ! = 1.. le r´sultat n’apparaˆ pas ` l’´cran. 0.. 1. 1. 3.1.2 Quelques matrices et vecteurs types Il existe des fonctions pour construire des matrices et vecteurs types. i ! 2.2. 4. 0. . 190. 0. -2 + 3*%i . %i] Y = ! 1. 1. 10. on utilise la syntaxe suivante (on peut se passer des crochets [] pour rentrer un scalaire) : -->c=1 + 2*%i c = 1.. 0. ! mais la matrice est bien sˆr gard´e en m´moire pour un usage ult´rieur. . ! ! ! ! ! ! Pour rentrer un nombre complexe. on tape simplement : -->b et la r´ponse de Scilab est la suivante : e b = ! 2. 0. 2. 3. 3.. 0. . . ! 8. ] 0.i ! ! .i -->Y = [ 1 + %i . . 0. + i . 0. En fait si vous terminez l’insu e e e truction par un point virgule... 1. + 3. 1... 2. 0. -1 . 1. 6. 44.. 1.. ! 27. . Essayer par exemple : e ıt a e -->b=[2 10 44 190]. pour voir le contenu du vecteur ligne b. dont voici une premi`re liste (il e y en a bien d’autres dont nous parlerons ult´rieurement ou que vous d´couvrirez avec le Help) : e e 8 .. 3. 5. 3. 0. 2. + 2. 4.. 0.

! 0. ! 0. ! 0. dont les ´l´ments diagonaux sont form´s ` partir d’un vecteur : ee e a -->B=diag(b) B = ! 2. Comme pour la fonction eye leurs arguments sont le nombre de lignes puis de colonnes d´sir´es. 0. 0. ! 0. 0. ! 1. 0. 1. ! ! 10.4) I = ! 1. 0. n > m) on obtient la matrice de la surjection (resp. 1. 0. 0. 0. ! 0. ! ! ! ! Les arguments de la fonction eye(n. 0.4) C = ! 1. Appliqu´e sur une matrice la fonction diag permet d’en extraire sa diagonale principale sous la forme e d’un vecteur colonne : -->b=diag(B) b = ! 2. 1. e matrices de z´ros et de uns e Les fonctions zeros et ones permettent respectivement de cr´er des matrices nulles et des matrices e « de 1 ».4) : e -->I=eye(4. 0. ! 1. extraction de la diagonale Pour obtenir une matrice diagonale. 0. 1. ! 1. 1. ! ! ! ! Rmq : cet exemple illustre le fait que Scilab distingue minuscule et majuscule. ! 0. 0. 0. 0. 0. 0. 0. 10. ! Mais on peut aussi utiliser comme argument le nom d’une matrice d´j` d´finie dans l’environnement et ea e tout se passe comme si l’on avait donn´ les deux dimensions de cette matrice : e -->O = zeros(C) O = ! 0.matrices identit´s e Pour obtenir une matrice identit´ de dimension (4. ! 0. 0. ! 0. 0. 0.) matrices diagonales. ! 0. 1. 1. ! ! 44. ! ! 190.m) sont le nombre de lignes n et le nombre de colonnes m de la matrice (Rmq : si n < m (resp. ! Cette fonction admet aussi un deuxi`me argument optionnel (cf exercices). injection) canonique de Km vers Kn . 190. ! 9 . 1. ! 1. 44. ! 0. e e Exemple : -->C = ones(3. 0. 1. 0. taper b pour vous rendre compte que ce vecteur existe toujours dans l’environnement. 1. 0. 0. 0.

6857310 0. 0. il n’y pas de probl`me (sauf entiers tr`s grands.0683740 0.8782165 0.2)10 = (0.)2 ) et e il y a donc un arrondi dans la repr´sentation machine.7 0. . 4. ! 1.9 ! La syntaxe est donc : y = valeur_initiale:incr´ment:limite_a_ne_pas_d´passer.. 0.7560439 0. ! 0. 4. ! Une instruction analogue permet. partant d’une valeur initiale pour la premi`re composante.5608486 ! 0.6283918 0.2 0. e (ii) et des erreurs d’arrondi num´rique qui s’accumulent au fur et ` mesure du calcul des composantes.extractions des parties triangulaires sup´rieure et inf´rieure e e Les fonctions triu et tril permettent elles d’extraire respectivement la partie triangulaire sup´rieure e (u comme upper) et inf´rieure (l comme lower) d’une matrice.3 0. 1. ! 1.6623569 ! vecteurs ` incr´ment constant entre 2 composantes a e Pour rentrer un vecteur (ligne) x ` n composantes r´guli`rement r´parties entre x1 et xn (c-`-d telles a e e e a n −x xi+1 − xi = xn−1 1 . et de former ainsi les autres composantes du vecteur jusqu’` e a ne pas d´passer une certaine limite : e -->y = 0:0.6653811 0. 6) M = ! 0.4 0.3:1 y = ! 0. ! 0. exemple : e -->U = triu(C) U = ! 1.5 0. 10. ! matrices de nombres al´atoires e La fonction rand (dont nous reparlerons) permet de cr´er des matrices remplies de nombres pseudoe al´atoires (suivants une loi uniforme sur [0.1 0. ! Pour les r´els (approch´ par des nombres flottants) c’est beaucoup moins ´vident du fait : e e e (i) que l’incr´ment peut ne pas « tomber juste » en binaire (par exemple (0.). e a Souvent l’incr´ment est ´gal ` 1 et on peut alors l’omettre : e e a -->ind = 1:5 ind = ! 1.6 0..8 0. 5. 2. si l’incr´ment est positif (resp. on utilise la fonction linspace : -->x = linspace(0.3 0. 1[ mais il est possible d’obtenir une loi normale et aussi de e choisir le germe de la suite) : -->M = rand(2. d’impoe ser « l’incr´ment » entre deux composantes. 1. 1.) ` fixer la limite de sorte e e a qu’elle corresponde ` la derni`re composante : a e -->i = 0:2:12 i = ! 0.9 1.0002211 ! 0. 1. n « piquets » donc n − 1 intervalles. n´gatif) et que limite < valeur_initiale (resp. 1. 2. limite e e > valeur_initiale) alors on obtient un vecteur sans composantes ( !) qui est un objet Scilab appel´e e matrice vide (cf section quelques primitives matricielles suppl´mentaires) : e 10 . 8. ! Finalement.00110011 . Lorsque l’on e e travaille avec des entiers. .6 0.2113249 0.8497452 0.1. . 0. 1. 12. 6. 3.3303271 0.11) x = ! 0. .

0. des fonctions de Bessel. -.Voici quelques exemples (pour lesquels on utilise une partie des matrices pr´c´demment rentr´es). 2. . par exemple : -->M = [sin(%pi/3) sqrt(2) 5^(3/2) . .1) pour une liste non exaustive2 . mais elle peut aussi ˆtre compos´e avec des matrices et des e e vecteurs ce qui d´route souvent le d´butant dans l’apprentissage de ce type de langage.5 . Une expression u e a e Scilab peut ˆtre toute simple en ne mettant en jeu que des quantit´s scalaires comme celles que l’on trouve e e dans les langages de programmation courants. etc.4142136 11.3. * . / et ^ (´l´vation ` la puissance) et d’un jeu de fonctions classiques (cf table e ee a (2. Les expressions e e « scalaires » suivent les r`gles habituelles : pour des op´randes num´riques (r´els. . complexes) on dispose e e e e des 5 op´rateurs +. .236014 0. m) × (m. des fonctions e elliptiques. exp(-1) cosh(3. p) . 2. . Ainsi pour rentrer une matrice « coefficients par coefficients » on peut utiliser en plus des constantes (qui sont en fait des expressions basiques) n’importe quelle expression d´livrant un scalaire (r´el ou e e complexe).). produit de deux matrices (si leurs dimensions sont compatibles (n.ainsi que des fonctions li´es aux lois de probabilit´ usuelles (fonctions de r´partition et leurs inverses). .-->i=3:-1:4 i = [] -->i=1:0 i = [] 2. etc. 9. 10.3 L’instruction d’affectation de Scilab et les expressions scalaires et matricielles Scilab est un langage qui poss`de une syntaxe simple (cf chapitre suivant) dont l’instruction d’affece tation prend la forme : variable = expression ou plus simplement expression o` dans ce dernier cas la valeur de expression est affect´e ` une variable par d´faut ans. e e e 11 . Rmq : tout texte rentr´ sur une ligne apr`s // est un commentaire e e e e e pour Scilab : ne les tapez pas.7) (1-sqrt(-3))/2] M = ! 0. produit d’un scalaire et d’une matrice. ! 3.3678794 20. e 2.1 Quelques exemples basiques d’expressions matricielles Toutes les op´rations usuelles sur les matrices sont disponibles : somme de deux matrices de mˆmes e e dimensions. 28.8660254 1. 5. 2 // taper A au pr´alable pour revoir le contenu de cette matrice e ! ! ! Scilab propose d’autres fonctions math´matiques comme les fonctions de Legendre.18034 ! ! 0.8660254i ! (Rmq : cet exemple montre un danger potentiel : on a calcul´ la racine carr´e d’un nombre n´gatif e e e mais Scilab consid`re alors que l’on a affaire ` un nombre complexe et renvoie l’une des deux racines e a comme r´sultat). ! 4. ils sont l` pour fournir quelques remarques et explications ! a -->D = A + ones(A) D = ! 2.

27.3) + (2.3) : que dit Scilab ? !--error 10 inconsistent multiplication --> At ! ! ! At = A’ // la transposee s’obtient en postfixant la matrice par une apostrophe = 1. complexes --> Ac = A + %i*eye(3.1 – quelques fonctions usuelles de Scilab +∞ 2 √ π +∞ −t2 e dt x -->A + M // somme de matrice impossible (3. 14. 9. ! 39. ! // je forme ici une matrice a coef. 14. 8. ! 1. 39. 3. 39. ! 14. ! --> C*A // produit de matrice impossible (3. 3. 3. 2.6) : que dit Scilab ? !--error 8 inconsistent addition -->E = A*C E = ! 3.3) Ac = 12 .4) dont les elements sont des 1 3. 2. ! 1. // C est une matrice (3. ! 39.abs exp log log10 cos sin sinc tan cotg acos asin atan cosh sinh tanh acosh asinh atanh sqrt floor ceil int erf erfc gamma lngamma dlgamma valeur absolue ou module exponentielle logarithme n´p´rien e e logarithme base 10 cosinus (argument en radian) sinus (argument en radian) sin(x) x tangente (argument en radian) cotangente (argument en radian) arccos arcsin arctg ch sh th argch argsh argth racine carr´e e partie enti`re E(x) = ( x ) = n ⇔ n ≤ x < n + 1 e partie enti`re sup´rieure x = n ⇔ n − 1 < x ≤ n e e partie enti`re anglaise : int(x) = x si x > 0 et = x sinon e 2 x 2 fonction erreur erf (x) = √π 0 e−t dt fonction erreur compl´mentaire ercf (x) = 1 − erf (x) = e Γ(x) = 0 tx−1 e−t dt ln(Γ(x)) d dx ln(Γ(x)) Tab. 4. ! 14.4)x(3.

3. 27.75 ! ! 1.25 ans = ! 0. .i ! -->x = linspace(0. ! 0. 8.75 1. ! 0. 4. // on peut diviser une matrice par un scalaire 2. 4. 282. 8.75 1. 36. 27. ! ! 1. 5. 3. -->Pext = Pext = ! 0.5 2. ! 0. 1. 2.25 0. 15. 3. .25 0. y*x’ // on obtient une matrice (5. ! 250. (1:5)’ // un autre vecteur colonne ! ! ! ! ! // produit scalaire (x | y) -->p = y’*x p = 10. ! ! ! ! ! --> Pext / 0. 4.5 ! ! 0. --> A^2 ans = ! 6.i 2.75 1.5 0. 2. 12. 6. ! -->y = y = ! 1.25 3. 10. ! 0. 8. ! 102. 4.25 ! ! 0.1)x(1. ! 804. + i 9.! ! ! 1. ! ! 0. 1. 5. ! ! ! ! ! // elevation a la puissance d’une matrice 14. ! 2. 4. 8.5 1. + i 2. 3. 12. 4. 6. ! 0. 16. 9. 1. 3. ! 0. 90.5)’ // je forme un vecteur colonne x = ! 0.i 9. ! 5. ! 0. . ! 4.5) ((5. ! 34. ! // on peut reutiliser la variable ans (qui contient // le dernier resultat non affecte a une variable) 13 --> [0 1 0] * ans --> . 20. 2. ! 0. ! 3.5 0. 1. 1.5 2. ! ! 1. 3. + i ! ! ! --> Ac_adj = Ac’ // dans le cas complexe ’ donne l’adjointe (transposee conjuguee) Ac_adj = ! 1.5)) de rang 1 : pourquoi ? 0.1.

8284271 ! 5.831354 4. 250.5)*ones(x) + triu(Pext)*tril(Pext)*y. 2.442794 9. je e ee ee conseille n´anmoins d’utiliser A.ans = ! 34.320D+11 ! Rmq : pour les fonctions qui ont un sens pour les matrices (diff´rent de celui qui consiste ` l’appliquer e a sur chaque ´l´ment.^n car cette ´criture est plus claire pour exprimer cette intention .958 ! 5. ! 1. on peut ´lever ` la puissance chaque coefficient en utilisant l’op´rateur postfix´ . --> // taper ans pour voir le resultat Une autre caract´ristique tr`s interessante est que les fonctions usuelles (voir table 2.59815 8103. 90. .^ e e a e e : A.1961524 ! 2./ ee ee e : A.4142136 ! 1. e e – si s est un scalaire et A une matrice.085537 1.576923 1. par exemple l’exponentielle. s. Ainsi pour ee obtenir l’exponentielle de A. Scilab utilise une factorisation LU avec e e e e pivot partiel suivie de la r´solution des deux syst`mes triangulaires.9270989 31.5247379 3. ! --> Pext*x .* et . ! Remarques : – tant que A n’est pas une matrice carr´e.7182818 54. ! 1.7182818 ! 2980./A ans = ! 1.7182818 ! 7.3890561 ! 20. 1.1005925 ! 28.0839 2. 1.3 R´soudre un syst`me lin´aire e e e Pour r´soudre un syst`me lin´aire dont la matrice est carr´e.*B est la matrice [aij bij ] et A. ! 1. 2.^A donnera la matrice [saij ]. le nom de la fonction est suivi par m.). Cependant ceci est rendu transparent e e pour l’utilisateur par l’interm´diaire de l’op´rateur \.2 Op´rations « ´l´ment par ´l´ment » e ee ee Pour multiplier et diviser deux matrices A et B de mˆme dimensions en appliquant ces op´rations e e « ´l´ment par ´l´ment » on utilise les op´rateurs . ee ee e Quelques exemples : -->sqrt(A) ans = ! 1./B [aij /bij ].0D+11 * ! ! ! 0.2)*rand(2. A^n va fonctionner au sens « ´l´ment par ´l´ment ». De mˆme. . Essayer par exemple : ij -->A.3.^p permet d’obtenir la matrice [ap ]. 3.213997 ! 90. ! 2.3. 1. essayer : e e 14 .1) s’appliquent e e aussi aux matrices « ´l´ment par ´l´ment » : si f d´signe une telle fonction f(A) est la matrice [f (aij )]. ! 1. 1.y + rand(5.6104422 11. ! 1. on rentre la commande : -->expm(A) ans = 1.7320508 -->exp(A) ans = ! 2. 1.468498 ! 2.

! ! 0. (ce que l’on symbolise par une division ` gauche par A) d’o` la a a u syntaxe utilis´e par Scilab. Par exemple : -->A33=A(3. extraire. ! ! 0.3.. ! -->A*x .4 R´f´rencer.3) A33 = 27. -->x_30 = x(30. e 2. ! ! 3. Lorsque la r´solution d’un syst`me lin´aire semble douteuse Scilab renvoie e e e quelques informations permettant de pr´venir l’utilisateur (cf compl´ments sur la r´solution des syst`mes e e e e lin´aires).100). il faut avoir en tˆte le syst`me initial Ax = y puis faire comme e e si on multipliait ` gauche par A−1 . ! -->x=A\b x = ! 1. ! ! 2.-->b=(1:3)’ b = ! 1. pour ne pas submerger l’ecran de chiffres // meme remarque // resolution de Rx=y // norm permet de calculer la norme de vecteurs (et aussi de matrices) // (par defaut la norme 2 (euclidienne ou hermitienne)) Rmq : vous n’obtiendrez pas forc´ment ce r´sultat si vous n’avez pas jou´ avec la fonction rand e e e exactement comme moi. e ee e e e e ().1) x_30 = . ! //je cree un second membre b // on resout Ax=b // je verifie le resultat en calculant le vecteur residu Pour se souvenir de cette instruction. concat´ner matrices et vecteurs ee e Les coefficients d’une matrice peuvent ˆtre r´f´renc´s avec leur(s) indice(s) pr´cis´s entre parenth`ses. -->y = rand(100.30) !--error invalid index 21 15 .. Ici on a obtenu un r´sultat exact mais en g´n´ral.b ans = ! 0.1. -->x=R\y. ! ! 0. ! ! 0.134D-13 // mettre le . -->norm(R*x-y) ans = 1.1).2935412 -->x(1. il y a des erreurs d’arrondi e e e e dues ` l’arithm´tique flottante : a e -->R = rand(100.

Voici un exemple : on consid`re la matrice e 16 . . ! -->A(1:2. j2 . . ! 3. et inversement pour un vecteur ligne.:) 1. m). i2 . i2 . ! Passons maintenant ` la concat´nation de matrices qui est l’op´ration permettant d’assembler (en les a e e juxtaposant) plusieurs matrices. 27. ! ! 2. . . 3. Un des avantages d’un langage comme Scilab est que l’on peut extraire des sous-matrices tout aussi ais´ment. ! 27. Quelques exemples simples pour commencer : e -->A(:. . 1. ! Dans la pratique on utilise g´n´ralement des extractions plus simples.[2 3]) ans = ! 1.[2 1]) ans = ! 9. on utilise l’expression i_debut:incr:i_fin pour g´n´rer les vecteurs d’indices. comme celle d’un bloc contigu e e ou bien d’une (ou plusieurs) colonne(s) ou ligne(s). .2935412 Rmq : si la matrice est un vecteur colonne.:) ans = ! 1. 9. . ainsi que le caract`re : pour d´signer toute l’´tendue dans la dimension e e e e e ad´quate (cf premiers exemples).2) ans = ! 1. . j2 . et si v1 = (i1 . ip et des colonnes j1 . 1. ! ! 1. ! -->A([3 1]. . . jq ) sont deux vecteurs (ligne ou colonne peut importe) d’indices dont les valeurs sont telles que 1 ≤ ik ≤ n et 1 ≤ jk ≤ m alors A(v1. pour en obtenir une autre. ! ! 9. jq . Exemples : -->A([1 3]. q)) form´e par e l’intersection des lignes i1 . ! ! 9. 27. ip ) a e e et v2 = (j1 . ! Passons maintenant ` la syntaxe g´n´rale : si A est une matrice de taille (n. . .1:2) // la sous matrice principale d’ordre 2 ans = ! 1. on peut se contenter de r´f´rencer un ´l´ment en pr´cisant ee ee e uniquement son indice de ligne. . ! // pour extraire la 2 eme colonne -->A(3. 1.-->x(30) ans = . Dans ce cas. Ainsi pour obtenir la sous-matrice form´e de la premi`re et troisi`me e e e e ligne : -->A(1:2:3. 4. ! ! 4. // ou encore A([1 3]. 1. . . 9.:) // la 3 eme ligne ans = ! 3. .v2) est la matrice (de dimension (p.1.

k2 . 4. . . . ! ! 8. ! ! 4. . 9. En particulier. 27. k2 . A21 . ! ! 3. . kp de M et M(:. -->A21=[1. A22 : e -->A11=1. pour les op´rations d’extraction et d’insertion. u(v) = [] d´truit les entr´es e e correspondantes. pour un vecteur (ligne ou colonne) u. A12 .). -->A22=[4 9 16.suivante. e e Il existe une syntaxe particuli`re pour d´truire un ensemble de lignes ou de colonnes d’une matrice : e e si v = (k1 . avec un d´coupage par blocs : e  1 2 3 4  1 4 9 16 A=  1 8 27 64 1 16 81 256     = A11 A12 A21 A22 .v) = [] d´truit les e e colonnes k1 . On va d’abord d´finir les sous-matrices A11 . 3. 16.:) = [] d´truit les lignes k1 . Voici e quelques exemples ` partir de la matrice A pr´c´dente : a e e -->A(5) ans = 2. 81. ! -->A(5:9) = -1 A = // il s’agit d’une insertion 17 .1]. ! ! 1. 8. ! pour la syntaxe tout se passe comme si nos sous-matrices ´taient de simples scalaires (il faut bien sˆr e u une certaine compatibilit´ entre le nombre de lignes et de colonnes des diff´rents blocs. -->A(5:9) ans = ! 2. . . enfin on obtient A par concat´nation de ces 4 blocs : e -->A=[A11 A12.16 81 256].8 27 64. 64. 256. . ! ! 16. Enfin.1. k2 . 2. 16. . 4. . . kp . . l’un d´signant les colonnes et l’autre les lignes). kp ) est un vecteur d’indices rep´rant des num´ros de lignes ou de colonnes d’une e e matrice M alors M(v. . il est possible d’utiliser cet ordre implicite en utilisant e seulement un seul vecteur d’indice (au lieu de deux. A propos de l’ordre des ´l´ments d’une matrice ee Les matrices de Scilab sont stock´es colonne par colonne et cet ordre des ´l´ments intervient dans e ee plusieurs fonctions (voir par exemple matrix qui permet de reformatter une matrice). . ! ! 1. A21 A22] A = ! 1. -->A12=[2 3 4]. ! ! 1.

e a e Dans un tel cas. ces e variables dont le nom d´bute n´cessairement par % ne peuvent pas ˆtre d´truites . Anew A A22 A21 A12 A11 x_30 A33 x y R b Pext p Ac_adj Ac At E D cosh ind xx i linspace M U O zeros C B I Y c T startup ierr scicos_pal home PWD TMPDIR percentlib fraclablib soundlib xdesslib utillib tdcslib siglib s2flib roblib optlib metalib elemlib commlib polylib autolib armalib alglib mtlblib SCI %F %T %z %s %nan %inf old newstacksize $ %t %f %eps %io %i %e %pi using 14875 elements out of 1000000. e Enfin si l’on veut supprimer une variable v1 de l’environnement. - 1. En e fait.3) ` (4. 64.. 256.. La commande clear utilis´e seule d´truit toutes vos e e e variables et si vous voulez simplement d´truire les variables v1. 1.e. e e – des constantes pr´d´finies comme π. – les noms des biblioth`ques de Scilab (qui se terminent par lib) et un nom de fonction : cosh. 27. dans la suite e ee du document j’utilise parfois abusivement le terme « primitives » pour d´signer des fonctions Scilab e (programm´es en langage Scilab) qui sont propos´es par l’environnement standard . il faut utiliser clear v1 v2 e v3.. 1. A21. . les fonctions (celles ´crites en langage Scilab) et les biblioth`ques sont consid´r´es comme des e e ee variables par Scilab . e e On peut changer la taille de la pile a l’aide de la commande stacksize(nbmots) o` nbmots d´signe ` u e la nouvelle taille d´sir´e. . e e e e – une variable importante newstacksize qui correspond ` la taille (par d´faut) de la pile (c-`-d de a e a la m´moire disponible). En fait la premi`re variable cr´´e ´tait la matrice A mais nous avons « auge e ee e ment´ »ses dimensions (de (3. e – ensuite Scilab indique le nombre de mots de 8 octets utilis´s ainsi que la m´moire totale disponible e e (taille de la pile) puis le nombre de variables utilis´es ainsi que le nombre maximum autoris´. la pr´cision machine eps et les deux e e e e autres constantes classiques de l’arithm´tique flottante (nan not a number) et inf (pour ∞) . et la mˆme commande sans argument stacksize() permet d’obtenir la taille e e e de la pile ainsi que le nombre maximum autoris´ de variables. 16. 1.! ! ! ! 1.4 Information sur l’espace de travail (*) Il suffit de rentrer la commande : -->who your variables are. and 75 variables out of 1023 et l’on voit apparaˆ : ıtre – les variables que l’on a rentr´es sous l’environnement : Anew. (et donc regagner de la place m´moire) on utilise la commande : clear v1. 1. e e ee Ceci est un point important dont nous reparlerons lors de la programmation en Scilab . l’unit´ imaginaire i. 81.1. 9. v2. ! ! ! ! 2. 1. 18 . Rmq : les « proc´dures » Scilab programm´es en Fortran 77 et en C sont e e appel´es « primitives Scilab » et ne sont pas consid´r´es comme des variables Scilab . 4. . A. A22. la variable initiale est d´truite pour ˆtre recr´´e avec ses nouvelles dimensions. 1. v3.4)) lors de l’exemple concernant la concat´nation de matrice. b dans l’ordre e inverse de leur cr´ation. .

Le troisi`me argument est une e e e chaˆ de caract`res (contenant ici que le seul caract`re b) pr´cisant que l’on veut une courbe bleue (sans ıne e e e plus de pr´cision sur le style.. J’´cris donc dans un fichier intitul´ par e e e exemple script1.. reprenons le trac´ de la fonction e−x sin(4x) en proposant de plus le choix e de l’intervalle de visualisation [a. b] ainsi que sa discr´tisation. e e ıt e Actuellement il peut ˆtre difficile de se diriger en utilisant les intitul´s des rubriques (par exemple e e Elementary functions est un ensemble « fourre-tout » qui m´riterait d’ˆtre red´coup´). e 4 3 19 ."y"..101). Graphic Library."b") -->xtitle("x". Si vous utilisez l’´diteur int´gr´ scipad4 vous pouvez faire ex´cuter votre script en utilisant le menu e e e e Execute ou plus directement avec le raccourci clavier Ctr-l.7 ´ Ecrire et ex´cuter un script e // ou encore exec nomfich On peut ´crire dans un fichier nomfich une suite de commandes et les faire ex´cuter par l’instruction : e e -->exec(’nomfich’) Une m´thode plus conviviale est de s´lectionner l’item File Operations propos´ par le menu obtenu e e e en appuyant sur le bouton File de la fenˆtre Scilab. En cliquant alors sur e e e e l’une de ces fonctions vous obtenez la page de la fonction en question.. vous pouvez rentrer la commande help e nom de la fonction dans la fenˆtre de commande Scilab pour obtenir la page directement. En cliquant sur une rubrique particuli`re vous obtenez la liste de toutes les fonctions e class´es dans cette rubrique. Comme exemple de script. 2. On peut tout d’abord cr´er un maillage de l’intervalle par la fonction linspace : e -->x=linspace(0. voire -->scipad fichier1 fichier2 .7 les pages e 3 . n’h´sitez donc pas e e e e e a ` utiliser apropos. On obtient alors un menu qui permet de s´lectionner e e son fichier (´ventuellement en changeant le r´pertoire courant) et il ne reste plus qu’` cliquer sur le bouton e e a Exec.y. grˆce aux a instructions « vectorielles » ne n´cessite aucune boucle : e -->y=exp(-x). chacune ´tant accompagn´e d’une br`ve description.2.sce les instructions Scilab suivantes : le format de base est en fait du xml a partir duquel on obtient le html.*sin(4*x). 2π]. ` Pour lancer scipad il suffit de cliquer sur le bouton Editor..5 Utilisation de l’aide en ligne Elle s’obtient en cliquant sur le bouton Help de la fenˆtre Scilab. et enfin : -->plot(x. Si vous rentrez simplement la commande help (ou si vous cliquez sur le d’aides sont au format html bouton Help) alors la page html affich´e correspond ` un classement de toutes les pages d’aide en un e a certain nombre de rubriques (Scilab Programming.. ou encore de rentrer l’ordre -->scipad. ce qui. Depuis la version 2. Utilities and Elementary functions."y=exp(-x)*sin(4x)") o` l’instruction plot permet de tracer une courbe passant par les points dont les coordonn´es sont u e donn´es dans les vecteurs x pour les abscisses et y pour les ordonn´es. les points sont reli´s par des segments de droites. calculer les valeurs de la fonction pour chaque composante du maillage. e 2. Si vous connaissez le nom de la fonction qui vous int´resse.2*%pi. dans la fenˆtre de commande.6 Visualiser un graphe simple Supposons que l’on veuille visualiser la fonction y = e−x sin(4x) pour x ∈ [0. le trac´ sera d’autant e e e plus fid`le que les points seront nombreux).). puis.. e Enfin la commande apropos mot cl´ vous permet d’obtenir toutes les pages dans lesquelles la chaˆ e ıne de caract`res mot cl´ apparaˆ dans le nom de la fonction ou dans sa br`ve description.

b = input(" Rentrer la valeur de b : ").4 y 0. Pour emacs il en existe deux mais le meilleur est de loin celui d’Alexander Vigodner dont les derni`res versions sont t´l´chargeables ` partir de l’url : e ee a http://www.sce (alors qu’un fichier contenant des fonctions sera suffix´ en .2 0. // calcul des ordonnees y = exp(-x)."b") xtitle("x".sci) . ce qui est naturel (de mˆme la division d’une matrice par un scalaire).b.html 2.6 0.n+1). il est recommand´ de suffixer le nom des fichiers scripts e par la terminaison .0 −0.*sin(4*x). pour s’y retrouver dans vos fichiers Scilab. certains ´diteurs (autres que scipad) peuvent aussi ˆtre munis d’un mode d’´dition sp´cifique pour e e e e Scilab (voir la page Scilab). Par contre Scilab utilise e 20 ."y=exp(-x)*sin(4x)") Rmq : 1.8 0. n = input(" Nb d’’intervalles n : ").com/avezunchik/scilab.8 2."y".4 0 1 2 3 x 4 5 6 7 Fig.geocities.1 – Un graphe simple // mon premier script Scilab a = input(" Rentrer la valeur de a : "). // calcul des abscisses x = linspace(a.y=exp(−x)*sin(4x) 0.8. // un petit dessin clf() // efface le contenu de la fen^tre graphique e plot(x.1 Compl´ments divers e Quelques raccourcis d’´criture dans les expressions matricielles e Nous avons vu pr´c´demment que la multiplication d’une matrice par un scalaire est reconnue par e e Scilab.2 −0.y. e 2. 2.

3.3333333 . 1. y2 = [1.0. si f est une fonction d´finie dans l’environnement. il semble que l’on puisse utiliser : 1. Nous avons vu pr´c´demment que si A est une matrice carr´e (n./f(x) ou 1.0./f(x) // ou encore 1 . // voici 2 seconds membres (on peut mettre --> // plusieurs instructions sur une seule ligne) -->X=A\[y1. on peut proc´der de la fa¸on suivante : e c -->y1 = [1. Si la matrice A est d´tect´e comme ´tant e e e e e singuli`re.2. Par exemple : e -->A=[1 2.1)) alors : x = A\b nous donne la solution du syst`me lin´aire Ax = b.4].5 ! ! 1.y2] // concat´nation de y1 et y2 e X = ! 4.8333333 ! ! . -->b=[1.0.2 Remarques diverses sur la r´solution de syst`mes lin´aires (*) e e e 1./f(x) e est un vecteur de mˆme taille que x dont la i`me composante est ´gale ` s/f (xi ).8. Lorsque l’on a plusieurs seconds membres. L’expression M + s o` M e u est une matrice et s un scalaire est un raccourci pour : M + s*ones(M) c’est ` dire que le scalaire est ajout´ ` tous les ´l´ments de la matrice. Ainsi pour calculer le e e a vecteur de composante 1/f (xi ).0. le r´sultat n’est pas celui escompt´.n) et b un vecteur colonne ` n e e e a composantes (donc une matrice (n.25 0. Scilab renvoie un message d’erreur.0]./f(x) 2.des raccourcis moins ´vidents comme l’addition d’un scalaire et d’une matrice.1]. -->A\b !--error 19 singular matrix 21 .3./B on obtient donc la matrice [a/bij ]. est syntaxiquement ´gal ` 1. La bonne mani`re e a e e e d’obtenir ce que l’on cherche est d’entourer le nombre avec des parenth`ses ou de rajouter un blanc entre e le nombre et le point : (1)./f(x) mais comme 1. a ea ee Autre raccourci : dans une expression du type A. x un vecteur e et s une variable scalaire alors : s.0833333 ! la premi`re colonne de la matrice X est la solution du syst`me lin´aire Ax1 = y 1 . Ces raccourcis permettent une ´criture plus synth´tique dans de e e nombreux cas (cf exercices).1 2]. .5 ! ! . alors que la e e e 2 = y2./B (qui correspond normalement ` la division a « ´l´ment par ´l´ment » de deux matrices de mˆme dimension). si A est un scalaire alors l’expression est ee ee e un raccourci pour : A*ones(B). deuxi`me correspond ` la solution de Ax e a 2.0.0. Par exemple.

Dans ce cas. 0. on a une solution unique si et seulement si m > n. -->A\b warning matrix is close to singular or badly scaled. .Cependant si la matrice A est consid´r´e comme mal conditionn´e (ou ´ventuellement mal ´quilibr´e) ee e e e e une r´ponse est fournie mais elle est accompagn´e d’un message de mise en garde avec une estimae e tion de l’inverse du conditionnement (cond(A) = ||A|| ||A−1 ||) : -->A=[1 2. ! ! 0. L’inconv´nient est que si vous avez fait une ere e reur dans la d´finition de votre matrice (par exemple vous avez d´fini une colonne suppl´mentaire. .1]] soit (m.[0. tout en ayant le mˆme nombre de lignes que le see e cond membre. – l’instruction A(2. ! ! 0.) est en fait un raccourci pour : e A = [A. l’exemple est e e instructif sur les points suivants : – x = A\y permet donc de r´soudre aussi un probl`me de moindres carr´s (lorsque la matrice n´est e e e pas de rang maximum.b ans = 1. ! -->A\b ans = ! 0. Scilab va vous renvoyer une solution (un vecteur colonne de dimension le nombre de colonnes de A) sans s’´mouvoir (sans afficher en g´n´ral de message d’erreur). c-`-d lorsque la matrice n’est pas de rang maximum (rg(A) < min(n. KerA = {0} et enfin b ∈ ImA cette derni`re condition ´tant exceptionnelle si b est pris au hasard dans Km . 2.n+1)) vous risquez de ne pas vous en apercevoir imm´diatement.3.0D-15 * ! .1110223 ! ! .4015D-17 ans = ! 1. on a e e soit aucune solution.1110223 ! En dehors de vous mettre en garde sur les cons´quences de ce type d’´tourderie. il vaut mieux utiliser x = pinv(A)*b.3)=1 (l’ erreur d’´tourderie. m) o` n et m sont les 2 a u dimensions) il vaut mieux calculer cette solution en passant par la pseudo-inverse de A (x = pinv(A)*b). 5 // ´tourderie e 22 . En effet.3)=1 A = ! 1.5 ! ! . n) les dimensions de A (telles que n = m). soit une infinit´ de solutions e 6 dans les cas difficiles.1 2+3*%eps]. ! Par contre si votre matrice n’est pas carr´e.0. la pseudo-inverse ´tant calcul´e via e e la d´composition en valeurs singuli`res de A (cette d´composition peut s’obtenir avec la fonction e e e svd) .0. on peut toujours e e e s´lectionner un vecteur unique x qui v´rifie certaines propri´t´s (x de norme minimale et solution e e ee de min ||Ax − b||). 1. si e e e dans ce cas l’´quation Ax = b n’a g´n´ralement pas une solution unique5 .140D-16 ! -->A*ans . results may be inaccurate. rcond = 7. la r´solution est confi´e ` d’autres algorithmes qui vont permettre e e a d’obtenir (´ventuellement) cette pseudo-solution6 . e En reprenant l’exemple pr´c´dent : e e -->A(2. ! ! 1. dans tous les autres cas. 2. e e e et votre matrice est de taille (n.

Par cons´quent on devrait avoir 2 ⊕ 3 m > 2 alors que la fenˆtre affiche e e e 2.3 Quelques primitives matricielles suppl´mentaires (*) e Somme."c") // effectue la somme de chaque ligne -> on obtient une colonne ans = ! 6. l` aussi. ee e e – l’´l´ment en position (2. il compl`te par des z´ros. on utilise sum : -->sum(1:6) ans = 21. 7. :). si A est une matrice rectangulaire (dont le nombre de colonnes est e e e ´gal ` celui de b) Scilab renvoie une solution. a Il existe un objet tr`s pratique « la matrice vide » que l’on d´finit de la fa¸on suivante : e e c 7 i B(i. ”r”) = e sum(B. produit des coefficients d’ une matrice.19) -->A(2. ! -->sum(B. – Lorque l’on a calcul´ la « solution » de Ax = b on ne l’a pas affect´ ` une variable particuli`re et e ea e Scilab s’est donc servi de ans que j’ai ensuite utilis´ pour calculer le r´sidu Ax − b. j).c’est ` dire que Scilab d´tecte que vous voulez compl´ter la matrice A (par une troisi`me colonne) a e e e mais il lui manque un ´l´ment. e a a 2. ee e a e e Or le epsilon machine ( m ) peut ˆtre d´fini comme le plus grand nombre pour lequel 1⊕ m = 1 en e e arithm´tique flottante7 . ”c”) = j B(:. ! ! 4. Dans ce cas. en fait tout nombre r´el x tel que m ≤ |x| ≤ M peut ˆtre cod´ par un nombre flottant f l(x) avec : |x − f l(x)| ≤ e e e o` m et M sont respectivement le plus petit et le plus grand nombre positif codable en virgule flottante normalis´e u e m |x| 23 . 4 5 6] B = ! 1. ! -->sum(B.10) (voir le Help pour la signification e a des arguments). 5. matrice vide Pour faire la somme des coefficients d’une matrice. ! En fait sum(B. il suffit de faire comme si l’on multipliait ` droite par A−1 (en symbolisant a cette op´ration par une division ` droite par A) : e a x = b/A et de mˆme que pr´c´demment."r") ans = ! 5."r") d´signe la somme des vecteurs lignes de la matrice B : sum(B. // effectue la somme de chaque colonne -> on obtient une ligne 9. 6. Avec Scilab on peut aussi directement r´soudre un syst`me lin´aire du type xA = b o` x et b sont e e e u des vecteurs lignes et A une matrice carr´e (en transposant on se ram`ne ` un syst`me lin´aire e e a e e classique A x = b ). ! ! 15. e e 3. il faut donc. Ceci vient du format utilis´ par d´faut mais on peut le modifier par l’instruction format : e e -->format(’v’.0000000000000009 alors que l’affichage par d´faut correspond ` format(’v’. 2. 3.8. faire attention. // 1:6 = [1 2 3 4 5 6] : on doit donc obtenir 6*7/2 = 21 !!!!! Cette fonction admet un argument suppl´mentaire pour effectuer la somme selon les lignes ou les e colonnes : -->B = [1 2 3.2) ans = 2.2) est normalement ´gal ` 2 + 3 m aux erreurs d’arrondi num´rique pr`s."c") correspondant ` la somme des vecteurs colonnes : sum(B.

"r") ans = ! 4. on obtient le r´sultat naturel : e -->sum([]) ans = 0. -->prod([]) ans = 1. et l’on obtient toujours la convention usuelle rencontr´e en math´matique : e e ui = 1. -->prod(B. ! ! 120. ! -->prod(B) ans = 720. ! somme et produit cumul´s e Les fonctions cumsum et cumprod calculent respectivement les sommes et produits cumul´s d’un e vecteur ou d’une matrice : -->x = 1:6 x = ! 1. 2. n} lorsque l’ensemble E est vide. on dispose de la fonction e ee prod : -->prod(1:5) ans = 120. 10. . 18. -->prod(B. . . ! . 6. De mani`re analogue..-->C =[] C = [] La matrice vide int´ragit avec d’autres matrices avec les r`gles suivantes : [] + A = A et []*A = []. 2. identique ` la convention utilis´e en math´matique pour les sommations : a e e n S= i∈E ui = i=1 ui si E = {1.. -->cumsum(x) ans = 24 3. si E = ∅. 4. ."c") ans = ! 6. pour effectuer le produit des ´l´ments d’une matrice. e e Si on applique maintenant la fonction sum sur cette matrice vide. 5. i∈E // en doit obtenir 5! = 120 // taper B pour revoir cette matrice. on impose en effet par convention S = 0.

"r") correspond ` e a prendre le minimun de chaque colonne minimum et maximum d’un vecteur ou d’une matrice Les fonctions min et max se chargent de ces op´rations. :) = k=1 x(k. min.4 5 6] x = ! 1. ! Ici il faut toujours faire attention car on peut avoir tendance ` supposer que l’option "r" fait la somme a cumul´e de chaque ligne mais il s’agit bien de la somme cumul´e des vecteurs lignes (ce qui correspond e e a ` faire la somme cumul´e sur chaque colonne). 15. 7. 9. 3."c") // somme cumul´e des vecteurs colonnes e ans = ! 1. ! -->cumprod(x) ans = ! 1. st deviation. ! -->cumsum(x. 3. 2. 2.! 1. ! 21. 9. ! Pour une matrice l’accumulation se fait simplement selon l’ordre colonne par colonne : -->x = [1 2 3. Elles fonctionnent exactement comme sum et e prod quant ` l’argument suppl´mentaire pour calculer les minima ou maxima de chaque ligne ou colonne. 10. 6. 5. Exemples : 8 mais qui ne fonctionne pas pour FIXME 25 . 120. 12. si on pose y = cumsum(x. ! ! 4. :) De mˆme si y = cumsum(x. ! ! 5. 6."c") alors : e j y(:. 15. 2."r") alors y est une matrice e de mˆme dimension que x et : e i y(i. 6. ! Et comme pour les fonctions sum et prod."r") // somme cumul´e des vecteurs lignes e ans = ! 1. a e Elles admettent aussi un argument de sortie suppl´mentaire donnant le premier indice o` le minimum e u ou maximum est atteint (les premiers indices pour les minima maxima selon les lignes ou les colonnes). max admettent aussi ce mˆme argument optionnel. 7. 3. 6. ! -->cumsum(x) ans = ! 1. Comme pour e sum et prod un autre moyen mn´motechnique8 pour se souvenir de l’op´ration effectu´e est de consid´rer e e e e que cette option ("r" ou "c") d´signe aussi la forme finale obtenue (et donc min(x. k) Les fonctions mean. ! ! 4. 3. ! 5. 15. 24. 720. j) = k=1 x(:. 21. on peut aussi faire les sommes et produits cumul´s selon e les lignes et les colonnes : -->cumsum(x.

1) ! 2.1849924 0.5 1 n−1 n 1/2 (xi − x) ¯ i=1 2 ."r") imin = ! 1. 6.2) y(2. 2.-->x = rand(1.1413027 0. 2. ! // les min sont y(1.3247241 0. -->mean(x) ans = 3.4342711 0.7888738 -->min(x) ans = 0. ! 26 .2505764 ! -->[xmin. ! // y(2. imin] = min(x) imin = 5. La formule utilis´e pour l’´cart type ´tant : e e e σ(x) = -->x = 1:6 x = ! 1.1493971 0.1413027 -->[ymin. ! ymin = ! 0.7530783 ! y(1.1493971 0."c") // minimum de chaque ligne imin = ! 1.1493971 ! ! 0.7738714 0.2) ymin = 0.3) -->[ymin.475374 ! 0.3) y = ! 0. ! // le min est obtenu pour y(2. x= ¯ 1 n n xi i=1 3.2) ymin = ! 0.1413027 // minimum de chaque colonne // => les min sont 0. 2. 4. imin] = min(y.1) y(2. imin] = min(y.5) x = ! 0. imin] = min(y) imin = ! 2.7530783 ! -->[ymin. // le min est obtenu en x(5) xmin = 0.2505764 0.1413027 ! moyenne et ´cart type e Les fonctions mean et st deviation permettent de calculer la moyenne et l’´cart type des compoe santes d’un vecteur ou d’une matrice. 5.2505764 -->y = rand(2. 2.8269121 ! 0.

! ! 4. 6. 5.8782165 0. ! -->mean(x."c") ans = ! ! 2. 5. exemple : -->A = rand(2. 2. 6.6623569 ! ! ! ! 27 .0683740 0.5 // la moyenne des vecteurs lignes (=les moyennes de chaque colonne) 4. 3. ! Remodeler une matrice La fonction matrix permet de remodeler une matrice en donnant de nouvelles dimensions (mais avec le mˆme nombre de coefficients en tout) . Une de ses utilisations est de transformer un vecteur ligne en vecteur colonne et inversement. 5. Signalons encore un raccourci qui permet de transformer une matrice A (vecteurs ligne et colonne compris) en un vecteur colonne v : v = A(:).2) A = ! 0. ! ! 2. ! -->B_new = matrix(B.5 3. 3.2) B_new = ! 1.8782165 ! 0. 2.4 5 6] x = ! 1. 6.8708287 De mˆme on peut calculer la moyenne (et aussi l’´cart type) des lignes ou des colonnes d’une matrice : e e -->x = [1 2 3.5 ! // la moyenne des vecteurs colonnes (=les moyennes de chaque ligne) -->mean(x. 3. 4 5 6] B = ! 1. ! ! 4.6623569 ! -->v=A(:) v = ! 0.3. e -->B = [1 2 3."r") ans = ! 2. ! 5.-->st_deviation(x) ans = 1.0683740 ! 0. ! Elle travaille en ordonnant les coefficients colonne par colonne. ! ! 4.5608486 ! ! 0.5608486 ! 0.

1 1.8497452 0.0002211 ! 0. 1.3076091 0.5341598 ! et renvoie le r´sultat sous forme d’un vecteur colonne (Scilab utilise la m´thode QR qui consiste ` obtenir e e a it´rativement une d´composition de Schur de la matrice). -->size(x) ans = ! 1.2113249 ! 0.0.5.8833888 0.Vecteurs avec espacement logarithmique Parfois on a besoin d’un vecteur avec une incr´mentation logarithmique pour les composantes (ce a `-d tel que le rapport entre deux composantes successives soit constant : xi+1 /xi = Cte) : on peut utiliser dans ce cas la fonction logspace : logspace(a. 1000.5) A = ! 0. ! Valeurs et vecteurs propres La fonction spec permet de calculer les valeurs propres d’une matrice (carr´e !) : e -->A = rand(5. 100.6857310 0.5208514i ! ! 0.2320748 0. vous pouvez utiliser la fonction gspec.9329616 0. Pour un probl`me de valeurs propres g´n´ralis´. on obtient directement son nombre de composantes : -->length(x) ans = 28 // B est la matrice (2. exemple : e e -->logspace(-2.7263507 0. dont la premi`re et la derni`re sont respectivement 10a et 10b .8. ! alors que length fournit le nombre d’´l´ments d’une matrice (r´elle ou complexe).01 0.1985144 0.3616361 ! ! ! ! ! -->spec(A) ans = ! 2.7560439 ! 0.312642 0.6653811 0.6623569 0.3) de l’exemple precedent 3.8) ans = ! 0. nl = 2.5208514i ! ! . 5.5608486 0.0.b.0696540 ! ! 0.nc]=size(B) nc = 3. Les vecteurs propres peuvent s’obtenir avec e e bdiag. 10000. ! .2312237 0.4 Les fonctions size et length size permet de r´cup´rer les deux dimensions (nombre de lignes puis de colonnes) d’une matrice : e e -->[nl.0683740 0.2164633 0. 100000.4777836 ! ! .0245759 . 2. -->x=5:-1:1 x = ! 5.0245759 + 0.0. e e e e 2.3303271 ! 0.2146008 0.8782165 0. 4.5442573 0.6283918 0.n) : permet d’obtenir un tel vecteur avec n composantes.6525135 0. Ainsi pour un ee e vecteur ligne ou colonne. 10.

. D´finir la matrice d’ordre n suivante (voir le e  2   −1   A= 0   . ... Ecrire l’instruction e qui permet de calculer la matrice Y (de mˆme taille que X) dont l’´l´ment en position (i. ¯ ¯ i=1 Tester avec des valeurs de n de plus en plus grandes. .   . ... .. . Tracer le graphe de la fonction f (x) = pour x ∈ [0.  . . que vaut diag(diag(A)) ? e 3. . calculer la moyenne cumul´e de ce vecteur.2)) permettent d’obtenir le nombre de lignes (rows) et de colonnes (columns) de la matrice A. . 0 2. . D´finir une matrice carr´e A quelconque (par exemple avec rand) e e e et construire en une seule instruction.. 4π] (´crire un script). .1)) et size(A. Soit A une matrice carr´e . . . Soit X une matrice (ou un vecteur. -->length(B) ans = 6. ce qui ´vitera de les faire passer comme arguments. . une matrice triangulaire inf´rieure T telle que tij = aij pour e i > j (les parties strictement triangulaires inf´rieures de A et T sont ´gales) et telle que tii = 1 (T e e est ` diagonale unit´).) que l’on a d´finie dans l’environnement. .  .’c’) (ou size(A. . 29 .9 Exercices d´tail de la fonction diag ` l’aide du Help) : e a  −1 0 · · · 0 . 2.5.. 0    . .  . . . Noter aussi que size(A. En fait ces deux primitives seront surtout utiles ` l’int´rieur de fonctions pour r´cup´rer les tailles des a e e e matrices et vecteurs. La fonction tril permet d’extraire la partie triangulaire inf´rieure d’une matrice (triu pour la e partie triangulaire sup´rieure). c-a-d le e 1 vecteur x dont les n composantes sont : xk = k k xi et tracer la courbe de la suite ainsi obtenue. e 6. Une petite illustration de la loi des grands nombres : obtenir avec la fonction rand n r´alisations e de la loi uniforme sous la forme d’un vecteur x.. . −1  · · · 0 −1 2 1. j) est ´gal e ee e a ` f (Xij ) dans les cas suivants : (a) f (x) = 2x2 − 3x + 1 (b) f (x) = |2x2 − 3x + 1| (c) f (x) = (x − 1)(x + 4) (d) f (x) = 1 1+x2 sin x x 5. a e ´ 4.’r’) e (ou size(A.

3. y=y+k..).. sans l’aide d’un d´bogueur). et donc son interpr`teur travaille moins. Par contre l’inconv´nient est qu’un e e programme ´crit en Scilab est plus lent (voire beaucoup plus lent) que si vous l’aviez ´crit en C (mais le e e programme en C a demand´ 50 fois plus de temps d’´criture et de mise au point.) est que les variables ne sont pas d´clar´es : lors des manipulations e e pr´c´dentes nous n’avons ` aucun moment pr´cis´ la taille des matrices. Un point important concernant la rapidit´ d’ex´cution est a e e e qu’il faut programmer en utilisant au maximum les primitives disponibles et les instructions matricielles (c’est ` dire : limiter le nombre de boucles au maximum)1 .. vous avez des facilit´s pour lier ` Scilab des sous-programmes fortran (77) ou C. en dehors des primitives toutes prˆtes (qui permettent avec les instructions matricielles. est de disposer d’instructions graphiques (ce qui ´vite e d’avoir ` jongler avec un programme ou une biblioth`que graphique) et d’ˆtre interprˆt´ (ce qui permet a e e ee de chasser les erreurs assez facilement. for k=v. . une e programmation tr`s synth´tique proche du langage math´matique. car la notation vectorielle/matricielle e et les primitives toutes prˆtes.. Un autre avantage de ce type de langage. end e Le nombre d’it´rations est donn´ par le nombre de composantes du vecteur ligne 2 .1 Les boucles Il existe deux types de boucles : la boucle for et la boucle while. les instructions matricielles permettent d’´viter un maximum de e boucles).Pour b´n´ficier du meilleur des e e e e deux mondes (c’est dire de la rapidit´ d’un langage compil´ et du confort d’un environnement comme e e celui de Scilab). pour e e les applications o` le nombre de donn´es est vraiment important (par exemple des matrices 1000 × 1000) u e il vaut mieux revenir ` un langage compil´.. e a 3. C’est l’interpr`teur de Scilab qui.1 La boucle for La boucle for it`re sur les composantes d’un vecteur ligne : e -->v=[1 -1 1 -1] -->y=0. D’autre part. En effet.Chapitre 3 La programmation en Scilab Scilab. .1. e e a e la valeur de k est ´gale ` v(i). Pascal. C++. Pour que les boucles de Scilab ressemblent ` des boucles du type : e a a pour i := ideb ` if in par pas de istep faire : a suite d’instructions fin pour 1 2 voir la section « Quelques remarques sur la rapidit´ » e si le vecteur est une matrice vide alors aucune it´ration n’a lieu e 30 . ni mˆme leurs types (r´elles. Cette caract´ristique est souvent d´consid´r´e (avec raison.). e e a e e e e complexes. permettent de restreindre consid´rablement le nombre de variables et de e e lignes d’un programme (par exemple. et ` la i`me it´ration. Scilab appelle alors a une routine (fortran) compil´e. du moins matriciel) dispose d’un e e e langage de programmation simple mais assez complet. . dans ce cas. La diff´rence essentielle par rapport aux langages e habituels (C. se charge de ce e travail. cf l’ancien fortran) d’un point de e e ee vue g´nie logiciel car cela peut conduire ` des erreurs difficilement rep´rables. lorsqu’il rencontre un nouvel objet. Dans le cas de langage e a e comme Scilab (ou Matlab) cela ne pose pas trop de probl`mes. ..

le r´sultat d’une instruction d’affectation n’est pas e affich´ mˆme si elle n’est pas suivie d’un point virgule . end o` les instructions sont s´par´es par des virgules (ou des points virgules si on ne veut pas voir le u e e r´sultat des instructions d’affectations ` l’´cran)... end ou encore (dans un script ou une fonction) : while condition instruction_1 . et lorsque l’incr´ment i_step est ´gal ` 1 nous e e a avons vu qu’il peut peut ˆtre omis. suite d’instructions. for k=A.. instruction_1..2 La boucle while Elle permet de r´p´ter une suite d’instructions tant qu’une condition est vraie..... y=y+v(i). end Signalons que les op´rateurs de comparaisons sont les suivants : e == < > <= >= ~= ou <> ´gal ` e a strictement plus petit que strictement plus grand que plus petit ou ´gal e plus grand ou ´gal e diff´rent de e et que Scilab poss`de un type logique ou bool´en : %t ou %T pour vrai et %f ou %F pour faux. ce comportement par d´faut pouvant ˆtre modifi´ avec l’instruction e e e e e mode 3 et ou non 31 . La boucle pr´c´dente peut alors ˆtre ´crite plus naturellement de la e e e e e fa¸on suivante : c -->y=0..... y = y + k.x=2*x. . Cependant dans un script (ou une fonction)..1.. par exemple : e e -->x=1 .. end Quelques remarques : – une boucle peut aussi it´rer sur une matrice.. while x<14..instruction_N . l’´cran) e 3.il suffit d’utiliser comme vecteur i_deb:i_step:i_fin . Le nombre d’it´rations est ´gal au nombre de colonnes e e e `me it´ration est ´gale ` la i`me colonne de la matrice. Les op´rateurs logiques sont : e e e & | ~ La syntaxe du while est la suivante : while condition.. On peut e e d´finir des matrices et vecteurs de bool´ens..3).. ce qui permet une pr´sentation de la forme : a e a e for variable = matrice instruction1 instruction2 . le e a e passage ` la ligne est ´quivalent ` la virgule. e e de la matrice et la variable de la boucle ` la i a e e a Voici un exemple : -->A=rand(3. end – la syntaxe pr´cise est la suivante : e for variable = matrice... for i=1:4.y=zeros(3.1)... instruction_N end ceci est uniquement valable pour un script car dans une fonction. . instruction n end o` les instructions peuvent ˆtre suivies d’un point virgule (toujours pour ´viter les affichages ` u e e a 3.

. Ici.............y=x. de mˆme que pour le while. si aucune action n’intervient dans le cas o` la condition u est fausse... si la partie else enchaˆ sur un autre if then ıne else. qui est facultatif. instructions est omise. select num...end // la variable x doit ^tre d´finie e e De mˆme dans un script ou une fonction. u e e e 3.2... Comme pour les langages habituels.. si vous allez ` la ligne.. case 2..... Le else.. 3.1 La construction if then else Voici un exemple : -->if x>0 then.. les virgules de s´paration ne sont pas e a e obligatoires.... y=-x.. on peut lier les mots cl´s else et if ce qui conduit finalement ` une pr´sentation du type : e a e if condition_1 then suite d’instructions 1 elseif condition_2 then suite d’instructions 2 .. Enfin.. La syntaxe de cette construction est la suivante : e e e e select variable_test case expr_1 suite d’instructions 1 ..2 Les instructions conditionnelles Il y en a aussi deux : un « if then else » et un « select case ». case 1.. permet de r´aliser une suite d’instructions dans le cas o` tous e u les pr´c´dents tests ont ´chou´s. la partie else....... end qui dans un script ou une fonction s’´crirait plutˆt : e o // ici on suppose que select num case 1 y = ’cas 1’ case 2 y = ’cas 2’ else y = ’autre cas’ end la variable num est bien definie 2’.. y = ’cas -->else. Scilab teste successivement l’´galit´ de la variable num avec les diff´rents cas possibles (1 puis 2).o` chaque instruction_k peut ˆtre suivie d’un point virgule et ce qui est appel´ condition est en u e e fait une expression d´livrant un scalaire bool´en. case expr_N 4 la variable y est du type « chaˆ de caract`res ». chaque condition est une expression d´livrant un scalaire bool´en. y = ’cas 1’. e e 3.... e e e et d`s que l’´galit´ est vraie.2 La construction select case (*) Voici un exemple (` tester avec diff´rentes valeurs de la variable num)4 a e -->num = 1.. les instructions correspondantes (au cas) sont effectu´es puis on sort de la e e e e construction..2... elseif condition_N then suite d’instructions N else suite d’instructions N+1 end o`. y = ’autre cas’.. cf prochain paragraphe ıne e 32 ....else.

.. 2.... 3. e Il en existe d’autres dont les chaˆ ınes de caract`res et les listes. e 2..... ! -->length(Ms) ans = ! 1. la chaˆ : e a ıne Scilab c’est "cool" ? on utilisera : -->est_ce_si_sur = "Scilab c’’est ""cool"" ?" ou bien : -->est_ce_si_sur = ’Scilab c’’est ""cool"" ?’ On peut aussi d´finir des matrices de chaˆ e ınes de caract`res : e -->Ms = ["a" "bc" "def"] Ms = !a bc def ! -->size(Ms) // pour obtenir les dimensions ans = ! 1. ! les entiers ´tant vu comme des nombres flottants e 33 . les bool´ens (matrices. En fait cette construction est ´quivalente ` la construction if suivante : e a if variable_test = expr_1 then suite d’instructions 1 . Dans le ıne e langage Scilab elles sont d´limit´es par des apostrophes ou des guillemets (anglais).. Ainsi pour affecter ` la variable est_ce_si_sur.suite d’instructions N else suite d’instructions N+1 end o` ce qui est appel´ expr_i est une expression qui d´livrera une valeur ` comparer avec la valeur de la u e e a variable variable_test (dans la plupart des cas ces expressions seront des constantes ou des variables).. 5 3.. elseif variable_test = expr_N then suite d’instructions N else suite d’instructions N+1 end 3.. vecteurs et scalaires) . et lorsqu’une chaˆ e e ıne contient un tel caract`re. il faut le doubler. les matrices (et vecteurs et scalaires) de nombres r´els5 ou complexes . e 3.......1 Les chaˆ ınes de caract`res e Dans l’exemple sur la construction case...3 Autres types de donn´es e Jusqu’` pr´sent nous avons vu les types de donn´es suivants : a e e 1.3... la variable y est du type chaˆ de caract`res.

e matrices ou scalaires « chaˆ ınes de caract`res » .[%t . s = s1 + s2 s = abcdef et l’extraction se fait via la fonction part : -->part(s.2) = 100.2113249 0. ! -->M = L(1) M = ! ! // extraction de la premiere entree 0. s2 = ’def’. bool´ens.3. .3:4) ans = cd Le deuxi`me argument de la fonction part est donc un vecteur d’indices (ou un simple scalaire entier) e d´signant les num´ros des caract`res que l’on veut extraire. %f]) L = L(1) ! ! 0. Voici quelques op´rations basiques sur les listes : e e e 0. length(M) renvoie une matrice d’entiers de mˆme format que M o` le coefficient e e u en position (i. listes..2). les « ordinaires » et les « typ´es ». et le 3`me un vecteur de bool´ens.["Vivement que je finisse" " cette doc.2). .) num´rot´s. j).3303271 ! // modification dans la premiere entree 34 -->L(1)(2.. le 2`me un vecteur de e ee e chaˆ ınes de caract`res. j) donne le nombre de caract`res de la chaˆ en position (i.7560439 L(2) !Vivement que je finisse L(3) ! T ! ! F ! e Je viens de d´finir une liste dont le premier ´l´ment est une matrice (2..3303271 ! cette doc.7560439 0.3) ans = c -->part(s. Voici un exemple de liste ordinaire : e -->L=list(rand(2.0002211 ! 0.0002211 ! 0. e ıne La concat´nation de chaˆ e ınes de caract`res utilise simplement l’op´rateur + : e e -->s1 = ’abc’. fonctions. .2 Les listes (*) Une liste est simplement une collection d’objets Scilab (matrices ou scalaires r´els ou complexes..2113249 0. Il y a deux e e e e sortes de listes. e e e 3.Noter que length n’a pas le mˆme comportement que sur une matrice de nombres : pour une matrice e de chaˆ ınes de caract`res M."]. .

-->L(2) ans = !Vivement que je finisse cette doc. ! 35 .0002211 ! 100.. -->length(L) ans = 4..-->L(1) ans = ! ! 0.2113249 0.2113249 0. avant les vacances ! ! 0. ! // je modifie la 2 eme entree -->L(2)(4) = " avant les vacances !"..0002211 ! 100.7560439 0. avant les vacances ! ! -->L(4)=" pour ajouter une 4 eme entree" L = L(1) ! ! 0.. -->L(2) = null() L = // destruction de la 2 eme entree // idem // quel est le nombre d’elements de la liste cette doc.7560439 0. ! L(1) ! ! 0.2113249 0.7560439 L(2) !Vivement que je finisse L(3) ! T ! ! F ! L(4) pour ajouter une 4 eme entree -->size(L) ans = 4.0002211 ! 100.

! L(3)(1) 1. L(3)(2) ! 1. 2.L(2) ! T ! ! F ! L(3) pour ajouter une 4 eme entree -->Lbis=list(1. le premier ´l´ment est une chaˆ de caract`res qui e ee ıne e permet de « typer » la liste (ceci permet de d´finir un nouveau type de donn´e puis de d´finir des e e e op´rateurs sur ce type). 2. ! -->L(3) = Lbis L = // la 3 eme entree de L est maintenant une liste L(1) ! ! 0. ce e ee e premier ´l´ment peut aussi ˆtre un vecteur de chaˆ ee e ınes de caract`res. Voici un exemple : on veut repr´senter un poly`dre (dont toutes les faces ont le mˆme e e e 36 .0002211 ! 100.1:3) Lbis = // je definis une autre liste Lbis(1) 1. En fait. 3. Lbis(2) ! 1. Pour ces listes.7560439 L(2) ! T ! ! F ! L(3) 0. 3. ! Passons aux listes « typ´es » . la premi`re donnant donc le type de e e la liste et les autres pouvant servir ` r´f´rencer les diff´rents ´l´ments de la liste (au lieu de leur num´ro a ee e ee e dans la liste). les ´l´ments suivants pouvant ˆtre n’importe quels objets scilab.2113249 0.

1. 8. 1. ! 1.1) cela peut e ee e ıne donner : P=[ 0 0 1 1 0 0 1 1. 1... 1.. 0. 0 0 0 0 1 1 1 1]. // les coordonnees des sommets // la connectivit´ des faces e Il me reste ` former ma liste typ´e qui contiendra donc toute l’information sur mon cube : a e -->Cube = tlist(["polyedre".. 1.. 1."face"]. connect = [1 2 3 4 5 8 7 6 3 7 8 4 2 6 7 3 1 5 6 2 1. Pour un cube (cf figure 3. 0 1 1 0 0 1 1 0. 1.P. 1. on stocke les coordonn´es de tous les sommets dans une matrice (de format e e (3.. je donne les e num´ros des sommets qui la constituent de sorte ` orienter la normale vers l’ext´rieur par la r`gle du e a e e tire-bouchon. ! 0.nombre d’arˆtes)... 0. 0.nb de faces)) la connectivit´ de chacune des faces : pour chaque face.. 5]. Puis on d´crit par une matrice (de format (nb ee e ıne e de sommets par face. 0.nb sommets)) qui sera r´f´renc´e par la chaˆ coord. 0. 0. 3. Pour cela..1 – Num´ros des sommets du cube e Cette entr´e de la liste sera r´f´renc´e par la chaˆ face. 0..connect) Cube = Cube(1) !polyedre coord face ! Cube(2) ! ! ! 0. 1. Cube(3) 1. 0. 4."coord".. 0. ! 37 ... 1. z 5 6 8 1 7 2 y 4 3 x Fig. 0..

>.0683740 -->A < B ans = ! T T F ! ! F F T ! mais si l’une des deux matrices est un scalaire.3) A = ! 0.2) ans = ! ! ! 0. 3. 7. 1. on peut utiliser la chaˆ de caract`res e ee e ıne e correspondante.coord(:.0002211 ! 0. 7. 7.==.3) B = ! 0. 3. 2.5 ans = ! T T F ! ! F T F ! Les op´rateurs bool´ens s’appliquent aussi sur ce type de matrice toujours au sens « ´l´ment par ´l´ment » : e e ee ee 38 0. Leur e e avantage est que l’on peut d´finir (i. 4. ! 0. alors A < s est un raccourci pour A < s*one(A) : -->A < 0. ! // ou encore Cube("coord")(:. 3. 5.2) -->Cube. 5. exemple : -->Cube.7560439 0. 1.3 Quelques expressions avec les vecteurs et matrices de bool´ens (*) e Le type bool´en se prˆte aussi ` des manipulations matricielles dont certaines b´n´ficient de raccourcis e e a e e d’´criture assez pratiques.face(:.e. 8. 6. *.8497452 0. 2. -. 4. 4.6623569 ! .6283918 ! 0. 6. >=. <=. 3. 2. 5.3303271 -->B = rand(2. 2. etc. ces listes typ´es se manipulent exactement comme les autres.5608486 ! 0.2113249 0. par exemple : ee ee -->A = rand(2.! ! ! ! 1. 8. 8. ! ! ! ! En dehors de cette particularit´. /. la e e e comparaison ayant lieu « ´l´ment par ´l´ment ».6653811 ! 0. 6. 3. on obtient une matrice de bool´ens de mˆme format. Lorsque l’on compare deux matrices r´elles de mˆme taille avec l’un des e e e op´rateurs de comparaison (<.1) ans = ! ! ! ! 1.8782165 ! 0. ! ! ! ! Au lieu de d´signer les ´l´ments constitutifs par leur num´ro. surcharger) les op´rateurs +. sur une tlist de type donn´ e e e (cf une prochaine version de cette doc ou mieux : consulter la doc en ligne sur la home page Scilab).3.6857310 0. ~=). 4. ! 1.

5) ans = ! 2. bool2s transforme une matrice de bool´ens en une matrice de mˆme format o` la valeur logique e e u « vraie » est transform´e en 1. Ainsi pour effectuer un calcul sous la condition que toutes les composantes d’un vecteur soient strictement positives.5935095 0. 0.5015342 ! // v < 0. 3.5664249 0.. La fonction find permet de r´cup´rer les indices des coefficients « vrais » d’un vecteur ou d’une e e matrice de bool´ens : e -->v = rand(1.4826472 -->find(v < 0...-->b1 = [%t %f %t] b1 = ! T F T ! -->b2 = [%f %f %t] b2 = ! F F T ! -->b1 & b2 ans = ! F F T ! -->b1 | b2 ans = ! T F T ! -->~b1 ans = ! F T F ! D’autre part il y a deux fonctions tr`s pratiques qui permettent de vectoriser des tests : e 1. On obtient alors un scalaire bool´en. Ces deux fonctions admettent ee e e un argument optionnel pour effectuer l’op´ration selon les lignes ou les colonnes.3. et « faux » en z´ro : e e -->bool2s(b1) ans = ! 1.3321719 0. Enfin les e e fonctions and et or proc`dent respectivement au produit logique (et) et ` l’addition logique (ou) de tous e a les ´l´ments d’une matrice bool´enne.5 donne un vecteur de booleens Une application de ces fonctions est expos´e plus loin (cf Quelques remarques sur la rapidit´). e 3.5) v = ! 0. end D’autre part scilab utilise aussi les raccourcis de certains langages (comme C) lors de l’´valuation e d’un ou ou d’un et : 39 .4 les expressions bool´ennes dans les tests (if et while) e Il est tol´r´ dans un test if ou while d’utiliser une expression qui renvoie un vecteur (ou une matrice) ee de bool´ens... ! 2. on peut utiliser : if x > 0 then . ! 0. 1. Dans ce cas c’est le produit logique des ´l´ments du vecteur qui permet de d´terminer si e ee e le test est vrai ou non.

il faut charger le fichier par l’instruction : exec("facts.. Chaque fonction doit commencer par a e e e l’instruction : function [y1. pour a et b.xm) o` les xi sont les arguments d’entr´e. La fonction a e doit se terminer par le mot cl´ endfunction. n2 =3...1 un premier exemple de fonction : la factorielle en scilab function [y] = fact1(n) // la factorielle : il faut ici que n soit bien un entier naturel y = prod(1:n) endfunction Supposons que l’on ait ´crit cette fonction dans le fichier facts.y2. Un exemple d’utilisation : while j > 0 & elem < v(j) v(j+1) = v(j) j = j-1 end Dans cette boucle.sce pour les scripts) 7 6 40 . e e 3. e e 2..sci (et en.sci") // ou encore getf("facts.. On peut alors utiliser cette fonction a partir de l’invite (mais aussi dans un script ou bien une autre ` fonction) : -->m = fact1(5) m = 120. Pour que Scilab puisse la e connaˆ ıtre..sci. fact1(n2) ans = 6.sci8 . Vient ensuite le corps de la u e e fonction (qui permet de calculer les arguments de sortie ` partir des arguments d’entr´e). si a est fausse7 b n’est pas ´valu´e. vous pouvez cliquer sur l’item Load into scilab du menu Execute ou mieux sur le e e raccourci clavier Ctrl-l.. Rmq : la tradition est de suffixer les noms des fichiers e contenant des fonctions en .y3.yn]=nomfonction(x1.1).4 Les fonctions Pour d´finir une fonction en Scilab. -->n1=2.1.4.. aucune erreur n’est g´n´r´e par l’expression elem < v(j) lorsque j = 0 puisqu’elle e ee n’est pas ´valu´e. les yj ´tant les arguments de sortie. ceci a lieu uniquement dans un test « if »ou « while »(ce comportement a ´t´ introduit ee a ` partir de la version 3. Si vous utilisez l’´diteur e int´gr´ scipad. rappelons le.. si a est vraie6 alors b n’est pas ´valu´e . 3. la m´thode la plus courante est de l’´crire dans un fichier. e e Mais. si a renvoie un vecteur de bool´ens il faut que toutes les composantes soient vraies e si a renvoie un vecteur de bool´ens il faut qu’au moins une composante soit fausse e 8 La tradition est de suffixer les noms des fichiers contenant des fonctions en . pour a ou b.sci") ce qui peut aussi se faire via le menu File operations comme pour les scripts. e e e dans lequel on pourra d’ailleurs mettre plusieurs fonctions (en regroupant par exemple les fonctions qui correspondent ` un mˆme th`me ou une mˆme application).

d’un script ou d’une autre fonction : a arg_s = fact1(arg_e) les arguments utilis´s sont appel´s arguments effectifs. r1 = . -->[r1. Dans ce cas scilab utilise la variable par d´faut ans pour stocker le r´sultat mais elle ne e e peut que stocker qu’un le premier objet renvoy´ par la fonction (le deuxi`me ´tant perdu).i -->resoud_equ_2d(1. dans le deuxi`me une variable (n2) et dans le troisi`me une expression e e e (n1*n2).4.i // appel sans affectation On peut remarquer que le troisi`me appel ne renvoie qu’une seule racine (la premi`re). c) // calcul des racines de a x^2 + b x + c = 0 // a. Avant de vous montrer d’autres exemples.1.0. r2] = resoud_equ_2d(1. Ceci est normal e e car on n’a pas affect´ le resultat de la fonction (qui renvoie 2 objets scalaires) contrairement aux deux e premiers appels.-->fact1(n1*n2) ans = 720. . voici quelques pr´cisions de vocabulaire. Dans l’´criture e e de la fonction.1.1) r2 = i r1 = .sqrt(delta))/(2*a) x2 = (-b + sqrt(delta))/(2*a) endfunction Voici trois essais avec cette fonction : -->[r1. e e e 3. + cn (t − x1 ) . . 3.4*a*c x1 = (-b .4. l’argument effectif e e e d’entr´e est une constante (5). r2] = resoud_equ_2d(1.1) r2 = . . (t − xn−1 ). 41 .x2] = resoud_equ_2d(a.3 troisi`me exemple : l’algorithme d’Horner e Il s’agit d’´valuer en un point t un polynˆme ´crit dans une base de Newton (Rmq : avec les xi = 0 e o e on retrouve la base canonique) : p(t) = c1 + c2 (t − x1 ) + c3 (t − x1 )(t − x2 ) + . Dans ma premi`re utilisation. b et c peuvent etre des reels ou des complexes et a doit etre non nul delta = b^2 . b. La correspondance entre arguments effectifs et formels (ce que l’on appelle couramment passage des param`tres) peut se faire de diverses mani`res (cf prochain paragraphe pour quelques pr´cisions en e e e ce qui concerne Scilab). Lorsque e e j’utilise cette fonction ` partir de l’invite.2 deuxi`me exemple : l’´quation du second degr´ e e e function [x1. l’argument de sortie y et l’argument d’entr´e n sont appel´s arguments formels .0.1) ans = .2. .

Cette instruction permet (avec l’instruction size qui renvoie le nombre de lignes et le nombre de colonnes) de ne pas faire passer la dimension des structures de donn´es (matrices.4.. En g´n´ralisant ` n quelconque et en utilisant une boucle. Petit rappel : l’instruction length renvoie le produit des deux e e dimensions d’une matrice (de nombres).coef) affectera ` la variable val la valeur : a m−1 coef1 + coef2 (tt − xx1 ) + · · · + coefm i=1 (tt − xxi ) aux erreurs d’arrondi num´rique pr`s. ` 42 . il faut que xx en ait au moins m − 1. si l’on veut que tout se passe bien.4 quatri`me exemple : le tri insertion e Voici une fa¸on de coder en scilab.x.. listes.).. + c(n)*(t-x(1))*. celui du tri insertion est a oublier (utiliser les fonctions sort ou gsort). ..En utilisant les facteurs communs et en calculant de la « droite vers la gauche » (ici avec n = 4) : p(t) = c1 + (t − x1 )(c2 + (t − x2 )(c3 + (t − x3 )(c4 ))).) e dans les arguments d’une fonction.. on obtient donc en Scilab : e e a function [p]=myhorner(t.*(t-x(n-1)) // par l’algorithme d’horner n=length(c) p=c(n) for k=n-1:-1:1 p=c(k)+(t-x(k))*p end endfunction Si les vecteurs coef et xx et le r´el tt sont bien d´finis dans l’environnement d’appel de la fonction e e (si le vecteur coef a m composantes.. en particulier si le code pour Horner peut ˆtre rendu rapide par vectorisation e e (cf exercices). l’algorithme du tri insertion sans sentinelle : c function x = tri_insertion(x) n = length(x) for i = 2:n temp = x(i) j = i-1 while j > 0 & temp < x(j) x(j+1) = x(j) j = j-1 end x(j+1) = temp end endfunction Noter que ces 4 premi`res fonctions scilab sont donn´es ` titre d’exemples simples pour d´buter dans e e a e l’´criture de fonctions scilab.. l’instruction : val = myhorner(tt. et donc dans le cas d’un vecteur (ligne ou colonne) son nombre de composantes. 3. on obtient l’algorithme d’Horner : (1) p := c4 (2) p := c3 + (t − x3 )p (3) p := c2 + (t − x2 )p (4) p := c1 + (t − x1 )p.c) // evaluation du polynome c(1) + c(2)*(t-x(1)) + c(3)*(t-x(1))*(t-x(2)) + // ..xx.

x = rand(m. num ligne ]) o` vous entrez le nom de la fonction comme une chaˆ de caract`res et (´ventuellement) le num´ro de u ıne e e e la ligne d’arrˆt (la valeur par d´faut est 1).. timer(). v2. k) w = 2*v(k) endfunction function [w] = titi(v. Enfin.sqrt(delta))/(2*a) x2 = (-b + sqrt(delta))/(2*a) endfunction 43 . il existe e a e un moyen de mettre des points d’arrˆt (break points en anglais) avec l’instruction : e setbpt(nom fonction [. end. .) qui permet de visuae liser la valeur des variables v1. e e e vous repartez donc avec un resume.Attention disp affiche ses arguments dans l’ordre inverse ! Vous pouvez mettre une ou plusieurs instruction(s) pause en des endroits strat´giques de la fonce tion.4*a*c x1 = (-b .v2.. Lorsque Scilab rencontre un tel point d’arrˆt tout se passe e e e comme si vous aviez mis une instruction pause apr`s la ligne mentionn´e. Vous pouvez en tenir compte e e e e pour acc´lerer certaines fonctions. end. t1=timer()/nb_rep timer().4. vous pouvez voir tous les points d’arrˆt que vous avez d´finis avec dispbpt(). y = toto(x.1). num ligne ]) Si vous ne pr´cisez pas le num´ro de ligne. Les points d’arrˆt doivent ˆtre explicitement enlev´s avec : e e e delbpt(nom fonction [. tous les points d’arrˆt install´s dans cette fonction sont e e e e d´truits. k) v(k) = 2*v(k) w = v(k) endfunction // script de test m = 200000. . a e 3..6 D´verminage d’une fonction e Pour d´boguer une fonction vous pouvez utiliser la fonction disp(v1. toutes les variables internes (donc propres ` la fonction) sont d´truites. c) // calcul des racines de a x^2 + b x + c = 0 // a.3. b et c peuvent etre des reels ou des complexes et a doit etre non nul delta = b^2 . t2=timer()/nb_rep Sur ma machine j’obtiens : t1 t2 = = 0.300). Voici un exemple caricatural mais qui met bien en ´vidence le coˆt du e e u passage par copie pour des arguments prenant beaucoup de place : function [w] = toto(v. Lorsque vos observations sont finies.00380 Lors de la sortie de la fonction. nb_rep = 2000. b.300).5 Passage des param`tres (*) e Le passage d’un param`tre se fait par r´f´rence si ce param`tre n’est pas modifi´ par la fonction et e ee e e par copie sinon (ainsi les param`tres d’entr´e ne peuvent pas ˆtre modifi´s).x2] = resoud_equ_2d(a. for i=1:nb_rep. Apr`s examen des variables. y = titi(x. . e a e Comme il est p´nible de rajouter des instructions pause dans toutes les fonctions ` d´boguer.4.00002 0. Lorsque Scilab rencontre cette instruction le d´roulement du programme s’arrˆte et vous pouvez e e examiner la valeur de toutes les variables d´j` d´finies ` partir de la fenˆtre Scilab (l’invite --> de Sciea e a e lab se transforme en -1->). la commande resume fait repartir le d´roulement des instructions (jusqu’` l’´ventuelle prochaine pause). e e e Voici un petit exemple avec la fonction resoud equ 2d d´finie pr´c´demment : e e e function [x1. for i=1:nb_rep.

3. .2.Je suppose que cette fonction a ´t´ charg´e dans Scilab. -1->b b = 2.4.r2] = resoud_equ_2d(1. soit avec un getf soit avec un exec : ee e -->setbpt("resoud_equ_2d") // un premier point d’arr^t e -->[r1.4494897i -1->x2 // x2 n’est tj pas d´finie (x2 est d´finie ` la ligne 6 de cette fct) e e a x2 !--error 4 undefined variable : x2 -1->dispbpt() // je vois mes 2 points d’arr^t e breakpoints of function :resoud_equ_2d 1 5 -1->resume // je red´marre (et donc je sorts de ma fonction) e r2 = . break permet de sortir uniquement de la boucle interne e 44 . + 2.1.7) // je lance le calcul => arr^t e Stop after row 1 in function resoud_equ_2d : -1->a a = 1.5) // je rajoute un point d’arr^t en ligne 5 e // j’examine quelques variables -1->x1 // x1 n’est pas encore definie ! x1 !--error 4 undefined variable : x1 -1->resume // je red´marre (jusqu’au prochain point d’arr^t) e e Stop after row 5 in function resoud_equ_2d : -1->x1 // je peux maintenant examiner x1 x1 = . Elle peut servir ` simuler les autres o a a 9 si la boucle est imbriqu´e dans une autre.1.2.7 L’instruction break Elle permet dans une boucle for ou while d’arrˆter le d´roulement des it´rations en passant le e e e contrˆle ` l’instruction qui suit le end marquant la fin de la boucle9 . .4494897i r1 = . -1->dispbpt() // je visualise mes points d’arr^t e breakpoints of function :resoud_equ_2d 1 -1->setbpt("resoud_equ_2d".2.4494897i -->delbpt("resoud_equ_2d") // je d´truits tous les points d’arr^t e e Notez que ces manipulations peuvent se faire maintenant de mani`re graphique avec scipad (voir les e items du menu Debug parmi lesquels show watch vous permet de choisir les variables dont vous voulez observer la valeur et configure execution vous permet de choisir la valeur des param`tres d’entr´e de e e la fonction).1.

l) n = max(size(v)) ind = 0 for i=1:n if part(v(i). until du Pascal) et celles avec a test de sortie au milieu ou bien ` traiter les cas exceptionnels qui interdisent le d´roulement normal d’une a e boucle for ou while (par exemple un pivot nul dans une m´thode de Gauss). on a la solution suivante plus naturelle (mais moins conforme aux crit`res purs et durs de la programmation structur´e) : e e function ind = recherche1(v. on ne peut pas non plus utiliser e size(v.’r’) ou size(v. celles avec le test de sortie ` la fin (genre repeat . Supposons que l’on veuille e simuler une boucle avec test de sortie ` la fin : a r´p´ter e e suite d’instructions jusqu’` ce que condition a o` condition est une expression qui d´livre un scalaire bool´en (on sort lorsque ce test est vrai). ceci vient du fait que length r´agit diff´remment si les composantes de la e e e matrice ou du vecteur sont des chaˆ ınes de caract`res (length renvoie une matrice de taille identique o` e u chaque coefficient donne le nombre de caract`res de la chaˆ correspondante).l) n = max(size(v)) i = 1 succes = %f while ~succes & (i <= n) succes = part(v(i)..types de boucles. break.1) == l then ind = i break end end endfunction Rappel : on peut remarquer l’emploi de la fonction size alors que la fonction length semble plus adapt´e pour un vecteur10 . u a Voici un exemple : on veut rechercher dans un vecteur de chaˆ ınes de caract`res l’indice du premier mot e qui commence par une lettre donn´e l. En utilisant une boucle e while (sans s’autoriser de break). On u e e pourra alors ´crire en Scilab : e while %t // d´but de la boucle e suite d’instructions if condition then. on peut ˆtre conduit ` la solution suivante : e a function ind = recherche2(v. e ıne si l’on veut un code qui fonctionne ind´pendamment du fait que v soit ligne ou colonne. Pour cela.. on va ´crire une fonction (qui renvoie 0 dans le cas o` e e u aucune des chaˆ ınes de caract`res ne commenceraient par la lettre en question). lisible et compacte. end end Il y a aussi des cas o` l’utilisation d’un break conduit ` une solution plus naturelle.1) == l i = i + 1 end if succes then ind = i-1 else ind = 0 end endfunction Si on s’autorise l’utilisation d’un break.’l’) d’o` le max(size(v)) u 10 45 .

warning.n)+"!") end f = prod(1:n) endfunction ce qui donnera par exemple : -->fact3(-4.8 Quelques primitives utiles dans les fonctions En dehors de length et size qui permettent de r´cup´rer les dimensions des structures de donn´es.6) WARNING:l’argument n’est pas un entier naturel: on calcule 4! ans = 24. disp qui permettent de d´boguer. ıne e J’ai utilis´ ici une concat´nation de 3 chaˆ e e ınes dont l’une est obtenue par la fonction sprintf qui permet de transformer des nombres en chaˆ de caract`res selon un certain format. l’argument unique de la fonction warning est une chaˆ de caract`res.56) !--error 10000 erreur dans fact2 : l’argument doit etre un nombre entier naturel at line 6 of function fact called by : fact(0. Comme pour la fonction error. type(v) renvoie un entier alors que typeof(v) renvoie une chaˆ de caract`res Voici un tableau r´capitulatif pour les types de donn´es ıne e e e que nous avons vus : 46 .floor(n) ~=0) | n<0 then error(’erreur dans fact2 : l’’argument doit etre un nombre entier naturel’) end f = prod(1:n) endfunction et voici le r´sultat sur deux arguments : e -->fact2(3) ans = 6. argn ou encore type et typeof.3. e e e et de pause. -->fact2(0. d’autres fonctions peuvent ˆtre utiles comme e e error.floor(n) ~=0) | n<0 then n = floor(abs(n)) warning(’l’’argument n’’est pas un entier naturel: on calcule ’+sprintf("%d".4.56) La fonction warning Elle permet d’afficher un message ` l’´cran mais n’interrompt pas le d´roulement de la fonction : a e e function [f] = fact3(n) // calcul de la factorielle d’un nombre entier positif if (n . La fonction error Elle permet d’arrˆter brutalement le d´roulement d’une fonction tout en affichant un message d’ere e reur . voici une fonction qui calcule n! en prenant soin de v´rifier que n ∈ N : e function [f] = fact2(n) // calcul de la factorielle d’un nombre entier positif if (n . ıne e Les fonctions type et typeof Celles-ci permettent de connaˆ ıtre le type d’une variable v. resume.

type de v matrice de r´els ou complexes e matrice de bool´ens e matrice de chaˆ ınes de caract`res e liste liste typ´e e fonction type(v) 1 4 10 15 16 13 typeof(v) constant boolean string list type de la liste function Un exemple d’utilisation : on veut s´curiser notre fonction factorielle en cas d’appel avec un mauvais e argument d’entr´e.nc]=size(n) if (nl ~= 1) | (nc ~= 1) then error(" erreur dans fact4 : l’’argument ne doit pas etre une matrice. Voici un exemple e e de fonction pour laquelle je d´sire un argument classique plus deux param`tres optionnels : e e function [y] = argopt(x."local") then coef_mult = 1 end if ~exists("coef_add".") end if (n . e Elle permet essentiellement d’´crire une fonction avec des arguments d’entr´e et de sortie optionnels e e (la fonction type ou typeof pouvant d’ailleurs l’aider dans cette tache).") end [nl.n)+"!") end f = prod(1:n) endfunction La fonction argn et les arguments optionnels argn permet d’obtenir le nombre d’arguments effectifs d’entr´e et de sortie d’une fonction lors d’un e appel ` celle-ci. coef_mult.. On l’utilise sous la forme : a [lhs.. et rhs (pour right hand side) donnant le nombre d’arguments d’entr´e effectifs. Scilab poss`de une e e e fonctionnalit´ tr`s pratique d’association entre arguments formels et arguments effectifs.floor(n) ~=0) | n<0 then n = floor(abs(n)) warning(’l’’argument n’’est pas un entier naturel: on calcule ’+sprintf("%d"..rhs] = argn() lhs (pour left hand side) donnant le nombre d’arguments de sortie effectifs. e Cependant pour ´crire ais´ment des fonctions avec des arguments optionnels. coef_add) // pour illustrer l’association entre argument formels et effectifs [lhs."local") then coef_add = 0 end y = coef_mult*x + coef_add endfunction 47 .. Un exemple d’utilisation est donn´ plus loin (Une fonction est une variable Scilab). e function [f] = fact4(n) // la fonction factorielle un peu plus blindee if type(n) ~= 1 then error(" erreur dans fact4 : l’’argument n’’a pas le bon type. rhs] = argn() if rhs < 1 | rhs > 3 then error("mauvais nombre d’’arguments") end if ~exists("coef_mult".

^ * . e 3.La fonction exists me permet de tester si les arguments coef mult et coef add ont ´t´ d´finis11 lors ee e de l’appel de la fonction. ce qui permet de leur donner une valeur par d´faut dans le cas contraire. Comme usuellement les op´rateurs num´riques12 ( + . Comme dans la plupart des langages.. Exemples : -->y1 = argopt(5) y1 = 5.5.* / ../ \ + Pour les op´rateurs bool´ens le « non » (~) est prioritaire sur le « et » (&) lui-mˆme prioritaire sur le e e e « ou » (|). le .). coef_add=10) y2 = 15./ \ ^ .* / .unaire n’est autoris´ qu’en d´but d’expression.5. coef_mult=2.5 3. Quelques remarques : e 1. coef_add=6. -->a234567890123456789012345 a23456789012345678901234 = 1. e e e ` e 12 il y en a d’autres que ceux qui figurent dans cette liste 11 48 .2 Priorit´ des op´rateurs e e Elle est assez naturelle (c’est peut ˆtre la raison pour laquelle ces r`gles n’apparaissent pas dans l’aide e e en ligne. coef_mult=2) // y4 doit ^tre ´gal ` y3 e e a y4 = 16. 3. Pour plus e de d´tails voir le « Scilab Bag Of Tricks ».^ ’ ) e e ont une priorit´ plus ´lev´e que les op´rateurs de comparaisons (< <= > >= == ~=). -->y2 = argopt(5. ceci est e e e ` e important car des variables de mˆme nom peuvent ˆtre d´finies a des niveaux sup´rieurs. on peut se permettre de mettre les arguments dans n’importe quel ordre. coef_add=6) y3 = 16. De e plus avec la syntaxe argument formel = argument effectif. On peut donc utiliser plus de lettres mais seules les 24 premi`res sont significatives. Voici un tableau e e e e r´capitulatif par ordre de priorit´ d´croissante pour les op´rateurs num´riques : e e e e e ’ ^ .* . -->y3 = argopt(5. c-`-d que e e a les expressions du type (o` op d´signe un op´rateur num´rique quelconque) : u e e e l’argument suppl´mentaire avec la valeur "local" r´duit la port´e de l’interrogation a la fonction elle mˆme . Lorsque l’on ne souvient plus des priorit´s. on met des parenth`ses ce qui peut d’ailleurs aider e e (avec l’ajout de caract`res blancs) la lecture d’une expression comportant quelques termes.. -->y4 = argopt(5.1 Compl´ments divers e Longueur des identificateurs Scilab ne prend en compte que des 24 premi`res lettres de chaque identificateur : e -->a234567890123456789012345 = 1 a23456789012345678901234 = 1..

n) // n est un argument optionnel. Voici un petit exemple14 : ouvrez un fichier e e pour ´crire les deux fonctions suivantes : e function [y] = f(x) y = sin(x). fib(n+2) = fib(n+1) + fib(n) if n <= 1 then f = 1 else f = fib(n-1) + fib(n-2) end endfunction 3. b. fib(1) = 1.y) endfunction 13 14 voir la section « Primitives et fonctions Scilab » du b´tisier e qui est inutile en dehors de son aspect p´dagogique : cf fplot2d e 49 .3 R´cursivit´ e e Une fonction peut s’appeler elle-mˆme.*exp(-abs(x)) endfunction function dessine_fonction(a.b. e elle peut ˆtre pass´e comme argument d’une autre fonction. Il faut alors mettre des parenth`ses : e op´rande op (. Voici deux exemples tr`s basiques (le deuxi`me illustrant une e e e mauvaise utilisation de la r´cursivit´) : e e function f=fact(n) // la factorielle en recursif if n <= 1 then f = 1 else f = n*fact(n-1) end endfunction function f=fib(n) // calcul du n ieme terme de la suite de Fibonnaci : // fib(0) = 1. rhs] = argn(0) if rhs == 3 then n = 61 end x = linspace(a.op´rande op . c a e e 3.op´rande e e sont interdites. Pour une expression du type : op´rande op1 op´rande op2 op´rande op3 op´rande e e e e o` les op´rateurs ont une priorit´ identique. l’´valuation se fait en g´n´ral de la gauche vers la u e e e e e droite : ((op´rande op1 op´rande) op2 op´rande) op3 op´rande e e e e sauf pour l’op´rateur d’´l´vation ` la puissance : e ee a a^b^c est ´valu´ de la droite vers la gauche : a^(b^c) e e c de fa¸on ` avoir la mˆme convention qu’en math´matique : ab . en cas d’absence de celui-ci on impose n=61 [lhs.op´rande) e e 2. et en particulier.5.n) y = fonction(x) plot(x.4 Une fonction est une variable Scilab Une fonction programm´e en langage Scilab13 est une variable du type « function » .5. fonction.

puis rentrez ces fonctions dans l’environnement et enfin, essayez par exemple : -->dessine_fonction(-2*%pi,2*%pi,f) -->dessine_fonction(-2*%pi,2*%pi,f,21) Une possibilit´ int´ressante de Scilab est que l’on peut d´finir directement une fonction dans l’envie e e ronnement (sans passer par l’´criture d’un fichier puis le chargement par getf) par l’interm´diaire de la e e commande deff dont voici la syntaxe simplifi´e : e deff(’[y1,y2,...]=nom_de_la_fonction(x1,x2,....)’,text) o` text est un vecteur colonne de chaˆ u ınes de caract`res, constituant les instructions successives de la e fonction. Par exemple, on aurait pu utiliser : deff(’[y]=f(x)’,’y = sin(x).*exp(-abs(x))’) pour d´finir la premi`re des deux fonctions pr´c´dentes. En fait cette possibilit´ est int´ressante dans e e e e e e plusieurs cas : 1. dans un script utilisant une fonction simple qui doit ˆtre modifi´e assez souvent ; dans ce cas on e e peut d´finir la fonction avec deff dans le script ce qui ´vite de jongler avec un autre fichier dans e e lequel on aurait d´fini la fonction comme d’habitude ; cependant depuis la version 2.6 vous e pouvez d´finir des fonctions dans un script avec la syntaxe habituelle ce qui est plus pratique e qu’avec un deff ; dans votre script vous pouvez donc ´crire les fonctions au d´but du texte : e e // definition des fcts utilis´es par le script e function .... endfunction function .... endfunction // debut effectif du script .... 2. la possibilit´ vraiment int´ressante est de pouvoir d´finir une partie du code de fa¸on dynamique : e e e c on ´labore une fonction ` partir d’´l´ments divers issus de calculs pr´c´dents et/ou de l’introduction e a ee e e de donn´es (via un fichier ou de fa¸on interactive (cf Fenˆtres de dialogues)) ; dans cet esprit voir e c e aussi les fonctions evstr et execstr un peu plus loin.

3.5.5

Fenˆtres de dialogues e

Dans l’exemple de script donn´ dans le chapitre 2, on a vu la fonction input qui permet de rentrer un e param`tre interactivement via la fenˆtre Scilab. D’autre part la fonction disp permet l’affichage ` l’´cran e e a e de variables (toujours dans la fenˆtre Scilab). En fait il existe une s´rie de fonctions qui permettent e e d’afficher des fenˆtres de dialogues, menus, selection de fichiers : x_choices , x_choose, x_dialog, e x_matrix, x_mdialog, x_message et xgetfile. Voir le Help pour le d´tail de ces fonctions (l’aide sur e une fonction propose toujours au moins un exemple).

3.5.6

Conversion d’une chaˆ de caract`res en expression Scilab ıne e

Il est souvent utile de pouvoir ´valuer une expression Scilab mise sous la forme d’une chaˆ de e ıne caract`res. Par exemple, la plupart des fonctions pr´c´dentes renvoient des chaˆ e e e ınes de caract`res, ce e qui s’av`re pratique mˆme pour rentrer des nombres car on peut alors utiliser des expressions Scilab e e (exemples sqrt(3)/2, 2*%pi, . . .). L’instruction qui permet cette conversion est evstr, exemple : -->c = "sqrt(3)/2" c = sqrt(3)/2

50

-->d = evstr(c) d = 0.8660254 Dans la chaˆ de caract`res vous pouvez utiliser des variables Scilab d´j` d´finies : ıne e ea e -->a = 1; -->b=evstr("2 + a") b = 3. et cette fonction s’applique aussi sur une matrice de chaˆ ınes de caract`res15 : e -->evstr(["a" "2" ]) ans = ! 1. 2. ! -->evstr([" a + [1 2]" "[4 , 5]"]) ans = ! 2. 3. 4. 5. ! -->evstr(["""a""" """b"""]) ans = !a b ! // conversion d’une chaine en une chaine

Il existe aussi la fonction execstr qui permet d’ex´cuter une instruction Scilab donn´e sous forme e e d’une chaˆ de caract`res : ıne e -->execstr("A=rand(2,2)") -->A A = ! 0.2113249 0.0002211 ! ! 0.7560439 0.3303271 !

3.6

Lecture/´criture sur fichiers ou dans la fen`tre Scilab e e

Scilab poss`de deux familles d’entr´es/sorties. Il faut ´viter de m´langer les instructions de ces deux e e e e familles surtout si vous ´crivez/lisez dans un fichier. e

3.6.1

Les entr´es/sorties ` la fortran e a

Dans le chapitre deux, nous avons vu comment lire et ´crire une matrice de r´els dans un fichier en e e une seule instruction avec read et write. De mˆme il est possible d’´crire et de lire un vecteur colonne e e de chaˆ ınes de caract`res : e

-->v = ["Scilab is free";"Octave is free";"Matlab is ?"]; -->write("toto.dat",v,"(A)") // aller voir le contenu du fichier toto.dat

-->w = read("toto.dat",-1,1,"(A)") w = !Scilab is free !
15

! !

et aussi sur une liste, voir le Help

51

!Octave is free ! !Matlab is ?

! ! !

Pour l’´criture, on rajoute simplement un troisi`me argument ` write qui correspond ` un format e e a a fortran : c’est une chaˆ de caract`res comprenant un (ou plusieurs) descripteur(s) d’´dition (s´par´s ıne e e e e par des virgules s’il y a en plusieurs) entour´s par des parenth`ses : le A signifie que l’on souhaite ´crire une e e e chaˆ de caract`res. Pour la lecture, les deuxi`me et troisi`me arguments correspondent respectivement ıne e e e au nombre de lignes (-1 pour aller jusqu’` la fin du fichier) et colonne (ici 1). En fait pour les matrices a de r´els vous pouvez aussi rajouter un format (plutˆt en ´criture) de fa¸on ` contrˆler pr´cisemment la e o e c a o e fa¸on dont seront ´crites les donn´es. c e e D’une mani`re g´n´rale les possibilit´s de Scilab en ce domaine sont exactement celle du fortran 77, e e e e vous pouvez donc lire un livre sur ce langage pour en savoir plus16 . Dans la suite je vais simplement donner quelques exemples concernant uniquement les fichiers « texte » ` acc`s s´quentiel. a e e Ouvrir un fichier Cela se fait avec l’instruction file dont la syntaxe (simplifi´e) est : e [unit, [err]]=file(’open’, file-name ,[status]) o` : u – file-name est une chaˆ de caract`re donnant le nom du fichier (´ventuellement pr´c´d´e du ıne e e e e e chemin menant au fichier si celui-ci ne se trouve pas dans le r´pertoire point´ par Scilab, ce r´pertoire e e e se changeant avec l’instruction chdir) ; – status est l’une des chaˆ ınes de caract`res : e – "new" pour ouvrir un nouveau fichier (si celui-ci existe d´j` une erreur est g´n´r´e) ; ea e ee – "old" pour ouvrir un fichier existant (si celui-ci n’existe pas une erreur est g´n´r´e) ; e ee – "unknow" si le fichier n’existe pas, un nouveau fichier est cr´´, et dans le cas contraire le fichier ee correspondant est ouvert ; Dans le cas o` status n’est pas pr´sent, Scilab utilise "new" (c’est pour cette raison que l’´criture u e e d’un fichier en une seule instruction write ´choue si le fichier existe d´j`). e ea – unit est un entier qui va permettre d’identifier le fichier par la suite dans les op´rations de lece tures/´critures (plusieurs fichiers pouvant ˆtre ouverts en mˆme temps). e e e – Une erreur ` l’ouverture d’un fichier peut ˆtre d´tect´e si l’argument err est pr´sent ; dans le cas a e e e e contraire, Scilab g`re l’erreur brutalement. Une absence d’erreur correspond ` la valeur 0 et lorsque e a cette valeur est diff´rente, l’instruction error(err) renvoie un message d’erreur permettant d’en e savoir un peu plus : on obtient en g´n´ral err=240 ce qui signifie : e e -->error(240) !--error 240 File error(240) already exists or directory write access denied Pour permettre de r´cup´rer un nom de fichier de fa¸on interactive on utilisera xgetfile qui permet e e c de naviguer dans l’arborescence pour selectionner un fichier. ´ Ecrire et lire dans le fichier ouvert Supposons donc que l’on ait ouvert un fichier avec succ`s : celui-ci est rep´r´ par l’entier unit qui nous e ee a ´t´ renvoy´ par file. Si le fichier existait d´j`, les lectures/´critures ont normalement lieu en d´but ee e ea e e de fichier. Si vous voulez ´crire ` la fin du fichier, il faut s’y positionner au pr´alable avec l’instruction e a e file("last", unit), et si pour une raison quelconque vous voulez revenir en d´but de fichier, on utilise e file("rewind", unit). Voici un premier exemple : on veut ´crire un fichier qui permet de d´crire une liste d’arˆtes du plan, e e e c’est ` dire que l’on consid`re n points Pi = (xi , yi ) et m arˆtes, chaque arˆte ´tant d´crite comme un a e e e e e
Vous pouvez r´cup´rer gratuitement le livre de Clive Page sur le serveur ftp ftp.star.le.ac.uk : se positionner dans e e le r´pertoire /pub/fortran et r´cup´rer le fichier prof77.ps.gz e e e
16

52

0000000000000 3.size(P.0041977781802D-02 0. la sortie prenant la forme : [signe]0.0000000000000 0..1)) // ecriture du nombre de points write(unit. nos points dans e la matrice P de format (n.0000000000000 4. 53 . x_n y_n m i1 j1 .. et l’on donnera simplement le num´ro (dans le tableau des points) du point de d´part (ici e e i) puis celui d’arriv´e (ici j)..5. Vient ensuite le nombre d’arˆtes puis la connectivit´ de e e e chaque arˆte.86075146449730 0. puis les coordonn´es de ces points. int16 et int32 voir le Help.connect) // ecriture de la connectivite file("close".99231909401715 5.52570608118549 0.0000000000000 0. D’autre part.size(connect. 2) et la connectivit´ des arˆtes dans la matrice connect de format (m. il existe cependant les types entiers int8.texte) // ecriture de la ligne de texte write(unit...−→ − segment Pi Pj .84941016510129 0.0000000000000 1.unit) // fermeture du fichier et voici le r´sultat obtenu : e un polygone au hasard 5.. pour les flottants double pr´cision.0000000000000 3..1)) // ecriture du nombre d’aretes write(unit.99312098976225 5.0000000000000 1. Supposons que notre ligne de texte soit contenue dans la variable texte. On a ensuite un entier donnant le nombre de points. la chaˆ de caract`res est pr´c´d´e d’un blanc (non contenu dans la chaˆ ıne e e e e ıne texte). la conversion en d´cimal donne environ 16 chiffres significatifs e e et les exposants sont compris (environ) entre -300 et +300.y o` x est la longueur totale du champ et y u la longueur de la mantisse.64885628735647 0. ce qui donne une longueur totale 17 Depuis la version 2.0000000000000 2..0000000000000 4.0000000000000 5. im jm La ligne de texte permet de mettre quelques informations.. On choisit comme format pour ce fichier. Pour obtenir quelque chose de mieux. ils sont ´crits avec un format relatif e ee e aux flottants. e a – pour les flottants.0000000000000 5.28553641680628 0.0000000000000 qui n’est pas tr`s harmonieux car nous n’avons pas pr´cis´ de formats d’´dition. e e l’´criture du fichier s’effectue avec les instructions : e write(unit. il faut rajouter ces formats fortran : – pour un entier. Le point n´gatif est e e e e e que les entiers ´tant consid´r´s comme des flottants par Scilab17 .P) // ecriture des coordonnees des points write(unit.mantisseE[signe]exposant . un format passe partout est Ex. on utilise Ix o` x est un entier strictement positif donnant la longueur du champ u en nombre de caract`res (le cadrage a lieu ` droite) ..74855065811425 0. la s´quence suivante : e e une ligne de texte n x_1 y_1 .41040589986369 2. 2).

4104058998636901E+00 Pour lire ce mˆme fichier. e e e ıne e En reprenant l’exemple pr´c´dent.E24.unit).1) P = read(unit."(A)") n = read(unit. lecture dans la fenˆtre scilab e ecriture.5257060811854899E+00 0. msscanf ecriture.16 (selon la magnitude d’un nombre et la e pr´sentation d´sir´e d’autres formats seraient plus adapt´s) .1. une ´criture plus harmonieuse est obtenue avec (en supposant moins e e e de 999 points et arˆtes) : e write(unit.16))") write(unit.1.7485506581142545E+00 0. lecture dans un fichier ecriture.1).16) signifiant que l’on veut ´crire sur une mˆme ligne deux champs comprenant un blanc e e suivi d’un flottant ´crit sur 24 caract`res) ce qui donne : e e un polygone au hasard 5 0.2) m = read(unit. Pour finir.P.2) file("close". a 3."(A)") write(unit."(2(X.size(P. Pour l’´criture. vous pouvez lire et ´crire dans la fenˆtre Scilab en utilisant respectivement unit = %io(1) e e et unit = %io(2).6488562873564661E+00 0. On peut donc utiliser le format E24.1). on peut alors obtenir une pr´sentation plus soign´e que celle obtee e e nue avec la fonction disp (voir un exemple dans le B´tisier dans la section « Primitives et fonctions e Scilab » (script d’appel ` la fonction MonteCarlo)). mscanf mfprintf."(2(X.8607514644972980E+00 0.size(connect. on peut utiliser le format A.2855364168062806E+00 0.I3))") file("close".E24. on pourrait utiliser la s´quence suivante : e e texte=read(unit.5004197778180242E-01 0. a e e e e 2(X. il faut utiliser mopen et mclose. les instructions de base sont : mprintf.texte. vous avez du remarquer que la fermeture d’un fichier s’obtient avec l’instruction file("close". mfscanf msprintf.de 24 caract`res.n.8494101651012897E+00 0.9923190940171480E+00 0.2 Les entr´es/sorties ` la C e a Pour l’ouverture et la fermeture des fichiers."(I3)") write(unit.1.1) connect = read(unit. lecture dans une chaˆ de caract`res ıne e 54 ."(I3)") write(unit.m.9931209897622466E+00 5 1 2 2 3 3 4 4 5 5 1 0.unit) // // // // // // lecture de la ligne de texte lecture du nombre de points lecture des coordonnees des points lecture du nombre d’aretes lecture de la connectivite fermeture du fichier Si vous avez bien lu ces quelques exemples.6.1. e e e e – pour ´viter le blanc pr´c´dant la chaˆ de caract`re.unit) // // // // // // ecriture de la ligne de texte ecriture du nombre de points ecriture des coordonnees des points ecriture du nombre d’aretes ecriture de la connectivite fermeture du fichier (le format X correspond ` l’´criture d’un caract`re blanc et j’utilise aussi un facteur de r´p´tition.connect.

16e". // %d pour les entiers %g".2. m = -23. s = "coucou".  . Voici un script pour vous d´crire les cas prine cipaux : n = 17. // %e pour les reels (notation avec exposant) %24. a = 0.c1 . %e pour les r´els en notation scientifique (c-a-d avec exposant). m). . e e 5. // nb complexe %s". si on veut afficher 4 valeurs. on e rajoute deux nombres entiers s´par´s par un point.2 + i 0. . n. %d4 ". . b = 1. .  . // %g pour les reels %e". . %5.3f permet d’avoir une sortie sans exposant avec 5 caract`res en tout dont 3 apr`s la virgule. Question : la sortie de 0. On cherche ` calculer une matrice de type a  t1 t2 .. e e 3..23e-02. La sortie doit prendre la forme : e [−]c0 . voire 3 si besoin. expr3. 1 chiffre avant la ` e virgule (le point en fait !). R´ponse : c’est parce que 0. . %g permet de choisir entre une sortie sans exposant (si c’est possible) ou avec.2 avec le format %24. par a exemple.16e paraˆ bizarre. . tn 1 1 t2 t2 . a). // %s pour les chaines de caract`res e Si vous executez ce script avec un « . le nombre de chiffres apr`s la virgule. expr4). il faut 4 directives : mprintf(" %d1 .0123 coucou Quelques explications : – le \n\r impose un passage ` la ligne (sous Unix le \n doit suffire) : ne pas le mettre si vous ne a voulez pas aller ` la ligne ! a – les %x sont des directives de formatage. . imag(c)). e e e 3. » ` la fin de l’ordre exec (c-a-d exec("demo mprintf. c’est ` dire qu’elles donnent la fa¸on dont la variable (ou a c constante) doit ˆtre ´crite : e e 1.000000e-01 2.. expr1. . 2. le premier donnant le nombre de caract`res e e e total et le deuxi`me.. . . 6 chiffres apr`s.2 ne ıt e tombe pas juste en binaire et donc en mettant suffisamment de pr´cision (pour la conversion binaire vers e d´cimal) on finit par d´tecter ce probl`me. real(c). %d pour les entiers .Dans la suite. m = %d". a). tn  2 2  . // on impose le nombre de "d´cimales" e %g + i %g". et enfin e l’exposant sur deux chiffres. j’explique uniquement l’usage de mprintf. 4. a). 1 tm t2 .. . %s s’utilise pour les chaˆ ınes de caract`res. expr2. mprintf("\n\r mprintf("\n\r mprintf("\n\r mprintf("\n\r mprintf("\n\r mprintf("\n\r n a a a c s = = = = = = %d. Pour imposer plus pr´cisemment la sortie. expression ou constante). . .. .2 2.c6 e±d1 d2 [d3 ] c’est a dire avec le signe (si le nombre est n´gatif). tn m m 55 . s).sce") . . a si vous avez appel´ le fichier par ce nom). e – ` chaque directive doit correspondre une valeur de sortie (variable. c = a + %i*b.  . Voici sur deux exemples quelques trucs ` a Vandermonde :  1  1  A= . la lettre e puis le signe de l’exposant. alors vous allez observer la sortie suivante : e n a a a c s = = = = = = 17.0000000000000001e-01 0. m = -23 0.7 Remarques sur la rapidit´ e connaˆ ıtre.

n + 1).04 -->timer().Voici un premier code assez naturel : function A=vandm1(t. timer() ans = 1.n+1) (ce qui ´vite le calcul de e la premi`re colonne).n) // idem a vandm5 avec une petite optimisation m=size(t. A e e a est une matrice (i. Comme au fur et ` mesure du calcul la matrice a grossie. mais l’on gagne peu. voire en inversant les deux boucles.j) = t(i)^(j-1) end end endfunction Comme a priori on ne d´clare pas les tailles des matrices et autres objets en Scilab nul besoin de lui e dire que le format final de notre matrice A est (m. Par contre si on fait une pseudo-d´claration de la matrice (par la fonction zeros(m.’r’) A = zeros(m. timer() ans = 6.’r’) for i = 1:m for j = 1:n+1 A(i.j) = ti^(j-1) // t doit etre un vecteur colonne a m composantes m=size(t.n+1)) : e function A=vandm2(t.n) // idem a vandm1 sauf que l’on fait une pseudo-declaration pour A m=size(t.’r’) A=ones(m.n) // calcul de la matrice de Vandermonde A=[a(i.1000)’. -->timer(). on a donc en tout n + m − 1 changements dans les dimensions de A. Scilab doit g´rer ce probl`me (pour i = 1. A est un vecteur ligne ` j composantes.^i end endfunction function A=vandm6(t.n) // la bonne methode : utiliser l’ecriture matricielle m=size(t. pour i > 1. A = vandm1(t.j)] 1<= i <= m // 1<= j <= n+1 // ou a(i.200).26 On peut essayer d’optimiser un peu ce code en initialisant A avec ones(m.j) = t(i)^(j-1) end end endfunction il n’y a plus ce probl`me et l’on gagne un peu de temps : : e -->t = linspace(0.’r’) 56 . A = vandm2(t.1. en ne faisant que des multiplications avec aij = aij−1 × ti (ce qui ´vite les calculs e e de puissances).n+1) for i=1:n A(:.i+1)=t. La bonne m´thode est de voir e que la construction de A peut se faire en utilisant une instruction vectorielle : function A=vandm5(t.200).n+1) // pseudo declaration for i = 1:m for j = 1:n+1 A(i. n + 1).

m] = size(t) y = zeros(t) for j=1:m.02 Voici un deuxi`me exemple : il s’agit d’´valuer en plusieurs points (des scalaires r´els mis dans un e e e vecteur ou une matrice) la fonction « chapeau » (cf fig (3.j) .j))/(c .a)/(b .n+1) for i=1:n A(:.c) // evalue la fonction chapeau (de parametres a.j) < b then y(i. timer() ans = 0.200).A=ones(m. Si ce travail doit ˆtre r´alis´ sur beaucoup de points il faut « vectoriser » ces tests pour e e e ´viter de faire travailler l’interpr´teur.*t end endfunction et on am´liore ainsi la rapidit´ de fa¸on significative : e e c -->timer().b) end end end. end endfunction 57 .a) elseif t(i.b.2 – Fonction « chapeau » plusieurs tests. A = vandm5(t.t(i.i+1)=A(:.j) = (t(i. Par exemple. b et c) sur le vecteur // (voire la matrice) t au sens ‘‘element par element’’.b et c doivent verifier a < b < c [n.i). for i=1:n if t(i. ce premier code naturel : e e function [y]=phi1(t. 3.2) :   0 si t ≤ a  t−a  b−a si a ≤ t ≤ b φ(t) = c−t  c−b si b ≤ t ≤ c   0 si t ≥ c Du fait de la d´finition par morceaux de cette fonction.a.j) = (c .c a b c t Fig.j) < c then y(i. // a. A = vandm6(t.b. son ´valuation en un point n´cessite en g´n´ral e e e e e 1 φ (t) a.j) > a then if t(i.200). timer() ans = 0.05 -->timer().

* (t .a.15. timer() // voir plus loin la d´finition de phi4 e ans = 0. c=0.a.a. e e – le code de phi4 utilise la fonction find qui est sans doute plus naturelle et plus simple ` utiliser : a sur un vecteur de bool´ens b elle renvoie un vecteur contenant les indices i tels que b(i)=%t (la e matrice vide si toutes les composantes sont fausses). // a. -->t = rand(200000.7 ) ind = ! 2.8782165 0. timer() ans = 0.c) // evalue la fonction chapeau (de parametres a.1 Remarques : – ma petite optimisation pour phi2 ne donne aucun gain (alors que c’´tait le cas pour une version e pr´c´dente de scilab sur une autre machine) .a.* (t .a)/(b .6) x = ! 0. y3 = phi3(t. b et c) sur le scalaire t // ou le vecteur (voire la matrice) t au sens \og element par element \fg.b.donne le r´sultat : e -->a = -0.12 -->timer().a.a)/(b .t)/(c . ! Sur une matrice bool´enne A vous obtenez la mˆme liste en consid´rant que la matrice est un e e e « grand » vecteur o` les ´l´ments de A ont ´t´ r´ordonn´s « colonne par colonne ». -->timer().6857310 0.b. b=0 . y1 = phi1(t.c).b) endfunction function [y]=phi3(t.0683740 0.b.b.1)-0. timer() ans = 2.3<x & x<0.a) + Indicatrice_b_c .a.c). Il est cependant u ee ee e e possible avec un deuxi`me argument de sortie de r´cup´rer la liste des indices de ligne et de colonne : e e e dans lesquels la fonction bool2s permet de convertir une matrice de bool´ens en matrice de r´els (vrai donnant 1 et e e faux 0) 18 58 .b) endfunction sont plus rapides : -->timer().c) // idem a phi2 avec une petite optimisation t_le_b = ( t <= b ) Indicatrice_a_b = bool2s( (a < t) & t_le_b ) Indicatrice_b_c = bool2s( ~t_le_b & (t < c) ) y = Indicatrice_a_b .a) + Indicatrice_b_c .t)/(c .12 -->timer().46 alors que les codes suivants18 : function [y]=phi2(t.b et c doivent verifier a < b < c Indicatrice_a_b = bool2s( (a < t) & (t <= b) ) Indicatrice_b_c = bool2s( (b < t) & (t < c ) ) y = Indicatrice_a_b .2 .b.* (c . y2 = phi2(t.c). 5.8497452 0. Exemple : -->x = rand(1.5608486 0.* (c .6623569 ! -->ind = find( 0. y4 = phi4(t.c). 6.5.b. timer() ans = 0.

δt = T /n et l’on peut utiliser les propri´t´s de l’exponentielle pour all´ger les calculs : ee e x(tk ) = eAkδt x0 = ek(Aδt) x0 = (eAδt )k x0 = eAδt x(tk−1 ) ainsi il suffit uniquement de calculer l’exponentielle de la matrice Aδt puis de faire n multiplications ´ « matrice vecteur » pour obtenir x(t1 ).t(indices_b_c))/(c .a) y(indices_b_c) = (c . 2.1.a. . k = 1.a)/(b .4)) 2. La solution du syst`me d’´quations diff´rentielles du 1er ordre : e e e dx (t) = Ax(t). .2320748 ! -->[il. x(t) ∈ Rn . Pour cela. on peut la a e calculer en un nombre n suffisamment grand d’instants uniform´ment r´partis dans cet intervalle e e tk = kδt. x(t2 ).2) A = ! 0. il y a sans doute quelque chose ` faire. . puis on essaiera de remplacer la boucle interne par une instruction matricielle.8 Exercices ´ 1. T ]. on programmera l’algorithme classique utilisant deux boucles. On e e e u e pourra utiliser l’instruction size qui permet de r´cup´rer les deux dimensions d’une matrice : e e [n. dt x(0) = x0 ∈ Rn .5) ic = ! 1. 3.7263507 0.b. Pour tester votre fonction. Ecrire une fonction pour r´soudre un syst`me lin´aire o` la matrice est triangulaire sup´rieure.1985144 0. 2. x(tn ).m]=size(A) Dans un premier temps. On d´sire obtenir la solution pour t ∈ [0. x(0) = x (0) = 1 59 . avec par exemple α = 0. .-->A = rand(2.5442573 ! ! 0. essayer de les « vectoriser ».c) // on utilise la fonction find plus naturelle t_le_b = ( t <= b ) indices_a_b = find( a<t & t_le_b ) indices_b_c = find( ~t_le_b & t<c ) y = zeros(t) y(indices_a_b) = (t(indices_a_b) . Si cette vectoae risation est impossible ou insuffisante il ne reste plus qu’` ´crire les parties cruciales en C ou en fortran ae 77. A ∈ Mnn (R) e peut ˆtre obtenue en utilisant l’exponentielle de matrice (cf votre cours d’analyse de 1`re ann´e) : e e x(t) = eAt x0 Comme Scilab dispose d’une fonction qui calcule l’exponentielle de matrice (expm). Ecrire un script pour r´soudre l’´quation e e diff´rentielle (un oscillateur avec amortissement) : e x + αx + kx = 0.ic]=find(A<0. ! il = ! 2. ! Voici maintenant le code de la fonction phi4 : function [y]=phi4(t. vous pourrez g´n´rer une matrice de nombres pseudo-al´atoires et n’en garder que la partie triangulaire e e e sup´rieure avec l’instruction triu : e A=triu(rand(4.b) endfunction Conclusion : si vos calculs commencent ` ˆtre trop longs.

Il est recommand´ a a e e d’utiliser une fonction auxiliaire [y]=f(t. · · · T T T T au lieu des exponentielles.v2) e a e i = v i ∧v i o` v i . e e (c) Exp´rimenter votre fonction avec des valeurs de m de plus en plus grande. puis la trajectoire dans le plan de phase.v1(2)*v2(1) endfunction Vectoriser ce code de mani`re ` calculer dans une mˆme fonction function [v]=prod_vect_v(v1. f2 (t. xn ].info]=intervalle_de(t. 7. T est un param`tre (la p´riode) et le signal sera caract´ris´ (en dehors e e e e de sa p´riode) par le vecteur cs de ces composantes dans la base f1 . T ) = 1.T. f3 (t. Ecrire une fonction [y] = signal_fourier(t. T ) = cos( ). Si e e t ∈ [x1 . Ecrire une fonction [i. Voici une fonction pour calculer le produit vectoriel de deux vecteurs : function [v]=prod_vect(v1. v i et v i d´signe la i`me colonne des matrices (3. e a Par exemple : --> --> --> --> --> //fin des calculs xset(‘‘window’’. (a) Quelle est la probabilit´ qu’ils se rencontrent ? (rep 67/288) e (b) Retrouver (approximativement) ce r´sultat par simulation : ´crire une fonction [p] = rdv(m) e e renvoyant la probabilit´ empirique de la rencontre obtenue avec m r´alisations. t = linspace(0.` que l’on mettra ´videmment sous la forme d’un syst`me de deux ´quations du premier ordre. T ) = sin( ).. uniform´ment et ind´pendamment l’un de l’autre.1] // un signal avec une composante continue // du fondamental. Chacun e e arrivera au hasard. f2 . T ) = cos( ). Mlle e e B attendra 5 minutes avant de partir. ce qui permettra de visualiser facilement un tel signal : --> --> --> --> --> --> T = 1 // une periode . 6. f4 (t.101) // les instants .T.cs).window-number)..v1(1)*v2(3) v(3) = v1(1)*v2(2) . A la fin e e e on pourra visualiser la variation de x en fonction du temps. f3 .n) contenant e les produits vectoriels v 1 2 u 1 2 e ces vecteurs. cs = [0.. la variable bool´enne info devra ˆtre ´gale ` %f (et %t dans le cas inverse).k) pour calculer fk (t. e 60 .y) // et un dessin .v1(3)*v2(2) v(2) = v1(3)*v2(1) .T. f5 (t. j) correspond ` e u a l’´valuation du polynˆme en t(i. On peut passer d’une fenˆtre graphique ` une autre avec l’instruction xset("window"..T.v2) // produit vectoriel v = v1 /\ v2 v(1) = v1(2)*v2(3) . pas d’harmonique 1 (periode 2T) mais une harmonique 2 [y] = signal_fourier(t. // calcul du signal plot(t. T ). dans l’intervalle [17. R´crire la fonction myhorner pour quelle s’adapte au cas o` l’argument t est une matrice (la fonction e u devant renvoyer une matrice p (de mˆme taille que t) o` chaque coefficient (i. Mr A 10 minutes. Enfin tout cela doit pouvoir s’appliquer sur un vecteur (ou une matrice) d’instants t. e o ´ 5. La rencontre : Mr A et Mlle B ont d´cid´ de se donner rendez-vous entre 17 et 18h. On r´cup`rera le e e e nombre de fonctions ` utiliser ` l’aide de l’instruction length appliqu´e sur cs..1 1 0.x) pour d´terminer l’intervalle i tel que xi ≤ t ≤ e xi+1 par la m´thode de la dichotomie (les composantes du vecteur x ´tant telles que xi < xi+1 ). · · ·.. 18].0) // on selectionne la fenetre numero 0 instruction pour le premier graphe (qui s’affichera sur la fenetre 0) xset(‘‘window’’. / e e e a 4.1) // on selectionne la fenetre numero 1 instruction pour le deuxieme graphe (qui s’affichera sur la fenetre 1) ´ 3.2 0 0 0.cs) qui renvoie un d´but de s´rie de Fourier en e e utilisant les fonctions : f1 (t.j)). T ) = sin( 2πt 2πt 4πt 4πt t).

. Chaque objet graphique peut ˆtre rep´r´ par un identificateur unique (appel´ handle) qui permet de e ee e modifier les propri´t´s de cet objet (par exemple la couleur d’une ligne polygonale. etc.1 G´n´ralit´s sur le nouveau graphique e e e Il faut savoir que scilab dispose. vous ´vitant de fastidieuses manipulations avec les handles graphiques5 .0. ` e e a des fonctions plus compl`tes qui permettent en une seule instruction de tracer toutes sortes de graphiques e types. r´cup´rer les coordonn´es du pointeur de la e e e e souris 2 voir a la fin de ce chapitre quelques remarques ` 3 composition est mon essai traduction en fran¸ais de “compound” et cet objet s’appelait “agregation” jusqu’` la version c a 3. Scilab poss`de de nombreuses possibilit´s qui vont de primitives de bas niveau1 . surtout si les valeurs par d´faut ne vous conviennent pas e exemples : trac´s de rectangles. la fonte utilis´e pour ee e 4 ainsi qu’` son p`re. ce nouveau mode apporte une petite compatibilit´ avec le graphique Matlab avec les e ´mulations des deux fonctions plot et surf.dma.1.fr/~mottelet/myplot. depuis la version 3. vous pouvez vous cr´er un style pr´cis qui s’appliquera alors automatiquement sur vos dessins e e ult´rieurs. des chaˆ ınes de caract`res. Dans une fenˆtre vous pouvez cr´er plusieurs objets de type syst`me d’axes de coordonn´es e e e e (qui sont donc fils de leur fenˆtre) et les axes contiennent ` leur tour les objets graphiques de base comme e a des lignes polygonales.utc. j’explique seulement une petite partie de ces possibilit´s. e 4. d’un nouveau mode graphique ne fonctionnant pas de la mˆme mani`re que l’ancien mode2 . etc.. e 4. Dans la suite.1 principes de base Le nouveau mode graphique repose sur une structure hi´rarchique d’objets dont la racine est la fenˆtre e e graphique. assez pratique.1.. 4 pour des objets non basiques comme les fenˆtres. En modifiant e e e e ces objets. En g´n´ral les e e e instructions de haut niveau comme plot ou plot2d rassemblent les objets de base qu’elles cr´ent dans e un seul objet de type composition3 (cf figure 4.) et aussi d’acc´der ` ses fils ıne e e a a e Parmi ces objets graphiques. des collections de triangles (Fec). les axes et les compositions e 5 ces manipulations se faisant alors une seule fois sur ces objets par d´faut e 6 par exemple la taille des titres (une propri´t´ du niveau axes) est par d´faut assez petite ee e 1 61 ..1. de polygones (avec ou sans remplissage).Chapitre 4 Les graphiques Dans ce domaine. e Au passage. Ce m´canisme est e e e 6. il en existe deux qui ne sont jamais dessin´s mais qui servent de mod`les e e pour le niveau figure et le niveau axes : la fenˆtre par d´faut et le syst`me d’axes par d´faut. une chaˆ de caract`res.html Dans ce cas vous devrez travailler uniquement avec les instructions offertes par cette contribution et la suite de ce chapitre n’est pas tr`s utile pour vous.1). Dans ce chapitre on va essayer d’apprendre ` utiliser ce e e a nouveau syst`me. Cependant si vous connaissez le graphique de Matlab vous e pouvez avoir int´rˆt ` utiliser la contribution plotlib de St´phane Mottelet : ee a e http://www.

on peut ainsi ´crire hf = scf(num) (rmq : hf = gcf() e e permet de r´cup´rer le handle de la fenˆtre courante) . plot2d. Voici quelques exemples : x=linspace(-1. est assez simple ` e e a utiliser.^2. e e e si cette fenˆtre n’existait pas.1 – Le nouveau graphique ` objets a 4. e e e – la syntaxe xdel([num]) est celle de l’ancien mode graphique7 . au moins pour la version 3.2 les fenˆtres graphiques e Comme dans l’ancien mode on peut facilement travailler avec plusieurs fenˆtres graphiques. plot3d . Scilab en cr´e une. e e efface la fenˆtre graphique num´ro num .fenêtre figure système d’axes axes ligne polygonale polyline composition compound ligne polygonale polyline ligne polygonale polyline chaîne de caractères text système d’axes axes chaîne de caractères text surface surface Fig.1. e si aucune fenˆtre graphique n’existe. Pour jongler avec plusieurs fenˆtres graphiques on utilise les commandes e suivantes : scf(num) xselect() clf([num]) xdel([num]) la fenˆtre courante devient la fenˆtre de num´ro num . 4. plot(x. e ee met en « avant » la fenˆtre courante . alors qu’aucune fenˆtre grae phique n’est activ´e. e e e 4.. elle est cr´´e par Scilab. 62 . Scilab efface la fenˆtre courante. qui se veut une ´mulation de la fonction Matlab de mˆme nom. Scilab choisit de mettre le dessin dans la fenˆtre de num´ro 0.1. qui peut e e e e recevoir les ordres graphiques. e d´truit la fenˆtre graphique num´ro num . Scilab d´truit la fenˆtre courante. e e Quelques commentaires : – scf(num) renvoie le handle de la fenˆtre.61).1. appel´e fenˆtre courante ou encore fenˆtre active.y) 7 mais fonctionne aussi pour le nouveau mode.1.. e e si num est omis. pour avoir le mˆme effet avec une e syntaxe nouveau mode il faut utiliser delete(hf) o` hf est le handle de la fenˆtre en question. y = x. u e – quand on lance une commande comme plot.2 l’intruction plot Cette instruction. e e e si num est omis. Noter e que parmi ces fenˆtres il y en a une seule.

2 0. traits pointill´s) ou bien encore le symbole utilis´ pour dessiner les e e e points (xi .4 −0..x.y1[. plot(x.0 x 0. En rajoutant d’autres caract`res on peut aussi u ıne e e e sp´cifier le type du trait (trait plein.x.8 −0."gx") Voici les possibilit´s actuelles pour ces caract`res de style : e e 8 Par ´chelle on sous-entend le rectangle de visualisation et ´ventuellement des propri´t´s suppl´mentaires.2.6 0.."g") xtitle("Courbes. l’instruction prend donc la forme : e plot(x1. essayer par exemple : clf() // pour effacer plot(x.^2. yi ).ybis) xtitle("Courbes.y.8 1."r".yter) on remarque que Scilab a chang´ l’´chelle pour s’adapter ` la troisi`me courbe et que les courbes e e a e pr´c´dentes ont ´t´ redessin´es dans cette nouvelle ´chelle.6 1.x.yter.2 y 1.0 x^2 1−x^2 2x^2 Fig.y2[.4 0."y") // un titre plus une l´gende pour les deux axes e legend("x^2".y. 1 − x2 et 2x2 Pour afficher simultan´ment plusieurs courbes. en pr´cisant aussi la couleur utilis´e : e e e clf() // pour effacer la fen^tre courante e plot(x.2 0.ybis.2 – Les fonctions x2 .yter."2x^2") // une l´gende pour les courbes e et vous devez obtenir quelque chose qui ressemble ` la figure 4. e e e e e 63 .8 1.x2..style1]. . 4.0 −1."x"... 2.0 0."b".2 0.style2]."."b--"..x.0 −0.0 1."1-x^2".ybis..6 −0.. plot(x.") // je rajoute un titre Continuons avec une troisi`me courbe qui ne tient pas dans l’´chelle8 pr´c´dente : e e e e yter = 2*y..8 0. a Courbes. e e ee e e Il est possible d’afficher les 3 courbes simultan´ment.6 0.4 1.Rajoutons maintenant une autre courbe : ybis = 1 .x."ro".4 0.) o` style est une chaˆ de caract`res pr´cisant la couleur.

plot(1:m. Cependant dans de nombreux cas. petite illustration de la loi des grands nombres .60)’.m). e e e 1. a.m). y2 = y1. + x o d + × ♦ ^ v > < les symboles s . x = rand(1. y3 = erf(x3)..3 modifier quelques propri´t´s des graphiques e e Nous allons voir maintenant comment r´gler certains param`tres qui ne peuvent l’ˆtre via la come e e mande plot.xm. xm = cumsum(x). drawlater() plot(x1.1]. 4.2*%pi.data_bounds = [1. e – pour obtenir d’autres couleurs. choisir le rectangle de visualisation : reprenons l’exercice 6 du chapitre 2. Notez que toutes les manipulations qui vont suivre peuvent se faire avec l’´diteur graphique qui se lance ` partir du menu edit de chaque e a fenˆtre graphique. etc./(1:m). 1]. plot(1:m. y1 = sin(t). // une ellipse x2 = cos(t). il faudra r´cup´rer le handle de la ligne et changer sa propri´t´ e e ee foreground. il faut donner ` la propri´t´ data bounds de l’objet syst`me e e a ee e d’axes la valeur du rectangle de visualisation sous la forme d’une matrice : xmin ymin xmax ymax m = 1000.60)’. clf(). par exemple "b--o" doit donner une ligne tiret´e avec un cercle pour chaque point . "m") 9 qui vaut "off" par d´faut e 64 . une solution possible est : m = 1000. imposer une ´chelle isom´trique : tr`s pratique pour dessiner des figures g´om´triques. il est plus pratique de modifier les propri´t´s ` e ee a partir de code scilab mˆme si l’´diteur reste pratique pour explorer les diverses possibilit´s. l’intervalle e e des ordonn´es doit ˆtre [0. tiret-point. "r". ce qui s’obtient avec ha = gca() (gca pour get current axes). // la fct erreur clf().. elle e e e e e 9 des axes sur "on".0. y1. clf().2.k b r g les couleurs noir c cyan bleu m magenta rouge y jaune vert w blanc les types de traits trait plein -tirets : pointill´s e -. Pour cela. xm = cumsum(x). // on r´cup`re le handle du syst`me d’axes e e e // on impose l’´chelle e 2.xm. * pentagram · ∗ Remarques : – il est possible de tracer simultan´ment une ligne avec des symboles en combinant couleur."b". x = rand(1.3) : s’obtient en positionnant la propri´t´ isoview ee t = linspace(0. En g´n´ral il faudra r´cup´rer au pr´alable le handle du syst`me d’axes contenant le grae e e e e e phique. style et e symbole.m. y3. Voici un exemple (cf figure 4./(1:m). // un cercle x3 = linspace(-2."b") mais le graphe obtenu n’est pas satisfaisant car pour illustrer pleinement le ph´nom`ne. x3. y2. x2."b") a = gca(). x1 = 2*cos(t).

ces r´affichages syst´matiques (et pas tous utiles) sont assez e e e p´nibles. le premier caract`re r`gle le comportement sur l’axe des x.4) : x = logspace(0..0 −0.log_flags="ln".5 −1. xtitle("log_flags=""ll""") drawnow() Cet exemple vous montre aussi comment dessiner plusieurs graphes dans la mˆme fenˆtre graphique e e en utilisant l’instruction subplot(m. a2. y = 1 .0 x 0.0 0.5 1. le graphe serait affich´ une premi`re fois lors du plot. clf() drawlater() subplot(1. le deuxi`me celui de e e e l’axe des y.5 2. "b")..a = gca(). n. y.0 1.."cercle". Voici un exemple (cf figure 4.2./x."x". a1. Le param`tre m correspond ` la d´coupe verticale (en e a e 65 ."y") drawnow() qui utilise aussi deux nouvelles instructions drawlater() et drawnow(). y.4. a2=gca(). Elles ne sont pas obligatoires mais elles ´vitent ` Scilab de redessiner syst´matiquement le graphique en cours de construce a e tion : sans elles.0 −0. a1=gca(). utiliser une ´chelle logarithmique : cette fois il faut r´gler la propri´t´ log flags de l’objet e e ee syst`me d’axes.log_flags="ll".isoview = "on". ellipse cercle fct erreur 1.3 – Ellipse. puis une deuxi`me lors du e e e changement de l’´chelle. Dans notre cas leur absence ne serait pas trop p´nalisante mais si vous e e dessinez un graphique plus cons´quent.0 −1. e Encore des courbes . xtitle("log_flags=""ln""") subplot(1.0 Fig. num). 4.1) plot(x.5 0. a. cercle et erf 3.2. et finalement une troisi`me et une quatri`me fois fois lors du rajout de e e e la l´gende puis du titre. // l’echelle devient alors isom´trique e legend("ellipse". C’est une chaˆ de deux caract`res chacun pouvant prendre la valeur ”n” (non e ıne e log) ou ”l” (log).0 −2.".5 −1.2) plot(x..5 y 0.200)’."fct erreur") xtitle("Encore des courbes . "b").

y.4) titlepage(["` droite". e e 4.14. a.0 0 1 2 3 4 10 −4 10 10 10 10 10 10 0 10 1 2 3 4 10 10 10 10 Fig.5) : x = linspace(-14. 4.8 −1 0 log_flags="ll" 10 0."en bas"]) a xselect() on scinde la fenˆtre verticalement en deux parties (gauche/droite). n ` la d´coupe horizontale.4 – ´chelles semilog et loglog e m parts ´gales).title.6) titlepage(["` droite".3 10 −2 10 −3 0.1) titlepage("` gauche") a subplot(3."en haut"]) a subplot(3.2. a = gca().0 0. et num au num´ro de la sous-fenˆtre s´lectionn´e parmi e a e e e e e les m × n. modifier le placement des axes : cela s’obtient en jouant avec les propri´t´s x location et ee y location du syst`me d’axes contenant le graphique : e x location "bottom" "top" "middle" placement obtenu en bas en haut en y = 0 si possible y location "left" "right" "middle" placement obtenu a ` gauche bas a ` droite en x = 0 si possible Voici un exemple (cf figure 4. j) a le num´ro n × (i − 1) + j).9 0. clf() plot(x. En fait rien n’interdit de modifier la e e grille au fur et ` mesure des subplot pour obtenir ce que l’on cherche. "b"). Par exemple. a. les sous-fenˆtres ´tant num´rot´es de la gauche vers la droite puis de haut en bas (ainsi e e e e la sous-fenˆtre en position (i.5 0.6 0.2.text = "La fonction sinus cardinal"."au centre"]) a subplot(3. a.2 0.2.log_flags="ln" 1. avec : a clf() subplot(1. 66 .7 0.x_location = "middle".y_location = "middle". Il faut en fait comprendre subplot comme une directive e e qui permet de s´lectionner une portion de la fenˆtre graphique.2) titlepage(["` droite".4 0.300)’. y = sinc(x).1 0.2. la sous-fenˆtre de droite ´tant e e e d´coup´e horizontalement en trois parts.

4 5 10 15 Fig. x."b".children(1). En fait l’objet syst`me d’axes c e de coordonn´es contient un grand nombre de propri´t´s qui sont explicit´es dans la page d’aide e ee e d´nomm´e axes properties. y(:. x. // l’identificateur de la composition des 4 courbes // (le handle du compound des 4 courbes) e. Les e e courbes10 sont donc filles de cette composition.4).1).8 0. // on change la couleur de la // courbe initialement verte (la 3 eme) e. 4.2 −0. e e La fonction sinus cardinal 1. e e e l’entit´ courante est la composition de nos courbes. modifier les propri´t´s d’une courbe : pour cela il faut r´cup´rer le handle de la courbe e e e e qui vous int´resse ce qui n’est pas forc´ment ´vident.4 0.5 – placement des axes en y = 0 et x = 0 5.0 −15 −10 −5 0 −0.children(2). // on change l’´paisseur de la e // courbe en cyan (la 4 eme) e.children(3). y = besselj(1:4.foreground =19.6 0.2 0. clf() drawlater() plot(x.y(:.y(:. Ces quelques explications devraient vous aider e a ` comprendre les manipulations suivantes : x = linspace(0.y(:."r". ` l’instar de la fenˆtre courante11 et a e du syst`me d’axes courant.line_style = 2. Une instruction comme plot « enrobe »ses e e e courbes dans un objet composition dans l’ordre inverse de celui que l’on a donn´ au d´part. xtitle("Quelques fonctions de Bessel") xgrid(12) drawnow() 10 11 qui sont des objets de type ligne polygonale on peut r´cup´rer son handle avec f=gcf() e e 67 .200)’.thickness = 3. il existe aussi la notion d’entit´ courante et justement."g".2). D’autre part.3). apr`s un plot.x).15. x.Cet exemple vous montre aussi une autre fa¸on de mettre le titre."c") e = gce(). // on change le style de la // courbe en rouge (la 2 eme) legend("J"+string(1:4)).0 0.

3 0. 19 doit correspondre ` du brun.opt_arg>* d´signe l’´ventuelle s´quence des arguments optionnels opt_arg prenant la forme13 : e e e e mot cl´=valeur la s´quence pouvant ˆtre mise dans n’importe quel ordre. a on utilisera plot2d(x. 4.2 0. children(2).1 −0.opt_arg>*) o` : u e – Mx et My sont respectivement la matrice des abscisses et celle des ordonn´es.1 0.6 – Bessels 4.) est un objet ligne polygonale .My <. e Quelques fonctions de Bessel 0. avec la carte par d´faut..5 0.4 0 5 10 15 J1 J2 J3 J4 Fig.Qui devraient vous permettre d’obtenir la figure 4.3 −0.[y1 y2 y3]. e – la fonction xgrid permet de rajouter une grille et son argument (on peut ne pas en mettre) est le num´ro de sa couleur. les vecteurs d’abscisses ou d’ordonn´es pouvent ˆtre indiff´remment ` e e e e des vecteurs lignes ou colonnes .b. x. x.. ainsi lors de la cr´ation du vecteur des abscisses. e e Nous allons exp´rimenter les principales options en essayant de reproduire les graphiques cr´´s e ee pr´c´demment avec plot. d’autre part.n)’. vous trouverez l’ensemble des propri´t´s ` la page d’aide polyline properties.. on a pas ` dupliquer le vecteur des abscisses : par exemple pour afficher x. ou encore x = (a :dx :b)’ 13 en fait argument formel=argument effectif 12 68 .6 0. e e a e La syntaxe g´n´rale a la forme : e e plot2d(Mx.y3.4 0.y2. si toutes les courbes ont les mˆmes e constitu´e par les k e e abscisses. .) si bien sˆr tous ces vecteurs sont des vecteurs colonnes. il sera souvent pratique d’utiliser x = e linspace(a.6. e a – line style doit ˆtre ´gal ` 1 pour une ligne continue et les valeurs sup´rieures donnent diff´rents e e a e e style de lignes pointill´es.0 −0.2 −0.. la k`me courbe ´tant e e `me colonnes12 de Mx et My .. ee a – Les couleurs se choisissent avec des num´ros relatifs ` la carte des couleurs courantes (voir un e a peu plus loin) . u – <.4 l’instruction plot2d Cette instruction est plus difficile ` utiliser que plot mais elle permet de sp´cifier certains param`tres a e e (r´glages concernant l’´chelle par exemple) sans avoir ` utiliser le handle du syst`me d’axes du graphique.y1. Quelques remarques : – Ici chaque enfant (children(1). mais auparavant voici quelques remarques : e e il faut faire attention a ce d´tail car avec plot.

// la fct erreur clf()."x".". a – choisir le style pour chaque courbe est plus difficile qu’avec plot . on utilise la combinaison rect=val.. e 1. – par contre le fait de pouvoir r´gler des param`tres d’´chelle donne. // une ellipse x2 = cos(t).^2. style=color("blue"). un code moins long14 e e e e e qu’avec plot . plot2d((1:m)’."y") legend("x^2"..61)’. style=[2 5 3]) xtitle("Courbes. y1 = sin(t)."2x^2") Voici quelques couleurs de la carte par d´faut : e 1 2 3 4 noir bleu vert clair cyan 5 6 13 16 rouge vif mauve vert fonc´ e bleu turquoise 23 26 19 32 violet marron brun jaune orang´ e Pour ´viter de retenir ces num´ros. // un cercle x3 = linspace(-2.60)’.). e e mais attention. e 2. ymax ] (ne pas mettre de .2. enfin plot2d s’ex´cute plus rapidement que plot.. elle est rajout´e dans la carte)..". soit une chaˆ e e e ıne de caract`res ("blue".2*%pi.^2. en g´n´ral. en vert et en bleu."red"."yellow". on obtient une ligne continue de couleur num´ro i et si i est n´gatif ou nul. xm = cumsum(x). ybis = 1 . y2 = y1..[y ybis yter].m. frameflag=4) legend("ellipse".."x".x... mais souvent le code pour plot2d est plus difficile a ´crire : il faut aller voir la documentation `e pour se souvenir des valeurs des param`tres. clf()./(1:m). choisir les couleurs et ou les symboles : il faut utiliser style=vec o` vec doit contenir autant u de composantes qu’il y a de courbes et si vec(i) est un entier strictement positif.m). entre ymin et xmax comme pour r´gler la propri´t´ data bounds ! ! ! !) e ee m = 1000."y") cf les exemples suivants.[y1 y2 y3].) e 15 La page d’aide color list vous donnera toutes les couleurs reconnues.style=[2 5 6]. val est ici le vecteur [xmin . rect=[1. etc15 .xm’. plot2d(x. e clf() x=linspace(-1. xmax .1. 14 69 . sp´cifier l’´chelle : pour choisir le rectangle de visualisation.60)’."fct erreur") xtitle("Encore des courbes . plot2d([x1 x2 x3].1]) Quant ` l’´chelle isom´trique.– la contrainte de mettre plusieurs courbes dans les matrices Mx et My implique qu’il est impossible de dessiner des courbes avec des discr´tisations diff´rentes (n points pour l’une et m = n pour l’autre) e e avec un seul appel ` plot2d . soit 3 entiers donnant la d´finition d’une couleur e e par ses intensit´s en rouge. ymin ."1-x^2". y = x.0. il existe la fonction color qui prend en entr´e. x = rand(1. on peut l’obtenir avec la combinaison frameflag=val o` val doit a e e u prendre la valeur 4 (´chelle iso obtenue ` partir des maxima et minima des donn´es) : e a e t = linspace(0."cercle". x1 = 2*cos(t). y3 = erf(x3). il s’agit d’un symbole qui sera dessin´ e e e dans la couleur courante du syst`me d’axes. yter = 2*y. Cette fonction retourne l’identificateur de la couleur e dans la carte courante (si la couleur en question manque.

a a En fait il faut savoir l’utiliser car les s´quences optionnelles de nombreuses primitives de dessin e ne disposent pas encore des mots cl´s frameflag et axesflag. y. logflag= "ll") xtitle("logflag=""ll""") 5. utiliser une ´chelle logarithmique : la s´quence correspondante est logflag=str o` str est la e e u mˆme chaˆ de deux caract`res chacun pouvant prendre la valeur ”n” (non log) ou ”l” (log) : e ıne e x = logspace(0. e a e e a y entre 0 et 9. a a z entre 0 et 5. clf() subplot(1.300)’.200)’. le placement des axes s’obtient avec la combinaison axesflag=val : x = linspace(-14. y = 1 . correspond ` la valeur ` donner pour axesflag.1) plot2d(x. style=2. les avec boite mais sans axes ni graduations avec boite. ni d’axes et de graduations avec boite. et.2.Voici les valeurs possibles pour ce param`tre (dans certains cas frameflag peut ˆtre accompagn´ du e e e param`tre rect) : e frameflag=0 frameflag=1 frameflag=2 frameflag=3 frameflag=4 frameflag=5 frameflag=6 frameflag=7 frameflag=8 on utilise l’´chelle pr´c´dente (ou par d´faut) e e e e ´chelle donn´e par rect e e ´chelle calcul´e via les les max et min de Mx et My e e ´chelle isom´trique calcul´e en fonction de rect e e e ´chelle isom´trique calcul´e via les max et min de Mx et My e e e idem ` 1 mais avec adaptation eventuelle pour graduation a idem ` 2 mais avec adaptation eventuelle pour la graduation a idem ` 1 mais les courbes pr´c´dentes sont redessin´es a e e e idem ` 2 mais les courbes pr´c´dentes sont redessin´es a e e e 3. le mot cl´ strf : il permet de remplacer ` la fois frameflag et axesflag.2. De plus il reste tr`s pratique lorsque e e vous voulez rajouter un dessin sur un autre sans modifier l’´chelle et le cadre ce qui s’obtient avec e strf="000" (et ´vite donc d’´crire frameflag=0.4. y. pour des raisons e a de compatibilit´ avec l’ancienne fa¸on d’utiliser plot2d. il contient aussi un drapeau (flag) pour e c l’utilisation de la l´gende ou non. axes et graduations (les x en bas. axesflag=5) xtitle("La fonction sinc") Voici le tableau donnant les diverses possibilit´s : e axesflag=0 axesflag=1 axesflag=2 axesflag=3 axesflag=4 axesflag=5 pas de boite. logflag= "ln") xtitle("logflag=""ln""") subplot(1. style=2.14. correspond ` la valeur ` donner pour frameflag . y. axesflag=0). les sans boite mais avec axes et graduations (trac´s e sans boite mais avec axes et graduations (trac´s e y ` gauche) a y ` droite) a vers le milieu) en y = 0 et x = 0) 4. clf() plot2d(x. y = sinc(x). e e 70 . axes et graduations (les x en bas. La valeur ` donner est une chaˆ de trois caract`res "xyz" avec : e a ıne e x ´gal ` 0 (pas de l´gende) ou 1 (l´gende ` fournir avec la combinaison leg=val) .2) plot2d(x./x. style=2.

clf() drawlater() plot2d3(x. yi+1 ). yi ) et (xi+1 . y = x. style=2. yi+1 )).y.children(1). plot2d2 trace un segment horizontal (entre (xi . rect=[0. frameflag=5.5.thickness = 4. plot2d3 Elles s’utilisent exactement comme plot2d : mˆme syntaxe avec les mˆmes arguments optionnels. yi )) puis un segment vertical (entre (xi+1 .0. 0) et (xi .-1. xtitle("Probabilit´s pour la loi binomiale B(6.n+1]) xtitle("plot2d2") plot2d2 12 10 8 6 4 2 0 −2 0 2 4 6 8 10 12 Fig. on ne peut pas dessiner en une seule fois plusieurs a courbes qui n’ont pas ´t´ discr´tis´es avec le mˆme nombre d’intervalles et l’on est oblig´ d’utiliser ee e e e e 71 .n)’.n+1. frameflag=5. 4. style=2.n+1.8)) : n = 6. x = (0:n)’.1/2)") e drawnow() 4. plot2d2 permet de dessiner des fonctions en escalier : au lieu de tracer un segment de droite entre les points (xi . plot2d3 dessine des diagrammes en bˆtons : pour chaque point (xi . x = (0:n)’. yi ) et (xi+1 . e e 1. e. yi ) et (xi+1 .7)) : n = 10.5 Des variantes de plot2d : plot2d2. clf() plot2d2(x. y = binomial(0.0. yi ) . yi ) plot2d3 trace un segment a vertical entre (xi . voici un exemple (cf figure (4. rect=[-1.y. avec plot2d et ses variantes.6 Dessiner plusieurs courbes qui n’ont pas le mˆme nombre de e points Contrairement ` plot. Voici un exemple (cf figure (4.4.32]) e = gce().7 – illustration pour plot2d2 2.

*cos(2*%pi*x1).Probabilités pour la loi binomiale B(6.ymin . il faut la fixer lors du premier appel puis utiliser e frameflag=0 pour les appels suivants16 .35 0.20 0. Voici un exemple (cf figure (4."x".9)) : x1 = linspace(0. x2 = linspace(0.15 0..1*(rand(x3)-0. style=2.".1. on peut se passer de sp´cifier l’´chelle sans mauvaise e e surprise puisque. 4.61)’. Cependant si on veut maˆ e ıtriser l’´chelle. y2 .0. // idem a y2 avec une perturbation ymin = min([y1 .ymax+dy]. y1 = x1. par d´faut (frameflag=8) les courbes pr´c´dentes sont redessin´es en cas de changement e e e e d’´chelle.1.25 0.1. y1.1/2) 0.1.dy.*(1-x1).30 0. y2 . y2 = x2.00 −1 0 1 2 3 4 5 6 7 Fig."x(1-x) + bruit").*(1-x3) + 0. style=5. x3 = linspace(0. frameflag=0) // 2eme et 3 eme appel : plot2d(x3. y3 = x3.05. y3. dy = (ymax .9. y3]).12)’.frameflag=0) // on utilise l’echelle precedente xtitle("Des courbes. style=-1. rect=rect) // 1er appel qui impose l’´chelle e plot2d(x2. frameflag=5. e e e 72 .ymin)*0.. y2."x(1-x)". Depuis la version 2-6. // pour se donner une marge rect = [0.5).8 – illustration pour plot2d3 plusieurs appels successifs."y") legend("x(1-x)*cos(pi x)". 16 cette m´thode est obligatoire si on veut une ´chelle isom´trique.*(1-x2). drawnow() Rmq : essayer cet exemple avec frameflag=1 au lieu de 5.05 0.31)’. ymax = max([y1 .10 0. y3]). // fenetre de visualisation clf() // effacement des graphiques precedents drawlater() plot2d(x1.

0 −0.2 0. %12pts = 2. %helvetica = 6. les styles et les tailles se rep`rent avec des entiers : e nom de la fonte Courier Symbol Times Times-Italic Times-Bold Times-Bold-Italic Helvetica Helvetica-Italic Helvetica-Bold Helvetica-Bold-Italic identificateur 0 1 2 3 4 5 6 7 8 9 taille de la fonte 8 points 10 points 12 points 14 points 18 points 24 points identificateur 0 1 2 3 4 5 Pour se rep´rer. par exemple : %symbol = 1. variables e e que l’on peut mettre dans son fichier . %10pts = 1.9 – Encore des courbes.7 Jouer avec le syst`me d’axes par d´faut e e Dans l’introduction sur le nouveau syst`me graphique de scilab. rien n’interdit de se cr´er des variables avec des noms un peu plus parlant.1 y 0.3 0..3 0. %times = 2. mais ` quoi peuvent-ils bien servir ? En fait il contiennent toutes les e e a valeurs par d´faut des diff´rentes propri´t´s de toute figure et de tout syst`me d’axes.scilab. Voici un exemple de fonction qui change les propri´t´s par d´faut : ee e 73 . %14pts = 3.4 0. %times_italic = 3.9 1.0 Fig.7 0. %times_bold = 4. %8pts = 0. 4.Des courbes. Avant de donner un exemple. 4.. %24pts = 5.4 0..6 0.1 0.. %helvetica_bold_italique = 9.0 x(1−x)*cos(pi x) x(1−x) x(1−x) + bruit 0.8 0. %18pts = 4.5 x 0. 0.2 0.1 −0. on a parl´ d’une figure par d´faut e e e et d’un syst`me d’axes par d´faut.3 0. Ainsi en modifiant e e ee e le syst`me d’axes par d´faut vous pouvez r´gler les propri´t´s de tous les axes qui seront cr´´s par la suite.2 −0. e e e ee ee Il est ainsi assez facile de se cr´er son propre style graphique. %helvetica_bold = 8. %helvetica_italic = 7. regardons e les fontes dont scilab dispose.

y_label. Plus pr´cisemment. X. y = exp(-x.z_label. a. la plage de l’histogramme correspondant ` e a l’intervalle Ci vaut donc (m ´tant le nombre de donn´es.title. Ci =]ci .x_label. . dans le cas o` n est un entier. a. // a est le handle sur ces axes par d´faut e a.9 R´cup´rer ses graphiques sous plusieurs formats e e Ceci est tr`s facile ` partir du menu File de la fenˆtre graphique. a. Depuis la version 2. avec  ∆C = (cn+1 − c1 )/n – X le vecteur (ligne ou colonne) des donn´es ` examiner . style=2.1. a.. son int´grale vaut 1 et approche e e e e donc une densit´ (dans le cas contraire. plot2d(x.5..1) e e x = linspace(-5.y_label.21). axesflag=0) card {Xj ∈Ci } m∆Ci 4. Lorsque l’histogramme est normalis´.X) // on lui superpose le trac´ de la densit´ de N(0. en choisissant l’item Export.title.. n. endfunction 4.8 Dessiner un histogramme La fonction scilab ad´quate s’appelle histplot et sa syntaxe est la suivante : e histplot(n. la valeur d’une plage correspond au nombre de composantes e de X tombant dans cette plage).font_size = %14pts. a.^2/2)/sqrt(2*%pi). <. soit un vecteur ligne (avec ni < ni+1 ) : 1. les donn´es sont comptabilis´es dans les n classes ´quidistantes : u e e e   c1 = min(X). 74 . c2 ].font_style = %helvetica_italic.font_size = %14pts.y.font_style = %helvetica_italic. ci+1 ].z_label.60)’.opt arg>* la s´quence des arguments optionnels comme pour plot2d avec cependant la come binaison suppl´mentaire normalization = val o` val est une constante (ou variable ou expression) e u bool´enne (par d´faut vrai).font_style = %helvetica_bold. clf() histplot(classes. a. a. i = 2. frameflag=0.font_size = %14pts. cn+1 = max(X) ci+1 = ci + ∆C C1 = [c1 . les donn´es sont comptabilis´es selon les k classes u e e Ci = [ni .font_size = %18pts. et ∆Ci = ni+1 − ni ) : e e si normalization = vrai card {Xj ∈ Ci } si normalization = f aux Voici un petit exemple.opt_arg>*) o` : u – n est soit un entier. un e a e autre menu vous propose diff´rents choix tournant autour du langage postscript ainsi que le format fig e qui permet lui de retravailler son graphique avec le logiciel de dessin vectoriel xfig. e a – <.font_size = %14pts.5.font_style = %helvetica_italic. a.x_label. classes = linspace(-5. dans le cas o` n est un vecteur ligne.function style1() sda() // remet ` plat les propri´t´s des axes par d´faut a e e e a = gda(). a 2. toujours avec la loi normale (cf figure (4."normal").5 vous pouvez aussi exporter en gif.10)) : X = rand(100000. ni+1 [ (le vecteur n ` donc k + 1 composantes) .

. la « pixmap » est bascul´e ` l’´cran.pixmap = "off". f... ici e1 et e2) basculement de la pixmap ` l’´cran (pour le premier dessin) a e 75 .. 4....24 0.. Voici le canevas e e e e a e le plus simple pour une animation en Scilab : f = gcf(). . Dans ce cas : – on omet l’instruction clf() .. chacun des dessins successifs de l’animation se constitue d’abord dans une m´moire (appel´e pixmap). on met ` jour le champ data de ces objets . e1 = . a e a – puis on appelle show pixmap().10 – Histogramme d’un ´chantillon de nombres al´atoires suivants N (0. e e – ` chaque it´ration.. 1) e e 4. e2 = . show_pixmap() end f.... – on r´cup`re les handles des objets graphiques variables .pixmap = "on".40 0..12 0. Avec le double buffer..36 0. ....04 0 −5 −4 −3 −2 −1 0 1 2 3 4 5 Fig....28 0.0. f. Notre canevas graphique ressemble alors ` : a f = gcf().08 0...16 0.. ..pixmap = "on"......10 Animations simples Il est facile de r´aliser des petites animations avec Scilab qui permet l’utilisation de la technique du e double buffer ´vitant les scintillements ainsi que celle des masques pour faire ´voluer un objet sur un e e fond fixe.. for i=1:nb_dessins clf() . show_pixmap() for i=2:nb_dessins // // // // // // on r´cup`re le handle de la fen^tre graphique e e e on met la fen^tre en mode double buffer e construction du premier dessin (on r´cup`re e e les handles des objets graphiques variables.. une fois termin´.20 0..32 0. puis... // on r´cup`re le handle de la fen^tre graphique e e e // on met la fen^tre en mode double buffer e // destruction des objets graphiques pr´c´dents e e // fabrication du (i eme) dessin dans la pixmap // basculement de la pixmap ` l’´cran a e // on remet la fen^tre en mode usuel e Souvent l’animation se compose de plusieurs ´l´ments graphiques dont certains sont invariables au ee cours du temps....

.1.. f.thickness = 5 .background = color("red").:)+xg(i) . show_pixmap().title. – la couleur int´rieure avec ep. ee 76 . xyr(2. f. r = 0. xyr = [cos(theta) -sin(theta).-1. – pour vous montrer quelques possibilit´s.title.background = color("black").thickness = 4.:)).foreground = .:)+1. f = gcf().7..data = [ xyr(1. l = 0. a. ea. L = 0.font_size = 4.n)’. xy = [-L/2 L/2 L/2 -L/2. je modifie un certain nombre de propri´t´s dont les couleurs e ee d’arri`re plan (background) de la figure et du syst`me d’axes .e1. end f. show_pixmap(). nb_tours = 4.. e e – le rectangle est dessin´ via xfpoly et lorsqu’on r´cup`re son handle ep. a. // modifications des donn´es de l’objet graphique e1 e // modifications des donn´es de l’objet graphique e2 e // basculement de la pixmap ` l’´cran a e // on remet la fen^tre en mode usuel e Voici un exemple d’animation o` l’on d´place un rectangle (de longueur L et de largeur l) sur un u e cercle de rayon r et de centre (0. f..4. a.. // les 4 points du bord -l/2 -l/2 l/2 l/2]. a.3.1]. ep. e – le cercle est dessin´ via xarc.360*64).7. xg = r*cos(t).. on en profite pour modifier : e e e – l’´paisseur de son contour avec ep. Pour utiliser la technique des masques.data = . le rectangle ´tant aussi anim´ d’un mouvement de rotation autour e e de son centre de gravit´. xy(2. voir la page d’aide figure properties. ep = gce(). vous devez changer la fonction logique d’affichage grˆce ` la a a propri´t´ pixel drawing mode.0.foreground = color("blue"). ep. xselect() clf(). Voici quelques d´tails suppl´mentaires pour vous aider ` comprendre ce script : e e e a – l’´chelle est r´gl´e uniquement via le handle a du syst`me d’axes : on passe en mode isom´trique e e e e e et on assure un rectangle de visualisation d’au moins [−1.data_bounds = [-1. a = gca(). xfpoly(xy(1..foreground = color("white"). t = linspace(0. 1] × [−1.title. ea = gce()... .. yg = r*sin(t). e – la couleur du contour avec ep..1..1.0. 0)....data = . ep.. for i=2:n theta = 3*t(i).isoview = "on". e n = 4000. 1] ..nb_tours*2*%pi.4. ea... .foreground = color("yellow"). ep.:)+yg(i) ]’.pixmap = "off".background = .thickness = 5.text = "Animation simple".6. e2. a. show_pixmap() end f... a. sin(theta) cos(theta)]*xy. xarc(-0.pixmap = "on"..pixmap = "off".foreground = color("green").7.background = color("grey").

y.11 Les surfaces : NOT YET UPDATED L’instruction g´n´rique pour dessiner des surfaces est plot3d17 . y) = cos(x)cos(y) pour (x. et z est une matrice (nx.z <. Depuis la version 2. on a c e e utilise : plot3d(x.y. 2π] × [0.opt_arg>*) o`. // la discretisation en x (et aussi en y : c’est la meme) z=cos(x)’*cos(x).31). 2π] : x=linspace(0. Dans la forme la plus simple. De fa¸on plus g´n´rale. pour des facettes triangulaires ou quadrangulaires. Dans l’exemple qui suit je repr´sente la e e e fonction f (x.j) = f(x(i).2*%pi.z) // le dessin Z 1 0 −1 0.4.opt arg>* d´signe la s´quence des arguments optionnels.1 X 6.x.opt_arg>*) plot3d1(x. il est particuli`rement simple de e e e la repr´senter pour un domaine rectangulaire des param`tres. x et y sont deux vecteurs lignes ((1. y). 4. sp´cifier une couleur par sommet et le rendu e de la facette est obtenu par interpolation des couleurs d´finies aux sommets. e e e alors α = angle(Oz. ny) telle que zi. opt arg prenant u e e la forme mot cl´=valeur.y(j)) plot3d(x. ny)) correspondants ` la discr´tisation en x et en y.1 Y 3. y) ∈ [0.11)18 . <.z <.j est a e « l’altitude » au point (xi .3 6.1 Introduction ` plot3d a Si votre surface est donn´e par une ´quation du type z = f (x. Oc la direction de la cam´ra.0 3. Avec une repr´sentation de votre e e e surface par facettes. on peut e aussi. Oc ) o` Oc est la projection de Oc sur le plan Oxy .11. theta=val theta et alpha=val alpha sont les deux angles (en degr´) pr´cisant le point de vue en e e coordonn´es sph´riques (si O est le centre de la boite englobante. e 4. c sauf que j’ai utilis´ des couleurs avec plot3d1 (transform´es en niveau de gris pour ce document) et le point de vue est e e un peu diff´rent e 18 17 77 . u plot3d1 qui s’utilise de fa¸on quasi identique permet de rajouter des couleurs selon la valeur en z.11 – la fonction z = cos(x)cos(y) Vous devez alors obtenir quelque chose qui ressemble ` la figure (4. nx) et e (1. yj ). Oc) et θ = angle(0x. Voici les arguments optionnels possibles : 1. // le jeu des valeurs en z : une matrice z(i.6.3 Fig. comme pour plot2d.0 0. on peut d´finir une couleur pour chaque facette.

flag=[2 4 4]) xtitle("variation du point de vue avec le parametre theta") xset("wshow") actuellement c’est l’algorithme du peintre qui est utilis´.alpha=alpha(1). iii. zmin . n = 200. le maillage est visible . c’est ` dire avec : a – mode = 2 la surface sera peinte (cˆt´ positif) avec la couleur 2 et le maillage sera apparent . avec mode < 0.80. e e e De plus le cˆt´ positif d’une face (voir plus loin) sera peint avec la couleur num´ro mode oe e alors que le cˆt´ oppos´ est peint avec une couleur que l’on peut changer avec l’instruction oe e xset("hidden3d". avec mode = 0.n/2) linspace(0. // un tour complet alpha = [linspace(60. ıne e u e e 3. Voici un petit script o` on utilise presque tous les param`tres de plot3d.x. c-a-d qu’un tri des facettes est effectu´ et les plus ´loign´es de e e e e l’observateur sont dessin´es en premier. e (b) le param`tre type permet de d´finir l’´chelle : e e e type 0 1 2 3 4 5 6 box 0 2 3 4 ´chelle obtenue e on utilise l’´chelle pr´c´dente (ou par d´faut) e e e e ´chelle fournie avec ebox e ´chelle obtenue ` partir des minima et maxima des donn´es e a e comme avec 1 mais l’´chelle est isom´trique e e comme avec 2 mais l’´chelle est isom´trique e e variante de 3 variante de 4 effet obtenu juste le dessin de la surface des axes sous la surface sont dessin´s e comme pour 2 avec en plus le dessin de la boite englobante comme pour 3 avec en plus la graduation des axes (c) et enfin le param`tre box contrˆle le pourtour du graphe : e o 4.1) // pour activer le double buffer driver("X11") // on fait varier theta for i=1:n xset("wwpc") // effacement du buffer courant plot3d(x. xmax . ebox=val ebox permet de d´finir la boite englobante. leg=val leg permet d’´crire un label pour chacun des axes (exemple leg="x@y@z"). l’argument e effectif val leg est une chaˆ de caract`res o` @ est utilis´ comme s´parateur de labels .z. ymin . Dans ce e script j’utilise flag=[2 4 4]. les faces cach´es sont « enlev´es19 ».n). zmax ]. e e ii. oe – type = 4 on utilise une ´chelle isom´trique calcul´e via les donn´es (ce qui doit ˆtre ´quivalent ` e e e e e e a choisir type = 3 avec un param`tre ebox obtenu en utilisant les minima et maxima des donn´es) . avec mode > 0.0. theta = linspace(30.colorid) (par d´faut la couleur 4 de la carte).%pi. on obtient un rendu « fil de fer » (wireframe) de la surface .theta=theta(i).leg="x@y@z".390.n/2)]. flag=val flag o` val flag est un vecteur ` trois composantes [mode type box] permet de pr´ciser u a e plusieurs choses : (a) le param`tre mode est relatif au dessin des faces et du maillage : e i. ymax . val ebox devant ˆtre un vecteur ` 6 composantes e e a [xmin .2. // vers le haut puis // vers le bas xselect() xset("pixmap". x=linspace(-%pi.31). e e – box = 4 le dessin apparaˆ ıtra avec une boite et des graduations. e 19 78 . C’est une animation qui vous u e permettra de comprendre le changement de point de vue avec les param`tres theta et alpha. les faces cach´es sont enlev´es et le maillage n’est pas dessin´. z=sin(x)’*sin(x).

e 4. Enfin.C) permet de la charger dans le contexte graphique de la fenˆtre graphique courante.yf.end // on fait varier alpha for i=1:n xset("wwpc") // effacement du buffer courant plot3d(x. Votre surface va alors ressembler ` une mosa¨ a ıque car la carte des couleurs par d´faut n’est pas « continue ».theta=theta(n). P3 =  1  .i) sont les coordonn´es du j`me sommets de la i`me facette. zf de dimensions (nb sommets par face. vert et bleu de la i e e trice que nous appellerons C. elle s’utilise comme pr´c´demment pour les autres arguments : e e plot3d(xf.C) xset("hidden3d".3 plot3d avec des facettes Pour utiliser cette fonction dans un contexte plus g´n´ral. z = cos(x)’*cos(x).13).opt_arg>*) Attention l’orientation des facettes est diff´rente de la convention habituelle. les changements ne se r´percutent pas imm´diatement e e e e sur votre dessin (ce qui est normal). Celle-ci est constitu´e par 3 matrices xf.zf <.flag=[2 4 4]) xtitle("variation du point de vue avec le parametre alpha") xset("wshow") end xset("pixmap". pour lequel : e e         0 1 0 0  0  . l’instruction xset("colormap".11. la i`me ligne correspondant `me couleur. deux fonctions.x.12). Modulo u e ce petit changement. Etant donn´ une telle mae ´ a ` l’intensit´ (comprise entre 0 et 1) en rouge.3). colors(i) donnant le num´ro (dans la carte) de la couleur u e e attribu´e ` la i`me facette. 79 .30) // choix de la couleur 30 pour les faces n´gatives e xbasc() plot3d1(x. P1 = 0 0 0 1 20 voir aussi la section Contributions sur le site Scilab. Petite remarque : si vous changez la carte des couleurs apr`s avoir dessin´ un graphique.2 La couleur Vous pouvez r´essayer les exemples pr´c´dents en rempla¸ant plot3d par plot3d1 qui met des coue e e c leurs selon la valeur en z.31).z. C = hotcolormap(32). cf figure (4. e Pour d´finir une couleur pour chaque facette.alpha=alpha(i).zf(j.i). Voici de nouveau e l’exemple 1 x = linspace(0.z. e e Une carte des couleurs est une matrice de dimensions (nb_couleurs. le troisi`me argument doit ˆtre une liste : list(zf. hotcolormap et greycolormap foure nissent deux cartes avec une variation progressive des couleurs20 . seul le signe du param`tre mode est utilis´ (pour mode ≥ 0 le maillage apparaˆ e e ıt et pour mode < 0 il n’est pas dessin´).0) driver("Rec") 4.x.11. P2 =  0  . flag=[1 4 4]) // tester aussi avec flag=[-1 4 4] Remarque : avec plot3d1.leg="x@y@z".yf(j.i). e a Comme premier exemple. il faut donner une description de votre sure e face par facettes. yf. e e e nb faces) o` xf(j.2*%pi. P4 =  0  .colors) e e e o` colors est un vecteur de taille nb_faces. Il suffit par exemple de retailler la fenˆtre graphique ou alors d’ene voyer l’ordre xbasr(numero_fenetre) pour redessiner (et la nouvelle carte est utilis´e). // la hot colormap avec 32 couleurs xset("colormap". visualisons les faces du t´tra`dre de la figure (4.

13 – un t´tra`dre e e et d´finissons les faces comme suit (de sorte ` obtenir les faces ext´rieures avec l’orientation positive pour e a e Scilab) : f1 = (P1 .12 – orientation des facettes en scilab z P4 P1 P 3 y P 2 x Fig. P3 ). yf = [ 0 0 0 0. P4 .P3 P4 P2 face négative pour Scilab face positive pour Scilab P1 Fig. Vous pouvez e a remarquer que plot3d utilise une simple projection orthographique et non une projection perspective plus r´aliste.list(zf. z = z(u. flag=[1 4 4]. v). // ouf ! xbasc() plot3d(xf. 4. P4 . P3 ). f2 = (P2 . e Pour des besoins courants. P3 . P2 .4) . 0 0 1 0]. 0 0 0 1]. leg="x@y@z". le calcul des facettes peut ˆtre effectu´s avec les fonctions suivantes : e e – eval3dp et nf3d pour les surfaces d´finies par x = x(u.14.11. 1 1 0 0]. f4 = (P1 . f3 = (P1 . 1 0 0 0. 0 1 0 1. P2 ) On ´crira alors : e // f1 f2 f3 f4 xf = [ 0 1 0 0. v) (voir 4. zf = [ 0 0 0 0.2:5). y = y(u. 0 0 1 0. 4.yf. theta=230) xselect() Avec ces param`tres vous devriez obtenir quelque chose qui ressemble ` la figure 4. P4 ).alpha=30. v). e 80 .

vous ne pouvez e e pas la visualiser directement avec plot3d. .:) = P. . . e e Si votre surface (poly´drique) est d´finie comme mon cube de l’exemple sur les tlists. .coord(1. . . . . . vn ) sont les discr´tisations d’un rectangle du e e domaine des param`tres. .coord(2. v1 .yf. y) (un exemple est propos´ plus loin (4. u2 . u2 .yf. v2 . v2 . .4 Dessiner une surface d´finie par x = x(u. la fonction qui d´finit le param`trage de votre surface doit ˆtre e e e e ´crite « vectoriellement ». .yf. .:) // pour inverser l’orientation xf(j. Pour obtenir la description attendue par Scilab.face). v2 .coord(3.face). u1 . u2 .:) = P.alpha=60) 4. flag=[1 4 0]. votre fonction va ˆtre appel´e une seule fois avec les deux « grands » vecteurs e e e de longueur m × n : U = (u1 . . . vn ) m fois v1 m fois v2 m fois vn 81 . . um ) et (v1 . um . . vous pouvez utiliser une fonction comme celle-ci : function [xf. nf] = size(P. Si (u1 . . plot3d(xf. .11. . num) yf(j. .list(zf. .14 – le t´tra`dre dessin´ avec Scilab e e e – genfac3d pour les surfaces d´finies par z = f (x.5)). v). u1 .2:7). vn . um ) 1 2 n V = (v1 . . v) e R´ponse : prendre une discr´tisation du domaine des param`tres et calculer les facettes avec la fonction e e e (eval3dp).11.:) = P. 4. um . . .theta=50. vous obtiendrez alors son dessin avec : e e e [xf.face(ns+1-j. . .zf] = facettes_polyedre(P) // transforme la structure Polyedre de l’exemple // sur les tlist en description de facettes pour // visualisation avec plot3d [ns. yf=zeros(P. num) end endfunction En d´finissant le cube comme pr´c´demment. . Pour des raisons d’efficacit´. . .face) // ns : nb de sommets par facette // nf : nb de facettes xf=zeros(P. . vn .face) for j=1:ns num = P. . v1 . v2 . y = y(u. zf=zeros(P. . .zf] = facettes_polyedre(Cube). . v). . num) zf(j. . . .Fig. u2 . . . . . . . . z = z(u.

*sin(theta/2)). x = (R + rho.*sin(theta) z = r*sin(phi) + 0. Vk ).*sin(theta) z = rho. -2*%pi.2*(1+ 0.*sin(theta/2)). phi).z] = tore_bossele(theta. 2*%pi. phi) // param´trisation d’une helice torique e R = 1. 20).4*sin(8*theta)) x = (R + r. rho) // param´trisation d’une bande de Mo¨bius e e R = 1. Vk ) Voici quelques exemples de param´trisation de surfaces.*cos(theta/2) endfunction function [x. Y et Z de longueur m × n tels que : Xk = x(Uk . ´crite21 de fa¸on ` pouvoir ˆtre utilis´e avec e e c a e e eval3dp : function [x.z] = tore(theta. votre fonction doit renvoyer 3 vecteurs X.*cos(theta) y = (R + r*cos(phi)). phi) // param´trisation d’un tore dont le petit rayon r est variable avec theta e R = 1.2 x = (R + r*cos(phi)).y.yf.*sin(theta) z = r*sin(phi) endfunction function [x. c’est que l’orientation n’est pas la bonne : il suffit alors d’inverser le sens de l’un des deux vecteurs de la discr´tisation du domaine des e param`tres.*cos(phi)).z] = helice_torique(theta. yf.y.*cos(phi)).*cos(theta) y = (R + r.z] = moebius(theta./ et ca marchera ! e e ¸ 82 . r = 0. r = 0. r = 0. 160).zf) xselect() Si vous voulez utiliser des couleurs et que vous ne les obtenez pas.5*theta endfunction function [x. zf] = eval3dp(tore_bossele. // calcul des facettes xbasc() plot3d1(xf. theta.*cos(theta) y = (R + r*cos(phi)).3 x = (R + r*cos(phi)). Zk = z(Uk . phi = linspace(0.A partir de ces deux vecteurs. [xf. e 21 en fait vous pouvez ´crire ces ´quations naturellement puis remplacer les * et / par des .y.*sin(phi) endfunction Voici un exemple qui utilise la derni`re surface : e // script pour dessiner une surface d´finie par des ´quations param´triques e e e theta = linspace(0.* et . phi) // param´trisation classique d’un tore de rayons R et r et d’axe Oz e R = 1.*sin(theta) z = r. Vk ). Yk = y(Uk .y.*cos(theta) y = (R + rho.

voici le ruban de Mo¨bius d´finit juste avant : e e nt = 120. il est maintenant possible d’associer une couleur pour chaque sommet d’une facette. ` partir d’une discr´tisation de u et v il faut a a e d´finir soit-mˆme des matrices X. mais.5..nt).nr). – une couleur par sommet pour celui de droite. X = (R + rho’*sin(theta/2)).11.zf] = nf3d(X. alpha=60. theta = linspace(0. theta=50) xselect() Remarque : pour obtenir les bonnes matrices.0. Z = rho’*cos(theta/2).Z). Pour cela il suffit de donner une matrice colors de mˆme taille que les matrices xf.colors) <. et de l’associer au troisi`me argument (zf) avec une liste : e plot3d(xf.*(ones(nr.6.Z).j = x(ui . Y. ce qui ne rend ee e pas le code tr`s clair : la fonction eval3dp est plus simple ` utiliser ! e a 4. Y = (R + rho’*sin(theta/2)).list(zf.*(ones(nr.5 plot3d avec interpolation des couleurs Depuis la version 2.zf. [xf. Z telles que : e e Xi.1)*sin(theta)).j = y(ui .Y..5. j’ai ´t´ oblig´ d’utiliser la fonction ones. vj ) Yi. 83 .yf. Comme exemple. vj ) Zi.yf. nr = 10.Fig. 4. rho = linspace(-0. vj ) et vos facettes s’obtiennent alors avec [xf. zf e e donnant la description par facette.2*%pi.zf] = nf3d(X.yf.15 – Un tore bossel´. e La fonction nf3d est un peu analogue ` eval3dp. c-a-d telle que colors(i.j = z(ui . R = 1.opt_arg>*) Voici l’exemple initial de plot3d avec affichage sans le maillage et avec : – une couleur par face pour le dessin de gauche.j) soit la couleur associ´e au i`me sommet e e de la j`me face.1)*cos(theta)).Y. yf.yf. flag=[2 4 6]. xbasc() plot3d(xf.

4.nb_col) col = dsearch(val.12 Les courbes dans l’espace : NOT YET UPDATED Pour dessiner une telle courbe l’instruction de base est param3d.x.1) plot3d(xf.2. Vous noterez aussi l’utilisation de la fonction genfac3d qui permet de calculer les facettes. classes) endfunction x=linspace(0.yf. // exemple pour illustration de plot3d avec interpolation de couleur function [col] = associe_couleur(val) // associe une couleur pour chaque valeur de val n1 = 1 // numero de la 1 ere couleur n2 = xget("lastpattern") // num´ro de la derniere couleur e nb_col = n2 .Fig.2. Voici l’exemple classique de l’h´lice : e 84 .z).31).zcolf). [xf.2) plot3d(xf.graycolormap(64)) zmeanf = mean(zf.n1 + 1 classes = linspace(min(val).2*%pi.16 – Le ruban de Mo¨bius e Pour calculer les couleurs.7 mais vous pouvez facilement vous en passer). j’utilise une petite fonction qui me permet d’associer lin´airement des valeurs e a ` la carte graphique courante (j’utilise la fonction dsearch disponible depuis la version 2.list(zf.2) // la fonte 6 (helvetica) n’est disponible // que dans la version cvs de scilab subplot(1.yf.zcols). zcols = associe_couleur(zf).max(val)."r").yf.6. z=cos(x)’*cos(x). flag=[-1 4 4]) xtitle("Une couleur par face") subplot(1.zf] = genfac3d(x. zcolf = associe_couleur(zmeanf). flag=[-1 4 4]) xtitle("Une couleur par sommet") xselect() 4. xbasc() xset("font".list(zf. xset("colormap".

:) .colors) <. param3d(x.y.-9]).17 – Avec et sans interpolation des couleurs t = linspace(0.100)’. c’est e e a ` dire que si colors(i) est un entier strictement positif.opt_arg>*) Les matrices x.4. xset("font". // le dessin 85 .1*(1-rand(y1)).2. Voici un exemple qui doit vous conduire ` la figure (4.4*%pi. y et z doivent ˆtre de mˆme format (np. flag=[4 4]) xset("font". 4. [1. y = sin(t) .1*(1-rand(z1)). modulo le fait que flag ne ne comporte pas de param`tre mode.Fig. // nombre de points P = rand(n.list(z.3) param3d1([x1 x2].1*t. x = cos(t). z2 = z1 + 0.[y1 y2].100). P1 = P(1:m.z <. Voici sa syntaxe : param3d1(x. P2 = P(m+1:n. on obtient un affichage des points (non reli´s) avec le symbole e e correspondant. // des points au hasard // on impose les dimensions de la boite englobante ebox = [0 1 0 1 0 1].1*(1-rand(x1)). x1 = cos(t).y.4*%pi. z = t.opt_arg>*) param3d1(x. // une helice x2 = x1 + 0.3). la i`me courbe est dessin´e avec la i`me couleur e de la carte courante (ou avec diff´rents pointill´s sur un terminal noir et blanc) alors que pour une e e valeur enti`re comprise entre -9 et 0.y.nc) et le nombre de courbes (nc) est donn´ par e e e leur nombre de colonnes (comme pour plot2d). Les param`tres optionnels sont les mˆmes que ceux de e e l’instruction plot3d. // ici je separe les points en 2 groupes pour montrer comment mettre des // symboles et des couleurs differentes pour les points m = 30. y2 = y1 + 0. xbasc(). z1 = 0. Voici un script qui explique comment dessiner deux groupes de points e avec des marques et des couleurs diff´rentes : e n = 50. e colors est un vecteur donnant le style pour chaque courbe (exactement comme pour plot2d).:).18) : a t = linspace(0.z) // effacer eventuellement la fenetre graphique avec xbasc() mais comme cette derni`re ne permet que d’affichier une seule courbe nous allons nous concentrer sur e param3d1 qui permet de faire plus de choses.list([z1 z2].4) xtitle("Helice avec perles") Comme pour plot2d on est oblig´ de l’appeler plusieurs fois si les diff´rentes courbes ` afficher n’ont e e a pas le mˆme nombre de points. y1 = sin(t) .

18 – Courbe et points dans l’espace.5) // du rouge avec la carte par defaut param3d1(P2(:. fchamp. fplot3d. champ qui permet de dessiner un champ de vecteurs en 2D . finalement de nombreuses fonctions graphiques ´voqu´es dans ce chapitre admettent des variantes e e permettant de faire des graphes de fonctions plus directement si on fournit une fonction scilab comme argument (le nom de ces fonctions commence par un f fplot2d.. grayplot et Sgrayplot qui permettent de repr´senter les valeurs d’une telle fonction en utilisant e des couleurs .list(P1(:..P2(:.1)....P1(:.Fig. flag=[0 0]) // -5 pour des triangles inverses // [0 0] : echelle fix´e et cadre dessin´ avec l’appel pr´c´dent e e e e xset("color". flag=[3 4]. 4.. y) d´finie sur un rectangle ..") xselect() 4. -5).1) // pour remettre le noir comme couleur courante xtitle("Des points.3). 4. fcontour2d. ebox=ebox) // flag=[3 4] : 3 -> echelle iso se basant sur ebox // 4 -> boite + graduation // pour le deuxieme groupe xset("color". contour2d et contour qui permettent de dessiner des lignes isovaleurs d’une fonction z = f (x. 5.1). theta=30. e 2. leg="x@y@z". 86 . alpha=60. fec joue le mˆme rˆle que les deux pr´c´dentes pour une fonction qui est d´finie sur une triangulation e o e e e plane ... xbasc() // premier groupe de points xset("color".2).13 Divers : NOT YET UPDATED Il existe encore beaucoup de primitives graphiques dont : 1.2) // du bleu avec la carte par defaut param3d1(P1(:. -9).2).).3). fplot3d1. 3..list(P2(:.

d’autre part il ´tait impossible de modifier e e e e les propri´t´s des graphiques une fois qu’ils ´taient affich´s. il restait toujours de nombreux bogues. peu d´crit dans la documentation en ligne.). il ´tait possible de faire un certain nombre de choses avec le graphique de e scilab mais cela pouvait se r´v´ler parfois compliqu´ . les utilisateurs ne sont pas e e pr´cipit´s pour le tester de mani`re intensive.7 (l’ancien graphique restant le standard) ...0 cette situation s’est am´lior´e mais. les possibilit´s 3d et les d´grad´s de couleurs sont toujours aussi limit´s et je ne parle e e e e 22 .25 s avec l’ancien e sur ma machine. voire d’antialiasing.. etc.0..4.14 quelques remarques sur le graphique scilab – Avant la version 3. comme ce nouveau graphique ´tait peu compatible e avec l’ancien. par exemple afficher 40000 carr´s avec l’instruction xfpolys prend 1 s en nouveau graphique et 0. – Avec les versions 3. ni de transparence de surfaces. ee e e – Ainsi (depuis pas mal d’ann´es) un projet de nouveau graphique a ´t´ mis en route pour essayer de e ee pallier ` ces d´fauts.1 puis 4. soit un facteur de 4 22 87 . ce projet se concr´tisant avec une version b´ta qui a pu ˆtre utilis´ dans scilaba e e e e e 2. mˆme pas d’acc´l´ration mat´rielle e ee e dans beaucoup de cas il semble mˆme que le nouveau graphique n’utilise pas les primitives 2d sous-jacentes de mani`re e e optimale.0 le nouveau graphique est devenu le standard (l’ancien pouvant ˆtre e heureusement toujours utilis´) et malgr´ des progr`s. e e e – Lors de la sortie de scilab-3. assez bogu´. une e e e documentation insuffisante...1. on ne peut toujours pas dire e e que le graphique scilab soit ` la hauteur de ce que nombre d’utilisateurs attendaient (toujours pas a de true color.

e 5.4) f(1) = u(2) f(2) = 0. u) u(t0 ) = u0 o` u(t) est un vecteur de Rn . e a 5.4*(1 . On suppose les conditions u remplies pour qu’il y ait existence et unicit´ de la solution jusqu’` un temps T .Chapitre 5 Applications et compl´ments : NOT e YET UPDATED FOR GRAPHICS Ce chapitre se propose de vous montrer comment r´soudre certains probl`mes types d’analyse num´rique e e e avec Scilab (en fait uniquement des ´quations diff´rentielles actuellement. il faut quand mˆme mettre t comme premier argument de la e e e fonction second membre.1 ´ Equations diff´rentielles e Scilab dispose d’une interface tr`s puissante pour r´soudre num´riquement (de mani`re approch´e) e e e e e des ´quations diff´rentielles avec la primitive ode.u) // second membre pour Van der Pol (c = 0. endfunction Rmq : Mˆme si l’´quation est autonome.u) // ici le code donnant les composantes de f en fonction de t et des composantes de u.1 Utilisation basique de ode Dans son fonctionnement le plus basique elle est tr`s simple ` utiliser : il faut ´crire le second membre e a e f comme une fonction Scilab avec la syntaxe suivante : function [f] = MonSecondMembre(t.u(1)^2)*u(2) . Par exemple voici un code possible pour le second membre de l’´quation de e Van der Pol : y = c(1 − y 2 )y − y et que l’on reformule comme un syst`me de deux ´quations diff´rentielles du premier ordre en posant e e e u1 (t) = y(t) et u2 (t) = y (t) : d dt u1 (t) u2 (t) = u2 (t) c(1 − u2 (t))u2 (t) − u1 (t) 1 function [f] = VanDerPol(t..) et apporte des compl´ments e e e pour pouvoir ´crire des petites simulations stochastiques. et u0 ∈ Rn .. Soit donc une ´quation diff´rentielle avec une condition e e e e initiale : u = f (t. f une fonction de R × Rn −→ Rn .1.u(1) endfunction 88 .

Pour s´lectionner a e une m´thode particuli`re."000") 5.x.. 2. Par d´faut (c-a-d sans e e e e s´lection explicite d’une des m´thodes) on a cependant une strat´gie intelligente puisque ode utilise e e e initialement une m´thode d’Adams pr´dicteur/correcteur mais est capable de changer cet algorithme par e e une m´thode de Gear dans le cas o` il d´tecte l’´quation comme « raide1 ». e e e // 1/ trace du champs de vecteur issu de l’equation de Van der Pol n = 30.delta.n). e u e e Voici un exemple complet pour Van der Pol.x) xselect() // 2/ resolution de l’equation differentielle m = 500 . D’autre part derri`re ode il y e e e e a plusieurs algorithmes possibles.m). VanDerPol). t(2).m). Scilab se met alors ` attendre un « ´v´nement graphique » du type « clic souris ».. // les instants pour lesquels on recupere la solution u0 = [-2. le pointeur ´tant positionn´ e e e sur la condition initiale voulue. et.:)’. delta = 5 x = linspace(-delta. Cette possibilit´ graphique s’obtient avec la primitive xclick dont la e syntaxe simplifi´e est : e [c_i.. t. Celle-ci e e a e peut se r´gler avec d’autres param`tres (qui ont des valeurs par d´faut). en partant de u0 (un vecteur colonne). .c_x.:)’.1. t(m) = T .T. prendra l’allure suivante : e e t = linspace(t0. Apr`s l’affichage du champ de vecteur. Comme dans ce cas l’espace des phases est un plan. D’autre part e e on va utiliser une ´chelle isom´trique pour les dessins. // la condition initiale [u] = ode(u0. chaque e e e condition initiale sera donn´e par un clic du bouton gauche de la souris2 .t.5 .t. [U] = ode(u0.Puis un appel a ode pour r´soudre l’´quation (l’int´grer) de t0 ` T .2. // ici y = x xbasc() fchamp(VanDerPol. Rmq : le nombre de composantes que l’on prend pour t e ui (t(j)) (la i a (les instants pour lesquels on r´cup`re la solution).T. lorsque cet ´v´nement a e e e e a lieu. t = linspace(0.x. a donnant les points de la grille sur lesquels seront dessin´s les fl`ches repr´sentant le champ de vecteur.y) o` MonSecondMembre est le nom de la fonction Scilab du second membre de l’´quation diff´rentielle... par exemple 0) et x et y sont des vecteurs lignes ` nx et ny composantes.t0. on peut d´j` obtenir une id´e de la dynamique en dessinant simplement le champ de vecteur dans un ea e rectangle [xmin . t est u e e l’instant pour lequel on veut dessiner le champ (dans le cas le plus courant d’une ´quation autonome on e met une valeur sans signification.. plot2d(u(1. il faut rajouter un param`tre dans l’appel (cf le Help). T = 30 . 2 comme sugg´r´ dans l’un des articles sur Scilab paru dans « Linux Magazine » e e 89 .5]. n’a rien ` voir avec la pr´cision du calcul. ymax ] avec l’instruction graphique fchamp dont la syntaxe est : fchamp(MonSecondMembre..0. e e e a et en voulant r´cup´rer la solution aux instants t(1) = t0 . on r´cup`re la position du pointeur (dans l’´chelle courante) avec c x et c y ainsi que le num´ro e e e e du bouton avec : 1 pour faire bref on dit qu’une ´quation diff´rentielle est « raide » si celle-ci s’int´gre difficilement avec les m´thodes (plus e e e e ou moins) explicites.j) est la solution approch´e de e e e `me composante ` l’instant t(j)).MonSecondMembre) On r´cup`re alors une « matrice » U de format (n. 0.u(2. xmax ] × [ymin . qui permettent de s’adapter ` diverses situations.c_y]=xclick().2 Van der Pol one more time Dans cette partie nous allons exploiter une possibilit´ graphique de Scilab pour obtenir autant de e trajectoires voulues sans refaire tourner le script pr´c´dent avec une autre valeur de u0 . m) telle que U(i.

e e // 1/ trace du champs de vecteur issu de l’equation de Van der Pol n = 30. ce point stationnaire change de nature (de stable il devient e a instable avec pour = 0 un ph´nom`ne de bifurcation de Hopf).x. strf="000") // un petit o pour marquer la C. On s’int´resse aux trajectoires avec des e e e conditions initiales voisines de ce point. y = linspace(-delta_y. delta_x = 6 delta_y = 4 x = linspace(-delta_x.length(couleurs)). t.I. Lorsque le param`tre passe d’une valeur e strictement n´gative ` une valeur positive.c_y]=xclick().valeur pour c i 0 1 2 bouton gauche milieu droit Dans le script. Voici la fonction calculant ce second membre : 90 . (5 + )/2). style=-9.u(2. if c_i == 0 then plot2d(c_x. j’utilise un plan de phase « rectangulaire ».m). num = modulo(num+1. 0. j’utilise un clic sur le bouton droit pour sortir de la boucle des ´v´nements. strf="000") elseif c_i == 2 then break end end 5. xbasc() fchamp(VanDerPol.y.:)’.:)’. T = 30 .0. strf="041") xselect() // 2/ resolution de l’equation differentielle m = 500 .n). et pour exploiter la totalit´ de la e fenˆtre graphique. nous allons utiliser la primitive ode avec un second membre qui admet e un param`tre suppl´mentaire et nous allons fixer nous mˆme les tol´rances pour la gestion du pas de e e e e temps du solveur. style=couleurs(num+1). VanDerPol).n).delta_x. e e Enfin. plot2d(u(1.c_x. on proc`de ` quelques fioritures de sorte ` changer de couleur pour chaque trajectoire (le tableau e a a couleur me permet de s´lectionner celles qui m’int´ressent dans la colormap standard. c_y.1) : toutes les trajectoires convergent vers une orbite p´riodique ce qui est bien le comportement e th´orique attendu pour cette ´quation. Derni`re fioritures : e e e je dessine un petit rond pour bien marquer chaque condition initiale. [u] = ode(u0.T. Voici notre nouvelle ´quation diff´rentielle (Le Brusselator) : e e du1 dt du2 dt = 2 − (6 + )u1 + u2 x2 1 = (5 + )u1 − u2 u2 1 qui admet comme seul point critique Pstat = (2.c_y]. Derni`re remarque : lorsque le champ de e e vecteur apparaˆ vous pouvez maximiser la fenˆtre graphique ! En cliquant plusieurs fois j’ai obtenu la ıt e figure (5. t = linspace(0.delta_y. couleurs = [21 2 3 4 5 6 19 28 32 9 13 22 18 21 12 30 27] // 17 couleurs num = -1 while %t [c_i. u0 = [c_x.3 Un peu plus d’ode Dans ce deuxi`me exemple. Pour obtenir une e e ´chelle isom´trique on utilise fchamp en rajoutant un argument optionnel comme pour plot2d (il faut e e utiliser strf=val strf car les param`tres frameflag et axesflag ne sont pas support´s).1.

1 – Quelques trajectoires dans le plan de phase pour l’´quation de Van der Pol e function [f] = Brusselator(t.54 -3.24 -6..6 -2.4 3. 5.2 0.t. e e juste avant le nom de la fonction second membre (ou de la liste form´e par celui-ci et des param`tres e e ` chaque pas de temps.6 4. tk−1 → tk = tk−1 + ∆tk .8 -3. on remplace dans l’appel ` ode le nom de la fonction e e a (ici Brusselator) par une liste constitu´e du nom de la fonction et du ou des param`tres suppl´mentaires : e e e [x] = ode(x0.0 Ο Ο Ο Ο Ο Ο Ο Ο Ο Ο Fig.2 2.4. le solveur calcule suppl´mentaires de la fonction).(6+eps)*u(1) + u(1)^2*u(2) f(2) = (5+eps)*u(1) .39 2.list(Brusselator. par2. par1. eps)) et l’on proc`de de mˆme pour tracer le champ avec fchamp.85 -1.u. 1 ≤ i ≤ n dans le cas o` l’on donne deux vecteurs de longueur n pour ces param`tres et : u e toli = rtol ∗ |Ui (tk )| + atol.0 1. e e Pour fixer les tol´rances sur l’erreur locale du solveur on rajoute les param`tres rtol et atol.85 0.t. A e une estimation de l’erreur locale e (c-a-d l’erreur sur ce pas de temps en partant de la condition initiale v(tk−1 ) = U (tk−1 )) : tk e(tk ) U (tk ) − tk−1 f (t.4 -1. v(t))dt + U (tk−1 ) (le deuxi`me terme ´tant la solution exacte partant de la solution num´rique U (tk−1 ) obtenue au pas e e e pr´c´dent) et compare cette erreur ` la tol´rance form´e par les deux param`tres rtol et atol : e e a e e e toli = rtoli ∗ |Ui (tk )| + atoli .0 -4.24 3.u(1)^2*u(2) endfunction Pour faire « passer » le param`tre suppl´mentaire. .70 -2.39 -4.list(MonSecondMembre.70 0.)) Dans notre cas : [x] = ode(x0.t0.eps) // f(1) = 2 . 1 ≤ i ≤ n 91 Ο Ο Ο Ο Ο Ο Ο Ο Ο Ο .t0.54 1.8 6..00 -0.

y_max = P_stat(2) + delta_y.eps)). delta_y = 4. style=couleurs(num+1).y. la seule fioriture suppl´mentaire est un marquage du point critique avec un e petit carr´ noir que j’obtiens avec la primitive graphique xfrect : e // Brusselator eps = -4 P_stat = [2 . le pas est accept´ et le solveur e calcule le nouveau pas de temps de sorte que le crit`re sur la future erreur ait une certaine chance de e se r´aliser. strf="000") elseif c_i == 2 then break end end 5. en plus du pas de temps Comme les m´thodes mise en jeu sont des m´thodes « multipas e e variable. y_min = P_stat(2) . strf="000") // un petit o pour marquer la C. on r´int`gre ` partir de tk−1 avec un nouveau pas de temps plus petit e e e a (calcul´ de sorte que le prochain test sur l’erreur locale soit aussi satisfait avec une forte probabilit´). e 92 .I..delta_x. rtol.u(2. couleurs = [21 2 3 4 5 6 19 28 32 9 13 22 18 21 12 30 27] num = -1 while %t [c_i.delta_y. x_max = P_stat(1) + delta_x. if c_i == 0 then plot2d(c_x. Cette fonction a e a utilise le g´n´rateur congruentiel lin´aire suivant4 : e e e   m = 231 a = 843314861 Xn+1 = f (Xn ) = (aXn + c) mod m. Par d´faut e e les valeurs utilis´es sont rtol = 10−5 et atol = 10−7 (sauf lorsque type selectionne une m´thode de Runge e e Kutta).1 G´n´ration de nombres al´atoires e e e La fonction rand Jusqu’` pr´sent elle nous a essentiellement servi ` remplir nos matrices et vecteurs.eps). o` u  c = 453816693 3 4 du moins par d´faut ou lorsque l’on choisit type = adams ou stiff e D’apr`s ce que j’ai cru comprendre en regardant le code source.si on donne deux scalaires.:)’. n ≥ 0.. T = 5 .x.0. y = linspace(y_min. style=-9. joue aussi avec l’ordre de la formule pour obtenir une bonne efficacit´ informatique.T.08. x_min = P_stat(1) .16.2. rtol = 1.c_x. n = 20. u0 = [c_x.16) // pour marquer le point critique xselect() // 2/ resolution de l’equation differentielle m = 500 . e e e Voici un script possible. atol = 1.d-10.d-09.. // 1/ trace du champ de vecteurs xbasc() fchamp(list(Brusselator. x = linspace(x_min. atol. t. (5+eps)/2]. num = modulo(num+1.P_stat(2)+0. 0.c_y]=xclick(). // tolerances pour le solveur t = linspace(0.m)... list(Brusselator. plot2d(u(1. Dans le cas contraire.08. c_y..:)’. n).c_y]. e e 3 » le solveur.0. // limites pour le trace du champ de vecteur delta_x = 6. y_max. n). Si |ei (tk )| ≤ toli pour chaque composante.length(couleurs)).2 5. x_max. strf="041") xfrect(P_stat(1)-0.0. [u] = ode(u0. Remarque importante : le solveur peut tr´s bien ´chouer dans l’int´gration.

l’heure du jour (0-23). e – et le neuvi`me. e – le huiti`me.74 -4.35 0.0 3.2 4.74 3. m − 1].4 0.6 6. 1[. e Pour obtenir un germe on peut par exemple additionner ces nombres entre-eux. Scilab e a e poss`de une fonction getdate qui fournit un vecteur de 9 entiers (voir le d´tail avec le Help). Le terme initial de la suite est souvent appel´ le germe et celui par d´faut est X0 = 0. les secondes (0-61 ?).8 8.) Notons e u e a que tous les g´n´rateurs de nombres al´atoires sur ordinateur sont des suites parfaitement d´terministes e e e e qui « apparaissent » comme al´atoires (pour les bons g´n´rateurs) selon un certain nombre de tests e e e statistiques. 5.0 -2. on divise les entiers a e obtenus par m (et l’on obtient un g´n´rateur de nombres r´els qui semblent suivre une loi uniforme sur e e e [0.89 3.2113249 Il est cependant possible de changer le germe ` tout moment avec l’instruction : a rand("seed". Parmi ces e e 9 entiers : – le deuxi`me donne le mois (1-12).germe) o` germe est un entier compris dans l’intervalle (entier) [0.50 -0.04 2.4.0 Ο Ο Ο Ο Ο Ο Ο Ο Ο Ο Fig. e – le septi`me. ce qui donne : v = getdate() rand("seed". sum(v([2 6 7 8 9]))) Noter aussi que l’on peut r´cup´rer le germe courant avec : e e germe = rand("seed") 93 Ο Ο Ο Ο Ο Ο Ο Ο Ο . les minutes (0-59). le jour du mois (1-31). Souvent on ressent le besoin d’initialiser u la suite en choisissant un germe plus ou moins au hasard (histoire de ne pas avoir les mˆmes nombres ` e a chaque fois) et une possibilit´ consiste ` r´cuperer la date et l’heure et de fabriquer le germe avec. Pour se ramener ` des nombres r´els compris dans l’intervalle [0.20 1.8 2. e – le sizi`me. m−1]. Ainsi e e le premier appel ` rand (le premier coefficient obtenu si on r´cup`re une matrice ou un vecteur) est a e e toujours : u1 = 453816693/231 ≈ 0.04 -2.2 – Quelques trajectoires dans le plan de phase pour le Brusselator ( = −4) Sa p´riode est bien sˆr ´gale ` m (ceci signifie que f est une permutation cyclique sur [0.89 -3.20 -2.4 5.35 -1.8 -1.6 -0. 1[).

loi). u = rand() fournit un seul nombre al´atoire. Quelques petites applications avec rand ` A partir de la loi uniforme.m. une loi uniforme sur les entiers de l’intervalle [n1 . on peut rajouter un argument suppl´mentaire pour imposer aussi la e e e loi : A = rand(n. o` loi est l’une des deux chaˆ u ınes de caract`res "normal" e ou "uniform".loi). n2 ] : X = floor(n1 + (n2+1-n1)*rand(n. e e e o 7 cette fonction est peu efficace pour p petit. A = rand(n. Voici une petite si vous utilisez ces petits trucs fonction pour simuler la loi g´om´trique (nombre d’´preuves de Bernouilli n´cessaires pour obtenir un e e e e succ`s)7 : e 5 6 mais peu efficace pour N grand ! d’une mani`re g´n´rale on utilisera plutˆt la fonction grand permet d’obtenir la plupart des lois classiques. On peut d’ailleurs e r´cup´rer la loi actuelle avec : e e loi=rand("info") // loi est l’une des deux cha^nes "uniform" ou "normal" ı Rappelons que rand peut s’utiliser de plusieurs fa¸ons : c 1.m) de nombres selon : 1. b] : X = a + (b-a)*rand(n. e 2. il est simple d’obtenir une matrice (n. on peut obtenir d’autres lois et rand fournit aussi une interface qui permet d’obtenir la loi normale (de moyenne 0 et de variance 1). Comme les it´rations e a e sont lentes en Scilab. e Pour simuler une ´preuve de Bernouilli avec probabilit´ de succ`s p : e e e succes = rand() < p ce qui nous conduit ` une m´thode simple5 pour simuler une loi binomiale B(N. si B est une matrice d´j` d´finie de dimensions (n.N) < p)) (bool2s transforme les succ`s en 1 et il ne reste plus qu’` les additionner avec sum).m) de nombres al´atoires . e e e 3.m) 2. enfin. il est plus clair de les coder comme des fonctions Scilab. on peut obtenir directement un vecteur (colonne) contenant m r´alisations de cette e loi avec : X = sum(bool2s(rand(m. e Pour les deux premi`res m´thodes."c") mais on aura int´rˆt ` utiliser la fonction grand qui utilise une m´thode plus performante. D’autre part ee a e 6 . n2 + 1[ et on prend la partie e e enti`re). 94 . p) : a e X = sum(bool2s(rand(1.` A partir de la loi uniforme sur [0.N) < p). Pour passer de l’une ` l’autre. une loi uniforme sur [a.m)) (on tire des r´els suivants une loi uniforme sur l’intervalle r´el [n1 . 1[. A = rand(B. on a proc`de de la fa¸on suivante : e c rand("normal") // pour obtenir la loi normale rand("uniform") // pour revenir a la loi uniforme Par d´faut le g´n´rateur fournit une loi uniforme mais il est judicieux dans toute simulation de s’assurer e e e que rand donne bien ce que l’on d´sire en utilisant l’une de ces deux instructions.m) remplit la matrice A (n. m) alors A = rand(B) permet d’obtenir la mˆme ea e e chose (ce qui permet d’´viter de r´cup´rer les dimensions de B) .

m.b) 5.lambda) 9. grand s’utilise presque de la mˆme mani`re que rand. p2. pour la loi de Poisson de moyenne µ : X = grand(n.1. pour la loi normale de moyenne µ et d’´cart type σ : e X = grand(n.147 109 ) est peut ˆtre un peu juste.1.1."uin". on obtient la loi Normale N (µ.loi. une loi uniforme sur les entiers d’un grand intervalle [0. m[ : X = grand(n.2. p2."unf". pour la loi uniforme sur [0.m) // pour obtenir une matrice (n.1.1."normal") 5."geom". [p1. celle-ci ´tant suivie de ses param`tres ´ventuels.p) 6..1. .1. k2 ] : X = grand(n.1. u ıne e e e e e Quelques exemples (pour obtenir un ´chantillon de n r´alisations.mu. pour la loi g´om´trique G(p) : e e X = grand(n. [p1. une loi uniforme sur les entiers de l’intervalle [k1 . pour la loi binomiale B(N. ` partir de la loi Normale N (0."lgi") o` m d´pend du g´n´rateur de base (par d´faut m = 232 (voir plus loin)) .2 La fonction grand Pour des simulations lourdes qui utilisent beaucoup de nombres al´atoires la fonction standard rand e avec sa p´riode de 231 ( 2.a.function [X] = G(p) // loi geometrique X = 1 while rand() > p // echec X = X+1 end endfunction Enfin.mu) 8."exp". sous la forme d’un vecteur colonne) : e e 1.1. 3."def") 4. 1[ : X = grand(n.]) o` loi est une chaˆ de caract`res pr´cisant la loi.p) 7.k2) (il faut que k2 − k1 ≤ 2147483561 mais dans le cas contraire ce probl`me est signal´ par un message e e d’erreur) . e e c-a-d que l’on peut utiliser l’une des deux syntaxes suivantes (pour la deuxi`me il faut ´videmment que e e la matrice A soit d´finie au moment de l’appel) : e grand(n.N. b[ : X = grand(n."poi".."bin".]) grand(A. . σ 2 ) (moyenne µ et ´cart type a e σ) avec : rand("normal") X = mu + sigma*rand(n. pour la loi exponentielle de moyenne λ : X = grand(n.k1.loi. Il est alors pr´f´rable d’utiliser grand qui e e ee permet aussi de simuler toutes les lois classiques.m) de tels nombres // ou encore en une seule instruction : X = mu + sigma*rand(n. u e e e e 2.m..."nor".sigma) 95 . pour la loi uniforme sur [a. 1). p) : X = grand(n.

"clcg4". Si vous voulez refaire exactement la mˆme a e simulation il faut connaˆ ıtre l’´tat initial (avant la simulation) du g´n´rateur utilis´ et le sauvegarder e e e e d’une fa¸on ou d’une autre. et "urand". // retour ` l’´tat initial a e X = grand(10.P.mu. [mu]=cdfnor("Mean". son inverse en 1 ou plusieurs points . ce dernier ´tant simplement le g´n´rateur de rand. e e Pour op´rer sur ces g´n´rateurs de base. e 2.1. et finalement [sigma]=cdfnor("Std". la fonction qui nous int´resse s’appelle cdfnor et la syntaxe est alors : e 1. s1 == s3 // s1 doit etre egal a s3 5. grand est muni de diff´rents g´n´rateurs de base (qui fournissent des entiers e e e selon la loi lgi).Q]=cdfnor("PQ".sigma.e1.1.e(2).e(4)).. toutes ces fonca tions commencent par les lettres cdf.e(2).sigma..1. [X]=cdfnor("X".e(3).. 3. X.e2. e e Remarques : – le fait de travailler ` la fois avec p et q = 1 − p permet d’obtenir de la pr´cision dans les zones o` p a e u est proche de 0 ou de 1. e e 3.) permet de r´cup´rer le (nom du) g´n´rateur courant e e e e le g´n´rateur nom gen devient le g´n´rateur courant e e e e permet de r´cup´rer l’´tat interne du g´n´rateur courant e e e e e impose l’´tat interne du g´n´rateur courant e e e La dimension de l’´tat interne de chaque g´n´rateur d´pend du type du g´n´rateur : de un entier pour e e e e e e urand ` 624 entiers plus un index pour Mersenne Twister9 . e e e Dans le Help.. Exemple : c grand("setgen". // de nouveau 10 nombres s3 = sum(X).e(1).Q) pour obtenir X = Fµ. // 10 nombres s1 = sum(X). // voila c’est fait ! grand("getsd") // doit retourner le vecteur e X = grand(10.mu."def"). e Ces deux derni`res syntaxes fonctionnant aussi si les arguments sont des vecteurs de mˆme taille.3 Les fonctions de r´partition classiques et leurs inverses e Ces fonctions sont souvent utiles pour les tests statistiques (χ2 . e e e une proc´dure d’initialisation avec un seul entier existe n´anmoins pour ce g´n´rateur..σi (Xi ) . ». σ 2 ).P. s1 == s2 // en g´n´ral s1 sera different de s2 e e grand("setsd". F (x)) .X. [P.."kiss") e = [1 2 3 4]. vous les trouverez ` la rubrique « Cumulative Distribution Functions. // kiss devient le g´n´rateur courant e e // etat que je vais imposer pour kiss // (il lui faut 4 entiers) grand("setsd"."kiss".P. Depuis la version 2.σi (Pi ) . X = grand(10. vous pouvez utiliser les instructions suivantes : e e e nom gen = grand("getgen") grand("setgen".) car elles permettent de calculer. "clcg2".σ (P ) (de mˆme que pr´c´demment les are e e −1 guments peuvent ˆtre des vecteurs de mˆme taille et l’on obtient alors Xi = Fµi .nom gen) etat = grand("getsd") grand("setsd". l’un des param`tres de la loi.mu) pour obtenir l’´cart type.σ (X) et Q = 1−P .e(3). // encore 10 nombres s2 = sum(X)."def"). Par d´faut grand utilise Mersenne Twister qui poss`de une p´riode gigantesque de 219937 e e e et il y a en tout 6 g´n´rateurs8 . e e −1 2. 4. .sigma) pour obtenir P = Fµ. ´tant donn´s les autres et un couple (x. "fsultra".X."def").Q. mu et sigma peuvent ˆtre des vecteurs (de mˆme taille) et l’on obtient alors pour P et Q des vecteurs avec Pi = Fµi .7. Lorsque p est proche de 0 la fonction travaille en interne avec p mais avec lorsque p est proche de 1 la fonction travaille en interne avec q .Q.e(1).X) pour obtenir la moyenne . la fonction de r´partition en 1 ou plusieurs points .Il y en a d’autres (cf la page d’aide). r soit : 1. 8 9 "mt" .e(4)). e e e e 96 . Prenons par exemple la loi normale N (µ.

. xm ) dont les composantes sont consid´r´es comme les r´alisations de variables al´atoires ind´pendantes et de ee e e e mˆme loi X1 . ` d´terminer son ou ses param`tres. ` e u e par exemple pour ´tudier le comportement de certains syst`mes a des entr´es (ou des perturbations) al´atoires ou mˆme pour e e ` e e e r´soudre des probl`mes purement d´terministes mais pour lesquels les m´thodes d’analyse num´rique sont trop compliqu´es e e e e e e ou impossible a mettre en oeuvre.1) (−a) = 2FN (0. la loi des grands nombres nous dit que e ¯ e ¯ Xm « converge » vers E[X] et le T..1 Simulations stochastiques simples Introduction et notations Souvent une simulation va consister en premier lieu. e ` a u 97 . Si m est suffisamment grand.1) (a) − 1 = 1 − α 10 en fait en statistique l’´chantillon est la plupart du temps obtenu a partir de mesures physiques (temp´rature. un th´or`me e e a e e e (lgn. de sondages. 5. ` 11 pour certaines lois on a des crit`res d’application. . biom´triques (tailles.... certains logiciels (comme R) proposent de tels jeux de donn´es (pour que les ´tudiants puissent se faire la e e e main !) mais pas scilab a l’heure actuelle .. Dans la e e e e e pratique le vecteur xm s’obtient directement ou indirectement ` partir des fonctions rand ou grand10 .. qui suivent e effectivement la loi en question.4. etc. pression. poids).. etc.. on aimerait connaˆ un intervalle Ic (souvent centr´ en xm ) pour affirmer que : ıtre e ¯ E[X] ∈ Ic avec probabilit´ de 1 − α e o` souvent α = 0.. par exemple si X ∼ Ber(p) alors l’approximation par la limite est e suffisamment pr´cise (pour ce que l’on cherche a en faire) ` partir du moment o` min(mp... e 5.4 5. ou encore si les param`tres sont connus. Si on pose : e 1 ¯ Xm = m m Xi i=1 la variable al´atoire moyenne (dont xm est une r´alisation)...). e ` e .1) (a) − FN (0. ` obtenir un vecteur : a xm = (x1 . alors.05 ou 0. les donn´es obtenues ´tant stock´es dans des fichiers (ou dans des bases e e e e de donn´es) .C.a. TCL. l’´cart type.L. m(1 − p)) > 10..).).4. ` v´rifier a e e e a e via un ou des tests statistiques que notre ´chantillon est (probablement) bien issu de v.... Xm (on notera X une variable al´atoire g´n´rique suivant la mˆme loi).. Pour les cas qui nous int´ressent (cas d’´cole) on connaˆ la plupart e e ıt du temps les r´sultats th´oriques exacts et la simulation sert en fait ` illustrer un r´sultat. le fonctionnement d’une m´thode ou d’un algorithme.C..2 Intervalles de confiance Une fois l’esp´rance empirique obtenue ` partir de notre ´chantillon (en scilab avec x bar m = e a e mean(xm)).– la chaˆ de caract`res permettant d’obtenir la fonction inverse n’est pas toujours "X". on peut approcher cette probabilit´ en consid´rant e e e la limite « atteinte11 » : √ b ¯ m(Xm − E[X]) 1 2 ≤ b) ≈ √ e−t /2 dt P (a < σ 2π a Si l’on cherche un intervalle de confiance “sym´trique” : e 1 √ 2π a −a e−t 2 /2 dt = FN (0. .L. etc. nous dit que : √ b ¯ m(Xm − E[X]) 1 2 lim P (a < ≤ b) = √ e−t /2 dt m→+∞ σ 2π a (on a pos´ V ar[X] = σ 2 ).. a m on cherche ` approcher les caract´ristiques de la loi sous-jacente comme A partir de l’´chantillon x e a e l’esp´rance. la fonction de r´partition (ou la densit´) ou.. voyez les ıne e pages d’aide correspondantes. X2 . si on emet une hypoth`se sur la e e e e e loi en question.01 (intervalles de confiance ` respectivement 95 % et 99 %).. n´anmoins les cas o` on utilise de telles simulations sont quand mˆme nombreux.. L’outil de base u a pour d´river de tels intervalles est le T. . (sous certaines conditions.

on a aα 1. alpha/2) On obtient donc finalement12 : aα σ aα σ E[X] ∈ [¯m − √ .. si les Xi suivent la loi normale N (µ. e Le probl`me est que l’on ne connaˆ g´n´ralement pas l’´cart type.) on e peut se passer de l’approximation de l’´cart type et l’intervalle s’obtient alors en r´solvant une e e in´quation.). ou encore l’estimation donn´e par : e Sm = 1 m−1 m ¯ (Xi − Xm )2 i=1 En rempla¸ant l’´cart type σ par sm (o` sm est la r´alisation de Sm ).. Poisson. ` voir la page d’aide correspondante : en fait les fonctions cdf n’ont pas une syntaxe tr`s r´guliere et "X" n’est pas toujours e e l’indicateur permettant d’obtenir la fonction de r´partition inverse.. σ 2 ) alors : ¯ √ Xm − µ m ∼ t(m − 1) Sm o` t(k) est la loi de Student ` k degr´s de libert´. on obtient alors un intervalle de c e u e confiance que l’on qualifie lui aussi d’empirique. L’algorithme standard de tri de Scilab est la fonction sort qui trie dans l’ordre d´croissant14 . exponentielle.. 0. e 5. Il existe cependant des cas particuliers : 1.. On utilise alors soit une majoe ıt e e e ration. xm + √ ] avec probabilit´ 1 − α x ¯ e m m u o` sm est l’´cart type empirique de l’´chantillon (sm = st deviation(xm) en scilab) et o` le aα u e e est calcul´ ` partir de la loi de Student (au lieu de la loi N (0.4.1) (1 − α α −1 ) ou encore − FN (0. ici c’est"T" ! e 14 voir aussi la fonction gsort qui permet de faire plus de choses 13 12 98 . 1)) : ea −1 aα = Ft(m−1) (1 − α ) 2 ce qui s’obtient en scilab13 par : a_alpha = cdft("T". 1-alpha/2.3 Dessiner une fonction de r´partition empirique e La fonction de r´partition de X est la fonction : e F (x) = Probabilit´ que X ≤ x e La fonction de r´partition empirique d´finie ` partir de l’´chantillon xm est d´finie par : e e a e e Fxm (x) = card{xi <= x}/m C’est une fonction en escalier qui se calcule facilement si on trie le vecteur xm dans l’ordre croissant (on a alors Fxm (x) = i/m pour xi ≤ x < xi+1 ). on utilise : e Pour un intervalle a 95%.96 que l’on approche souvent par 2.. alpha/2) 2. Dans ce cas. lorsque la variance s’exprime en fonction de l’esp´rance (Bernouilli.alors : −1 aα = FN (0. Pour trier le vecteur xm dans l’ordre croissant. m-1. les diverses approximations u a e e pr´c´dentes n’existent plus (approximation par la limite et approximation de l’´cart type) et on e e e obtient alors : aα sm aα sm µ ∈ [¯m − √ . 1-alpha/2.. xm + √ ] x ¯ m m avec probabilit´ 1 − α environ (si l’approximation par la limite est correcte.1) ( ) 2 2 ce qui s’´crit en scilab : e a_alpha = cdfnor("X". 1.

Voici un code possible : function repartition_empirique(xm) // trac´ de la fonction de repartition (empirique) e // associ´e ` l’´chantillon xm e a e m = length(xm) xm = .2 0. xm = grand(m..sort(-xm) La fonction plot2d2 nous permet alors de dessiner cette fonction sans se fatiguer.1 0 −4 −3 −2 repartition empirique −1 0 1 2 3 4 Fig..0. style=2) // on rajoute la courbe sur le premier dessin xtitle("Fonctions de r´partition exacte et empirique") e qui m’a permis d’obtenir la figure (5.1. Voici maintenant un exemple avec la loi normale N (0.3 – Fonctions de r´partition exacte et empirique pour la loi normale e 5.3). 1) : m = 100. plot2d(x.9 0. y.4. ones(x)). // dessin de la fct de repartition empirique // les donnees pour tracer la fonction de repartition "exacte" x = linspace(-4.5 0.sort(-xm(:)) ym = (1:m)’/m plot2d2(xm.4 0. ym. xbasc() repartition_empirique(xm).1)..100)’.8 0. 5. Fonctions de répartition exacte et empirique 1. Et soit l’hypoth`se H : « les variables e a e al´atoires sous-jacentes (X1 .. y = cdfnor("PQ".. zeros(x). on peut sans doute calculer les statistiques ´l´mentaires (moyenne et ´cart e ee e 99 .4.4 Test du χ2 Soit donc xm = (x1 .3 0. On a envie de savoir si cette hypoth`se est r´aliste e e e ou pas. Sur cet ´chantillon. .. Xm ) suivent la loi L ».7 0."nor".0 0. xm ) notre ´chantillon ` analyser. leg="repartition empirique") endfunction comportant une petite astuce : le xm( :) permet de faire fonctionner le code mˆme si on utilise la fonction e a ` partir d’un vecteur ligne. x. .xm = .6 0.

n-1.a. . error("probl`me de comptage"). e 17 exercice : d´composer cette instruction vectorielle pour comprendre comment (et pourquoi) elle fonctionne. par exemple pour la loi U[0. m copies e e ind´pendantes de X. on donne souvent la r`gle e mpmin > 5 (pmin = mini pi ) comme condition d’application minimale de ce test . . for i=1:n occ(i) = sum(bool2s(xm == v(i))). si l’hypoth`se est bonne on s’attend a ce que oi ne soit pas trop loin de mpi . 1-alpha. ainsi vous pouvez v´rifier cette condition et ´crire un message pour pr´venir l’utilisateur si elle n’est pas satisfaite. d’o` le rejet de l’hypoth`se pour y > yα . xm )). ´tant alors positif e α Si on utilise. soit de mˆme format que occ (ici un a e e vecteur colonne vu mon choix pour occ).. 1 ≤ i ≤ n}.. donc si l’hypoth`se e ` e est fausse. on pourra utiliser la m´thode suivante : e occ = zeros(n...1] . ce mˆme proc´d´ e e e peut s’appliquer aux lois discr`tes finies pour lesquelles la condition d’application du test n’est pas e satisfaite.. on utilise n intervalles ´quidistants . on s’attend a obtenir une valeur ´lev´e pour y. a e ee e e e il faut retrancher d’autant le nombre de degr´s de libert´ pour le χ2 .1).. Xm au lieu de l’´chantillon e e x1 . end e Et pour obtenir la quantit´ y on pourra ´crire (en utilisant l’´criture vectorielle17 ) : e e e y = sum( (occ . Remarques : – l’approximation par la loi du χ2 est valable si m est suffisamment grand. En Scilab./ (m*p) ) ` la condition que p (le vecteur donnant les probabilit´s de L)... . xm on d´finit16 alors une variable al´atoire Y qui suit approximativement (pour m suffisamment e e grand) la loi du χ2 ` n − 1 degr´s de libert´.. e 15 100 ... e e 2 s’applique sur une loi discr`te prenant on peut alors mettre en oeuvre un test statistique. on peut e e construire une fonction de r´partition empirique qui doit converger lorsque (m → +∞) vers la fonction e d’un point de vue intuitif. Le test du χ e un nombre fini de valeurs.m*p). n−2 n−1 5..5 Test de Kolmogorov-Smirnov Ce test est plus naturel que celui du χ2 lorsque la loi attendue a une fonction de r´partition continue. pi ).01. le test u e e a a a 15 si y ≤ y . e e e – il est facile de regrouper ces calculs dans une fonction . X2 .. par exemple si la loi attendue e e est B(n − 1. ` e e u e 16 via la variable al´atoire vectorielle O = (O1 .. – si vous faites le test ` partir d’une loi dont certains param`tres ont ´t´ d´termin´s avec les donn´es. p) et que vous utilisiez p = xm /(n − 1) alors le seuil ` ne pas d´passer pour un test ¯ a e −1 −1 positif serait de yα = Fχ2 (1 − α) au lieu de yα = Fχ2 (1 − α).. A partir des r´alisations des Xi (disons le vecteur xm = (x1 .. . // ou encore length(find(xm==v(i))) end if sum(occ) ~= m then.^2 .. ce seuil s’obtiendra par : u y_seuil = cdfchi("X".05 o` encore α = 0.. de mˆme pour une loi discr`te prenant un e e e nombre infini de valeurs.. La valeur seuil est alors obtenue par : a e e −1 yα = Fχ2 (1 − α) n−1 avec souvent α = 0. on peut regrouper celles en queue de la distribution . Le e test consiste ` calculer la quantit´ : a e n (oi − mpi )2 y = i=1 mpi o` oi est le nombre de r´sultats xj ´gaux ` vi et ` comparer la valeur obtenue y ` un seuil yα ..type empirique) et si celles-ci semblent raisonnablement proches de l’esp´rance et de l’´cart type de L. Par exemple supposons que la loi de L est donn´e par {(vi . r´elle dont la loi a une fonction de r´partition continue F et X1 . les variables al´atoires X1 ..4. e Soit X une v. Xm . dans la formule donnant y. – pour une loi continue le test peut s’appliquer en regroupant les valeurs par intervalles. alpha) Pour calculer les occurences oi avec scilab. On ) qui suit une loi multinomiale.

la valeur obtenue pour km aura tendance e e ae ` ˆtre grande. .. si l’hypoth`se envisag´e est fausse.4.. .. Le test KS consiste justement ` mesurer un ´cart entre la fonction de r´partition e a e e exacte et la fonction de r´partition empirique (obtenue avec notre ´chantillon (x1 .05 ou 0.de r´partition exacte.01 par exemple. . . Si on remplace nos r´alisations par les variables al´atoires a a e e correspondantes. e a Urne de Polya On effectue N tirages dans l’urne de Polya.xi+1 [ 2 Fxm (x) − F (x) = i − F (xi ). et on va alors rejetter l’hypoth`se lorsque : e km > H −1 (1 − α) avec α = 0. sa loi a la fonction de r´partition suivante : a e +∞ m→+∞ lim P (Km ≤ x) = H(x) = 1 − 2 j=1 (−1)j−1 e−2j 2 x2 Comme pour le test du χ2 . Celle-ci contient au d´part r boules rouges et v boules e vertes et chaque tirage consiste ` tirer une boule au hasard et ` la remettre dans l’urne avec c boules de a a la mˆme couleur. ..xi+1 [ F (x) − Fxm (x) = F (xi+1 ) − i m les deux quantit´s suivantes se calculent facilement : e + km = − km = √ m sup −∞<x<+∞ (Fxm (x) − F (x)) = √ m max ( 1≤j≤m j − F (xj )) m j−1 ) m √ m sup −∞<x<+∞ + max(km . La th´orie e e nous dit qu’` la limite. xm ). On a obtenu les a e e r´sultats suivants : e nombre de jets nombre d’exp´riences e 1 36 2 25 3 26 4 27 5 12 6 12 7 8 8 7 9 8 10 9 ≥ 11 30 par exemple il y a 36 exp´riences o` le 1 est sorti lors du premier lanc´. Supposons ce tri e effectu´. x2 .. il est clair que km est en fait une variable al´atoire (que l’on notera Km ).6 Exercices D´ truqu´ ou non ? e e On a effectu´ 200 fois l’exp´rience suivante avec le mˆme d´ : on le jette autant de fois qu’il le faut e e e e jusqu’` obtenir un 1 (mais on arrˆte lorsque le 1 n’est pas sorti au bout de 10 lanc´s).. e Effectuer un test χ2 pour essayer de r´pondre ` la question. 5. et m sup x∈[xi . en remarquant que : e sup x∈[xi . V0 = v. On note Xk la proportion de boules vertes apr`s k tirages et Vk le nombre de boules e e vertes : v . X0 = v+r Si l’on choisit v = r = c = 1. (F (x) − Fxm (x)) = √ m max (F (xj ) − 1≤j≤m et l’on obtient alors km = − km ). Si on utilise l’approximation H(x) 1 − 2e−2x alors la valeur seuil a ` ne pas d´passer est : e 1 2 ln( ) kseuil = 2 α Le calcul de km ne pose pas de probl`me si on trie le vecteur (x1 . 25 o` le 1 est sorti au deuxi`me e u e u e lanc´. on a les r´sultats suivants : e 101 . xm )) d´fini par : e e e √ km = m sup |F (x) − Fxm (x)| −∞<x<+∞ et ` le comparer ` une valeur « admissible ». etc.

vers la loi uniforme sur [0. 2. Cette fonction renvoie alors XN et VN : function [XN.. Ecrire une fonction Scilab function [X] = pont_brownien(t. tracer la densit´ χ2 tout e e e en positionnant la valeur obtenue par le test ainsi que la valeur seuil par des traits verticaux.5 for i=1:N u = rand() // tirage d’une boule V_plus_R = V_plus_R + 1 // ca fait une boule de plus if (u <= XN) then // on a tire une boule verte : on a XN proba de // tomber sur une verte (et 1 .. . par exemple... sur un autre. On pourra utiliser la e fonction find pour rep´rer les urnes o` l’on a tir´ une boule verte. Le pont brownien Le processus stochatisque suivant (o` U d´signe la loi uniforme sur [0.1. E(XN ) = E(X0 ) = X0 = 1/2 . dans la suite on appelera cette fonction m fois avec une valeur de n assez grande18 il faut donc l’´crire sans utiliser de boucle. . +2 N +2 3.. Ecrire un script scilab mettant en place cette simulation du pont Brownien : effectuer m simulations de Xn (t) (avec n grand) et illustrer graphiquement la convergence en loi (en dessinant la fonction de r´partition empirique et en lui juxtaposant la fonction de r´partition exacte de Y (t) puis effectuer e e le test de Kolmogorov-Smirnov. 1]) : u e 1 Xn (t) = √ n est tel que pour t ∈]0.. vous allez ´crire une fonction capable de simuler m e e processus en « parall`le » (il ne s’agit pas de vrai parall´lisme informatique mais simplement e e d’exploiter le fait que les op´rations matricielles sont efficaces en Scilab). pour N → +∞.. Pour effectuer diff´rentes simulations. Essayer de r´aliser des illustrations graphiques. e e 3. e u e 2. on peut programmer une fonction prenant le param`tre N e e et qui effectue N tirages successifs. N +1 } » avec un test du χ2 . Vous allez mettre en oeuvre une simulation pour illustrer les deux premiers r´sultats. XN = 0.. On pourra placer la fonction pr´c´dente en d´but du script pour e e e travailler avec un seul fichier. e 1. Continuer votre script en testant l’hypoth`se H sur le comportement de la variable al´atoire XN e e « H : XN suit une loi uniforme sur { N 1 . Ecrire un script pour retrouver par simulation le r´sultat attendu pour l’esp´rance (avec son intere e valle de s´curit´). XN converge p. tracer les probabilit´s empiriques e e obtenues et les probabilit´s exactes sur un mˆme dessin et. e 2.. on a : e n→+∞ n (1{Ui ≤t} − t) i=1 lim Xn (t) = Y (t) ∼ N (0. 1). XN suit une loi uniforme sur { N 1 ..s.n) permettant d’obtenir une r´alisation e de Xn (t) . VN] = Urne_de_Polya(N) // simulation de N tirages d’une "Urne de Polya" : VN = 1 . V_plus_R = 2 . N +1 } . 1[ fix´. t(1 − t)) On cherche ` illustrer ce r´sultat ` l’aide de simulations. 18 pour essayer d’approcher Y (t) ! 102 . a e a Travail ` r´aliser : a e 1. +2 N +2 4.XN sur une rouge) VN = VN + 1 end XN = VN / V_plus_R // on actualise la proportion de boules vertes end endfunction mais pour effectuer des statistiques cons´quentes cette fonction va ˆtre appel´e tr´s souvent et e e e e comme les it´rations sont lentes en Scilab.

vous pouvez par exemple e tester avec n = 1000 et m = 200..Remarque : il n’est pas facile de r´gler de bonnes valeurs pour m et n : lorsque m croit il y a un moment e o` le test ´choue car il d´tecte en fait que n n’est pas assez grand (puisque la loi normale est obtenue u e e a ` la limite lorsque n → +∞). Avec t = 0. 1000.. 500. et le test fonctionne bien (il y a tr`s peu de rejet) mais e avec m = 10000 le test est presque toujours n´gatif. 103 . Si on augmente n (avec par exemple n = 10000 e mais les calculs commencent ` ˆtre un peu long sur un PC performant de 2003) alors le test redevient ae « normalement » positif.3. il faut alors r´augmenter n.

... y = zeros(K.1 D´finition d’un vecteur ou d’une matrice « coefficient par coeffie cient » Cette erreur est l’une des plus fr´quentes. par d´faut..1) et l’on ne retrouve plus ces d´fauts.1)). Scilab red´finit ea e a e e les dimensions de ces vecteurs (il ne sait pas que leur taille finale sera (K.1) . Lors de la deuxi`me ex´cution (je viens de changer le param`tre e e e e e K. e e – K > 100 on a apparemment pas de probl`mes (mis ` part le fait que la taille de vecteurs est de e a nouveau ` chaque fois diff´rente ` partir de l’it´ration 101). il va cr´er des vecteurs colonnes. ` chaque it´ration.. Par cons´quent si la nouvelle valeur de K est telle que : e – K < 100 alors nos vecteurs x et y ont toujours 100 composantes (seules les K premi`res ont ´t´ e ee modifi´es) et le dessin ne repr´sentera pas ce que l’on veut .) les vecteurs x et y sont connus et tant que k est inf´rieur ` 100 (la valeur initiale de K) il se contente e a de changer la valeur des composantes. y = zeros(K. Notre script s’´crira donc : e e K = 100 // le seul parametre de mon script x = zeros(K.Chapitre 6 B´tisier e Cette partie essaie de r´pertorier quelques erreurs fr´quentes que l’on peut commettre en Scilab. on d´finit les deux vecteurs x et y de fa¸on assez e e e c naturelle et tout semble fonctionner. Consid´rons le script suivant : e e K = 100 // le seul parametre de mon script for k=1:K x(k) = quelque chose y(k) = autre chose end plot(x.1).1). e e 6. Il y a d´j` un petit d´faut car.2 Apropos des valeurs renvoy´es par une fonction e Supposons que l’on ait programm´ une fonction Scilab qui renvoie deux arguments. Notons aussi que. for k=1:K x(k) = quelque chose y(k) = autre chose end plot(x.y) Lorsque l’on ex´cute ce script pour la premi`re fois.. par exemple : e 104 .y) 6. a e a e La bonne m´thode est de d´finir compl`tement les vecteurs x et y avec une initialisation du genre : e e e x = zeros(K.

8.x2] = resol(1.250D-08 celui-ci est mis dans la variable ans.. 1.5 Vecteurs lignes. e Cependant pour effectuer les calculs rapidement. vous avez oubli´ de recharger le fichier qui contient e e cette fonction dans Scilab avec l’instruction getf (ou exec) ! Une petite astuce : votre instruction getf (ou exec) n’est certainement pas tr`s loin dans l’historique des commandes. x2 = c/(a*x1) else x2 = (-b . Dans un contexte matriciel ils ont une signification pr´cise mais pour d’autres applications il semble e naturel de ne pas faire de diff´rence et d’adapter une fonction pour qu’elle marche dans les deux cas.. e e 6. Un moyen imparable pour ´viter ce probl`me est de pr´ciser la loi ` e e e a chaque appel (voir chapitre pr´c´dent).e-08) ans = .c) // resolution de l’equation du second degre a x^2 + b x + c = 0 // formules ameliorees pour plus de robutesse numerique // (en evitant la soustraction de 2 nombres voisins) if (a == 0) then error(" on ne traite pas le cas a=0 !") else delta = b^2 . x1 = c/(a*x2) end end end endfunction D’une mani`re g´n´rale. on utilise la syntaxe : e e e e -->[x1.8. lorsque l’on invoque une fonction ` partir de la fenˆtre Scilab de la fa¸on e e e a e c suivante : -->resol(1. 0.e-08. On peut utiliser alors la fonction o a e matrix de la fa¸on suivante : c 105 .b.4*a*c if (delta < 0) then error(" on ne traite pas le cas ou delta < 0 ") else if (b < 0) then x1 = (-b + sqrt(delta))/(2*a) . 1) avec : rand("normal")..function [x1. Si on veut de nouveau la loi uniforme il ne faut pas oublier l’instruction rand("uniform"). a 6. 0.1. 1. x1 = . plus certainement.. vecteurs colonnes.250D-08 6.3 Je viens de modifier ma fonction mais.4 Probl`me avec rand e Par d´faut rand fournit des nombres al´atoires selon la loi uniforme sur [0.1.e-08) x2 = .sqrt(delta))/(2*a) . Pour r´cup´rer les deux valeurs. seule la premi`re est affect´e dans ans. Mais ans est toute seule et comme cette fonction renvoie 2 valeurs.e-08. taper alors sur la touche ↑ e jusqu’` la retrouver. il est pr´f´rable de recourir ` des expressions matricielles ee a plutˆt qu’` des it´rations et il faut alors choisir une forme ou l’autre.x2] = resol(a. tout semble se passer comme avant la modification ! Vous avez peut ˆtre oubli´ de sauvegarder les e e modifications avec votre ´diteur ou. 1[ mais on peut obtenir la e e loi normale N (0.80000000.

6 Op´rateur de comparaison e Dans certains cas Scilab admet le symbole = comme op´rateur de comparaison : e -->2 = 1 Warning: obsolete use of = instead of == ! ans = F mais il vaut mieux toujours utiliser le symbole ==.7 Nombres Complexes et nombres r´els e Tout est fait dans Scilab pour traiter de la mˆme mani`re les r´els et les complexes ! Ceci est assez e e e pratique mais peut conduire ` certaines surprises. par exemple lorsque vous ´valuez une fonction r´elle a e e √ hors de son domaine de d´finition (par exemple x et log(x) pour x < 0.8 Primitives et fonctions Scilab : SHOULD BE UPDATED Dans ce document j’ai utilis´ plus ou moins indiff´remment les termes primitive et fonction pour e e d´signer des « proc´dures » offertes par la version courante de Scilab. Pour savoir si l’on a affaire a une variable r´elle ou complexe.x = matrix(x. -->isreal(c) ans = F 6. 6.1. on peut utiliser le raccourci : a x = x(:) 6. acos(x) et asin(x) pour e x ∈ [−1.1) // pour obtenir un vecteur colonne Si on cherche simplement ` obtenir un vecteur colonne. + i -->isreal(c) ans = F -->c = 1 + 0*%i c = 1. Il existe cependant une diff´rence e e e 106 .length(x). acosh(x) pour x < 1) car Scilab renvoie alors l’´valuation de l’extension complexe de la / e fonction. 1]. on peut utiliser la fonction e isreal : -->x = 1 x = 1. -->isreal(x) ans = T -->c = 1 + %i c = 1.length(x)) // pour obtenir un vecteur ligne x = matrix(x.

"unf".. par exemple exp ´choue : e e -->[I.exp.. 1 par exemple sin.1. e e That ’s all Folks. Depuis la version 2.b) ym = f(xm) im = (b-a)*mean(ym) sm = (b-a)*st_deviation(ym) endfunction Pour l’argument f . N´anmoins il subsiste quelques e probl`mes (actuellement r´solus dans la version de d´veloppement). e e e Voici un exemple de probl`me que l’on peut rencontrer : la fonction suivante permet d’approcher une e int´grale par la m´thode de Monte Carlo : e e function [im.a.b. ` ce e ee a titre vous pouvez faire passer une fonction en tant qu’argument d’une autre fonction.1. les primitives sont aussi des sortes de variables Scilab (de type fptr). une fonction Scilab est attendue mais ce code devrait aussi fonctionner avec les fonctions math´matiques qui sont des primitives Scilab1 puisqu’elles sont maintenant consid´r´es comme e ee des variables.7. N´anmoins un test avec une primitive.sci".10000) // bug ! Cependant si vous chargez la fonction MonteCarlo avec getf muni de l’option de non compilation : -->getf("MonteCarlo.sm]=MonteCarlo(a. exp et beaucoup d’autres sont des primitives. 107 ."n") ce bug (corrig´ dans le cvs actuel) est alors contourn´.m) // /b // approx de | f(x) dx par la methode de Monte Carlo // /a // on renvoie aussi l’ecart type empirique xm = grand(m. et.sigma]=MonteCarlo(0.f.fondamentale entre une primitive qui est cod´e en fortran 77 ou en C et une fonction (appel´e aussi e e macro) qui est cod´e en langage Scilab : une fonction est consid´r´e comme une variable Scilab.

diag(diag(A)) + eye(A) 4.. // pour fixer une valeur a n. Un script possible (` exp´rimenter avec diff´rentes valeurs de n) : a e e n = 2000. "illustration de la lgn : xbar(n) -> 0.^2) // avec des raccourcis 5.5 qd n -> + oo") 108 ..1) .^2 ."y". Voici le script : n = 101.*(X + 4) // en utilisant un raccourci d’ecriture (d) --> Y = ones(X).n) . avec comme ´l´ments diagonaux ceux de la matrice initiale. --> n = 5 // pour fixer une valeur a n. Si A est une matrice (n. diag(A) renvoie un vecteur colonne contenant les ´l´ments diagonaux ee de A (donc un vecteur colonne de dimension n). // pour eviter la division par zero.diag(ones(n-1.4*%pi.1).. ee 3."x"./x(2:n)]. (a) --> Y = 2*X.n-2)]) 2..-1) Un moyen plus rapide consiste ` utiliser la fonction toeplitz : a -->n=5. -->toeplitz([2 -1 zeros(1. n). // pour la discretisation x = linspace(0.3*X + 1 // en utilisant un raccourci d’ecriture --> Y = 1 + X.y."xbar".5) --> T = tril(A) . "n".1). --> A = 2*eye(n./(ones(X) + X..^2 ../(1 + X./(1:n).n). plot(1:n.1). plot(x. y = [1 .Annexe A Correction des exercices du chapitre 2 1. x = rand(1. sin(x(2:n)).*(-3 + 2*X) // plus un schema a la Horner (b) --> Y = abs(1 + X..*(-3 + 2*X)) (c) --> Y = (X ."y=sin(x)/x") 6.3*X + ones(X) --> Y = 2*X.diag(ones(n-1. xbar. diag(diag(A) renvoie alors une matrice carr´e e diagonale d’ordre n. xbar = cumsum(x). Voici une possibilit´ : e --> A = rand(5.n)..^2) --> Y = (1). .

if n ~= m then 109 ..m] = size(U) // quelques verifications .i) ~= 0 then x(i. if n ~= m then error(’ La matrice n’’est pas carree’) end [p..:) end if U(i.b) // // idem a sol_tri_sup1 sauf que l’on utilise un peu // plus la notation matricielle // [n..Annexe B Correction des exercices du chapitre 3 1.m] = size(U) // quelques verifications .q] = size(b) if p ~= m then error(’ Second membre incompatible’) end // debut de l’algo x = zeros(b) // on reserve de la place pour x for i = n:-1:1 somme = b(i.b) // // resolution de Ux = b ou U est triangulaire superieure // // Remarque : Cet algo fonctionne en cas de seconds membres multiples // (chaque second membre correspondant a une colonne de b) // [n.. L’algorithme classique a deux boucles : function [x] = sol_tri_sup1(U..i) else error(’ Matrice non inversible’) end end endfunction Voici une version utilisant une seule boucle function [x] = sol_tri_sup2(U.j)*x(j..U(i.:) = somme/U(i.:) for j = i+1:n somme = somme .

n+1). L’addition avec une matrice vide est definie et donne : A = A + [].:).-k -alpha] // k = 1. 2. Donc lors de cette premiere iteration.:) sont vides. // // script pour resoudre x" + alpha*x’ + k*x = 0 // // Pour mettre l’equation sous la forme d’un systeme du 1er ordre // on pose : X(1. T = 20.i-1).i) = M*X(:. // calcul de l’exponentielle de A dt // le calcul for i=2:n+1 X(:.U(i.-k -alpha].T] va etre // decoupe en n intervalles t = linspace(0.:) // voir le commentaire final if U(i. // pas de temps A = [0 1. Elles correspondent ` un objet qui est bien defini en Scilab (la matrice vide) a qui se note [].t(i)) dt = T/n.error(’ La matrice n’’est pas carree’) end [p. X(:.1) = [1. X = zeros(2.i) else error(’ Matrice non inversible’) end end endfunction Commentaire : lors de la premiere iteration (correspondant ` i = n) les matrices U(i.0) xbasc() xselect() plot(t.’temps’.i) ~= 0 then x(i.i+1:n)*x(i+1:n.n+1). // discretisation temporelle : l’intervalle [0. end // affichage des resultats xset("window".i+1:n) et a x(i+1:n.T.:) . // les conditions initiales M = expm(A*dt).1) xbasc() xselect() 110 .t) = x’(t) // // On obtient alors : X’(t) = A X(t) avec : A = [0 1. alpha = 0.i) correspondra a X(:. // instant final n = 100. // les instants : X(:.t) = x(t) et X(2.:) + [] c’est a dire que somme = b(n.’Courbe x(t)’) xset("window".1.:) = somme/U(i.q] = size(b) if p ~= m then error(’ Second membre incompatible’) end // debut de l’algo x = zeros(b) // on reserve de la place pour x for i = n:-1:1 somme = b(i. on a somme = b(n.’position’.1].X(1.:).

function [p]=myhorner(t.t.c) // evaluation du polynome c(1) + c(2)*(t-x(1)) + // par l’algorithme d’horner // t est un vecteur d’instants (ou une matrice) n=length(c) p=c(n)*ones(t) for k=n-1:-1:1 p=c(k)+(t-x(k)).T) c(3)*(t-x(1))*(t-x(2)) + .plot(X(1.’vitesse’.:).t.x) // recherche dichotomique de l’intervalle i tel que: x(i)<= t <= x(i+1) // si t n’est pas dans [x(1). else. l=length(cs) y=zeros(t) for j=1:l y=y + cs(j)*f(j.:).i_bas > 1 itest = floor((i_haut + i_bas)/2 ) if ( t >= x(itest) ) then..*p end endfunction 5. i_haut=itest.’position’.’Trajectoire dans le plan de phase’) 3.T) end endfunction function [y]=f(i..x(n)] on renvoie info = %f n=length(x) if t < x(1) | t > x(n) then info = %f i = 0 // on met une valeur par defaut else info = %t i_bas=1 i_haut=n while i_haut .T.X(2.x.T) // les polynomes trigonometriques pour un signal de periode T : // // // // si i est pair : f(i)(t)=sin(2*pi*k*t/T) (avec k=i/2) si i est impair : f(i)(t)=cos(2*pi*k*t/T) (avec k=floor(i/2)) d’ou en particulier f(1)(t)=1 que l’on traite ci dessous comme un cas particulier bien que se ne soit pas necessaire 111 .info]=intervalle_de(t. end end i=i_bas end endfunction 4.cs) // // // // // cette fonction renvoie un signal T-periodique t : un vecteur d’instants pour lesquels on calcule le signal y ( y(i) correspond a t(i) ) T : la periode du signal cs : est un vecteur qui donne l’amplitude de chaque fonction f(i. function [i.t. Fabrication d’une serie de fourier tronquee : function [y]=signal_fourier(t. i_bas= itest.

Voici une solution : e function [p] = rdv(m) tA = rand(m.17. TB + 1/12] = ∅. 18].18) tB = grand(m. suit une loi uniforme sur le carr´ [17. TB ) qui.1) rencontre = tA+1/6 > tB & tB+1/12 > tA.1) tB = rand(m.18) rencontre = tA+1/6 > tB & tB+1/12 > tA. La rencontre : soit TA et TB les temps d’arriv´e de Mr A et Melle B.17. 18]) et la rencontre ` lieu si [TA . p = sum(bool2s(rencontre))/m endfunction on peut aussi utiliser la fonction grand d´crite dans le chapitre sur les applications : e function [p] = rdv(m) tA = grand(m. ce qui permet d’obtenir p = 67/288. TB ∈ [17. En fait e a une exp´rience de la rencontre correspond ` la r´alisation de la variable al´atoire vectorielle R = e a e e (TA . TA + 1/6] ∩ [TB . p = sum(bool2s(rencontre))/m endfunction 112 .// t est un vecteur d’instants if i==1 then y=ones(t) else k=floor(i/2) if modulo(i. Pour calculer cette probabilit´.2)==0 then y=sin(2*%pi*k*t/T) else y=cos(2*%pi*k*t/T) end end endfunction 6. e e on peut bien sˆr faire comme si la rencontre devait avoir lieu entre minuit et une heure :-) ! Par u simulation. avec les hypoth`ses."unf". La probabilit´ e e e de la rencontre se calcule donc en faisant le rapport entre la surface de la zone (correspondant ` a une rencontre effective) d´finie par : e   TA ≤ TB + 1/12 T ≤ TA + 1/6  B TA . 18] et la surface du carr´ (1). on effectue m exp´riences et la probabilit´ empirique est le nombre de cas o` la rencontre e e u a lieu divis´ par m. Ce sont deux variables al´atoires e e ind´pendantes de loi U ([17. 18] × [17.1."unf".1.

on agglom`re e e e e e e e dans une mˆme classe tous les r´sultats correspondants ` un nombre de lanc´s sup´rieur strictement ` e e a e e a 10. y = sum( (occ ."def") // tirage d’une boule (ds chacune des m urnes) V_plus_R = V_plus_R + 1 // ca fait une boule de plus (qq soit l’urne) ind = find(u <= XN) // trouve les numeros des urnes dans lesquelles // on a tire une boule verte VN(ind) = VN(ind) + 1 // on augmente alors le nb de boules vertes de ces urnes XN = VN / V_plus_R // on actualise la proportion de boules vertes end endfunction 113 . 25 . 8 ..^(0:9) . 8 . N´anmoins on a e e 200 × min(pr) 6.m*pr).73915 alors que yseuil = 18. VN] = Urne_de_Polya_parallele(N..1. XN = 0. q = 5/6. P (J = 2) = qp. P (J = 3) = q 2 p. ce d´ semble donc correct.5 ce qui est tout juste au dessus de la condition d’applicabilit´ du test (on pourrait e donc demander quelques exp´riences suppl´mentaires).1) for i=1:N u = grand(m. 10. 9 . 200*min(pr)) On obtient y = 7. pr = [p*q. Avec les donn´es de l’exp´rience. 12 . P (J = 10) = q 9 p.Annexe C Correction des exercices du chapitre 5 : NOT YET UPDATED FOR GRAPHICS D´ truqu´ ou non ? e e Si on note J la variable al´atoire correspondant au r´sultat de l’exp´rience alors J suit la loi e e e g´om´trique G(p) avec p = 1/6 si le d´ est non truqu´.307. . d’o` le script : u occ= [36 . et y_seuil (95 \%) = %g". 30]. 0. 27 .05).5*ones(m. e e Urne de Polya La fonction scilab function [XN. mprintf("\n\r Test sur le de :") mprintf("\n\r y = %g.. 26 . q^10]’./ (m*pr) ). y. p = 1/6. y_seuil = cdfchi("X". Ce qui nous donne les probabilit´s (notant q = 1 − p = 5/6) : e P (J = 1) = p. 7 . V_plus_R = 2 ..95.m) VN = ones(m. P (J > 10) = q 10 D’autre part le tableau donne directement le nombre d’occurence. 12 .1) .^2 . 0. y_seuil) mprintf("\n\r 200*min(pr) = %g".

xbasc(). strf="000") xstring(Y_seuil. strf="000") xtitle("Frequences empiriques (traits verticaux) et probabilites exactes (croix)") subplot(2. Y_seuil).1) plot2d3((1:N+1)’/(N+2). style=5.EN-delta. rect = [0 0 1 ymax*1.-0. style=-2.01.1*max([Y_seuil Y]). mprintf("\n\r Intervalle (empirique) de confiance a 95\% : [%g.N). xset("font". densite_chi2(Y.^(N/2 .EN+delta). style=2 . p]). frequences. end // petite verification Y = sum( (occ . strf="000") xstring(Y.5 114 .05. // 2/ test chi2 alpha = 0. // increment pour l’intervalle empirique (2 pour 1.5").alpha).2) // on trace la densite chi2 a N ddl X = linspace(0."). m = 5000. p = 1/(N+1).. style=1.2.1)) : e E exact = 0.9599. mprintf("\n\r E estime = %g". // esperance empirique sigma = st_deviation(XN).-0.N). [XN.*exp(-X/2)/(2^(N/2)*gamma(N/2)) endfunction frequences = occ/m.m). densite_chi2(Y_seuil. end if sum(occ) ~= m then. mprintf("\n\r Test du chi 2 : ") mprintf("\n\r -------------.. error(" Probleme.1). Y_seuil = cdfchi("X".^2 / (m*p) ). axesflag=2) // un trait vertical pour Y plot2d3(Y.N) d = X. // proba theorique pour chaque resultat (loi uniforme) occ = zeros(N+1. "Yseuil") xtitle("Positionnement de Y par rapport a la valeur Yseuil") Voici un r´sultat obtenu avec N = 10 et m = 5000 (cf figure (C.1. frameflag=1. // 1/ calcul de l’esp´rance et de l’intervalle de securite e EN = mean(XN).1.%g]". // ecart type empirique delta = 2*sigma/sqrt(m). "Y") // un trait vertical pour Yseuil plot2d3(Y_seuil.D. rect=rect. Y).05].2) subplot(2. .1..1). plot2d(X. mprintf("\n\r valeur seuil a ne pas depasser : %g".m*p).Le script Scilab // polya simulation : N = 10.) mprintf("\n\r E exact = 0..1-alpha.p*ones(N+1.1).50)’. VN] = Urne_de_Polya_parallele(N. style=2. D = densite_chi2(X.N). leg="densite chi2". if (Y > Y_seuil) then mprintf("\n\r Conclusion provisoire : Hypothese rejetee !") else mprintf("\n\r Conclusion provisoire : Hypothese non rejetee !") end // 3/ illustrations graphiques function [d] = densite_chi2(X. nax=[0 N+2 0 1]) plot2d((1:N+1)’/(N+2).") mprintf("\n\r valeur obtenue par le test : %g".N.01. for i=1:N+1 occ(i) = sum(bool2s(XN == i/(N+2)))..EN). ymax = max([frequences .

167 0. sigma = sqrt(t*(1-t)). m = 2000. lui superpose celui de la fonction de r´partition attendue (pour n = +∞) et e e finalement effectue le test KS : t = 0.5033433] Test du chi 2 : -------------valeur obtenue par le test : 8.3176 valeur seuil a ne pas depasser : 18. affiche le graphe de la fonction de e r´partition empirique.1.0 0.n) X = sum(bool2s(grand(n..417 0.583 0.917 1. n = 4000.083 0.500 0. C.4884901.307038 Conclusion provisoire : Hypothese non rejetee ! Frequences empiriques (traits verticaux) et probabilites exactes (croix) 0.0.750 0.833 0. for k=1:m // // // // l’´cart type attendu e n "grand" le nb de simulations initialisation du vecteur des realisations 115 .667 0."def") <= t) .250 0.4959167 Intervalle de confiance a 95% : [0. X = zeros(m..333 0.1).t)/sqrt(n) endfunction Le script Ce script effectue m simulations de la variable al´atoire Xn (t).1 × × × × × × × × × × × 0.000 0.1 – Illustrations pour le test du χ2 de l’urne de Polya.000 Positionnement de Y par rapport a la valeur Yseuil densite chi2 Y Yseuil Fig. Le pont brownien La fonction function [X] = pont_brownien(t.E estime = 0.3.

// tri prcum = (1:m)’/m.n).X. Km = sqrt(m)*max([Dplus . FX = cdfnor("PQ".1204036 valeur seuil a ne pas depasser : 1.x.K_seuil). K_seuil = sqrt(0.") mprintf("\n\r valeur obtenue par le test : %g".0*ones(x).sigma*ones(x)).2212382 Conclusion provisoire : Hypothese non rejetee ! 116 . // les ordonnees pour la fonction exacte plot2d(x. if (Km > K_seuil) then mprintf("\n\r Conclusion provisoire : Hypothese rejetee !") else mprintf("\n\r Conclusion provisoire : Hypothese non rejetee !") end Voici des r´sultats obtenus avec n = 1000 et m = 4000 : e Test KS : -------valeur obtenue par le test : 1.sort(-X).style=2.X(k) = pont_brownien(t.5*log(2/alpha)).(0:m-1)’/m ).max(X). Dmoins = max( FX .P. Km).05. // affichage des resultats // mprintf("\n\r Test KS : ") mprintf("\n\r -------. strf="000") // on l’ajoute sur le dessin initial // mise en place du test KS alpha = 0. Dmoins]). xbasc() plot2d2(X.sigma*ones(X)). Dplus = max( (1:m)’/m .60)’.Q]=cdfnor("PQ". mprintf("\n\r valeur seuil a ne pas depasser : %g".FX ). end // la boucle pour calculer les realisations // le dessin de la fonction de repartition empirique X = . // les abscisses et [P. prcum) x = linspace(min(X).0*ones(X).

52 size. 46 e e programmation affectation. 93 rand. 44 evstr. 8 op´rations ´l´ment par ´l´ment. produit. transposition. 8 logspace. 7 error. 32 listes « typ´es ». 16 sum. 6 fonctions math´matiques usuelles. 34 e matrices concat´nation et extraction. 30 continuer une instruction . 13 e entrer une matrice. 48 execstr. 29 e e op´rateurs de comparaisons. 26 st deviation. 21 timer. 12 e ee ee r´solution d´un syst`me lin´aire. 22 cumsum. 44 warning. 12. 6 d´finir directement une fonction. 19 e e e remodeler une matrice. 24 stacksize. 26 linspace. 49 expm. 26 op´rateurs bool´ens. 54 triu tril. 21 matrice vide [] . 37 input. 28 boucle while. 25 mean. 29 break. 5 matrice vide []. 26 matrix. 31 e complexes entrer un complexe. 17 prod. 48 e fonctions. 8 type et typeof. 26 spec. 24 ode. 25 somme. 12 eye. 16 write. 22 rand. 30 conditionnelle : select case. 29 e primitives scilab argn. 49 117 . 45 bool2s. 42 conditionelle : if then else. 50 find. 37 cumprod. 90 listes. 44 who. 9 boucle for. 17 length. 7 file. 22 diag. 9 e g´n´ration de nombres al´atoires e e e grand. 38 sauvegarde et lecture sur fichier.Index chaˆ ınes de caract`res. 7 plot. 8 read. 9 valeurs propres. 7 priorit´ des op´rateurs. 51 zeros. 86 ones.

Sign up to vote on this title
UsefulNot useful

Master Your Semester with Scribd & The New York Times

Special offer: Get 4 months of Scribd and The New York Times for just $1.87 per week!

Master Your Semester with a Special Offer from Scribd & The New York Times