## Avant de commencer
SCILAB est téléchargeable rapidement [http://www.scilab.org/](http://www.scilab.org/).
Le logiciel est accompagné d'une documentation très complète.
De nombreux TP sont présents sur le site de Scilab référencé ci-dessus.
Il faut savoir que scilab, comme matlab, est basé sur un noyau de
fonctions en Fortran ou en C déjà compilées donc rapides
d'utilisation. En revanche, tout ce que vous créerez vous-même sera
interprété ce qui ralentira l'exécution par rapport à d'autres
langages. De plus, la gestion des nombres n'est pas toujours optimale
car ils sont codés en complexes double précision ce qui peut être lourd.
### Console
La ligne de commande dans la console permet de taper des opérations
élémentaires, comme pour une calculatrice scientifique. Il faut taper tous les
opérateurs, et bien mettre des parenthèses autour de la formule. Une fois la
formule correctement entrée, appuyer sur la touche "entrée" affiche le résultat.
Par exemple :
```
--> 1+1
ans =
2.
```
`ans` est l’abréviation de answer, il s’agit du nom
de la variable où la réponse est stockée.
### Variables
```
--> x=9
```
- `clear x` supprime `x`
- `clear` supprime toutes les variables et fonctions.
Variables permanentes :
| variable | valeur |
| :--------------- |:---------------|
| ans | dernière réponse |
|%t,%f | Constante booléenne Vrai,Faux |
|%e,%pi | $e$ , $\pi$ |
|%inf | infini |
### Opérations de base
```
--> 3+2
```
Si on ajoute un `;` à la fin de la ligne, cell-ci est lue, mais le résultat n'est pas affiché : c'est le mode silencieux.
```
--> a=2; b=2;3*a+8*b^3 // le résultat de ce dernier calcul sera affiché
ans =
70.
```
```
1+sqrt(2)
```
On peut naviguer, comme dans le shell, dans l'historique des commandes avec les fléches directionnelles.
```
--> %e,%pi
--> log(%e^2)
```
On peut utiliser des variables :
```
--> a=3;
--> a^2
--> clear a
```
### Objet de base : la matrice
Tout est matrice pour scilab
Une **matrice ligne** (vecteur ligne) :
```
--> vl = [1 2 3 10 100*%pi] //espace ou virgule
vl =
1. 2. 3. 10. 314.15927
```
Une **matrice colonne** (vecteur colonne) :
```
--> w=[2;-3*%pi;7] // point virgule
w =
2.
-9.4247780
7.
```
Transposée : opérateur `'`
```
--> vl'
ans =
1.
2.
3.
10.
314.15927
```
#### Vecteur dont les éléments forment une suite arithmétique
Syntaxe `v=a:r:b` premier terme `a`, raison `r`, ne dépassant pas `b`
```
--> w=[-3:1.5:14]
w =
-3. -1.5 0. 1.5 3. 4.5 6. 7.5 9. 10.5 12. 13.5
```
Lorsque le pas est 1, on peut l'omettre.
```
--> y=[0:9]
y =
0. 1. 2. 3. 4. 5. 6. 7. 8. 9.
```
Subdivision uniforme d'un intervalle avec `v=linspace(début, fin, nombre de valeurs)`
```
--> v=linspace(-5,8,6)
v =
-5. -2.4 0.2 2.8 5.4 8.
```
#### Création de matrices
Avec la liste des coefficients
```
--> A=[1,2,3;4,5,6]
A =
1. 2. 3.
4. 5. 6.
--> A=[1:4;2:5;3:6]
A =
1. 2. 3. 4.
2. 3. 4. 5.
3. 4. 5. 6.
```
Matrices prédéfinies :
| variable | valeur |
| :--------------- |:---------------|
| `ones(n,m)` | matrice nxm dont les éléments valent 1 |
| `zeros(n,m)` | matrice nxm dont les éléments valent 0 |
| `eye(n,m)` | matrice nxm dont les éléemnts diagonaux valent 1, et 0 ailleurs |
### Opérations sur les matrices
**Concaténation**
La concaténation permet de juxtaposer vecteurs et matrices dont les formats sont compatibles.
```
--> u=1:3; v=[u,u,u]
v =
1. 2. 3. 1. 2. 3. 1. 2. 3.
--> u=1:3; v=[u;u;u]
v =
1. 2. 3.
1. 2. 3.
1. 2. 3.
```
**Opérations algébriques**
| Syntaxe | k*A | A+B | A-B | A*B | A^n | inv(A) ou A^(-1)| A' |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Signification | $kA$ | $A+B$ | $A-B$ | $AB$ | $A^n$ | $A^{-1}$ | $^tA$ |
**Opérations algébriques pointées**
Ce sont des opérations élément par élément
| Syntaxe |A.*B | A./B | A.^n |
| --- | --- | --- | --- |
| Valeur | $(a_{ij}b_{ij})$ | $(a_{ij}/b_{ij})$ | $(a_{ij}^{n})$ |
```
--> u.^2
ans =
0. 4. 16. 36. 64. 100.
```
**Fonctions matricielles**
Si `A` est une matrice, et `f` une fonction connue de scilab, `f(A)` retourne la matrice sont les éléments sont les images des éléments de `A` par
`f`.
```
--> A=[1 2 3;4 5 6;7 8 9]
A =
1. 2. 3.
4. 5. 6.
7. 8. 9.
--> sqrt(A+1)
ans =
1.4142136 1.7320508 2.
2.236068 2.4494897 2.6457513
2.8284271 3. 3.1622777
```
**Accès à une partie**
```
--> A=[1 2 3;4 5 6];
--> A(1,2) = 10
A =
1. 10. 3.
4. 5. 6.
--> u=[0 2 4 8 10];
--> u(3),u(1:3),u($)
ans =
4.
ans =
0. 2. 4.
ans =
10.
```
On peut rechercher dans un vecteur
```
--> (A>2)
ans =
F T T
T T T
--> find(u>2)
ans =
3. 4. 5. 6.
```
Pour extraire des lignes ou des colonnes ou des éléments particuliers :
```
--> A=[1,2,3;4,5,6;7,8,9];
--> A(1,3)
--> A(1,:)
--> A(:,1)
--> A($,:)
--> A(1:2:$,:)
--> A($:-1:1,:)
```
### Fonctions usuelles prédéfinies
**Analyse**
`exp,log,sin,abs,floor`
```
--> exp(3),log(2),sin(%pi/3),abs(-2),floor(2.178)
ans =
20.085537
ans =
0.6931472
ans =
0.8660254
ans =
2.
ans =
2.
```
**Matrice**
`min,max,mean,median,sum,cumsum,size`
```
--> u=1:10, s=sum(u),cs = cumsum(u),m=mean(u),
u =
1. 2. 3. 4. 5. 6. 7. 8. 9. 10.
s =
55.
cs =
1. 3. 6. 10. 15. 21. 28. 36. 45. 55.
m =
5.5
```
### Graphiques
On commence par créer un vecteur de 10000 valeurs régulièrement espacées entre 0 et 100 :
```
-->x=linspace(0,100,10000);
```
On aurait pu aussi bien poser :
```
--> x=0:.01:100
```
Nous voulons obtenir la représentation graphique de la fonction $x \rightarrow x\sin(x)$ sur $[0,100]$ :
```
--> plot(x,x .*sin(x))
```
Pour ajouter une autre courbe :
```
--> plot(x,x);
```
Tout demander d'un coup
```
--> clf; plot(x,x .*sin(x),x,x,x,-x)
```
On peut modifier le style des courbes
```
--> X=linspace(-%pi,%pi,20);
--> clf;plot(X,sin(X),"+-b");
```
L'option **+-b** signifie qu'on représente chaque point par une croix (+) , qu'on les relie par un trait continue (-), en bleu (b)
Regardez l'aide pour toutes les options.
### Statistiques
La fonction `rand(l,c)` permet de générer une matrice de nombres réelles aléatoires (par défaut, distribution uniforme sur [0,1[)
Par exemple, pour simuler 100 lancers d'un dé à six faces :
```
--> m=floor(6*rand(100,1)+1)
```
On utilisera aussi la fonction `grand` (help grand) qui permet de simuler la plupart des lois classiques : binomiale, bernoulli, exponentielle, poisson, uniforme, normale, etc.
La fonction `tabul(mat)` est très pratique : elle renvoie une matrice de deux colonnes avec les valeurs prises
par les coefficients de mat sur la première colonne et leurs effectifs respectifs sur la deuxième.
```
--> t = tabul(m)
```
Pour obtenir une représentation graphique sous forme d’un diagramme en bâtons,
on utilise `bar(liste des abs,liste des ord)` :
```
--> bar(t(:,1),t(:,2))
```
On peut aussi générer un camembert (une tarte en anglais :-))
```
--> pie(t(:,2),t(:,1),string(t(:,1)))
```
