## 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$ |
</table>


**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))
```
<div align="center">
<img src="./img/img1.png">
</div>

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");
```

<div align="center">
<img src="./img/img2.png">
</div>


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))
```

<div align="center">
<img src="./img/img3.png">
</div>

On peut aussi générer un camembert (une tarte en anglais :-))

```
--> pie(t(:,2),t(:,1),string(t(:,1)))
```

<div align="center">
<img src="./img/img4.png">
</div>


