Vous êtes sur la page 1sur 32

Chapitre 1

Scilab et algorithmique

I Prsentation du logiciel Scilab


Scilab est un logiciel libre dvelopp par un consortium constitu :
dorganisations publiques (entre autre lINRIA, le CNES, le CEA),
dentreprises (Peugeot, Renault, EDF, etc.),
dcoles et duniversits (entre autres lcole Polytechnique).
On peut le tlcharger gratuitement 1 .
Scilab est un logiciel de calculs numriques, il ne sait donc pas grer des variables qui nont
pas de valeurs. Ainsi, il peut calculer cos(x) et cos(-x), si x a une valeur, mais na aucune ide de
la signification de la formule cos(x)=cos(-x). De mme, il est incapable de faire des calculs du type

(1 + 2)2 = 3 + 2 2. Il peut vrifier lgalit 3/2 = 6/4, en calculant les valeurs des deux membres
et en comparant ces valeurs, mais ne simplifiera pas les fractions tout seul.
Par contre, il permet de :
programmer des fonctions, i.e. des instructions excutes sur des donnes et pouvant tre
appeles, dans lespace de travail, voire dans dautres fonctions.
travailler avec des donnes sous forme matricielle de manire efficace. Ainsi, on pourra faire
lopration A X, si A et X sont des matrices de tailles compatibles.
contrler le flux dexcution i.e. excuter certaines instructions plusieurs fois (on parle alors
de boucle), ou choisir les instructions excutes selon les valeurs dune variable. Ce contrle du
flux se fait laide de mots cls, comme if, end, for et while.
travailler de manire trs rapide avec les fonctions mathmatiques. La plupart des fonctions
mathmatiques sont dj implmentes, en particulier les algorithmes complexes pour le calcul
des probabilits et le calcul matriciel.
afficher des rsultats sous forme graphique.

Scilab au concours de BCPST Dans la quasi totalit des sujets dcrit de concours, une question
Scilab est prsente, note entre 2 et 4 points. Il faut donc savoir crire de petites fonctions Scilab pour
lcrit. Une erreur de syntaxe sans gravit nest pas sanctionne lourdement. Par contre, les erreurs
dalgorithmique sont davantage sanctionnes.

1. Par exemple, sur le site officiel : http://www.scilab.org/.

1
Une preuve orale doption est aussi prvue, sous forme dun projet et dexercices loral. La
moyenne de lpreuve tourne autour de 13 et seuls les points au-dessus de 10 sont pris en compte.
Dans les rapports de jury, il est systmatiquement rappel quun effort en informatique est payant
et fait gagner des points, lcrit comme loral.
Enfin, rappelons que, dans la plupart des coles que lon peut intgrer avec une BCPST, un cours
dinformatique est prvu en premire anne. Il sagit trs souvent dun cours sur un logiciel de calculs
numriques (Scilab ou Matlab 2 ), ainsi le temps consacr linformatique en BCPST nest pas du
temps perdu , mme si cest une matire nouvelle par rapport la classe de Terminale et qui
demande donc un certain investissement au dbut.

II Prise en main du logiciel : les trois interfaces de travail


Scilab propose trois environnements de travail : la ligne de commande, les scripts et les fonctions.

La ligne de commande Cest linterface de travail par dfaut : on tape une commande et le calcul
est fait. Le rsultat est affich si la ligne ne finit pas par ;, sinon il est effectu sans affichage. On peut
retrouver les commandes dj tapes en utilisant .
Application 1 Tapez les commandes dans lespace de travail, tout ce qui suit le symbole // sont
des commentaires, il est donc inutile de les recopier.

2+2 //exemple de calcul simple


2+2; // le mme avec un ;
(1-%i)* 2 // exemple de calcul dans C : %i est le i complexe
3*2 // exemple de multiplication
sqrt(2) // appel dune fonction mathmatique
%pi // constante pi
i*2 // ne pas oublier les %
log 2 // ni les ().

Lorsque le flux dexcution est suspendu (i.e. lorsquon se trouve dans une boucle for ou un if),
alors rien ne se passe jusqu ce que lon entre le mot cl end. Pour indiquer que les excutions sont
suspendues, les invites de commandes > sont rapproches.
Application 2 Taper les commandes :

for i=1:10
disp(i)
end

Remarquez la manire dont les invites de commandes > sont rapproches.


Ce mode est utile pour des tests rapides, mais les commandes tapes ne peuvent tre mmorises 3 .
Dune manire gnrale, il est dconseill de taper des commandes permettant de contrler le flux

2. quivalent propritaire du logiciel Scilab. Le gnrateur de nombres alatoires est moins puissant, mais linterface
est plus agrable.
3. Lhistorique peut tre retrouv par la commande gethistory.
dinstructions dans la ligne de commande, i.e. ds quon utilise if, for ou while, il faut utiliser un
script ou une fonction.
Pour interrompre le flux dexcution en cas durgence, il faut utiliser le raccourci clavier
CTRL+C. Linvite de commande devient -1->, on peut alors annuler le tout en utilisant la commande
abort.
Application 3 Taper les commandes :

i=1;
while (i<10)
disp(i)
end

Pour sortir de lexcution, utiliser le raccourci clavier CTRL+C, puis la commande abort.

Les scripts Un script est un fichier texte qui contient une suite de commandes. Lorsque le fichier est
excut, les commandes sont excutes une par une, comme si elles taient tapes dans la ligne de com-
mande. Si une erreur est rencontre, lexcution sarrte. Les scripts permettent donc de sauvegarder
la suite dinstructions effectues pour pouvoir la refaire.
Pour crer un script, il faut donc utiliser un diteur de texte 4 , dans lequel on cre un fichier
texte quon enregistre, de prfrence avec lextension .sce qui signifie Scilab executable. Puis, pour
excuter le fichier, il faut utiliser la commande exec(fichier.sce), en ayant pris soin de donner
Scilab le chemin du rpertoire contenant le fichier 5 . Bien entendu, il faut sauvegarder le fichier avant
de lexcuter.
Application 4 Ouvrir lditeur, enregistrez dans le fichier presentation.sce la suite dinstructions :

clear; //efface toutes les variables


clc; //efface lcran
nom=input("Quel est ton nom?","string");
disp("bonjour "+nom);

Excuter ce script.
La solution un exercice de Scilab sera donc toujours un script permettant de raliser lexprience
demande.
Pour prendre de bonnes habitudes :
un script commence par la commande clear; qui permet deffacer toutes les variables, afin de
bien vrifier que dventuelles commandes prcdentes ninterviennent pas dans le script.
Ensuite on charge les diffrentes fonctions,
puis la description des constantes,
enfin lappel aux fonctions.
Notons, de plus, que rien nempche de faire appel un script dans un script, en utilisant la commande
exec.
4. On peut utiliser celui intgr Scilab, mais il est peu puissant. Le mieux est donc dutiliser un programme externe,
par exemple Geany. Voir sur le site web comment configurer Geany pour Scilab.
5. La commande pwd indique le rpertoire de travail. On le change avec la commande cd. Il est aussi possible dutiliser
le menu.
Comme tous les langages de programmation, Scilab permet lutilisation de commentaires, tout
ce qui suit // tant ignor. Cette fonctionnalit doit tre utilise pour expliquer ce que fait le code.
Dans les preuves dcrit, il est conseill aussi dajouter des commentaires pour expliquer sa dmarche.
Un code sans commentaires na aucune valeur.
De mme, les espaces entre les mots ne sont pas pris en compte lors de lexcution, ce qui est
particulirement intressant pour les tabulations qui permettent de structurer visuellement le code.

Les fonctions Une fonction est une suite dinstructions excutes sur des entres permettant le
calcul de sorties. Cette suite dinstructions est enregistre dans un fichier texte. Les entres sont
donnes par lutilisateur et les instructions nont donc un sens pour Scilab qu lappel de la fonction
sur certaines entres. Lavantage dune fonction est quelle peut tre appele sur nimporte quel type
dentre, exactement comme une fonction mathmatique. Par exemple, si on considre la fonction
function [out]=f(x,y), on pourra lappeler sous la forme f(2,i), mais aussi sous la forme 6 f(x,x),
f(2x,y), etc. On pourra aussi utiliser linstruction f(f(x,y),z).
Il ne faut donc pas donner de valeurs aux variables dentres dans la fonction. Une fonction du
type f : x 7 x2 + 3x + 2, qui serait implmente sous la forme :
function out=f(x)
x=2;
out=x^2+3*x+2;
endfunction
ne fera que renvoyer la valeur 12, ce qui nest absolument pas la fonction demande.
De mme, une fonction doit systmatiquement donner une valeur aux sorties, sinon elle ne calcule
rien. La fonction f doit donc contenir une instruction du type out=, o out est le nom de la variable
de sortie 7 . Ces deux erreurs (donner une valeur aux entres dans la fonction et ne pas donner de
valeur aux sorties) sont considres comme des erreurs dalgorithmique.
La syntaxe dune fonction est trs particulire. Il faut indiquer Scilab que les variables en entre
nont pas de valeurs, et que les instructions nauront de sens que lors de lappel de la fonction.
Une fonction doit donc toujours commencer par une ligne
function [y1,y_2, ... , yn]= nom_fonction(x1,x2 ... , xm)
o les xi sont les entres, tandis que les yi sont les sorties, et finir par la commandeendfunction.
La fonction est ensuite ajoute Scilab via la commande exec(fichier.sci), lextension .sci
( Scilab Input ) tant conseille pour les fichiers de fonctions. Il est aussi conseill dutiliser un
fichier par fonction, le fichier portant le nom de la fonction.
Si Scilab dtecte une erreur de syntaxe (si, par exemple, il manque un end), il met une erreur en
indiquant la ligne correspondante. Si la fonction est correctement charge, une nouvelle variable est
alors cre dans Scilab, portant le nom de la fonction. Une fonction peut ainsi tre utilise comme
entre dune autre fonction.
La fonction peut alors tre excute, en tapant la commande correspondante, les entres tant
indiques dans une parenthse.
Par exemple, on doit entrer dans lditeur les lignes :
6. Si x est une variable qui a dj une valeur videmment.
7. Ceci tant valable bien sr pour toutes les sorties si il y en a plusieurs.
function out=f(x,y)
out=cos(x)*y;
endfunction

Ces lignes doivent tre enregistres dans un fichier f.sci. Ensuite, on doit charger la fonction,
i.e. excuter la commande exec(f.sci). On peut ensuite lappeler avec, par exemple :

f(%pi/4,%i);//renvoie 0.7071068i
x=2;y=4;
z=f(x+y,y);//stocke - 1.117662 (soit 4sin(6)) dans z
f(f(1,1),0.3) // exemple de composition.

Si il y a plusieurs sorties, seule la dernire est affiche, le reste peut tre rcupr en stockant les
valeurs de sorties.
Par exemple :

function [u,v]=f(x,y)
u=x+y;
v=x-y;
endfunction

La commande f(3,4) ne renverra que la valeur 7. Pour rcuprer la valeur -1, il faut taper :
[x,y]=f(3,4); la variable x contiendra alors 7, et y contiendra -1.
Notons enfin que les instructions de la fonction ne sont effectues que lorsque la fonction est
appele, ce qui peut poser des problmes si la fonction est appele sur des entres, en dehors de son
domaine de dfinition.
Par exemple, une fonction f : (x, y) 7 . . . dfinie si (x, y) R2 , et contenant linstruction if
x < y, ne posera aucun problme lors du chargement de la fonction. Par contre, un appel de la
fonction du type f (i, 4) provoquera un message derreur. Cest pourquoi, il est conseill dcrire des
commentaires, au dbut dune fonction, un petit descriptif des entres et des sorties. De mme que
lon doit prciser le domaine de dfinition dune fonction en mathmatiques.
Enfin, pour modifier une fonction, il faut modifier le fichier, puis le sauvegarder et le recharger (de
nouveau avec la commande exec). Un avertissement est alors affich pour signaler que la fonction est
redfinie : Warning :redefining function: nomfonction.
Application 5 Ouvrir lditeur et sauvegardez dans le fichier demandeAge.sci les lignes :

function age=demandeAge(prenom)
//entre: prenom (chane de caractre)
//sortie: age (rel)= ge donn
//Cette fonction demande lge de la personne dont le prnom est en entre
disp("Bonjour "+ prenom);
age=input(prenom+ ", quel est ton ge?");
endfunction

Pour appeler cette fonction :


enregistrez votre fichier,
chargez la fonction avec la commande exec(demandeAge.sci);
appelez-la avec une commande du type demandeAge(toto);
Que se passe-t-il si on appelle la fonction avec demandeAge(5); ?
Modifier la fonction pour quelle affiche merci la fin.

III Algorithmique : crire un programme


Dfinition 1. Un algorithme est une suite finie dinstructions dterministes permettant deffec-
tuer un calcul, dobtenir la valeur dune fonction ou, dune manire gnrale, de rsoudre un problme.
On sintressera en mathmatiques des algorithmes du type :

a tant donn, calculer une approximation de a, en donnant une marge derreur sur cette
approximation.
A et b tant donns, rsoudre le systme Ax = b.
Renvoyer une approximation de par la mthode de Monte-Carlo en utilisant 1000 lancers.
Calculer une valeur numrique de sin( 21
).
Trouver la trajectoire dun pendule soumis la gravit.
Mais linformatique peut aussi tre utilise pour :
modliser sous forme graphique la propagation dun feu dans une fort ou les dplacements de
fourmis la recherche de nourriture,
tant donn une position sur un jeux dchecs, donner la liste des coups possibles.
Plusieurs remarques simposent :
par instruction, on entend un ordre donn lordinateur , cest--dire faire un calcul, appeler
une fonction, affecter une variable, effectuer un test, etc, mais en aucun cas, on ne peut prendre le
point qui ralise le maximum de la fonction f sur lintervalle [0, 1], si on ne dispose pas de moyens
effectifs de calculer ce maximum. Cest la diffrence entre linformatique et les mathmatiques :
en mathmatiques on peut montrer lexistence de certains objets, en informatique, on a besoin
de pouvoir les calculer.
utiliser des instructions dterministes nempche par lutilisation dalatoires. En fait implicite-
ment un gnrateur de nombres alatoires est ajout aux entres. Par contre, tant donn des
entres identiques (dont le gnrateur alatoire), les sorties seront identiques, encore une fois
comme pour une fonction en mathmatiques.
le problme de la finitude est complexe : il faut pouvoir prouver quun algorithme sarrte et
ne boucle pas indfiniment, en particulier dans le cas dalgorithmes rcursifs, qui sappellent
eux-mmes.
sajoute ces notions une dfinition de lefficacit. Un algorithme doit faire le moins de calculs
possibles pour calculer la sortie, de manire diminuer le temps de calcul. De plus, un algorithme
doit, si possible, utiliser le minimum despace mmoire.

IV Utilisation de variables
La premire notion informatique lie celle dalgorithme est la notion de variable : une variable
est un bloc de mmoire qui est nomm.
Ainsi, linstruction a=2; alloue un bloc de mmoire dans la RAM et y insre la valeur 2. On parle
daffectation de la variable a. Le caractre a fait alors rfrence ce bloc de mmoire. Lorsquon tape
linstruction b=a+2, le bloc de mmoire est lu, lopration est effectue et le rsultat est stock dans
la variable b. Ainsi, le = en informatique na pas le mme sens que le = mathmatique, en particulier
linstruction b=a nest pas identique linstruction a=b :
b=a lit le contenu de la variable a, et stocke ce contenu dans la variable b, a nest donc pas
modifie,
a=b lit le contenu de la variable b, et stocke ce contenu dans la variable a, b nest donc pas
modifie. Cest donc exactement le contraire.
Cette remarque permet dutiliser des instructions comme a=a+2, qui ajoute 2 au contenu de la
variable a. Ainsi, pour itrer une fonction partir dun point a, i.e. pour calculer les termes dune suite
(un ) dfinie par u0 = a et un+1 = f (un ), si on na besoin que du dernier terme de la suite, on pourra
utiliser linstruction x=a, pour initialiser une variable x la valeur de a, puis rpter linstruction
x=f(x).
Si on utilise une variable non affecte, on obtient alors un message derreur explicite undefined
variable : x. Utiliser une variable sans lui avoir donner de valeur est considr comme une faute
dalgorithmique. Bien entendu, dans une fonction, les variables en entres sont supposes tre affectes,
ou plus exactement sont affectes lors de lappel de la fonction.
Application 1
Tapez la suite de commandes, et observez le rsultat :

a=1; //affectation de variables le ; vite laffichage


a
b=a+3;
b
b=a+3 // influence du ;
2*b
(2b-1) /2 //ne pas oublier les *
b*2-1/2 // corrigez en utilisant la flche
(b*2-1)/2 // attention aux parenthses
B // B est diffrent de b

Application 2 Effacez lespace de travail avec la commande clear; puis tapez la commande :

a=a+3;

Que se passe-t-il ?
Application 3 Si lon excute la suite de commande :

a=2;
a=a*a;
a=a*a;
a=a*a;

Que contient la variable a ?


Application 4 Si lon effectue la suite de commande :

a=5;
b=3;
c=a;
a=b;
b=c;
Quelles valeurs contiennent les variables a et b ? Cette technique permet de transfrer la valeur dune
variable dans une autre.
Application 5 Calculez rapidement le 5-ime terme de la suite dfinie par : u0 = 2, et un+1 =
un sin(un ). Proposez une mthode avec une fonction et une sans.
Les types de donnes que peut contenir une variable en Scilab sont principalement :
un rel,
un complexe, en utilisant %i,
une chane de caractres,
une matrice ou un vecteur (considr comme une matrice avec une unique ligne/colonne),
une variable boolenne %t (vraie=true) ou %f (fausse=false),
une fonction.
La commande who_user permet dafficher le nom des variables affectes 8 , et la commande clear
permet deffacer lespace de travail, i.e. toutes les variables affectes. Pour connatre la valeur
dune variable, il suffit de taper son nom sans ajouter le ;, la valeur est alors affiche. Une commande
graphique permet dditer les variables, cest la commande browsevar();.

Porte des variables La manire dont les variables peuvent tre utilises par une fonction dpend
de la porte dune variable, i.e. du domaine dans lequel cette variable a une valeur :
une variable affecte dans lespace de travail est globale, cest--dire quelle est connue dans
toutes les fonctions. Ainsi, si dans lespace de travail on a dfini une variable f , nimporte quelle
fonction peut utiliser cette variable. Ceci est particulirement utilis si f est une fonction. On
peut considrer que lensemble de lespace de travail est implicitement ajout en entre dune
fonction.
de telles variables peuvent tre modifies dans une fonction, mais cest alors leur valeur locale
qui est modifie par la fonction, mais pas dans lespace de travail. Par exemple, si dans lespace
de travail on dfinit n=3, une fonction pourra utiliser le contenu de la variable n et faire des
oprations du type n=n+1, mais une fois sortie de la fonction, la valeur de n sera toujours 3.
Cela est vrai aussi, et particulirement utilis pour les entres dune fonction : si une fonction
y=f(x) modifie son entre en utilisant des instructions du type x=x-1, lappel de la fonction
avec une instruction du type f(x) ne modifie pas la valeur de x dans lespace de travail.
pour viter toute erreur, il est ainsi conseill dutiliser uniquement des variables locales, i.e.
une fonction doit pouvoir fonctionner uniquement avec ses entres. Cest de toute manire sous
cette forme que sont demandes les fonctions lors des preuves dcrit.
une variable utilise par une fonction est locale. Ainsi, si une fonction dfinit et utilise une
variable n, n naura pas de valeur en dehors de la fonction, ce qui permet de ne pas ajouter
de nouvelle variable. En particulier, appeler une fonction dfinie par y=f(x) avec linstruction
f (2) ne dfinit pas de variable y. On peut ainsi appeler la fonction sur une variable nomme z
et stocker le rsultat dans une variable nomme x, etc. Peu importe le nom de la variable dans
la fonction, cela nintervient pas sur les variables de lespace de travail.
8. Dautres variables systme sont aussi affiches, il suffit de ne pas en tenir compte.
Ainsi, on peut comparer une fonction Scilab une bote noire, calculant une sortie donne partir
dentres et des variables contenues dans lespace de travail, mais ne modifiant pas lespace de travail.
Application 6 crire une fonction du type :

fonction y=f(x)
x=x+1;
y=x^2;
endfunction

La lancer avec la suite de commandes :

exec("f.sci");
a=3;
f(a)

Quelle est la valeur de la variable a, celle de la variable x et celle de la variable y ?


Si on tape ensuite dans la ligne de commande :

x=5;
f(x^2)

Quelle est la valeur affiche ? Quelle est la valeur de la variable x ?

Erreurs de syntaxe classiques avec les variables :


Scilab fait la diffrence entre majuscule et minuscule.
il faut utiliser le symbole * pour une multiplication, 2b renvoie une erreur. Pour viter cette
confusion, on ne peut pas utiliser une variable commenant par un chiffre.
les lettres grecques ne sont pas acceptes, ainsi que les lettres accentues dans les noms de
variables. On utilisera donc des noms de variables du type phi.
les instructions daffection des variables doivent tre de la forme
variable=expression. Une expression du type 3=a est une erreur dalgorithmique, ainsi que
a+b=c+d, qui na aucun sens en informatique.
dans une instruction de la forme variable=expression, cest dabord expression qui est
value et ensuite le rsultat est stock dans variable. Ainsi, linstruction b=a+b; calcule a+b
et stocke le rsultat dans b.
pas daccents ni despace dans les noms de variables.

V Contrle du flux dexcution


Le contrle du flux dexcution permet dexcuter certaines instructions plusieurs fois, ou selon la
valeur de certaines variables.

V.1 Variables boolennes et instructions conditionnelles if


Variable boolenne Une variable boolenne est lquivalent informatique dune proposition ma-
thmatique. Cest donc une variable qui ne peut prendre que deux valeurs : true (T) ou false
(F).
Pour la dfinir, on utilise un oprateur de comparaison , cest--dire >,<,==,>=,<=,=. Il
existe deux possibilits pour 6= : ~= et <>.
Par exemple, si on a dfini deux variables x et y, linstruction x==y renvoie la valeur true si les
variables ont la mme valeur, false sinon. On utilise == pour bien signifier quil ne sagit pas dune
affectation. Linstruction x=y (qui met la valeur de y dans la variable x) est trs diffrente de x==y
qui compare les deux valeurs 9 . Attention ne pas confondre ces deux instructions : cela peut tre
considr comme une erreur dalgorithmique. On retiendra donc quil faut toujours mettre == dans
un test.
Les variables boolennes peuvent tre combines laide des oprateurs ~, & et | , quivalents en
mathmatiques non, et et ou respectivement.
Remarque: Mathmatiquement, la proposition p et q est fausse ds que p est fausse. Du
coup, lorsque Scilab rencontre une variable boolenne du type p et q , il commence regarder la
valeur de p. Si celle-ci est fausse, alors, il na pas besoin de regarder la valeur de q.
Dune part, cela vite des tests, et donc du temps de calcul inutile, mais lapplication la plus
importante est surtout que si p est fausse, la variable q peut-tre indfinie.
Lexemple typique est celui dun tableau : si on doit lire llement i dans un tableau tab de taille
n, il faut sassurer que i [[1, n]].
On rencontrera, par exemple le test :

if (i<=n) & (i>=1) & (tab(i)==0)

qui teste dabords si i [[1, n]], avant de comparer la valeur de la case i de tab 0. Si la valeur de i
nest pas dans lintervalle, alors tab(i) nest pas lu. Au contraire, si on avait crit :

if (tab(i)==0) & (i<=n) & (i>=1)

alors, si la valeur de i nest pas dans lintervalle, Scilab renverra une erreur puisquon essaie de lire
un lment qui nexiste pas.
On peut donc dire quen informatique p et q nest pas rigoureusement identique q et p .

Instructions conditionnelles : if Les variables boolennes sont surtout utilises pour des ins-
tructions conditionnelles, cest--dire que lon peut donner des instructions diffrentes lordinateur
selon la valeur dune variable boolenne. On contrle le flux dexcution selon la valeur des variables
boolennes.
De mme quen mathmatiques on peut dfinir la fonction

sin(x) si x 6= 0
x
x 7 ,
0 sinon

on peut dfinir la fonction Scilab :

function y=f(x)
if (x==0)
y=0;
else
9. Notons dailleurs que x==y est identique y==x, alors quon a vu que x=y est le contraire de y=x.
y=sin(x)/x;
end
endfunction

La syntaxe gnrale dune instruction if est donc :

if (test) then
//bloc dinstructions si test vrai
else
//bloc dinstructions si test faux
end

Le then est optionnel, il peut tre remplac par un retour la ligne. La partie else est aussi option-
nelle : il peut trs bien ny avoir aucune instruction si la condition est fausse.
Application 1 crire une fonction out=potentielHydrogene(pH) qui prend en entre un nombre
pH, et qui renvoie 1 si le ph est basique, 0 si il est neutre, et -1 si il est acide. Modifiez la fonction
pour quelle sorte une chane de caractres : basique, neutre ou acide (selon les cas).
On peut enchaner les instructions conditionnelles en utilisant elseif, qui permet dviter de
devoir mettre plusieurs end. La syntaxe de base est :

if (test) then
//bloc dinstructions si test1 vrai
elseif(test2) then
//bloc dinstructions si test1 faux et test2 vrai
else
//bloc dinstructions si test1 faux et test2 faux
end

Par exemple, limplmentation de la fonction :







1 si x > 0
signe : x 7 1 si x < 0

0 sinon

peut scrire :

function y=signe(x)
if (x>0) then
y=1;
elseif(x<0) then
y=-1
else
y=0
end
endfunction
Comme on le voit, il est important de tabuler correctement le programme pour voir clairement
quelles sont les instructions rptes.
On peut aussi imbriquer les structures conditionnelles avec la syntaxe :

if (test1)
//dbut des instructions si test1 vrai
...
if(test2)
//instructions si test1 vrai et test2 vrai
end//fin du if(test2)
//suite et fin des instructions si test1 vrai
else
//dbut des instructions si test1 faux
...
if(test3)
//instructions si test1 faux et test3 vrai
else
//instructions si test1 faux et test3 vrai
end//fin du if(test3)
//suite et fin des instructions si test1 faux
end

Pour viter toute confusion, il vaut mieux crire, en commentaire, quel if correspond chaque end.

V.2 Instructions rptes : boucles


Une boucle et un bloc dinstructions qui est rpt plusieurs fois. Il existe deux manires de faire
des boucles : les boucles for et les boucles while.

Boucle for Si on connat davance combien de fois il faut rpter le bloc dinstructions, on utilise
alors le mot cl for, qui permet dindexer le nombre de rptitions sur une variable.
La syntaxe est :

for var=dbut:pas:fin
//bloc dinstructions
...
end

Cela permet dinitialiser une variable (ici var) la valeur dbut. Ensuite, le bloc dinstructions entre
le for et le end est excut. Dans ce bloc, on peut utiliser (ou pas) la valeur de la variable var. Ensuite,
la variable var est incrmente de la valeur pas. Si la variable var est infrieure ou gale la valeur
de fin, le bloc dinstructions est de nouveau excut et la variable de nouveau incrmente. Lorsque
la variable var dpasse la valeur de fin, linstruction continue aprs le end (on dit que linstruction
sort de la boucle). Le pas peut-tre omis et vaut alors 1 par dfaut.
Considrons, par exemple, une fonction qui calcule la somme des n premiers entiers. Elle peut tre
implmente avec une boucle for :
function y=somme(n)
// entre: n entier,
// sortie: y somme des n premiers entiers
y=0;
for i=1:n
y=y+i;
end
endfunction

Application 2 laide dune boucle for, calculer 7!


Application 3 laide dune boucle for, calculer la somme des carrs des vingt premiers nombres
entiers.
Quelques remarques : Il faut initialiser la variable y 0 pour pouvoir utiliser linstruction
y=y+i qui permet dajouter i y. Pour un calcul de somme, il est judicieux dinitialiser y 0. Pour
un calcul de produit, on prfrera videmment, linitialiser 1. Si y est un vecteur et quon ajoute
chaque itration une composante, alors on peut linitialiser la matrice vide : y=[]. Enfin, si y est
une chane de caractres, on pourra linitialiser la chane vide via y="";.
Le nombre de rptitions dans une boucle for peut tre dtermin lavance : cest le nombre de
valeurs possibles pour la variable var.
Rien nempche de faire des boucles du type : for k=10:-1:1, i.e. avec un pas ngatif. Le pro-
gramme prcdent peut tre crit sous la forme :

function y=somme(n)
// entre: n entier,
// sortie: y somme des n premiers entiers
y=0;
for i=n:-1:1
y=y+i;
end
endfunction

Une boucle telle que fin>debut est ignore : lexcution ne rentre jamais dans la boucle. Enfin, il
nest pas ncessaire que la variable var passe exactement par fin : par exemple, i=1:2:10 permettra
deffectuer la boucle 5 fois (pour i=1,3,5,7 et 9).

Boucle while Si la boucle ne se finit que lorsquune condition est ralise, on utilise alors une
boucle while qui permet de rpter un bloc dinstructions jusqu ce quune condition appele test
darrt soit atteinte.
La syntaxe est :

while (test)
//bloc dinstructions rpt jusqu ce que test soit faux
...
end
Linstruction teste la valeur du boolen test, quon appelle test darrt. Si cette valeur est
fausse, lexcution continue jusquau end. Ensuite, le test darrt est de nouveau valu et le bloc
dinstructions est rpt. On ne sort de la boucle que si le test est faux.
On ne peut donc pas dterminer le nombre de passages dans la boucle lavance. Le problme de
la finitude se pose donc clairement : il faut prouver que lon sort de la boucle.
Notons que si le test darrt est faux ds le dpart, on ne rentre jamais dans la boucle.
On peut aussi crire la somme des n premiers entiers avec une boucle while :

function y=somme(n)
// entre: n entier,
// sortie: y somme des n premiers entiers
y=0;
while(n>0)
y=y+n;
n=n-1;
end
endfunction

Quelques remarques : Ici, on utilise directement la variable dentre n comme la variable de


test qui va donc tre modifie par la fonction. Mais cest la copie locale de la variable qui est modifie.
Ainsi, si on tape les commandes x=5; somme(x); la variable x vaudra toujours 5.
On pourrait aussi crire

function y=somme(n)
// entre: n entier,
// sortie: y somme des n premiers entiers
y=0;
i=1;
while(i<=n)
y=y+i;
i=i+1;
end
endfunction

Cela impose dajouter une variable i.


Enfin, il faut faire attention lordre des oprations et au test. Par exemple, dans cette dernire
fonction, si on remplace while(i<=n) par while(i<n), on fait une erreur dalgorithmique, puisquil
manquera une excution de la boucle : on najoutera pas la valeur n. Autre erreur, si on renverse les
deux lignes du bloc while, en crivant :

function y=somme(n)
// entre: n entier,
// sortie: y somme des n premiers entiers
y=0;
i=1;
while(i<=n)
i=i+1;
y=y+i;
end
endfunction

On fait de mme une erreur dalgorithmique, puisquon ajoutera les valeurs 2, 3 . . . n + 1, au lieu de
1, 2, . . . n.
Pour viter les erreurs, le plus simple est de tester au brouillon lalgorithme sur de faibles valeurs,
en crivant toutes les instructions envoyes lexcution. Dans lexemple ci-dessus, en testant pour
n=3, on obtient les instructions :

y=0;
i=1;
//rentre dans la boucle (i=1)
i=i+1;// i vaut 2
y=y+2;//y vaut 2
//deuxime passage par while, (i=2)
i=i+1;//i vaut 3
y=y+3;//y vaut 5
//troisime passage par whle, (i=3)
i=i+1;//i vaut 4
y=y+4; y vaut 9.
//fin du while car (4>3)

Application 4 Algorithme de Syracuse On choisit un entier quelconque. Sil est pair, on le


divise par 2, sinon on le multiplie par 3 et on ajoute 1. Puis on rpte ce processus jusqu arriver
1.
Cet algorithme se termine toujours en un nombre fini ditrations.
crire une fonction qui prend en entre un entier et :
affiche lcran la suite des itrs,
renvoie le nombre ditrations qui ont t ncessaires pour revenir 1.

Quand utiliser while ? Les boucles while sont donc plus facilement sources derreurs, mais indis-
pensables ds quon ne sait pas lavance combien ditrations vont tre ncessaires.
Cest le cas, par exemple, si on cherche le point fixe dune fonction. En itrant une suite un+1 =
f (un ), on excute alors la suite dinstructions :

x=a;
while(f(x)~=x)
x=f(x)
end

La boucle continue jusqu ce quun point fixe soit atteint. Bien entendu, lalgorithme nest valide que
parce quil se finit, i.e. parce quon a prouv quon converge.
Autre exemple : supposons quon souhaite poser la question Voulez vous continuer ? jusqu obtenir
la rponse o ou n. On utilise alors une boucle while, selon cette syntaxe :
rep="";//on pourrait mettre nimporte quelle valeur diffrente de o ou n
while ( (rep<>"o")&(rep<>"n"))
rep=input("Voulez-vous continuer?","string");
end

Ce bloc de commande peut lui-mme tre inclus dans une boucle while du type : while (rep=="o"),
en ayant pris soin dinitialiser la variable rep "o" de manire rentrer au moins une fois dans la
boucle.

VI Algorithmique lmentaire
Le problme de lchange de deux variables Soient deux variables a et b. Pour changer les
valeurs contenues dans ces variables, il faut passer par une variable auxiliaire gnralement nomme
tmp ou aux pour bien montrer son caractre temporaire. Il faut ainsi utiliser les instructions tmp=a;
a=b; b=a;
Cette remarque stend aux calculs daffectations les unes la suite des autres. Par exemple, si
on veut calculer les termes des suites (an ) (bn ) dfinies par :
(
an+1 = an bn
n N, an +bn
bn+1 = 2

et quon ne veut garder que la dernire valeur. On ne peut pas utiliser les expressions :
a=sqrt(a*b);b=(a+b)/2; car, dans ce cas, la deuxime instruction utilise, non pas la valeur de a
originale, mais celle modifie par la premire instruction. Il faut donc encore passer par une variable
temporaire, par exemple : tmp=sqrt(a*b);b=(a+b)/2;a=tmp;.
Attention ce type derreur dalgorithmique, qui ne pose aucun problme de syntaxe, mais ne
donnera jamais le bon rsultat.

Conserver ou pas des variables Supposons quon considre la suite de Fibonnaci un dfinie par
u1 = 1 et u2 = 1 un+2 = un+1 + un .
Pour crire une fonction qui renvoie la valeur de un en fonction de n, on doit a priori sauvegar-
der toutes les valeurs des (uk )k<n dans la fonction, en utilisant un vecteur de taille n, contenant
[u1 , u2 , u3 . . . , un ], et ensuite ne renvoyer que la dernire composante du vecteur 10 .
Cela scrit :

function out=fibbo(n)
// n entier naturel
// out = valeur du n-ime terme de la suite de fibbonacci
u=[1,1]; //initialisation du vecteur u, par les deux premiers termes
for i=3:n
//on ajoute une composante au vecteur u somme des deux composantes prcdentes:
u(i)=u(i-1)+u(i-2);
end
10. Voir le chapitre suivant pour la manipulation de vecteurs/matrices en Scilab. Ici, on se sert uniquement du fait
que u(i) est la i-me composante du vecteur i.
out=u(n);
//rem: si n<3, on ne rentre pas dans la boucle, le rsultat est donc valable
endfunction

Le dfaut de cette mthode est quil y a une perte de mmoire. Pour calculer u1000 , on na pas
besoin des 999 termes prcdents, mais uniquement de 2 : u999 et u998 .
On peut donc raisonner diffremment. On utilise deux variables : un pour la valeur de un et unm1 11
pour la valeur de un1 . chaque itration, i.e. pour passer de n n + 1, on doit mettre jour la
variable un comme la somme de la valeur de un et de un1 . Ainsi, un contient bien la valeur de un+1 .
On crit donc linstruction : un=un+unm1;. Il faut aussi modifier la valeur de la variable unm1 pour
quelle contienne, non plus un1 , mais la valeur de un , qui tait contenue dans la variable un avant
modification et quon aura donc pris la peine de sauvegarder dans une variable temporaire.
Le programme devient alors :

function out=fibbo(n)
// n entier naturel
// out = valeur du n-ime terme de la suite de fibbonacci
un=1;//les deux valeurs sont initialises 1
unm1=1;
for i=3:n
//on sauvegarde la valeur de un:
tmp=un;
//la valeur courante est mise jour: cest la somme des deux valeurs prcdentes
un=un+unm1;
//la valeur de unm1 est mise jour: cest la valeur de un sauvegarde
unm1=tmp;
end
out=un;
//rem: si n<3, on ne rentre pas dans la boucle, le rsultat est donc valable
endfunction

Ce dernier algorithme utilise beaucoup moins de variables.


Cette ide se comprend aussi facilement dans le cas du calcul du terme un dans une suite dfinie
par un+1 = f (un ), en fonction du premier terme u0, de la fonction f et de n.
On pourrait crire ce programme sous la forme :

function y=suite(n,f,u0)
// n entier naturel
// f fonction telle que la suite rcursive est bien dfinie en partant de u0
// u0 premier terme
// y = valeur du n-ime terme de la suite dfinie par u0 et u(n+1)=f(u(n))
u=[u0];//initialisation de u un vecteur ne contenant que le terme u0
for i=1:n
u(i)=[u,f(u(i-1)];//ajout dune composante au vecteur u
11. Abrviation de u n moins 1 .
end
out=u(n+1);
endfunction
Cette fonction construirait donc un long vecteur de taille n+1, contenant [u0 , u2 , . . . , un+1 ]. chaque
itration, une composante est ajoute 12 au vecteur u, cette nouvelle composante tant limage de la
prcdente par la fonction f.
On pourrait aussi crire cette fonction sous la forme plus condense :
function y=suite(n,f,u0)
y=u0;//initialisation de y
for i=1:n
y=f(y);//on remplace y par son image par f
end
endfunction
Quelques remarques : La fonction f est ici une entre de la fonction suite. on utilise ici le fait
quon peut mettre une fonction en entre dune autre fonction.
Si on demande, dans une copie, dcrire une fonction qui ne dpend que de n et de u0, et qui permet
de calculer le n-ime terme dune suite dfinie par u0 et par exemple : un+1 = sin(un ) + cos(un ), on
a tout intrt dfinir la fonction f dans la fonction suite 13 . Cela donnera :
function y=suite(n,u0)
//dfinition de la fonction f:
deff("y=f(x)","y=cos(x)+sin(x)");
y=u0;//initialisation
for i=1:n
y=f(y);//on remplace y par son image par f
end
endfunction

Dcalage dindices En Scilab, les indices commencent 0 et non 1. On a dj rencontr cette


difficult pour le calcul de la suite u(n), lorsquon a crit :
u=[u0];//initialisation
for i=1:n
u(i)=[u,f(u(i-1)];//ajout dune composante au vecteur u
end
out=u(n+1);
Du point de vue mathmatique, on calcule un vecteur qui contient [u0 , . . . , un ], mais avec Scilab, les
lments du vecteur sont [u(1),u(2),u(3)... u(n+1)]. Ce vecteur est donc de taille n+1, et lindice
i en Scilab correspond donc lindice mathmatique i 1. Il faut donc veiller ne pas faire derreur
lors du passage entre les deux indices.
12. Ici aussi, voir la partie sur les matrices/vecteurs. On utilise simplement le fait que si u est un vecteur de taille n,
[u,a] est un vecteur de taille n+1, obtenu en concatnant a au vecteur u.
13. Attention, la fonction suite ne sera alors valable que pour cette fonction f particulire. La fonction f nest plus
une entre de la fonction suite.
VII savoir
Utiliser laide Laide en ligne est disponible via les commandes help NomFonction ou apropos
MotCle

rreurs darrondis Scilab ne fait que des calculs approchs et fait donc des erreurs num-
riques. chaque calcul, une erreur est faite. Un des buts des mathmatiques est donc de contrler
la propagation de ces erreurs.
Par exemple, supposons quon excute les lignes de code :

clear;
x=0;
for i=1:30
x=x+0.1;
end

En thorie, la valeur de x est alors 3, ce qui est dailleurs la valeur affiche par Scilab. Pourtant,
le test x==3 renverra la valeur F. Les erreurs darrondis faites durant les 30 additions font que la
valeur de x est diffrente de 3, ce qui peut se vrifier en utilisant la commande : format(25), qui
permet de modifier la prcision de laffichage. La valeur de x avec cette prcision est alors : x=
3.0000000000000013322676 .
Autre exemple : si on demande Scilab dinverser une matrice, puis de multiplier la matrice par
linverse, on nobtient pas exactement lidentit.

-->A=rand(4,4);A*A^{-1}
ans =

1. 1.471D-16 1.718D-16 - 3.771D-16


1.958D-16 1. - 8.496D-17 - 2.040D-16
2.147D-17 1.269D-17 1. 6.635D-17
1.786D-16 4.605D-17 - 1.455D-16 1.

Les termes hors diagonaux sont quasi nuls.


Dernier exemple, la suite de commandes

n=2;i=1
while (n<n^2)
i=i+1;
n=n^2;
end
disp(i)

se termine et affiche une valeur de i. En effet, Scilab ne peut grer des entiers trop grands.
Quand utiliser un script et quand utiliser une fonction ? Pour comprendre la diffrence entre

un script et une fonction, considrons, par exemple, le cas du calcul de a par la mthode de Newton,
i.e. en itrant la fonction f (x) = 21 x + xa . La suite dinstructions :


clear;
n=10;//nombre ditrations

y=2;
deff("y=f(x)","y=0.5*(x+ (a/x))");
for i=1:n
y=f(y);
end
y //y est la valeur calcule

Cette suite dinstructions peut tre rentre dans un script, qui permet alors de calculer 2, en
itrant 10 fois la fonction f . Cette mthode peut servir de test, mais elle nest pas trs souple :
si on veut augmenter le nombre ditrations, on est oblig de changer la valeur de n, puis de
sauvegarder et de relancer le script avec exec.
idem, si on veut changer la valeur 2.
il faut savoir que y est la valeur calcule. Dans le cas o y est dj une variable alloue, il faut
remplacer (partout) y par z.
Pour toutes ces raisons, il est prfrable de rentrer ces valeurs dans une fonction. Cette fonction
prend en entre a et n et retourne la valeur trouve de y 14 . Cette fonction scrit :

function y=newton(a,n)
y=a;
deff("y=f(x)","y=0.5*(x+ (a/x))");
for i=1:n
y=f(y);
end
endfunction

Ensuite, cette fonction peut tre appele par une instruction du type f(2,10), f(3,20), etc. Le
rsultat peut tre stock dans une variable z, en posant z=f(3,10). De plus, si y a une valeur dans
lespace de travail, cette valeur nintervient pas.
Un autre exemple parlant est le cas des entres sorties au clavier. Un script qui demanderait un
entier en utilisant la commande input, calculerait et afficherait son carr, a un intrt pdagogique,
mais aucun intrt pour reprsenter la fonction x 7 x2 sur [0, 1], puisquil faudrait rentrer des
centaines de valeurs la main entre 0 et 1 et noter leur carr.
Enfin, en informatique, on sintresse aux proprits dun algorithme comme celui de Newton.
Par exemple, on se demande si, lorsquon augmente les itrations, on obtient vraiment une meilleure
approximation. Ou, on veut savoir si il y a des valeurs de a pour lesquelles la convergence est plus ou

14. Gnralement, les entres et les sorties sont donnes par lnonc. Il faut respecter, dans ce cas, ce qui est demand
dans lnonc.
moins rapide. Ainsi, il est conseill dcrire, en parallle de la fonction, une dmo de cette fonction,
qui va tre un script appelant la fonction sur diverses valeurs pour la tester.
Par exemple, on crira un script sous la forme :

clear;
exec("newton.sci");
//test avec a=2 et n=10
y=newton(2,10);
disp(y,"valeur trouve");
disp(abs(y-sqrt(2)),"erreur commise");
//test avec a=3 et n=10
y=newton(3,10);
disp(y,"valeur trouve");
disp(abs(y-sqrt(3)),"erreur commise");

Dans un exercice de Scilab, il est ainsi conseill de fournir un couple script/fonction. La fonction
contient lalgorithme demand, et le script quelques tests permettant de prouver sa validit et de
montrer son fonctionnement.

Les fonctions Scilab connatre Les fonctions connatre sont :

Interrompre le flux dexcution Comme on la vu, si on excute les commandes :

i=0;
while(i<>10)
disp("coucou");
end

on bloque le flux dexcution dans la boucle while. Lexcution restant dans le bloc indfiniment,
scilab continue de tourner indfiniment et est inutilisable. Pour arrter le flux dexcution, il faut
alors utiliser le raccourci clavier CTRL+C, Linvite de commande devient alors -1->, on peut alors
tout arrter en utilisant la commande abort. Cette technique peut aussi tre utilise pour stopper
la commande input. En complment, on peut utiliser la commande halt qui bloque lexcution tant
quune touche nest pas appuye, de manire par exemple laisser le temps de lire sur lcran.
Pour utilisateurs avancs 15 , on peut utiliser ces fonctionnalits de dbogueur en interrompant
volontairement le flux dexcution avec la commande pause. Une fois le flux dexcution stopp, on
peut, par exemple, examiner le contenu des variables pour dterminer la source de lerreur, puis, soit
relancer le programme avec resume, soit le stopper avec abort.
Par exemple, en utilisant un script contenant :

clear;
i=0;
while (i<>10)
disp("test")
15. Et uniquement eux.
%i Nombre complexe i
%pi Nombre
%e Nombre e
clear Efface toutes les variables
who Affiche les variables affectes
ans Valeur du dernier calcul
x=real(z) Partie relle dun nombre complexe z
x=imag(z) Partie imaginaire dun nombre complexe z
x=conj(z) Conjugu dun nombre complexe z
x=abs(z) Module dun nombre complexe z / valeur absolue dun
nombre rel
x=phasemag(z) Argument en degr dun nombre complexe
sqrt, exp, log Fonctions racine, exponentielle, et logarithme
sin, cos, tan Fonctions sinus, cosinus, et tangente
round, floor, ceil Fonction partie entire approche, infrieure et suprieure
disp("la valeur de x est Affiche la valeur de x est suivie de sa valeur, si x est un rel
"+string(x));)
halt() Attend lappui sur une touche, trs utile dans un script pour
bloquer lexcution entre chaque calcul
x=input("question") Affiche la question et stocke la rponse dans la variable x, la
rponse doit tre un rel
x=input("question", Affiche la question et stocke la rponse dans la variable x, la
"string") rponse doit tre une chane de caractre
lines(0) Permet dviter les [More y or n]
save("sauv.sav") Permet de sauvegarder toutes les variables affectes, i.e. les-
pace de travail
load("sauv.sav") Permet de restaurer les variables sauvegardes
help fonction Aide sur la fonction fonction
apropos MotCle Recherche dans laide sur le mot cl MotCle

Table 1.1 Fonctions Scilab connatre


pause;
end

va arrter le flux dexcution au premier affichage de test. Linvite de commande permet alors
de connatre la valeur de i, voire de la modifier avec [10]=return(i);, qui permet de revenir au
programme avec une valeur modifie de i.

Affichage des rsultats Lorsque vous affichez des rsultats, Scilab va vous demander More y or
n?. et vous devez appuyer sur y pour en voir davantage, sur n pour ne plus en voir. Pour empcher ce
comportement, il faut utiliser la commande lines(0);. Attention, le flux dexcution est alors plus
difficile stopper.
Application 1 Recherche dun nombre par essais successifs
crire un script qui :
tire un nombre entier x au hasard, entre 0 et 25. Pour cela, on utilisera linstruction :
x=round(25*rand(1,1));
Le but est que lutilisateur trouve, par essais successifs, ce nombre x.
Le script demande un nombre lutilisateur,
puis affiche Le nombre ... est suprieur au nombre cherch ou infrieur au nombre cherch
selon les cas,
et continue ainsi jusqu ce que x soit trouv.
lorsque cest le cas affiche Flicitations, vous avez trouv en .. essais
Chapitre 2

Types de donnes en Scilab

Dans ce chapitre, on va sintresser aux types de donnes que peut manipuler Scilab.

I Matrices et vecteurs
I.1 Crer des matrices et des vecteurs en Scilab

Donner les coefficients dune matrice Pour rentrer une matrice en Scilab, on peut rentrer ses
lments un par un : par exemple : M=[1,2,3;3,2,1];, crera la matrice M :
" #
1 2 3
M= .
3 2 1

On voit donc que , permet de changer de colonne et que ; permet de changer de ligne. On peut aussi
remplacer ; par un retour la ligne, et , par un espace.
Il ny a pas, par contre, de notion de vecteur : un vecteur est simplement une matrice possdant
une ligne (vecteur ligne), ou une unique colonne (vecteur colonne).
Si Scilab ne sait pas grer les dimensions, il renvoie le message derreur : inconsistent row/column
dimensions.

Commandes sur les matrices Le tableau 2.1 rcapitule les commandes connatre pour la ma-
nipulation des matrices et des vecteurs.

I.2 Manipuler les matrices et les vecteurs en Scilab

Initialisation affectation Les matrices peuvent tre stockes dans des variables et se manipulent
exactement de la mme manire.
En fait en Scilab, toute variable est une matrice. Ainsi, si on dfinit la variable a par a=2, puis
que lon fixe la valeur ligne 3, colonne 4 de a comme gale 5, Scilab ajoute des 0 la variable a
pour en faire une matrice 3 lignes et 4 colonnes.
Application 1 Si on tape la suite de commandeS : clear;x(5)=3; que contient la variable x ?

25
[n,m]=size(A) Taille dune matrice A
n=size(A,"r") Nombre de lignes (row) dune matrice A
m=size(A,"c") Nombre de colonnes dune matrice A
m=size(A,"*") Nombre dlments dune matrice A
m=length(v) Nombre dlments dun vecteur v
x=linspace(a,b,n) Construit un vecteur ligne x contenant n points quidistants
entre a et b
x=a:p:y Construit un vecteur ligne x qui contient les nombres de a
b par pas de p.
x=a:y Idem mais avec un pas de 1 par dfaut
rand(n,m) Construit une matrice alatoire de taille n par m
eye(n,n) Construit la matrice identit de taille n
ones(n,m) Construit une matrice ne contenant que des 1 de taille n par
m
zeros(n,m) Construit une matrice ne contenant que des 0 de taille n par
m
[ ] Matrice vide, permet en particulier dinitialiser sans valeur

Table 2.1 Manipulation des matrices et des vecteurs.

Oprations mathmatiques Les oprations mathmatiques se font comme avec des variables
classiques :
x*M permet de multiplier la matrice M par un scalaire x,
A*B permet de multiplier deux matrices A et B,
A+B permet de les additionner,
A^k permet de calculer Ak , en particulier A^(-1) permet dinverser 1 la matrice A
A permet de calculer la transpose de la matrice A.
Si les dimensions ne sont pas compatibles, on obtient des messages derreur comme : inconsistent
addition, ou inconsistent multiplication.
Enfin, notons que la suite de commandes : A=rand(4,4);A*A^(-1) ne renvoie pas exactement
la matrice identit, mais quelque chose de trs proche du fait des erreurs numriques. Il existe aussi
une commande inv(A) pour calculer linverse.

Manipulation des lments, extraction de sous-matrices Pour avoir accs llment ligne
i colonne j, il suffit dutiliser linstruction : A(i,j). Ceci est valable en lecture autant quen criture,
i.e. pour modifier la valeur de llment qui est dans A. De mme, pour un vecteur, la syntaxe est
v(i) pour llment i. Attention, le premier lment est le 1, le dernier vaut la taille en ligne/colonne.
Pour extraire une partie de la matrice, par exemple le vecteur des lments lignes 1 3 de la
colonne 2, on utilise : A(1:3,2). Pour extraire la ligne 3, on dispose dun raccourci : A(:,3), idem
pour la colonne 2 : A(2,:). Par souci de simplicit, un raccourci permet aussi dobtenir le dernier
lment : A(:,$) est ainsi la dernire colonne, tandis que v($) est le dernier lment de v.
Ces matrices extraites peuvent tre bien entendu stockes dans de nouvelles variables.
1. Ne pas oublier les parenthses autour du -1.
Enfin, comme pour les lments, cette extraction est valable en lecture comme en criture. Ainsi,
par exemple, les commandes :
A=rand(4,4); A(1,:)=1:4; A(:,2)=ones(4,1);
permettent de crer une matrice alatoire, puis de remplacer la premire ligne par les entiers de 1
4. Enfin, elles remplacent la colonne 2 par des 1.
Ceci peut aussi tre utilis pour supprimer une ligne ou une colonne en affectant la valeur matrice
vide. Par exemple : A(1,:)=[]; supprime la ligne 1 de la matrice A.
Si on essaie de lire un lment qui nexiste pas, Scilab retourne un message derreur : invalid
index. Par contre, si on essaie dcrire sur un lment qui nexiste pas, par exemple si on crit :
A=rand(4,4); A(5,5)=3;
Scilab ajoute des zros la matrice A de manire pouvoir mettre llment (5,5) 3.
Note: Lextraction de sous-matrice peut mme se faire avec une liste dindices : A=rand(10,10);v=[1,3,5]; w=[4,6];B=A(v,
la variable B contiendra alors les lignes 3 2 coefficients obtenus en prenant les lments des lignes 1, 3 et 5 et
des colonnes 4 et 6.

Changement de taille Pour changer la taille dune matrice, i.e. organiser les lments dune autre
manire, on utilise la commande M=matrix(v,n,m), qui prend en entre une matrice ou un vecteur v
contenant nm lments et sort la matrice M de taille n par m contenant les lments de v rangs en
colonnes.
Exemple:
-->x=1:10;matrix(x,5,2)
ans =

1. 6.
2. 7.
3. 8.
4. 9.
5. 10.

-->matrix(x,2,5)
ans =

1. 3. 5. 7. 9.
2. 4. 6. 8. 10.

Concatnation de matrice/vecteur Pour concatner des matrices et des vecteurs, on procde


comme si il sagissait de nombres. Ainsi, pour obtenir la matrice C, constitue de la matrice A au-
dessus de la matrice B, il suffit de faire : C=[A;B]. Tandis que C=[A,B] permettra dobtenir la matrice
A gauche de la matrice B.
Exemple: Par exemple, on peut obtenir la matrice :
1 2 3 1 0 0

4 5 6 0 1 0

A=
7 8 9 0 0 1


1 1 1 0 0 0

1 1 1 0 0 0
laide de la commande :
A=[matrix(1:9,3,3), eye(3,3);ones(2,3),zeros(2,3)]

Notons que cette fonctionnalit est particulirement utile lorsquon stocke le rsultat dans la mme
matrice. Par exemple, on utilise : M=[M,x] pour ajouter la matrice M la valeur de la variable x.

galit On peut tester si deux matrices ou deux vecteurs sont gaux avec la commande isequal,
qui renvoie F ou T. Pour comparer lment par lment, on peut utiliser simplement == ou >=, on
obtient alors une matrice de F et de T, qui donne pour chaque lment, si il est gal ou suprieur
son correspondant.

Oprations non mathmatiques Scilab permet de faire des oprations non mathmatiques, utiles
dans la pratique pour manipuler rapidement les matrices. On dispose en effet de :
addition matrice/scalaire Si x est un scalaire et M une matrice ou un vecteur, M+x permet dajouter
chaque lment de M la valeur de x, cela correspond donc 2 M+x*ones(n,m), o n et m sont
la taille de la matrice M.
multiplication lment par lment Lorsquon dispose de deux matrices A et B de mme taille,
on peut parfois vouloir les multiplier lment par lment. Cela peut tre fait par la commande
A.*B qui vite ainsi le passage par une boucle for. Bien entendu, il faut que les tailles soient
compatibles pour que cette opration ait un sens. Pratiquement, lopration C=A.*B remplace
la suite dinstructions :

[n,m]=size(A);
for i=1:n
for j=1:m
C(i,j)=A(i,j)*B(i,j);
end
end

Fonctions de Scilab Le tableau 2.2 contient une liste des oprations sur les vecteurs/matrices dj
implmentes dans Scilab. Mme si il ne faut pas connatre par cur ces fonctions, il faut
connatre lexistence de ces fonctions pour gagner du temps, en vitant de les rcrire chaque
fois. Il faut aussi tre capable de retrouver sans erreur la syntaxe exacte en utilisant laide et
des exemples. En particulier, attention aux arguments c et r. Par exemple sum(A,r) est
la somme sur les colonnes, le r signifiant quon obtient un vecteur ligne. Attention, la plupart
de ces fonctions sont interdites pour loption, elles ne sont donc donnes ici qu titre indicatif.

Application de fonctions sur des matrices On peut appliquer toutes les fonctions mathma-
tiques sur des matrices. Dans ce cas, cest la matrice contenant chacun des lments qui est renvoye.
Par exemple, on peut faire :

A=rand(4,4); sin(A);

2. Ceci explique aussi pourquoi en mathmatiques, il ne faut pas crire M + 2 la place de M + 2I, pour Scilab M+2
nest pas M+2*eye(2,2), mais M+2*ones(2,2).
qui calcule limage par la fonction sinus des lments de A, en vitant ainsi de faire une boucle sur les
lments.
Ceci est particulirement utilis pour les graphiques. Par exemple :

x=linspace(-10,10,100); y=sin(x)+cos(x);

permet dobtenir un vecteur y contenant limage par la fonction x 7 sin(x) + cos(x) de 100 points
quidistants dans lintervalle [10, 10]. Ensuite, la commande 3 plot2d(x,y) permettra de dessiner
cette fonction.

max(M) Maximum dune matrice M


max(M,c) Maximum sur chacune des lignes
max(M,r) Idem pour les colonnes
min(M) Idem pour le minimum
mean(v) Moyenne
median(v) Mdiane
st_deviation Dviation standard
sort(v) Trie un vecteur par ordre dcroissant
sort(M,c) Trie chaque ligne de la matrice M.
sort(M,r) Idem pour les colonnes
sortup(v) Idem par ordre croissant.
sum(v) Somme des lments de v
sum(A,c) Somme de chacune des lignes de A
sum(A,r) Idem pour les colonnes
prod(A) Idem pour le produit

Table 2.2 Fonctions matricielles et vectorielles en Scilab

Application 2 Taper les commandes et expliquer :

A=[1,2,3;4,5,6]
A=[1;2;3;4,5,6] //o est lerreur?
A=eye(3,3)
A=zeros(4,5)
A=ones(3,2)
A=rand(2,2)
t=1:10
T=0:0.1:3
x=linspace(-10,10,20); //linspace = quirpartis
A=rand(3,4);B=rand(3,4); A+B;
A //transposition.
size(A)
size(A,r)
size(A,c)
3. Voir le prochain chapitre sur les graphiques.
size(A,*)
A=rand(3,4); B=[1,1]; A*B //produit
[B,3]
B=[B,B] //concatnation
A*B //pourquoi cela provoque une erreur?
A(1,1)
A(1:3,2)
A(:,3) //: =toutes les lignes /colonnes
A(2,:)
C=A(1:2,3:4) //extraction
A(1:5,6:8) //o est lerreur?
A(1,1)=0; A //modification dun lment
A(1,:)=[]
A($,2) //$ donne le dernier lment.
A=rand(3,3);
A=rand(3,3); B=rand(3;3); C= A^(-1)*B; A*C
Application 3 Crer deux matrices de taille 3 3, puis comparer A.*B et A*B. Expliquer.

II Chanes de caractres
En Scilab, les chanes de caractres (string en anglais), i.e. les textes, sont des variables comme
les autres.
Les oprations sur ces objets sont simplement :
linitialisation, obtenue en faisant x="Lundi, Mardi, ";
la concatnation, obtenue en faisant x+y
la comparaison, obtenue en faisant x==y ou x<>y. Par contre x>y na pas de sens. Voir plus loin
pour la comparaison lordre lexicographique.
la conversion, dun rel en chane de caractres gale sa valeur, par la fonction string(x), o x
est une variable contenant un rel.
lvaluation, est lopration inverse de la conversion. Elle prend en entre une expression, par
exemple "x+y" et renvoie le rel obtenu en valuant cette expression, ici la somme de la va-
riable x et de la variable y. Cette opration est obtenue laide de evstr(c), o c est une
chane de caractres.
la longueur dune chane , i.e. le nombre de lettres, est obtenu par la fonction length(c), o c
est une chane de caractres.
laffichage Laffichage lcran se fait avec la commande disp. Par exemple : disp("Bonjour").
Cette commande est conseiller pour afficher un mlange de contenu de variables numriques
et de chanes de caractres : par exemple : disp("la valeur de x est " + string(x))
Lextraction de sous-chanes Si x est une chane de caractres, alors part(x,i) est le caractre
situ la position i, tandis que la commande part(x,1:3) renverra les trois premires lettres.
Cela peut tre tendu au cas dun vecteur v contenant des entiers. La commande part(x,v)
renverra les caractres aux indices donns par v.
La conversion en valeur ascii La conversion ascii permet de coder une lettre en un nombre qui
indique sa position dans la table des caractres. Les 10 chiffres sont cods en premier (de 0
9), puis la lettre a est cod en 10, la lettre b en 11, etc. Les lettres majuscules sont cods
avec un chiffre ngatif : la lettre A est cod en -10, B en -11 etc. Cette conversion est faite avec
les commandes str2code qui convertit une chane en un vecteur de codes, et code2str qui
convertit un vecteur de codes en chane. Cela est surtout utilis pour faire des oprations sur
les chanes faisant appel lordre lexicographique (ex. dcaler dun certain nombre de lettres,
classer par ordre alphabtique).
Exemple:

x="oui";
//on peut comparer des chanes de caractres
if (x=="non") then disp("Pourquoi?"); end

//pour sparer la variable x et la chane de caractres x on utilise les " "


z=bonjour;//renvoie un message derreur
z="bonjour";
length(z)//nombre de lettres

2*z; //renvoie une erreur: on ne peut pas * des chanes de caractres

x="10";// une chane de caractres peut contenir un nombre.


y=2*x;//mais on ne peut pas faire dopration dans ce cas,
//x ne contient pas la valeur 10 mais la chane de caractres 10
y=2*evstr(x);//ici on convertit dabord x en nombre
disp("la valeur de y est"+y);//erreur car y est un nombre
//on ne peut pas additionner une chane de caractres et un nombre.
disp("la valeur de y est"+string(y));
//par contre, on peut concatner deux chanes de caractres.

z="bonjour"
x=part(z,1);// x contient "b"
y=part(z,1:3);//y contient "bon"

Enfin, on peut crer des matrices ou des vecteurs contenant des chanes de caractres. Par exemple,
un carnet dadresses pourra tre reprsent par une matrice 6 colonnes, avec des entres du type :

["Nom","Prnom","Adresse","Ville","Code postal","Tlphone"];

Chaque ligne reprsentera une entre dans le carnet dadresses, et on ajoutera des entres avec par
exemple :

M=[M;"Hoche";"Lazare","73 avenue de Saint-Cloud", ...


"Versailles","78000","01.30.84.08.50"];

noter quune telle matrice ne peut pas contenir la fois des chanes de caractres et des rels.
Par exemple : x=["test",2] renverra un message derreur, do lutilisation de evstr(c) lorsquon
a besoin de faire des calculs avec les champs.
Note: Attention une erreur classique : il ne faut pas utiliser dapostrophe dans les chanes de caractres,
qui sont alors confondues avec les ". Par exemple : x="jaime faire du Scilab"; renverra une erreur.
Application 1
1. crire un script qui pose les questions : Nom ? , puis Prnom ? , et enfin Anne de
naissance ? puis affiche : Bonjour ... ag(e) de .. ans en indiquant les valeurs rentres.
2. crire un autre script qui :
demande lutilisateur un nombre,
crit Le carr de ... est ... , en remplaant les points par la valeur rentre et son carr.
3. Modifier ce script pour quil pose lutilisateur la question Voulez-vous continuer ? et attende
o ou n, toute autre rponse amenant reposer la question jusqu ce que lune de ces deux
rponses soit entre.

Utilisation du codage ascii Le codage ascii doit tre utilis ds quon fait intervenir lordre
lexicographique.
Application 2 Codage Csar : Le codage Csar consiste coder un mot, en dcalant sa position
dans lalphabet dun paramtre fix appel cl. Par exemple, le mot bcpst, avec un cl de 6 sera cod
en hivza.
Cela peut-tre fait simplement en remarquant que : str2code(abc) renvoie le vecteur : [10, 11, 12],
tandis que si la variable v vaut [16, 17, 18], on a : code2str(v) renvoie la chane de caractres ghi.
crire partir de ces lments une fonction prenant en entre une chane de caractres et sortant
une chane de caractres codes avec le codage de csar et avec la cl 6.
crire une fonction permettant deffectuer le dcodage.
Modifier ces fonctions de manire prendre en entre la cl.
On ne prendra que des chanes constitues de lettres minuscules, sans espace.
Application 3 crire une fonction estAvant prenant en entre deux chanes de caractres a et b,
et sortant un boolen gal vrai si le mot a arrive avant dans le dictionnaire.