xxIntroduction Scilab

Introduction x Scilabx

Philippe Roux

29 avril 2009

Table des matixres

1 Prise en main de Scilab 2 Les nombres en Scilab 3 Les variables 4 Les matrices 5 Les Boolxens 6 Les chaxnes de caractxres 7 Les fonctions 8 Programmation 9 Sorties graphiques

Scilabxest un logiciel de calcul numxrique, qui permet de manipuler la plupart des objets mathxmatiques courants (nombres rxels, boolxens, matrices, fonctions, polynxmes, graphes,…). Scilabxest aussi un logiciel libre (depuis la version 5) dont vous pouvez vous procurer la dernixre version sur le site de l’INRIA (Institut National de la Recherche en Informatique et en Automatique):

                       http://www.scilab.org/  Vous

y trouverez les fichiers nxcessaires pour l’installer sur n’importe qu’elle plate-forme (PC WINDOWS™/UNIX ou MACINTOSH™) . Techniquement, Scilabxest un interprxteur de commandes, il se prxsente donc comme une calculatrice ou un shell: les commandes, tapxes x l’invite des commande ou lancxes x partir d’un script, sont traduites dans un autre langage (Fortran ou C), compilxes, puis exxcutxes par le noyau du systxme d’exploitation, le rxsultat (ou l’erreur) est rxcupxrx par Scilabxet affichx dans la console.

xxxxxxxxxx___________________________________________
xxxxxxxxxxxxxxxxxxxxxxxxxxxscilab-4.1.2
xx
xxxxxxxxxxxxxxxxxxxxCopyrightx(c)x1989-2008
xxxxxxxxxxxxxxxxConsortiumxScilabx(INRIA,xENPC)
xxxxxxxxxx___________________________________________
xx
xx
xxStartupxexecution:
xxxxloadingxinitialxenvironment
xx
xx-->_
xx
xx
xx
xx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.

Fig.x1: la console Scilabx

1 Prise en main de Scilabx Lorsque vous dxmarrez Scilabxla fenxtre principale s’ouvre comme sur la figure FIG.1. Un curseur apparaxt juste aprxs l’invite des commandes (-->) c’est x cet endroit que vous pourrez lancer les lignes de commandes qui seront exxcutxes sxquentiellement, de la mxme manixre qu’avec une calculatrice ou que dans une fenxtre xterm sous linux. Pour pouvoir utiliser la console il faut comprendre les quelques rxgles suivantes:

chaque commande Scilabxdoit se terminer par

un retour x la ligne ( ↩), ce qui nous limite x une commande par ligne,

une virgule (,), ce qui permet de mettre plusieurs commandes par ligne,

ou un point virgule (;) qui permet aussi d’exxcuter plusieurs commandes par ligne en bloquant l’affichage du rxsultat prxcxdant le point virgule. Le point virgule est trxs utile pour masquer le rxsultat d’un calcul intermxdiaire.

vous pouvez copier/coller des instructions avec la souris (mais pas modifier une ligne de commande dxjx exxcutxe)

On peut rappeler les commandes prxcxdemment exxcutxe en utilisant les touches du curseur ↑ et ↓.

dans une ligne tout ce qui suit un double slash (//) est ignorx (ce qui permet d’insxrer du commentaire).

Scilabxpossxde une aide en ligne accessible depuis la barre de menus, dans l’onglet?.

PIC Fig.x2: L’aide en ligne de Scilabx

Vous pouvez aussi accxder x l’aide en ligne de Scilabxdirectement depuis la console. Pour cela il y a deux commandes diffxrentes suivant le type de recherche qu’on veut faire dans l’aide en ligne:

help commande si vous voulez connaxtre ce que fait une commande dont vous connaissez dxjx le nom,

apropos motxclx si vous cherchez des commandes ayant rapport avec un thxme dxcrit par un motxclx

par exemple:

xx-->helpxsin
xx-->aproposxsinus

la premixre commande va trouver la page d’aide de la fonction sinus (sin en Scilabx) alors que la deuxixme va renvoyer la liste des commande ayant un rapport avec la fonction sinus (en fait la liste des fonctions trigonomxtriques comme sur la figure FIG.2).

Une dernixre chose importante qu’il faut comprendre pour bien travailler avec Scilabxc’est la notion derxpertoire courant. On a souvent besoin avec Scilabxd’importer des informations, ou au contraire d’en exporter, et ceci x l’aide de fichiers. Lorsque c’est le cas, Scilabxva chercher x effectuer ces opxrations avec les fichiers prxsents dans son rxpertoire courant. Au dxmarrage de Scilabxce rxpertoire est le rxpertoire depuis lequel Scilabxa xtx lancx. Par exemple, sous windows™, xa peut xtre C:\Program Files\Scilab-x.x.x\bin\ si vous dxmarrez Scilabxdepuis son rxpertoire d’installation par dxfaut. Il existe plusieurs fonctions dxdixes x la manipulation des rxpertoire courant :

Pour connaxtre le rxpertoire courant actuel: getcwd() ou pwd()

pour changer de rxpertoire courant: cd() ou chdir()

pour crxer un rxpertoire (dans le rxpertoire courant actuel): mkdir()

pour lister le contenu du rxpertoire courant ls Plus gxnxralement, on peut aussi exxcuter des commandes systxmes avec la fonction unix()

(la sortie pouvant xtre redirigx vers scilab ou pas).

xx-->getcwd()xxxansx=xxxxC:\ProgramxFiles\Scilab-4.1.2\binxxxx-->cd('C:/')
xxxansxx=xxxxxC:\xxxx-->lsxxxansxx=xxxx!tempxxxxxxxxxxxxxxxxxxxx!
xx!xxxxxxxxxxxxxxxxxxxxxxxx!xx!ProgramxFilesxxxxxxxxxxx!xx!xxxxxxxxxxxxxxxxxxxxxxxx!
xx!WINDOWSxxxxxxxxxxxxxxxxx!xx!xxxxxxxxxxxxxxxxxxxxxxxx!xx!DocumentsxandxSettingsxx!
xxxx-->mkdir('scilab') xxxansxx=xxxxxxxx1.xxxx-->chdir('scilab') xxxansxx=xx
xxxxxx0.xxxx-->pwd()xxxansxx=xxxxxC:\scilabxxxx-->cd('..') xxxansxx=xxxxxC:\

On peut aussi accxder x certaines fonctionnalitxs, comme changer ou afficher le rxpertoire courant, x partir du menu fichier.

PIC

2 Les nombres en Scilabx

Les objets de base du langage Scilabxsont les nombres rxels. Il sont reprxsentxs par des nombres flottant double prxcision (i.e.xavec un exposant signx et une mantisse d’environ 16 dxcimales), Scilabxles affiche dans la console par dxfaut sous forme dxcimale avec 8 chiffres significatifs. Les opxrations usuelles sur les rxels sont codxes de manixre naturelle, voici leur liste par ordre de prioritx croissante:

11addition11soustraction11multiplication11division11puissance

11 + 11  −  11  ∗  11 / 11

11

et on a en plus accxs x la plus part des fonctions spxciales:

11fonctions trigonomxtriques 11sin(), asin(), cos(), acos(), tan(), atan(), cotg()
11fonctions hyperboliques 11sinh(), asinh(), cosh(), acosh(), tanh(), atanh(), coth()
11fonctions d’arrondis  11round(), int(), floor(), ceil()

11logarithme et exponentielle 11exp(), log(), log10(), log2()
11autre  11sqrt()(racine), abs() (valeur absolue), pmodulo() (modulo)

11

,

Voici quelques manipulations de base:

xx-->1+2xxxansxx=xxxxxxxx3.xxxx-->2*3xxxansxx=xxxxxxxx6.xx-->1/3
xxxansxx=xxxxxxxx0.3333333xxxx-->1/4;sin(1)xxxansxx=xxxxxxxx0.8414710xx
xx-->2^(1/2),sqrt(2)xxxansxx=xxxxxxxx1.4142136xxxansxx=xxxxxxxx1.4142136xx

Notez qu’un nombre en Scilabxcontient toujours le caractxre “.”, y compris les nombres entiers (mxme si le point est facultatif lors de la saisie).

Les constantes, comme e et π, jouent un rxle particulier en mathxmatiques elles ont donc une place x part dans Scilab et sont stockxes dans des variables non modifiables qui commencent par le caractxre %. Voici les plus utiles:

%e,%pi sont assez explicites (sinon les taper dans Scilabxpour obtenir leur valeur).

La constante %i reprxsente le nombre complexe i, en particulier Scilabxmanipule les nombres complexes exactement comme les nombres rxels.

%eps reprxsente le “zxro machine”, en particulier %eps donne l’ordre de grandeur des erreurs d’arrondis dans les calculs en nombres flottants.

%inf reprxsente “l’infini machine”: toute valeur trop grande (grosso-modo plus grande que 10^{300}) est considxrxe comme ayant la valeur %inf (infini).

Quand un rxsultat ne peut xtre interprxtx Scilabxrenvoie %nan qui signifie “Not A Number”.

Enfin les deux valeurs “Vrai” et “faux” sont deux constantes dxfinies en Scilabxpar %T et %F (voir plus loin la partie sur les boolxens)

xx-->(1+%i)^2xxxansx=xxx2.ixxxx-->%epsxxx%epsxx=xxx2.220E-16xx
xx-->(10^(160))^2xxxansx=xxxInfxxxx-->%inf*0xxxansxx=xxxxxNan

3 Les variables

Pour simplifier la manipulation des nombres nous allons utiliser des variables. Une variable est dxterminxe par un nom composx d’une suite d’au plus 24 caractxres d’abord une lettre xventuellement suivit d’autres lettres, de chiffres, ou de caractxres spxciaux comme x mais diffxrent des opxrateurs dxjx dxfinis par Scilab: +*/^[](){}'&|~ . L’affectation d’une valeur (rxelle, complexe, boolxenne ou autre) dans une variable se fait en utilisant =. Si le rxsultat de la dernixre opxration n’a pas xtx stockx dans une variable spxcifique alors il est stockx dans la variable ans:

xx-->a=1+%i;b=sqrt(2);xc=a/bxxxcx=xxxxx.7071068x+x.7071068ixx-->d=%fxxxdx=xxxxF
xx-->a*bxxxansx=xxxxx1.4142136x+x1.4142136ixx-->ansxxxansx=xxxxx1.4142136x+x1.4142136i

Il n’y a donc pas de dxclaration prxalable des variables en Scilab, celle-ci sont crxes lors de l’affectation. La notion de type d’une variable (constant,

string, function ...) est donc beaucoup moins rigide en Scilabxque dans un langage compilx. En particulier le type d’une variable donnx peut changer d’une affectation x l’autre!

Si besoin on peut tester le type d’une variable avec la fonction typeof :

xxx-->a,typeof(a)xxxaxx=xxxxxxxx1.x+xixxxansxx=xxxxxconstantxx-->d,typeof(d)
xxxdxx=xxxxxxFxxxansxx=xxxxxboolean

Plusieurs commandes permettent de connaxtre la liste des variables utilisxes dans un session Scilabx. La commande who va lister tous les noms des variables de l’environnement Scilabx. On pourra ainsi se rendre compte que Scilabxtravaille avec de nombreuses variables d’environnements (chemins vers des rxpertoires particuliers, noms de librairies, constantes particulixres,…). La commande whos -type permet de spxcifier le type de variable qu’on veut lister, et donc de clarifier quelque peut l’affichage. Il existe aussi une interface graphique pour visualiser la liste des variables et leur type, on y accxde

par la commande browsevar() ou par le menu Applications->Editeur de
variables.
xx-->who
xxyourxvariablesxare...
xx
xxxansxxxxxxxwhosxxxxxxdxxxxxxxxxcxxxxxxxxxbxxxxxxxxxa
xxxscicos_palxxxxxxxxxx%scicos_menuxxxxxxxx%scicos_short
xxx%scicos_helpxxxxxxxx%scicos_display_mode
xxxmodelica_libsxxxxxxxscicos_pal_libsxxxxx%helpsxxxxWSCI
xxxhomexxxxxxSCIHOMExxxPWDxxxxxxxTMPDIRxxxxMSDOSxxxxxSCI
xxxguilibxxxxsparselibxxxxxxxxxxxxdesslibxxpercentlib
xxxpolylibxxxintlibxxxxelemlibxxxutillibxxxstatslibxxalglib
xxxsiglibxxxxoptlibxxxxautolibxxxroblibxxxxsoundlibxxmetalib
xxxarmalibxxxtkscilibxxtdcslibxxxs2flibxxxxmtlblibxxx%F
xxx%Txxxxxxxx%zxxxxxxxx%sxxxxxxxx%nanxxxxxx%infxxxxxxCOMPILER
xxx%gtkxxxxxx%guixxxxxx%pvmxxxxxx%tkxxxxxxx$xxxxxxxxx%t
xxx%fxxxxxxxx%epsxxxxxx%ioxxxxxxx%ixxxxxxxx%e
xxxusingxxxxxx18185xelementsxxoutxofxxxx5000000.
xxxxxxxxxxxxandxxxxxxxxx71xvariablesxoutxofxxxxxxx9231
xx
xxyourxglobalxvariablesxare...
xx
xxxLANGUAGExx%helpsxxxxdemolistxx%browsehelpxxxxxxxxxLCC
xxx%toolboxesxxxxxxxxxx%toolboxes_dir
xxxusingxxxxxxx1174xelementsxxoutxofxxxxxx11000.
xxxxxxxxxxxxandxxxxxxxxxx7xvariablesxoutxofxxxxxxxx767
xx
xx-->whosx-typexconstant
xxNamexxxxxxxxxxxxxxxxxxxxxTypexxxxxxxxxxxSizexxxxxxxxxxxBytes
xx
xxcxxxxxxxxxxxxxxxxxxxxxxxxconstantxxxxxxx1xbyx1xxxxxxxxx32
xxbxxxxxxxxxxxxxxxxxxxxxxxxconstantxxxxxxx1xbyx1xxxxxxxxx24
xxaxxxxxxxxxxxxxxxxxxxxxxxxconstantxxxxxxx1xbyx1xxxxxxxxx32
xx%scicos_display_modexxxxxconstantxxxxxxx1xbyx1xxxxxxxxx24
xx%nanxxxxxxxxxxxxxxxxxxxxxconstantxxxxxxx1xbyx1xxxxxxxxx24
xx%infxxxxxxxxxxxxxxxxxxxxxconstantxxxxxxx1xbyx1xxxxxxxxx24
xx%epsxxxxxxxxxxxxxxxxxxxxxconstantxxxxxxx1xbyx1xxxxxxxxx24
xx%ioxxxxxxxxxxxxxxxxxxxxxxconstantxxxxxxx1xbyx2xxxxxxxxx32
xx%ixxxxxxxxxxxxxxxxxxxxxxxconstantxxxxxxx1xbyx1xxxxxxxxx32

4 Les matrices

Il s’agit de la structure de donnxes la plus importante dans Scilabx, elle sera constamment utilisxe. Scilabxpermet de construire toutes sortes de matrices, x partir des rxels, mais aussi en utilisant des boolxens, des chaxnes de caractxres …on peut ensuite effectuer toutes les opxrations algxbriques usuelles dxfinies sur les matrices.

Il y a plusieurs manixres de dxfinir une matrice. La plus simple consiste x saisir la liste des coefficients d’une matrice ligne par ligne, les lignes xtant sxparxes par des points-virgules, en utilisant l’opxrateur de concatxnation [x]:

xx-->A=[1x2x3;x4x5x6;x7x8x9]xxxAx=xxx1.x2.x3.xxx4.x5.x6.xxx7.x8.x9.xx
xx-->xB=[-1x0;x0x1;x-3x0]xxxBx=xxx-x1.x0.xxxxx0.x1.xxx-x3.x0.

On peut accxder aux valeurs stockxes dans une matrice en utilisant l’opxrateur d’extraction (). Pour rxcupxrer (resp. modifier) la valeur en position i, j de la matrice A il suffit d’appeler la commande A(i,j) (resp. A(i,j)=) sauf pour la matrice vide [] et xventuellement les matrices x une ligne ou une colonne:

xx-->A(1,2)xxxansxx=xxxxxxxx2.xx-->A(1,2)=-2xxxAxx=xxxxxxxx1.xx-x2.xxxx3.xxxxxx4.xxxx5.xxxx6.
xxxxxx7.xxxx8.xxxx9.xxxx-->L=[1x2x3]//laxmatricexlignexxxLxx=xxxxxxxx1.xxxx2.xxxx3.
xx-->L(1,3)//accxsxnormalxxxansxx=xxxxxx3.xx-->L(2)//accxsxsimplifixxxxansxx=xxxxxx2.

Lorsqu’on modifie un coefficient qui “dxborde” de la matrice de dxpart la matrice est augmentx du nombre de lignes et de colonnes nxcessaires et les cases correspondantes sont mises x 0:

xx-->C=[1x2x3;x4x5x6;x7x8x9]xxxCxx=xxxxxxxx1.xxxx2.xxxx3.xxxxxx4.xxxx5.xxxx6.
xxxxxx7.xxxx8.xxxx9.xxxxxxxx-->C(5,4)=10xxxCxx=xxxxxxxx1.xxxx2.xxxx3.xxxx0.
xxxxxx4.xxxx5.xxxx6.xxxx0.xxxxxx7.xxxx8.xxxx9.xxxx0.xxxxxx0.xxxx0.xxxx0.xxxx0.

xxxxxx0.xxxx0.xxxx0.xxxx10.

Pour de petites matrices on rentrera tous les coefficients un x un comme ci-dessus mais pour des matrices plus importantes il est utile de pouvoir les construire plus ou moins automatiquement. On peut utiliser pour cela l’opxrateur d’incrxmentation:. Par exemple pour construire une matrice x une ligne contenant les entiers de a x b on xcrira [a:b], si on veut spxcifier un pas diffxrent de 1 on pourra xcrire [a:pas:b] avec pas adaptx (2 pour aller de 2 en 2 ou −1 pour diminuer de 1 x chaque pas):

xx-->L1=[1:5]xxxL1xx=xxxxxx1.xxxx2.xxxx3.xxxx4.xxxx5.xx-->L2=[7:2:15]
xxxL2xx=xxxxxx7.xxxx9.xxxx11.xxxx13.xxxx15.xx-->L=[10:-1:5]xxxLxx=
xxx10.xxxx9.xxxx8.xxxx7.xxxx6.xxxx5.xx-->L=[10:-2:20]xxxLxx=xxxxxxx[]

On peut ensuite construire d’autres matrices x partir des prxcxdentes par concatxnation

xx-->[L1,xL2]//onxplacexL1xxxgauchexdexL2
xxxansxx=
xxxxxx1.xxxx2.xxxx3.xxxx4.xxxx5.xxxx7.xxxx9.xxxx11.xxxx13.xxxx15.
xx-->[L1;xL2]//onxplacexL1xau-dessusxdexL2
xxxansxx=
xxxxxx1.xxxx2.xxxx3.xxxxx4.xxxxx5.
xxxxxx7.xxxx9.xxxx11.xxxx13.xxxx15.

mais il faut faire attention aux tailles des matrices utilisxes:

xx-->[A,xB]x//juxtaposerxAxpuisxBxxxansxx=xxxxxx1.xxxx2.xxxx3.xx-x1.xxxx0.
xxxxxx4.xxxx5.xxxx6.xxxx0.xxxx1.xxxxxx7.xxxx8.xxxx9.xx-x3.xxxx0.xx
xx-->[A;B]//pourxmettrexBxsousxAxxxxxxx!--errorx6xxinconsistentxrow/columnxdimensions
xxxx-->[B,A]//juxtaposerxBxpuisxAxxxxxansxx=xxxxxx-x1.xxxx0.xxxx1.xxxx2.xxxx3.
xxxxxx0.xxxx1.xxxx4.xxxx5.xxxx6.xxxx-x3.xxxx0.xxxx7.xxxx8.xxxx9.xxxx

Il existe aussi des fonctions permettant de crxer des matrices de tailles (p, n) dxjx rempliesx:

11matrice vide11matrice nulle11matrice identitx11matrice de 111matrice alxatoire

11    []    11zeros(p,n)11   eye(p,n)   11 ones(p,n) 11   rand(p,n)

11

On peut aussi appliquer ces diffxrentes fonctions x des matrices dxjx existante pour obtenir une matrice de mxme taille (essayer zeros(A), zeros(B)).

xx-->zeros(4,3)xxxansxx=xxxxxxxx0.xxxx0.xxxx0.xxxxxx0.xxxx0.xxxx0.
xxxxxx0.xxxx0.xxxx0.xxxxxx0.xxxx0.xxxx0.xx-->ones(2,3)xxxansxx=xx
xxxxxx1.xxxx1.xxxx1.xxxxxx1.xxxx1.xxxx1.xx-->eye(3,3)xxxansxx=xxxxxxxx1.xxxx0.xxxx0.
xxxxxx0.xxxx1.xxxx0.xxxxxx0.xxxx0.xxxx1.xx-->rand(3,2)xxxansxx=xx
xxxxxx0.9488184xxxx0.7340941xxxxxx0.3435337xxxx0.2615761xxxxxx0.3760119xxxx0.4993494

La syntaxe des opxrations matricielles est plus compliquxe que pour les nombres flottants. En effet il faut distinguer les opxrations “terme x terme” qui s’appliquent x des matrices de mxme taille

les opxrations matricielles pour lesquelles les tailles des matrices en prxsence doivent vxrifier certaines conditions,

les opxrations qui combinent une matrice et un nombre Commenxons par les opxrations terme x terme (par ordre de prioritx croissante):

11addition11soustraction11multiplication11division11puissance

11   +   11     -     11     .*     11  ./  11 .ˆ

11

xx-->A+Axxxansxx=xxxxxxxx2.xxx-x4.xxxxx6.xxxxxx8.xxxxx10.xxxx12.
xxxxxx14.xxxx16.xxxx18.xx-->A-Axxxansxx=xxxxxxxx0.xxxx0.xxxx0.xxxxxx0.xxxx0.xxxx0.
xxxxxx0.xxxx0.xxxx0.xx-->A./Axxxansxx=xxxxxxxx1.xxxx1.xxxx1.xxxxxx1.xxxx1.xxxx1.
xxxxxx1.xxxx1.xxxx1.xx-->A.*Axxxansxx=xxxxx1.xxxxx4.xxxxx9.xxx16.xxxx25.xxxx36.
xxx49.xxxx64.xxxx81.xx-->A.^2xxxansxx=xxxxx1.xxxxx4.xxxxx9.xxx16.xxxx25.xxxx36.
xxx49.xxxx64.xxxx81.xx-->A.^Axxxansxx=xxxxx1.xxxxxxxxx0.25xxxxxxxxx27.
xxx256.xxxxxxx3125.xxxxxxxx46656.xxx823543.xxxx16777216.xxxx3.874D+08

x ne pas mxlanger avec les opxrations purement matricielles (par ordre de prioritx croissante):

11produit11division11puissance11transposition11conjugaison

11   *   11   /   11   x^11    .'    11    '

11

xx-->A*B//produitxmatricielxxxansxx=xxxxxx-x10.xx-x2.xxxx-x22.xxxx5.xxxx-x34.xxxx8.
xx-->B.'//transposxexxxansxx=xxxxxx-x1.xxxx0.xx-x3.xxxxxx0.xxxx1.xxxx0.xxxx-->A*Axxxansxx=
xxxxxxxx14.xxxxx12.xxxx18.xxxxxx66.xxxxx65.xxxx96.xxxxxx102.xxxx98.xxxx150.xx-->A^2
xxxansxx=xxxxxxxx14.xxxxx12.xxxx18.xxxxxx66.xxxxx65.xxxx96.xxxxxx102.xxxx98.xxxx150.

il faut donc faire attention x ce que les tailles des matrices soient compatibles entre elles, sinon on obtiendra un message d’erreur:

xx-->A+Bxxxxxx!--errorx8xxinconsistentxadditionxxxx-->B*Axxxxxx!--errorx10

xxinconsistentxmultiplication

sauf dans le cas ox l’une des matrices est de taille 1 × 1 auquel cas on fera une opxration terme x terme entre un nombre et une matrice:

11addition11soustraction11multiplication

11   +   11     -     11     *

11

xx-->AxxxAxx=xxxxxxxx1.xx-x2.xxxx3.xxxxxx4.xxxx5.xxxx6.xxxxxx7.xxxx8.xxxx9.xxxx-->1+A
xxxansxx=xxxxxxxx2.xx-x1.xxxx4.xxxxxx5.xxxx6.xxxx7.xxxxxx8.xxxx9.xxxx10.xxxx-->2-A
xxxansxx=xxxxxxxx1.xxxx4.xx-x1.xxxx-x2.xx-x3.xx-x4.xxxx-x5.xx-x6.xx-x7.xxxx-->3*A
xxxansxx=xxxxxxxx3.xxx-x6.xxxxx9.xxxxxx12.xxxx15.xxxx18.xxxxxx21.xxxx24.xxxx27.

Il faudra faire attention aux confusions possibles entre les diffxrentes opxrations matricielles, termes x termes ou scalaire. En particulier le cas des divisions matricielles peuvent conduire x des erreurs complexes:

lorsqu’on veut faire une division terme x terme d’un rxel par une matrice il faut faire attention x la position du point du ./, s’il touche le rxel x diviser

le point sera ignorx: 1./A ⇔1/A ⇎(1)./A . Pour une matrice A carrxe 1/A est en fait l’inverse de la matrice (si il existe) qu’on peut aussi obtenir par inv(A) ou

A^(-1) .

On peut vxrifier la diffxrence sur l’exemple suivant:

xx-->1./Axxxansxx=xxxxxxx0.125xx-x1.75xxxxxxxxx1.125xxx-x0.25xxxxx0.5xxxxxxxx-x0.25
xxxxx0.125xxxx0.9166667xx-x0.5416667xxxx-->(1)./Axxxansxx=xxxxxxx1.xxxxxxxxx-x0.5xxxxxx0.3333333
xxxxx0.25xxxxxxxxx0.2xxxxxx0.1666667xxxxx0.1428571xxxx0.125xxxx0.1111111xx

Pour les calculs d’inverse (qui peut ne pas exister dans certains cas) on obtient le mxme rxsultat qu’avec 1/A

xx-->A^(-1)xxxansxx=xxxxxxx0.125xx-x1.75xxxxxxxxx1.125xxx-x0.25xxxxx0.5xxxxxxxx-x0.25
xxxxx0.125xxxx0.9166667xx-x0.5416667xxxx-->inv(A)xxxansxx=xxxxxxx0.125xx-x1.75xxxxxxxxx1.125
xxx-x0.25xxxxx0.5xxxxxxxx-x0.25xxxxx0.125xxxx0.9166667xx-x0.5416667

Enfin, quand on a une matrice A de taille inconnue on peut rxcupxrer le nombre de lignes et/ou de colonnes par les instructions size(A),size(A,1),size(A,2). On peut aussi utiliser length() quand la matrice a une seule ligne ou une seule colonne pour rxcupxrer sa longueur.

xx-->size(A)xxxansxx=xxxxxxxx3.xxxx3.xxxx-->size(B)xxxansxx=xxxxxxxx3.xxxx2.xxxxxx
xx-->size(C)xxxansxx=xxxxxxxx5.xxxx4.xx-->size(C,1)xxxansxx=xxxxxxxx5.xx-->size(C,2)xxxansxx=
xxxxxxxx4.xx-->size(L1)xxxansxx=xxxxxxxx1.xxxx5.xxxxxx-->length(L1)xxxansxx=xxxxxxxx5.xx

Il existe beaucoup de fonctions Scilab utiles pour les matrices: sum pour faire la somme des coefficients d’une matrice, prod pour le produit , min et max pour trouver le coefficient le plus petit/le plus grand d’une matrice …

xx-->AxxxAxx=xxxxxxxx1.xx-x2.xxxx3.xxxxxx4.xxxx5.xxxx6.xxxxxx7.xxxx8.xxxx9.
xxxx-->sum(A)xxxansxx=xxxxxxxx41.xxxxxxxx-->max(A)xxxansxx=xxxxxxxx9.xx

En gxnxral, lorsqu’on applique une fonction de ℝ dans ℝ x une matrice elle est appliquxe x chaque terme de la matrice. cependant certaines fonctions courantes possxdent une dxfinition matricielle que ne correspond pas simplement x l’application de la fonction x chaque terme de la matrice. Dans Scilabxles versions matricielles des fonctions rxelles sont dxsignxes par le mxme nom avec un m en plus x la fin. Par exemple pour la fonction exponentielle:

xx-->exp(A)//applicationxtermexxxterme
xxxansxx=
xx
xxxxxx2.7182818xxxx0.1353353xxxx20.085537
xxxxxx54.59815xxxxx148.41316xxxx403.42879
xxxxxx1096.6332xxxx2980.958xxxxx8103.0839
xx
xx-->expm(A)//exponentiellexdexmatrice
xxxansxx=
xx
xxxxxx185820.61xxxx178590.07xxxx270297.43
xxxxxx988276.19xxxx949854.08xxxx1437565.7
xxxxxx1527664.9xxxx1468268.9xxxx2222171.

5 Les Boolxens

Scilabxpermet aussi d’effectuer les principales opxrations de comparaisons entre nombres. Le rxsultat d’une telle opxration est un boolxen, Scilabxreconnaxt donc aussi le type Boolxen et effectue les opxrations xlxmentaires associxes. Les deux valeurs “Vrai” et “Faux” sont deux constantes dxfinies en Scilabxpar %T et %F, le tableau ci-dessous donne les principaux opxrateurs associxes aux boolxens:

11xgal11diffxrent11infxrieur11supxrieur11infxrieur11supxrieur11ou11et11non
11   11       11 strict 11 strict 11 ou xgal 11 ou xgal 11  11  11

11==11 <> 11 < 11 > 11 <= 11 >= 11 | 11&11 ∼

11

Attention x ne pas confondre avec l’opxrateur de comparaison == avec celui d’affectation =. Voici quelques exemples d’utilisation des boolxens avec Scilab:

xx-->3<1xxansx=xxxxxFxx-->3=1//mauvaisexcomparaisonxxxWarning:xobsoletexusexofx=
xxinsteadxofx==x!xxxxxansxx=xxxxFxxxx-->3==1//bonnexcomparaisonxxxansxx=xxxxFxxxx
xx-->%i^2==-1xxxansx=xxxxxTxx-->~(3<1)&(%i^2==-1)xxxansx=xxxxxTxx-->%T|%Fxxxansx=xxxTxxxx

On peut fabriquer des matrices de Boolxens x partir de comparaisons directement entre matrices de rxels, la fonction find permet de trouver les cases de valeur vrai dans une matrice Boolxens:

xx-->x=rand(2,4)
xxxxxx=
xxxxxx0.8782165xxxx0.5608486xxxx0.7263507xxxx0.5442573
xxxxxx0.0683740xxxx0.6623569xxxx0.1985144xxxx0.2320748
xx-->y=rand(2,4)
xxxyxx=
xxxxxx0.2312237xxxx0.8833888xxxx0.3076091xxxx0.2146008
xxxxxx0.2164633xxxx0.6525135xxxx0.9329616xxxx0.312642
xx
xx-->x<y
xxxansxx=
xxxxFxTxFxF
xxxxTxFxTxT
xx-->min(x)//minimumxdexx
xxxmxx=
xxxxxx0.0683740
xx
xx-->x==min(x)
xxxansxx=
xxxxFxFxFxF
xxxxTxFxFxF
xx
xx-->[i,j]=find(x==min(x))//positionxduxminimum
xxxjxx=
xx
xxxxxx1.
xxxixx=
xx
xxxxxx2.
xx

xx-->[i,j]=find(x==1)//unxcasxsansxsolution
xxxjxx=
xx
xxxxxxx[]
xxxixx=
xx
xxxxxxx[]

6 Les chaxnes de caractxres

Scilab permet de manipuler facilement les chaxnes de caractxres, pour crxer une chaxne de caractxres il suffit de la mettre entre apostrophes:

xx-->'unexchaxne'
xxxansxx=
xx
xxxunexchaxne

si on veut mettre une apostrophe dans une chaxne de caractxres, il faudra la faire prxcxder elle aussi d’une apostrophe:

xx-->txt='lexcaractxrexd''xchappementxestxl''apostrophe'
xxxtxtxx=
xx
xxxlexcaractxrexd'xchappementxestxl'apostrophe

On peut effectuer de nombreuses opxrations sur les chaxnes: concatxner deux chaxnes par +, calculer la longueur d’une chaxne par length() ou encore extraire le k^{ieme} xlxment d’une chaxne avec part(chaxne,k):

xx-->length(txt)
xxxansxx=
xx
xxxxxx43.
xx-->part(txt,2)
xxxansxx=
xx
xxxe
xx-->'texte='+txt
xxxansxx=
xx
xxxtexte=lexcaractxrexd'xchappementxestxl'apostrophe

Chaque caractxres possxde un code numxrique les fonctions str2code et code2str permettent de passer de la chaxne au code et inversement. Par exemple le code de a est 10 et 11 est le code de b:

xx-->str2code('a'),code2str(11)
xxxansxx=
xx
xxxxxx10.
xxxansxx=
xx
xxxb
xx-->logo='Scilabx5'
xxxlogoxx=
xx
xxxScilabx5
xx-->str2code(logo).'
xxxansxx=
xx
xxxx-x28.xxxx12.xxxx18.xxxx21.xxxx10.xxxx11.xxxx40.xxxx5.
xx-->code2str(ans)
xxxansxx=
xx
xxxScilabx5

La conversion d’un rxsultat de calcul en chaxne de caractxre se fait par la fonction string, attention de ne pas confondre la chaxne affichxe et la variable qu’elle reprxsente:

xx-->%e//nexpasxconfondrexlexnombre
xxx%exx=
xx
xxxxxx2.7182818
xx
xx-->string(%e)//etxlaxchaxnexdexcaractxres
xxxansxx=
xx
xxx2.7182818
xx
xx-->%e==string(%e)
xxxansxx=
xx
xxxxF

Lors de l’exxcution de certains programmes il peut xtre utile de faire apparaxtre des informations x l’xcran, pour cela on peut utiliser la fonction disp:

xx-->u=%e-1
xxxuxx=
xx
xxxxxx1.7182818
xx-->disp(u)//affichagexd'unexvariable
xx
xxxxxx1.7182818
xx-->disp('u=%e-1='+string(u))//affichagexd'unxmessage
xx
xxxu=%e-1=1.7182818
xx-->disp(u,'u=%e-1=')//plusxcomplexe
xx
xxxu=%e-1=
xxxxxx1.7182818

On peut faire appel x d’autres foncions pour afficher des rxsultats x l’xcran, Par exemple la fonction C printf peut xtre appelxe directement dans Scilab:

xx-->printf('laxvaleurxdexexestx\nxe=x%fx\n',%e)
xxlaxvaleurxdexexest
xxxe=x2.718282
xx-->printf('lesxpremiersxentiersxnaturelsxsontx%d,%d,%dx...\n',0,1,2)
xxlesxpremiersxentiersxnaturelsxsontx0,1,2x...

On peut aussi fabriquer des matrices de chaxnes de caractxre dans un fichier avec les commandes write ou mputl et les lire avec read ou mgetl:

xx-->M=['anglais'x'hello';  xx-->'franxais'x'bonjour';  xx-->'espagnol'x'hola']  xxxMxx=xx
xx!anglaisxxxhelloxxxx!xx!xxxxxxxxxxxxxxxxxxx!xx!franxaisxxbonjourxx!xx!xxxxxxxxxxxxxxxxxxx!
xx!espagnolxxholaxxxxx!xxxx-->mputl(M,'essai.txt') xxxxxx-->mgetl('essai.txt') xxxansxx=
xxxx!xanglaisxxx!xx!xxxxxxxxxxx!xx!xfranxaisxx!xx!xxxxxxxxxxx!xx!xespagnolxx!
xx!xxxxxxxxxxx!xx!xhelloxxxxx!xx!xxxxxxxxxxx!xx!xbonjourxxx!xx!xxxxxxxxxxx!xx!xholaxxxxxx!

Attention mputl permet de rxcrire sur un fichier ce que ne permet pas write:

xx-->mputl(M,'essai.txt')
xx-->mputl(M,'essai.txt')//rxxcriturexsurxlexfichier
xx
xx-->write('essai.txt',M)//rxxcriturexsurxlexfichier
xxxxxxxxxxxxxxxxxxxxxxx!--errorx240
xxFilexessai.txtxalreadyxexistsxorxdirectoryxwritexaccessxdenied

7 Les fonctions

Un des concepts mathxmatique les plus important en informatique est le concept de fonction. Scilabxpossxde un type de variable function spxcifique pour coder les fonctions, d’ailleurs toutes les commandes que nous avons vu jusqu’ici sont en fait des fonctions Scilabx.

D’un point de vue mathxmatique, une fonction est une relation qui x un paramxtre d’entrx associe au plus une valeur en sortie:

.  \begin{aligned}f : & A & ⟶ & B \\ & x & ⟼ & y = f(x) \end{aligned}  la

dxfinition d’une fonction dans Scilabxreprend exactement ce schxma mais sans contrxler le type des variables en entrxe/sortie (normal, puisque l’on ne dxclare pas les types des variables avant affectation). Par exemple, la fonction de ℝ dans ℝ dxfinie par f(x) = 1 + x^{2} sera codxe en Scilabxpar

xxfunctionx[y]=f(x)
xxy=1+x^2
xxendfunction

Maintenant il faut sauver ce code dans un fichier (appelons le mafonction.sci) et le charger dans la session Scilabxpour pouvoir ensuite l’utiliser. On peut pour cela utiliser n’importe quel xditeur de texte, mais Scilabxpossxde un xditeur de texte, scipad, parfaitement adaptx au langage Scilab (coloration syntaxique, numxrotation des lignes, recherche de mots, interfaxage avec Scilab, dxbogage …). Pour lancer Scipad

cliquez sur l’onglet Editeur de la barre de menus

dans la console utiliser la commande scipad() une nouvelle fenxtre va s’ouvrir: c’est l’xditeur de texte que vous pouvez utiliser pour saisir le

code de la fonction f.

PIC Fig.x3: l’xditeur de texte scipad

Lorsqu’on veut enregistrer des dxfinitions de fonctions Scilabxdans un fichier on lui donnera un nom avec une extension de la forme *.sci. Par contre si on

veut sauvegarder dans un fichier une liste de commandes x exxcuter sxquentiellement (c’est x dire un script) on utilisera plutxt un nom avec une extension de la forme

*.sce.

On peut xcrire plusieurs dxfinitions de fonctions dans un mxme fichier. Une fois le fichier sauvx on peut le charger dans Scilabxdepuis le menu execute de scipad (cf figure FIG.3) ou avec la commande exec depuis la console. Une fois chargxe, on peut utiliser la fonction comme les autres fonctions Scilabx. On peut aussi avoir besoin de dxfinir une fonction en une seule ligne avec la commande, c’est possible avec la commande deff, mais moins maniable qu’avec la commande function (il faut une certaines comprxhension des problxmes lixs aux chaxnes de caractxres dans ce cas).

xx-->exec('mafonction.sci')//dxfinitionxviaxunxfichier
xx-->deff('[y]=f(x)','y=1+x^2')//dxfinitionxenxligne
xx-->f(2)
xxxansxx=
xx
xxxxxx5.
xx-->whosx-typexfunction
xxNamexxxxxxxxxxxxxxxxxxxxxTypexxxxxxxxxxxSizexxxxxxxxxxxBytes
xx
xxwhosxxxxxxxxxxxxxxxxxxxxxfunctionxxxxxxxxxxxxxxxxxxxxxx8512
xxfxxxxxxxxxxxxxxxxxxxxxxxxfunctionxxxxxxxxxxxxxxxxxxxxxx216
xx-->f(x)
xxf(x)
xxxxxx!--errorx4
xxundefinedxvariablex:xx
xxatxlinexxxxxxx5xofxexecxfilexcalledxbyx:
xxexec('fonction.sce',1)

l’erreur gxnxrxe x la dernixre ligne ci-dessus impose une remarque importante

Scilabxest un logiciel de calcul numxrique et pas un logiciel de calcul formel, la commande f(x) n’a aucun sens si x n’est pas une variable dxfinie (x=2 ou une

matrice par exemple). De mxme les commandes du type f(x)=1+x^2 ne dxfinissent pas une fonction Scilabx.

Si on veut appliquer cette fonction f x une matrice il faut se mxfier des confusions entre opxrations terme x terme et opxrations matricielles. Par exemple, si x est une matrice carrxe x^2 sera interprxtx comme un produit matriciel et non comme une xlxvation au carrx de chaque terme. pour xviter ce genre de problxmes on utilisera la commande feval pour xvaluer une fonction sur chaque valeur d’une matrice:

xx-->A=[1x2;x3x4]xxxAxx=xxxxxxxx1.xxxx2.xxxxxx3.xxxx4.xxxx-->f(A)xxxansxx=
xxxxxxxx8.xxxxx11.xxxxxx16.xxxx23.xxxx-->1+A.^2xxxansxx=xxxxxxxx2.xxxxx5.
xxxxxx10.xxxx17.xxxx-->feval(A,f)xxxansxx=xxxxxxxx2.xxxxx5.xxxxxx10.xxxx17.

Cependant, en mathxmatiques, on peut considxrer que les ensembles de dxpart et d’arrivx d’une fonction sont en fait des produits d’ensembles. Ce point de vue est valable dans Scilabxce qui permet de considxrer facilement des fonctions ayant plusieurs variables en entrxe et en sortie contrairement x d’autre langages (comme le langage C). Mais il faudra faire attention x bien rxcupxrer les paramxtres en sortie:

xxfunctionx[a,b]=f(x,y)xxa=x+yxxb=x*yxxendfunctionxxxxxx-->[a,b]=f(2,3)xxxbxx=
xxxxxx6.xxxaxx=xxxxxx5.xxxx-->//bxestxperdue!xx-->f(2,3)xxxansxx=xxxxxxxx5.xx

Pour bien utiliser les fonctions Scilabxil faut aussi comprendre le problxme des variables locales et des variables globales. Le mxcanisme d’appel de fonction en conxu pour que les variables dxfinies x l’intxrieur du corps de la fonction n’interfxrent pas avec celle dxfinies dans la session Scilabxqui appelle la fonction.

xxx-->a=1,b=2
xxxaxx=
xx
xxxxxx1.
xxxbxx=
xx
xxxxxx2.
xx-->deff('[a,b]=g(x)','a=x+1,b=2*b')
xxWarningx:redefiningxfunction:xg
xx
xx-->[u,v]=g(3)//lesxvaleursxdexaxetxbxsontxprisentxenxcompte
xxxvxx=
xx
xxxxxx4.
xxxuxx=
xx
xxxxxx4.
xx-->a,b//maisxellesxnexsontxpasxmodifixexdansxl'environnementxglobal
xxxaxx=
xx
xxxxxx1.
xxxbxx=
xx
xxxxxx2.

On retiendra la rxgle suivante:

Lors de l’appel x une fonction, si une variable apparaissant dans le corps de la fonction n’est pas dxfinie dans l’environnement local (entre les commandes

function et endfunction) alors pour xvaluer cette variable Scilabxva chercher si cette variable est dxfinie dans la session d’ox la fonction a xtx appelxe (ce qu’on appelle l’environnement global). Si la variable n’est pas dxfinie dans l’environnement global il y aura une erreur avec le message undefined variable.

Autant que faire se peut, on xvitera d’utiliser dans le corps d’une fonction des variables qui ne sont pas dxfinies dans le corps de la fonction. si toute fois on a besoin d’utiliser des variables globales on pourra utiliser la commande global pour partager des variables entre plusieurs fonctions et l’environnement global.

8 Programmation Toutes les commandes vues depuis le dxbut de ce chapitre forment les instructions de base du langage de programmation de Scilabx. Mais pour aller plus loin il nous manque les instructions de base de l’algorithme que sont les branchements conditionnels et les boucles.

11  pseudo-code  11 scilab

11

11                                11
11sixcondition  alorsxaction1 sinonxaction2 fin si11ifxconditionxthenxaction1 xxxxxxxxxxxxxxelsexaction2 xend

11pourxcpt=debut  jusqu’xxfin parxpas fairexactions fin faire11forxcpt=debut:pas:fin xxxxxactions xend

11tant quexcondition  fairexactions fin faire11whilexcondition xxxxxactions xend

11
11
11

{11 \atop 11}

Dans ce qui prxcxde condition reprxsente une expression dont l’xvaluation conduit x une valeur boolxenne (%t ou %f) et les action∗ reprxsentent des suites de commandes Scilabxx exxcuter suivant le cas. La syntaxe de la boucle for mxrite une explication particulixre. En effet la syntaxe debut:pas:fin est exactement celle pour crxer une matrice ligne dont les valeurs partent de debut pour arriver x fin par incrxment de pas. On peut donc xcrire les boucle for sous la forme:

xxforxcpt=L

ox L est une matrice ligne et le compteur cpt prendra successivement toutes les valeurs de L (dans l’ordre). Cette remarque est trxs utile pour rxxcrire certaines boucles plus simplement.

Dans une structure conditionnelle l’instruction then peut xtre omise, mais si ce n’est pas le cas alors les instructions if et then doivent obligatoirement

xtre sur la mxme ligne.

Pour mieux comprendre prenons l’exemple trxs simple du calcul d’un factoriel. Si on veut xcrire un script pour calculer 10! en utilisant la dxfinition n! = n × (n − 1)! et 1! = 1, on xcrira un fichier avec le code:

xxfact=1
xxforxk=1:10
xxxxxxfact=k*fact
xxend

On sauve ce code dans un fichier script.sce que l’on peut exxcuter dans Scilabxavec la

commande exec('script.sce') ou en cliquant sur l’onglet execute-->load into

scilab de l’xditeur scipad.

On xvitera de lancer de lancer des instructions if, for, while …xdirectement dans la console et on privilxgiera l’utilisation de fichiers (scripts).

En particulier lorsqu’une commande if, for ou while est lancxe dans la console aucune commande n’est exxcutxe tant que le end correspondant n’a pas xtx exxcutx.

On peut aussi utiliser le langage de programmation Scilabxx l’intxrieur d’une fonction Scilabx. Par exemple pour la fonction dxfinie par factoriel(n) = n! on aura:

xxfunctionx[fact]=factoriel(n)xxfact=1xxforxk=1:nxxxxxxfact=k*factxxend
xxendfunctionxxxx-->factoriel(10)xxxansxx=xxxxxxxx3628800.xxxx

On peut aussi utiliser la rxcursivitx

xxfunctionx[fact]=factoriel(n)xxifxn==0xthenxfact=1xxxxxxxxxxelsexfact=n*fact(n-1)
xxendxxendfunctionxxxx-->factoriel(10)xxxansxx=xxxxxxxx3628800.xxxx

9 Sorties graphiques

Scilabxpossxde une librairie graphique trxs puissante, qu’il n’est pas possible de prxsenter entixrement ici. Pour pouvoir dxbuter avec Scilabxil faut commencer par comprendre comment tracer une courbe du plan comme le graphe d’une fonction par exemple.

Pour tracer une courbe Scilabxpossxde une fonction plot2d(x,y) qui va tracer une ligne brisxe en reliant par des segments de droites les points de coordonnxes (x(i),y(i)). Pour avoir un affichage convenable du graphe il faut donc avoir suffisamment de points pour que la courbe est un aspect “lisse” et pas celui d’une ligne brisxe. La dxmarche est donc la suivante:

dxcouper l’intervalle en un nombre suffisant de valeurs rangxes dans une matrice colonne x

calculer les valeurs correspondantes de f(x) (par exemple avec feval) et les stocker dans une matrice colonne y

exxcuter la commande plot2d(x,y) pour ouvrir la fenxtre ox s’affichera le graphe

Pour amxliorer l’aspect du graphe on pourra utiliser certaines options de la fonction plot2d (voir l’aide en ligne pour plus de dxtails), par exemple:

axesflag pour gxrer le positionnement des axes,axesflag=5 pour avoir des axes qui se croisent en (0, 0),

frameflag pour gxrer la taille de la fenxtre et les xchelle,frameflag=4 pour une xchelle isomxtrique, frameflag=6 pour avoir une xchelle avec des graduations “simples”,

xgrid() permet d’afficher une grille pour lire les coordonnxes,

legends() permet d’afficher une lxgende,

xxdeff('y=f(x)','y=x+cos(x)')
xxx=[-%pi:0.01:%pi]';
xxy=feval(x,f);
xxplot2d(x,y,5,axesflag=5,frameflag=6)
xxxgrid(3)//grillexverte

xxPIC

Quand on a plus besoin du graphe on peut dxtruire la fenxtre ou utiliser la commande clf() pour effacer le contenu de la fenxtre. On peut aussi superposer des courbes en exxcutant plusieurs fois plot2d sans effacer la fenxtre ou en une seule commande comme ci-dessous:

xxclf()//effacementxdexlaxfenxtre
xxdeff('y=g(x)','y=cos(x)/(1+x^2)')
xxy2=feval(x,g);
xxplot2d([xxx],[yxy2],[5x2],axesflag=5,frameflag=6)
xxxgrid(3)
xxlegends(['f(x)'x'g(x)'],[5x2],2)//affichagexd'unexlxgende

PIC

Pour les fonctions x deux variables on peut faire des graphiques en trois dimensions avec plot3d1(x,y,z). Il faudra cette fois dxcouper le domaine en petits rectangles (c’est x dire dxcouper l’intervalle des x et des y puis calculer les valeurs correspondantes de z=f(x,y). Pour faciliter l’interprxtation du graphe Scilabxpermet un affichage des niveaux en couleur x l’aide d’une table des couleurs (colormap en anglais).

xxclf()
xxdeff('z=f(x,y)','r=sqrt(x^2+y^2),z=exp(-r)*cos(3*%pi*r)')

xxx=[-1:0.01:1]';y=x;
xxz=feval(x,y,f);
xxcmap=hotcolormap(64);//tablexdex64xcouleurs
xxxset("colormap",cmap);//chargementxdexlaxcolormap
xxplot3d1(x,y,z)//affichagexduxgraphe

PIC