Cours Info

Cours d’Informatique
et Algorithmique
ECS1B 2020/2021 – Lycée Carnot
Matthias Gorny
www.ecs1b.matthiasgorny.fr
Table des matières
1 Découverte de Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
I Prise en main de Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1) Un logiciel de calcul numérique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2) L’environnement de travail Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
II Calculs sur les nombres réels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
III Création de variables par affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
IV Variables booléennes et opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . 8
V Chaines de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
VI Vecteurs/listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2 Programmes et fonctions en Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

I Introduction à l’algorithmique et la programmation . . . . . . . . . . . . . . . . . . . . . . . . . . 12
II L’éditeur de texte SciNotes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
III Interaction avec l’utilisateur : entrée et sortie de données . . . . . . . . . . . . . . . . . . . . . . 14
1) La commande input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2) La commande disp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
IV Fonctions en Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1) Création d’une fonction Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2) Utilisation d’une fonction Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3) Fonctions VS programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3 Structures conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4 Structures répétitives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
I Boucle For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
II Boucle While . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
III Calcul des termes d’une suite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1) Calculer le nième terme d’une suite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2) Calculer les n premiers termes d’une suite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3) Sommer les n premiers termes d’une suite . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4) Calculer le plus petit rang pour lequel la suite vérifie une condition . . . . . . . . . . . . . . . 23
5 Représentation graphique en Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

I Représentation de points dans le plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
1) Avec la fonction plot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
2) Avec la fonction plot2d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
II Tracé de courbes représentatives de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
III Diagrammes à barres et histogrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1) Diagrammes à barres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2) Histogrammes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
6 Matrices avec Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
I Création et modification d’une matrice en Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
1) Création d’une matrices en Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2) Accès aux éléments d’une matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3) Modification d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
II Opérations sur les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
1) Opérations matricielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
2) Opérations terme à terme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3) Opérateurs de comparaison sur les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4) Fonctions spécifiques sur les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
III Inversion de matrices et résolution de AX = B . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1) Calcul de l’inverse d’une matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
2) Rang et base du noyau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
IV Résolution de AX = B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
7 Probabilités avec Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

I Générateur de nombres (pseudo) aléatoires : la fonction rand . . . . . . . . . . . . . . . . . . . . 37
1) Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2) La fonction rand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
II Simulation de variables aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1) ... à partir de la fonction rand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
2) ... avec la fonction grand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Chapitre 1
Découverte de Scilab
I Prise en main de Scilab
1) Un logiciel de calcul numérique
Le logiciel retenu pour la programmation dans le programme d’ECS est Scilab, abréviation
de Scientific Laboratory. Il s’agit d’un logiciel open source gratuit de calcul numérique qui
fournit un puissant environnement de développement pour les applications scientifiques
et l’ingénierie.
Un logiciel de calcul numérique manipule des expressions numériques. C’est un outil de calcul scientifique, qui
permet d’obtenir un résultat approché avec une grande précision. Notons la différence avec les logiciels dits de
calcul formel qui manipulent des expressions symboliques et utilisent des expression exactes 2 .
Vous pouvez télécharger Scilab gratuitement sur le site https://www.scilab.org/fr. Vous trouverez notamment
sur ce site des aides et des tutoriels qui peuvent être de bons compléments à ce cours.
2) L’environnement de travail Scilab

Lorsqu’on on lance Scilab, une fenêtre apparaît composée de plusieurs sous-fenêtres : la console Scilab, le navigateur
de fichier, le navigateur de variables et l’historique des commandes.
1. La console Scilab est la zone où l’on tape les commandes. Le symbole - -> signifie que l’ordinateur attend
une instruction. On peut alors saisir une commande et appuyer sur la touche Entrée pour que cette
commande soit interprétée.
• On peut écrire plusieurs instructions sur une même ligne en les séparant d’une virgule.
• On peut faire suivre une commande par un point-virgule si l’on ne souhaite pas que le résultat de la commande
s’affiche dans la console. On dit que l’exécution se fait sans écho.
• Appuyer sur les touches Ctrl + C arrête l’exécution d’une commande.
• L’usage des touches fléchées ↑ et ↓ fait apparaitre les commandes précédemment tapées.
√
2. Par exemple, un logiciel formel travaillera avec 2, alors qu’un logiciel de calcul numérique travaillera avec son approximation
numérique 1, 41421356237
Lycée Carnot - ECS1B 4 Matthias Gorny

2. Le navigateur de fichier est la zone où l’on peut choisir le répertoire courant de Scilab, c’est-à-dire le
répertoire dans lequel se trouvent les fichiers avec lesquels on travaille 1 . On peut notamment les ouvrir en
double-cliquant dessus.
3. Le navigateur de variables est la zone qui répertorie toutes les variables crées par l’utilisateur depuis
l’ouverture de Scilab.
4. L’historique des commandes est la zone qui liste toutes les commandes que l’utilisateur a tapées dans la
console Scilab.
5. L’icône permet d’ouvrir l’éditeur de texte SciNotes dans une nouvelle fenêtre. Cet outil permet de créer
des scripts (des programmes, des fonctions, etc.) que l’on peut exécuter ensuite dans la console. Nous y
reviendrons en détail dans le chapitre suivant.
6. L’icône permet d’ouvrir l’Aide en ligne dans une nouvelle fenêtre (on peut également taper la commande
help dans la console). Cet outil permet de trouver une commande Scilab et de savoir comment l’utiliser.
Pour obtenir des informations sur une commande en particulier, on peut taper dans la console help suivi
du nom de la commande.
On peut personnaliser l’environnement de travail, notamment en modi-
fiant la taille des fenêtres grâce aux doubles flèches qui apparaissent
lorsque l’on place le curseur de la souris entre deux fenêtres. On peut
également déplacer des fenêtres. Pour cela, on clique sur la fenêtre
que l’on veut déplacer : une bande bleue 2 apparait. Il suffit alors de
maintenir le chic gauche de la souris enfoncé pour déplacer la fenêtre
à l’endroit voulu.
On peut également supprimer la fenêtre en cliquant sur la petite croix (attention la fermeture de la console
provoque bien la fermeture de Scilab...). Enfin on peut insérer l’éditeur de texte SciNotes à l’espace de travail en
employant la même méthode (c’est ce que l’on fera ultérieurement).
II Calculs sur les nombres réels

Scilab utilise la représentation des nombres réels en virgule flottante en suivant la norme IEEE-754. Hormis le
nombre 0, Scilab travaille avec les réels compris entre environ 2, 225 × 10−308 et 1, 798 × 10308 et leurs opposés,
avec une approximation décimale maximale de ε ≈ 2, 22 × 10−16 .
Exemples :
-->10∧308 -->10∧309
ans = ans =
1.00D+308 Inf
Les opérations arithmétiques élémentaires sur les réels se font à l’aide des symboles suivants :
+ addition * multiplication ∧ puissance
- soustraction / division ** puissance
Exemples :
-->2+4, 2-4 -->2*4, 2/4 -->2∧4, 2**4
ans = ans = ans =
6. 8. 16.
ans = ans = ans =
- 2. 0.5 16.
Les opérations en Scilab, comme en mathématiques, ont un ordre de priorité 3 et on utilise donc également
des parenthèses pour lever tout ambiguïté (par exemple qu’en est-il si on a des exposants successifs ? Et bien
Scilab fait les calculs de droite à gauche et non de gauche à droite).
1. Pour moi il s’agit de C:\Gorny\Scilab\

2. Elle est bleue sous Windows, mais noire sous Mac OS X ou Linux.
3. L’ordre de priorité est le suivante : les Parenthèses, puis les Exposants, puis les Multiplications ou les Divisions (de gauche à
droite) et puis enfin les Additions ou les Soustractions (de gauche à droite).

Exemples :
-->7*4-6, 7*(4-6)
ans = -->5/7/2, (5/7)/2, 5/(7/2) -->3∧4∧2, 3∧(4∧2), (3∧4)∧2
22. ans = ans =
ans = 0.3571429 43046721.
- 14. ans = ans =
0.3571429 43046721.
-->8/2*4 ans = ans =
ans = 1.4285714 6561.
16.
Certaines constantes sont prédéfinies dans Scilab (il s’agit bien sûr d’approximations) :
%pi le nombre π %e la constante d’Euler e = exp(1)
Scilab intègre également des fonctions prédéfinies :

log la fonction logarithme népérien floor la fonction partie entière
exp la fonction exponentielle cos la fonction cosinus
sqrt la fonction racine carrée sin la fonction sinus
abs la fonction valeur absolue tan la fonction tangente
Exemples :
-->abs(log(0.5))
-->%e**2, exp(2) -->floor(-2.56) ans =
ans = ans = 0.6931472
7.3890561 - 3.
ans = -->%pi, cos(%pi), sin(%pi)
7.3890561 -->sqrt(2), sqrt(-2) %pi =
ans = 3.1415927
-->log(7.389) 1.4142136 ans =
ans = ans = - 1.
1.9999924 1.4142136i ans =
1.225D-16
Comme on peut le remarquer sur ci-dessus, Scilab permet aussi de manipuler des (approximations des) nombres
complexes grâce à la variable %i qui représente le complexe i.
Exemples :
-->%i, %i*%i, 1/(1+%i) -->exp(%i*%pi/4)
%i = ans =
i 0.7071068 + 0.7071068i
ans =
- 1. -->abs(%i)
ans = ans =
0.5 - 0.5i 1.
La valeur d’un calcul affiché dans la console est un arrondi et non le contenu exact de la valeur conservée en
mémoire. Pour afficher une valeur avec plus de précision, on peut changer le format d’affichage avec la fonction
format (qui prend en argument un entier entre 2 et 25).
Exemples :
-->sin(%pi),format(6),sin(%pi)
-->format()
ans =
ans =
0.00000000000000012
1. 10.
ans =
0.000
-->%pi, format(20); %pi
%pi =
-->format(26)
3.1415927
!--error 999
%pi =
format : Valeur erronée de l’argument no 1 :
3.14159265358979312
Doit être dans l’intervalle [2,25].

La commande format() affiche le format actuel. Dans l’exemple ci-dessus le 10. signifie que l’affichage actuel
utilise 10 caractères en comptant le signe. Mentionnons l’existence de la variable %eps qui renvoie la valeur de la
précision machine ε.
III Création de variables par affectation

Nous avons déjà rencontré des variables dans les exemples précédents. Lorsque l’on effectue un calcul dans la
console, le résultat de ce calcul se stocke dans une variable appelée ans .
Plus généralement, les variables permettent de stocker des données. Créer une variable par affectation consiste à
associer une valeur à un nom. Si on dispose d’une valeur expression (qui est soit directement une valeur, soit
une expression permettant le calcul d’une valeur), on utilise la syntaxe nom=expression pour affecter la valeur
expression à la variable appelée nom.
S’il n’existe pas de variable appelée nom, alors cette instruction crée la variable nom et lui affecte expression.
Si la variable nom existe déjà, alors cette instruction efface l’ancienne valeur de la variable et la remplace par la
valeur expression. Pour connaître la valeur affectée à une variable existante, il suffit de taper son nom dans la
console et de valider.
La commande nom=expression; permet d’affecter la valeur expression à la variable nom sans que le résultat
ne s’affiche dans la console (pratique si l’on fait tourner un programme effectuant des milliers d’affectations). On
dit que l’exécution de fait sans écho.
Exemples :
-->x -->x=6*x-3; x
!--error 4 -->4*x-5, x x =
Variable non définie : x ans = 15.
7.
-->x=3; y=4; z=x*y+1 x = -->t=ans/2+1
z = 3. t =
13. 4.5
Remarques :
• Le nom d’une variable ne doit pas commencer par un chiffre. Il peut être constitué d’au plus vingt-quatre
caractères, chacun pouvant être une lettre sans accent, un chiffre ou un des symboles suivants : _, #, !,
?, $. Scilab fait également la distinction entre minuscules et majuscules.
• Il est suggéré d’utiliser des noms courts et explicites pour les variables. Cela permettra de s’y retrouver plus
facilement lorsqu’on reprendra un code ultérieurement. N’hésitez pas à ajouter des commentaires (avec le
symbole //) pour expliquer le contenu d’une variable.
• Le symbole = dans Scilab est appelé l’opérateur d’affectation. Il n’a pas le sens usuel du = mathématique.
De plus il faut bien respecter la syntaxe : ce qui se trouve à gauche du symbole = est modifié ou créé par ce
qui se trouve à droite du symbole =.
Comme on l’a vu plus haut, on peut affecter à une variable une expression contentant d’autres variables.... y
compris elle même :
Exemple :
-->y=y**2+2*y+1//on remplace la valeur de a par la valeur de a∧2+2a+1
y =
25.
Quelques commandes utiles :

who_user donne la liste des variables crées par l’utilisateur et les fonctions qu’il a appelées
clear nom1,nom2 efface les variables nom1 et nom2 de l’espace de travail
clear efface toutes les variables crées dans l’espace de travail
On peut affecter différents types de données à des variables : des nombres bien sûr, mais aussi des vecteurs,
matrices, chaines de caractères, booléens, etc. Nous y reviendrons en détail. Notons l’existence de la fonction
typeof qui permet d’associer à chaque donnée son type.

Exemple :
-->x=2*%pi; typeof(x)
ans =
constant
IV Variables booléennes et opérateurs de comparaison

Un booléen, en logique et en programmation informatique, est un type de variable à deux états :
T (vrai) ou F (faux). En Scilab, les variables booléennes sont %t pour vrai et %f pour faux.
Scilab permet de faire des tests logiques avec les variables booléennes et les opérateurs logiques
& opérateur et | opérateur ou ∼ opérateur non
Exemples :
-->%f, typeof(%f) -->∼%t, ∼%f -->%t|%t, %t|%f -->%t&%t, %t&%f
ans = ans = ans = ans =
F F T T
ans = ans = ans = ans =
boolean T T F
Scilab manipule des égalités et inégalités de réels permettant d’effectuer des tests logiques de comparaison. Les
opérateurs de comparaison sont :
== test d’égalité > supérieur strict < inférieur strict
<> différent >= supérieur ou égal <= inférieur ou égal
Le résultat d’un test de comparaison est une variable booléenne.

Exemples :
-->5>=6 -->log(%e)==1 -->x=%pi/4; y=(x>0)&(x<1); y
ans = ans = y =
F T T
Ne pas confondre l’opérateur d’égalité == et l’opérateur d’affectation =.

-->5=6
Attention : Utilisation obsolète de ’=’ àla place de ’==’.
On peut également faire des opérations arithmétiques avec les variables booléennes. Dans ce cas elles sont
automatiquement converties en réels : %t en 1 et %f en 0.
Exemple :
k=%f; 0.7∧k*0.3∧(1-k)
ans =
0.3
Remarque : La précision de Scilab peut provoquer des erreurs dans les tests. Par exemple
sqrt(3)∧2==3
ans =
F
Pour comprendre d’où provient l’erreur, étudions l’écart relatif entre sqrt(3)∧2 et 3 et comparons la avec la
précision ε de Scilab (stockée dans la variable %eps).
-->abs(sqrt(3)∧2-3)<%eps -->abs(sqrt(3)∧2-3)<3*%eps
ans = ans =
F T

V Chaines de caractères
Une chaîne de caractère (string en anglais) est une suite de caractères alphanumériques. En Scilab, les chaînes de
caractères sont délimitées par des apostrophes ’ ou des guillemets ". On peut stocker une chaine de caractère
dans une variable.
Exemple :
-->a="Hello"
a =
Hello
Lorsqu’une chaîne de caractère contient le caractère ’ ou le caractère ", il faut le doubler.

-->b=’J’utilise Scilab’ -->b=’J’’utilise Scilab’
!--error 276 b =
Opérateur, virgule ou point-virgule manquant. J’utilise Scilab
L’opérateur + permet de concaténer deux chaînes de caractères.

Exemples :
-->c=’World’ -->a + c -->a + ’ ’ + c + ’!’
c = ans = ans =
World HelloWorld Hello World!
Lorsqu’une chaine de caractère est composée exclusivement de chiffres, il ne faut pas confondre l’opérateur
+ de la concaténation et celui de l’addition. De même on ne peut pas additionner un nombre et une chaine de
caractère. Par contre on peut convertir une variable numérique en chaine de caractère avec la fonction string .
-->’20’+’17’ -->20+’17’
ans = !--error 144
2017 Opération non définie pour les opérandes données.
-->20+17 -->x=%pi
ans = x =
37. 3.1415927
-->typeof(’20’) -->"Une valeur approchée de pi est " + string(x) + ’.’

ans = ans =
string Une valeur approchée de pi est 3.1415927.
VI Vecteurs/listes
Scilab manipule les vecteurs (c’est-à-dire des listes ordonnées de réels, ou de booléens, ou de chaînes de caractère,
etc.) que l’on peut également stocker dans une variable. Pour construire un vecteur par extension, on donne la liste
des éléments du vecteur entre crochets et en les séparant de virgules. La commande [] construit une liste vide.
Exemples :
-->A=[1,2,3,4,5,6] -->C=[’nord’,’sud’,’est’,’ouest’]
A = C =
1. 2. 3. 4. 5. 6. !nord sud est ouest !
-->B=[%f,%t,%t,%f,%f] -->D=[]
B = D =
F T T F F []
Il existe d’autres manières de construire des vecteurs contenant des nombres : si x et y sont des réels, si p est un
réel strictement positif et si n un entier strictement positif, alors

x:y construit un vecteur constitué des nombres de x à y par pas de 1.
x:p:y construit un vecteur constitué des nombres de x à y par pas de p.
linspace(x,y,n) construit un vecteur constitué de n nombres entre x et y, régulièrement espacés.
ones(1,n) construit un vecteur de taille n constitué uniquement de 1.
zeros(1,n) construit un vecteur de taille n constitué uniquement de 0.
rand(1,n) construit un vecteur de taille n constitué de nombres tirés aléatoirement dans ]0, 1[.
Exemples :
-->linspace(1,3,5), ones(1,4), zeros(1,5)
-->-2:5, 3:2
ans =
ans =
1. 1.5 2. 2.5 3.
- 2. - 1. 0. 1. 2. 3. 4.
ans =
5.
1. 1. 1. 1.
ans =
ans =
[]
0. 0. 0. 0. 0.
-->2:0.1:3
-->rand(1:6)
ans =
ans =
2. 2.1 2.2 2.3 2.4 2.5
0.4148104 0.2806498 0.1280058
2.6 2.7 2.8 2.9 3.
0.7783129 0.2119030 0.1121355
Si v et w sont des vecteurs, si x est un réel et si i et j sont des entiers strictement positifs, alors
length(v) renvoie la taille du vecteur v
v(i) renvoie la iième coordonnée du vecteur v
v($) renvoie la dernière coordonnée du vecteur v
v(i)=x remplace la iième coordonnée du vecteur v par le réel x
v(i)=[] supprime la iième coordonnée du vecteur v
v(i:j) renvoie un vecteur contenant les coordonnées de i à j de v
v(i:j)=w remplace les coordonnées de i à j de v par les coordonnées de w (vecteur de même taille que v(i:j))
v(i:j)=[] supprime les coordonnées de i à j de v
[v,w] renvoie la concaténation des vecteurs v et w
Exemples :
-->v=[1,2,3,4,5,6]; v(2), v(%)
ans =
-->v(1:2)
2.
ans =
ans =
1. 2.
6.
-->v(3:2)
-->v(7)
ans =
!--error 21
[]
Index invalide.
-->v=[1,-1,-2]; w=[8,9]; [v,w]
-->v(3)=7; v(4)=[]
ans =
1. 2. 7. 5. 6.
1. - 1. - 2. 8. 9.
-->v(4:5)=[-1,-2], v(2:3)=[]
-->v=[v,0]
v =
v =
1. 2. 7. - 1. - 2.
1. - 1. - 2. 0.
v =
1. - 1. - 2.
Insistons sur la dernière commande de l’exemple : si on dispose d’un vecteur v et d’un nombre x, alors la commande
v=[v,x] (resp. v=[x,v] ) ajoute une nouvelle coordonnée au vecteur v contenant la valeur x en dernière (resp.
première) position.
Comme pour les nombres, on peut faire des opérations (terme à terme) sur les vecteurs : si v et w sont des
vecteurs de même taille, et si x est un réel non nul, alors
v+w additionne terme à terme les vecteurs v et w
v-w soustrait terme à terme le vecteur w au vecteur v
x*v multiplie chaque coordonnée de v par x

v/x divise chaque coordonnée de v par x
v.*w multiplie terme à terme les vecteurs v et w
v./w divise terme à terme le vecteur v par w
v.∧w effectue la puissance terme à terme du vecteur v par le vecteur w
Les fonctions usuelles (log, exp, sqrt, abs, floor, cos, sin, tan) s’appliquent également aux vecteurs
coordonnée par coordonnée.
Exemples :
-->v=[1,3,5,7]; w=[8,6,4,2];
-->v+[1,2]
-->v+w, v-w, 2*v, w/2 !--error 8
ans = Addition incohérente.
9. 9. 9. 9.
ans = -->v*w
- 7. - 3. 1. 5. !--error 10
ans = Multiplication incohérente.
2. 6. 10. 14.
ans = -->floor(log(w)), exp(v), sin(w)
4. 3. 2. 1. ans =
2. 1. 1. 0.
-->v.*w,v./w, v.∧w ans =
ans = 2.7182818 20.085537 148.41316
8. 18. 20. 14. 1096.6332
ans = ans =
0.125 0.5 1.25 3.5 0.9893582 - 0.2794155 - 0.7568025
ans = 0.9092974
1. 729. 625. 49.
Enfin les opérateurs de comparaison et les opérateurs logiques s’appliquent aussi aux vecteurs de même taille. Les
opérations se font terme à terme et le résultat est un vecteur de même taille contenant des variables booléennes.
Exemple :
-->u=[1,2,3,4]; v=[1,%pi,2,%e]; w=[%e,sqrt(2),0,5]; (v>=w)|(u>w)
ans =
F T T F
Terminons par deux fonctions : si v est un vecteur constitué de booléens, alors

or(v) retourne T si au moins un des éléments de v vaut T et retourne F sinon
and(v) retourne T si tous les éléments de v ont la valeur T et retourne F sinon
Exemples :
-->v=[%t,%t,%f]; or(v), and(v)
ans =
T
ans =
F
Remarque : Nous avons uniquement vu les vecteurs lignes pour le moment. Nous verrons les vecteurs colonnes
et plus généralement les matrices ultérieurement. Retenons pour l’instant la commande u’ qui transforme le
vecteur ligne u en un vecteur colonne (on dit que l’on transpose le vecteur u). Par exemple :
-->u+u’
-->u=[1,3,5,7]; u’
!--error 8
ans =
Addition incohérente.
1.
3.
-->u*u’
5.
ans =
7.
84.
L’addition d’un vecteur ligne et d’un vecteur colonne n’a pas de sens et renvoie une erreur. La multiplication
par contre fonctionne... nous verrons dans le chapitre sur les matrices ce que cela signifie.

Chapitre 2
Programmes et fonctions en Scilab
I Introduction à l’algorithmique et la programmation

Un algorithme est une suite finie d’instructions à exécuter dans un ordre déterminé, permettant de résoudre, en
un nombre fini d’étapes, un problème particulier.
La structure d’un algorithme est semblable à celle d’une recette de cuisine : on démarre avec une liste d’ingrédients
(les entrées pour un algorithme) et on décrit les étapes successives à effectuer dans un certain ordre (les instructions
pour un algorithme) à partir des ingrédients et d’outils mis à notre disposition. L’application de ces étapes nous
permet d’obtenir des plats (les sorties pour un algorithme) prêts à être servis.
L’outil informatique permet de réaliser rapidement un très grand nombre de calculs. Si chaque étape d’un algorithme
donné peut être décomposé en plusieurs sous-étapes suffisamment simples et compréhensibles pour être effectuée
par un ordinateur, alors on peut envisager de lui confier l’exécution de cet algorithme. Un programme informatique
est donc la traduction d’un algorithme en langage compréhensible par un ordinateur. On dit alors que l’on code ou
que l’on implémente l’algorithme.
Il existe de nombreux langages compréhensibles par un ordinateur (Java, C, Python, Pascal, HTML, LaTeX, etc).
Ils n’ont pas tous la même utilité mais ils respectent généralement les même principes de bases. Dans ce cours,
nous utilisons uniquement le langage Scilab qui permet l’implémentation d’algorithmes de calcul numérique (cf.
chapitre 1).
Exemple : Un algorithme consistant à écrire un entier naturel n (écrit en base 10) en base b est le suivant :
1. On prend en entrée deux entiers naturels n et b.
2. On stocke la valeur de n dans une variable a.
3. On garde en mémoire le reste de la division euclidienne de a par b. On remplace la valeur de a par la valeur
du quotient.
4. On répète l’étape 2 jusqu’à ce que le quotient de la division soit égal à 0.
5. On écrit les restes successifs du dernier au premier.
Une traduction de cet algorithme en langage Scilab est le programme suivant :
//On demande à l'utilisateur d'entrer n et b
n=input('Entrer un entier naturel : ')
b=input('Entrer une base : ')
a=n; q=1; bin=' ';//On crée une chaîne de caractère vide, appelée bin
while q>0//Tant que q est non nul, on répète les instructions suivantes.
q=0
while b*(q+1)<a
q=q+1;
end//A l'issue de cette boucle, q est le nouveau quotient
r=a-b*q; a=q;
bin=string(r)+bin;//On ajoute le reste r devant bin
end
disp('L''entier '+string(n)+' s''écrit '+string(bin)+' en base '+string(b)+'.')
II L’éditeur de texte SciNotes

Lorsque l’on écrit des programmes comportant un grand nombre d’instructions, l’usage de la console Scilab montre
vite ses limites. Notamment l’enregistrement n’est pas possible et, à chaque exécution d’une commande, pour la
modifier et l’exécuter à nouveau, il faut la réécrire entièrement ou la rechercher dans l’historique. Nous allons
donc travailler avec des scripts qui permettent de rassembler en un même fichier une succession d’instructions.
Pour créer des scripts, nous allons utiliser l’éditeur de texte SciNotes.

SciNotes possède d’autres fonctionnalité très utiles permettent d’améliorer la lisibilité d’un code (organisation par
blocs, coloration des mots clés, indentations, complétion automatique pour aider à la rédaction d’un code).
Cliquer sur l’icône ouvre SciNotes dans une nouvelle fenêtre :
1. L’icône permet d’ouvrir un nouveau script. Cliquer sur le menu Fichier permet aussi d’ouvrir des
fichiers déjà créés et enregistrés.
2. On écrit les instructions du script dans la fenêtre principale. Il est important de penser à enregistrer
régulièrement ses scripts, en utilisant le raccourci Ctrl + S .
3. On peut ouvrir plusieurs scripts en même temps qui s’organisent en onglets. Pour accéder à un script déjà
ouvert, il suffit de cliquer sur son onglet.
4. En maintenant enfoncé le clic gauche de la souris sur la barre bleue, on peut déplacer SciNotes et l’insérer
dans l’environnement de travail Scilab.
5. Un fois un script terminé, on peut l’exécuter dans la console Scilab. Pour cela on peut cliquer sur Exécuter
et on se retrouve alors face à différents modes d’exécution :
• l’exécution avec écho (qui affiche dans la console les commandes exécutées et les réponses pour les commandes
qui ne sont pas terminées par ;). Un raccourci est Ctrl + L .
• l’exécution avec écho jusqu’à la position du curseur. Un raccourci est Ctrl + E .
• l’exécution sans écho (qui affiche seulement les réponses pour les commandes qui ne sont pas terminées par ;).
Un raccourci est Ctrl + Maj + E .
Si le programme est sauvegardé dans le répertoire de travail sous le nom nomprogramme.sce, alors on peut aussi
exécuter sans écho en tapant sur la console Scilab la commande exec(’nomprogramme.sce’, -1) .
Remarques :
• Il faut enregistrer un script avant de l’exécuter... sinon on exécute sa précédente version.
Dans SciNotes, lorsqu’un script a été modifié mais pas enregistré, une petite astérisque apparait dans le
titre de l’onglet (cf. 3) correspondant au script en question.
• Le symbole // marque le début d’un commentaire : ce qui suit ce symbole ne sera pas exécuté. Un bon
code est un code commenté (cela facilite la compréhension du code quand on le reprend quelque temps plus
tard...)
• Par défaut, un script est sauvegardé avec l’extension .sce (ou .sci pour les fonctions, cf. paragraphe
IV). On se retrouvera rapidement avec de nombreux scripts. Pour gagner du temps, il convient donc de les
organiser par nom (par exemple TP3-Exo5.sce) ou de créer des dossiers.

III Interaction avec l’utilisateur : entrée et sortie de données
Lorsque l’on écrit un programme c’est pour demander à une machine de faire quelque chose. Il peut donc être
pratique de faciliter la communication avec la machine.
1) La commande input
La commande qui permet à un programme de demander quelque chose à l’utilisateur est input (entrée en
français). Plus précisément, la syntaxe est la suivante :
var=input("message")
Lors de l’exécution du programme, cette commande va afficher la chaîne de caractères "message" sur la console
(en général le message demande à l’utilisateur d’écrire une variable : un nombre ou un vecteur ou un booléen,
etc.). Ce que l’utilisateur répond au programme (c’est-à-dire la commande qu’il écrit dans la console) est stocké
dans la variable var et pourra être utilisée par la programme.
Exemple : (dans la console)
-->n=input("Entrer un nombre entier : ")
Entrer un nombre entier : 6
n =
6.
La commande var=input("message","string") permet de saisir une chaîne de caractères. Plus précisément, elle
affiche comme précédemment la chaîne de caractères "message". Ce que l’utilisateur répond est stocké dans la
variable var sous la forme d’une chaine de caractère.
-->nom=input("Comment vous appelez-vous ? ","string")
Comment vous appelez-vous ? Bond, James Bond
nom =
Bond, James Bond
2) La commande disp
La commande qui permet à un programme d’afficher des variables ou des phrases en sortie est disp, abréviation
de display (afficher en français). Plus précisément, la syntaxe est la suivante :
disp(var1,var2,...,varn)
Ici var1,var2,...,varn désignent des variables qui ont été affectées lors des instructions du programme. Il peut
s’agit de chaînes de caractères si on veut écrire une phrase.
-->n=7; s=n*(n+1)/2;
-->disp(s," est ", n, "La somme
-->disp("La somme des entiers de 1
des entiers de 1 à")
à ", n, " est ", s)
La somme des entiers de 1 à
28.
7.
est
est
7.
28.
La somme des entiers de 1 à
Assez curieusement, lors de l’exécution du programme, cette commande affiche les variables dans l’ordre
inverse. Le mieux est encore d’utiliser disp avec une seule chaîne de caractères qui consiste en une phrase
(rappelons que la commande sting(var) permet de convertir la variable var en chaîne de caractères, cf. le
chapitre précédent).
-->disp(’La somme des entiers de 1 à’ + string(n) + ’ est ’ + string(s) + ’.’)
La somme des entiers de 1 à7 est 28.

Exemple : Écrivons un programme qui demande à l’utilisateur deux réels x et q et un entier n et affiche une
phrase indiquant la valeur du nième terme d’une suite géométrique de raison q et de terme initial x.
x=input('Entrer le terme initial de la suite géométrique :')

q=input('Entrer la raison de la suite géométrique :')
n=input('Entrer un rang :')
u=x*q∧n;
disp('La valeur du '+string(n)+'-ième terme de la suite géométrique de raison '+
string(q)+' et de terme initial '+string(x)+' est '+string(u)+'.')
Exécutons ce programme (appelé SuiteGeom.sce) sans écho dans la console :

-->exec(’C:\Gorny\Scilab\SuiteGeom.sce’, -1)
Entrer le terme initial de la suite géométrique :3
Entrer la raison de la suite géométrique :-1.2
Entrer un rang :19
La valeur du 19-ième terme de la suite géométrique de raison -1.2

et de terme initial 3 est -95.844.
IV Fonctions en Scilab
Comme on a pu le voir jusqu’à présent, Scilab dispose de nombreuses commandes et fonctions diverses. On sera
vite amené à créer nos propres fonctions afin de simplifier l’écriture d’un programme et de condenser en une seule
commande une suite d’instructions.
Ces instructions dépendent éventuellement de variables d’entrées (appelées arguments d’appel ou d’entrée) qui
peuvent être des nombres, des vecteurs, des booléens, des chaînes de caractères... Après l’exécution de ces
instructions, la fonction renvoie généralement une ou plusieurs des variables de sortie (appelées arguments de
sortie).
1) Création d’une fonction Scilab

On écrit le code d’une fonction Scilab dans un script SciNotes. La syntaxe d’une fonction est la suivante :
function [y1,...yp]=nomfonction(x1,...,xn)
instructions
endfunction
Les variables x1,...,xn sont les arguments d’entrées de cette fonction. Elles vont intervenir dans le bloc
d’instructions instructions. Les variables y1,...,yn sont créées et/ou modifiées par le bloc d’instructions et
sont les arguments de sortie. Ici la fonction s’appelle nomfunction. Le script contenant le code doit être enregistré
dans le répertoire de travail sous le nom nomfunction.sci (insistons sur l’extension .sci et non .sce).
Remarques :
• Le bloc d’instruction instructions s’appelle le corps de la fonction.
• Si la fonction ne renvoie qu’une seule variable en sortie, alors les crochets dans la première ligne de code
sont facultatifs.
• Ne pas nommer une fonction avec un nom déjà utilisé par une fonction Scilab.
• Les variables utilisées dans le corps d’une fonction sont des variables internes, c’est-à-dire les modifications
apportées à un argument d’entrée dans le corps de la fonction ne sont pas visibles à l’extérieur de la fonction
(sauf si l’argument d’entrée est aussi un argument de sortie).
Si le script d’une fonction utilise une variable qui n’est pas un argument d’entrée et qui n’est pas définie
dans le corps de la fonction, alors
— ou bien la variable a été définie dans l’espace de travail et Scilab utilisera sa valeur par défaut.
— ou bien elle n’a pas été définie et Scilab affichera un message d’erreur.

Exemple : Écrivons une fonction qui prend en entrée deux réels x et q et un entier n et renvoie la valeur du nième
terme d’une suite géométrique de raison q et de terme initial x (on comparera avec le programme précédent).
function u=SuiteGeom(x,q,n)
u=x*q∧n
endfunction
2) Utilisation d’une fonction Scilab

Pour utiliser la fonction nomfunction que nous venons de créer, il faut la charger dans l’environnement de travail
Scilab. Pour cela on tape la comman exec(’nomfunction.sci’,-1) dans la console Scilab (en s’assurant au préalable
que la fonction est bien enregistrée dans le répertoire de travail). On peut également utiliser le menu Exécuter
ou les raccourcis Ctrl + E ou Ctrl + Maj + E (selon que l’on souhaite une exécution avec ou sans écho).
Contrairement aux autres scripts, il n’y a pas besoin de ré-exécuter une fonction dès que l’on veut l’utiliser. La
fonction que l’on a créée et exécutée se rajoute aux fonctions Scilab et s’utilise de la même façon.
Avant de l’utiliser, il faut recharger la fonction dès qu’on la modifie.
Exemple : Testons la fonction précédemment implémentée (on l’a au préalable enregistré sous le nom SuiteGeom.sci).
-->exec(’C:\Gorny\Scilab\SuiteGeom.sci’, -1) -->SuiteGeom(15,0.6,1), SuiteGeom(15,0.6,10)

ans =
-->SuiteGeom(6,2,13) 9.
ans = ans =
49152. 0.0906993
Modifions cette fonctions pour qu’elle renvoie aussi la valeur du nième terme d’une suite arithmétique de
raison q et de terme initial x.
function [u,v]=SuiteGeomArith(x,q,n)
u=x*q∧n
v=x+q*n
endfunction
Testons cette fonction (enregistrée au préalable sous la nom SuiteGeomArith.sci).
-->exec(’C:\Gorny\Scilab\SuiteGeomArith.sci’, -1)
-->SuiteGeomArith(6,2,13) -->[x,y]=SuiteGeomArith(6,2,13)
ans = y =
49152. 32.
x =
-->x=SuiteGeomArith(6,2,13); x 49152.
x =
49152.
Quand une fonction Scilab admet plusieurs arguments de sortie, si on l’applique à des arguments d’entrées,
c’est uniquement la première sortie qui est affichée. De même si on stocke les sorties dans une seule variable, c’est
uniquement la première sortie qui est stockée. C’est ce que l’on observe ci-dessus. Pour afficher les deux sorties de
la fonction, il a fallu stocker les sorties de la fonctions dans un vecteur dont la taille est égale au nombre de sorties.
sin(x)
Exemple 2 : Implémentons la fonction f : x 7−→ .
1 + x2
function y=f(x)
y=sin(x)/(1+x∧2)
endfunction

Exécutons cette fonction (appelée f.sci) sans écho dans la console et testons-là.
-->exec(’C:\Gorny\Scilab\f.sci’, -1)
-->f([1,2])
-->f(3),f(-1) !
ans = at line 2 of function f
0.0141120 called by :
ans = f([1,2])
- 0.4207355
Il faut penser à utiliser les opérations .* , ./ et .∧ afin de pouvoir prendre en argument des vecteurs ou
des matrices (on aura besoin de cette fonctionnalité dès le chapitre suivant).
Modifions la fonction pour permettre cela :
function y=f(x)
y=sin(x)./(1+x.∧2)
endfunction
N’oublions pas d’exécuter à nouveau la fonction la fonction... et testons-la :

-->exec(’C:\Gorny\Scilab\f.sci’, -1)
-->X=[1,2]; Y=f(X)
Y =
0.4207355 0.1818595
Par contre cette méthode ne fonctionne pas si la fonction présente des structures conditionnelles (cf. chapitres
suivants 1 ). Pour le moment ce n’est pas très important.
3) Fonctions VS programmes
Il ne s’agit pas vraiment d’une opposition puisqu’une fonction est un type particulier de programme. Nous allons
apprendre au fil des TP à utiliser des programmes (sous entendus des scripts utilisant éventuellement input et
disp) ou des fonctions selon le besoin (ou selon l’énoncé).
Les commandes input et disp permettant de dialoguer avec l’utilisateur. Cela peut-être pratique lorsque l’on
désire être guidé pas à pas sur le fonctionnement du programme et/ou lorsqu’on veut afficher des résultats avec
des explications. Une limite importante à la commande input est qu’il faut ré-exécuter le programme à chaque
fois. Les fonctions au contraire permettent d’effectuer un ensemble d’instructions par simple appel de la fonction
dans la console. Elles permettent d’exécuter une série d’instructions un grand nombre de fois dans plusieurs
parties d’un programme (d’ailleurs une fonction peut-être elle-même définie au sein d’un script). Cela permet
une simplicité du code et donc une taille de programme minimale. D’autre part, une fonction peut faire appel à
elle-même, on parle alors de fonction récursive.
Une erreur classique est d’utiliser input (pour communiquer à Scilab les variables d’entrée) ou disp (pour
renvoyer les variables de sortie) dans une fonction. Imaginons un instant une telle fonction...
• Si on fait appel un grand nombre de fois à cette fonction (pour tracer une courbe représentative par exemple,
cf. chapitre 5) alors, à chaque appel, il va falloir répondre à la question posée par le input.
• La commande disp affiche une phrase et non une valeur : on ne peut pas stocker le résultat dans une
variable (à moins de faire un copier/coller mais ce n’est vraiment pas pratique si on veut répéter un grand
nombre de fois) qui est donc inutilisable. Si on exécute 10000 fois cette fonction, alors une phrase va
s’afficher 10000 fois (on préférerait par exemple stocker les 10000 valeurs dans un vecteur).
Bref on retiendra que
On ne met jamais de input ou de disp dans une fonction.
1. Si les instructions ne sont pas vraies pour tous les éléments du vecteur d’entrée, alors c’est l’instruction du else qui s’appliquera
à tous. Dans ce cas on pourra utiliser une boucle for dans la console : si f est la fonction et X un vecteur, alors la commande
Y=[]; for x=X; Y=[Y,f(x)]; end; stocke dans Y les images par f des éléments de X (en détail : on crée une liste vide Y et, pour
chaque élément x du vecteur X, on ajoute f(x) à la liste Y). On peut aussi ajouter cette boucle for directement dans le script de la
fonction.

Chapitre 3
Structures conditionnelles
En programmation, une structure conditionnelle permet de réaliser une séquence d’instructions lorsqu’une certaine
condition est vraie (on parle alors de condition if/then – si/alors en français). Elle peut aussi présenter une
alternative et réaliser une autre séquence d’instructions lorsque cette même condition est fausse (on parle alors de
condition if/then/else – si/alors/sinon en français). La syntaxe est la suivante :
debut_du_programme
if condition then
instructions_if
else
instructions_else
end
fin_du_programme
L’expression condition prend pour valeur un booléen (elle soit vraie, soit fausse). Si elle est vraie, alors le bloc
d’instructions instructions_if s’exécute (mais pas le bloc d’instructions instructions_else). Si condition
est fausse, alors le bloc d’instructions instructions_else s’exécute (mais pas instructions_if). Ensuite la
suite du programme s’exécute.
S’il n’y a pas d’alternative, alors on n’écrit pas else et évidemment pas le bloc d’instructions instructions_else.
Exemple : Écrivons un programme qui demande deux entiers a et b et teste si a est divisible par b.
a=input('Entrer un entier : ')
b=input('Entrer un entier non nul : ')
//pour tester si un nombre n est un entier,
//on peut tester s'il est égal à sa partie entière.
n=a/b;
if n==floor(n) then
disp(string(a)+" est divisible par "+string(b)+".")
else
disp(string(a)+" est divisible par "+string(b)+".")
end
Exécutons ce programme (appelé TestDiv.sce) sans écho dans la console :

-->exec(’C:\Gorny\Scilab\TestDiv.sce’, -1) -->exec(’C:\Gorny\Scilab\TestDiv.sce’, -1)
Entrer un entier : 111 Entrer un entier : 1014
Entrer un entier non nul : 11 Entrer un entier non nul : 3
111 n’est pas divisible par 11. 1014 est divisible par 3.
Il est également possible d’imbriquer plusieurs structures conditionnelles les unes à l’intérieur des autres. Si on a
trois alternatives, une syntaxe possible est le script ci-dessous.
debut_du_programme
if condition1 then
instructions1
else
if condition2 then
instructions2
else
instructions_else
end
end
fin_du_programme

Les expressions condition1 et condition2 prennent pour valeur des booléens. Si condition1 est vraie, alors
instructions1 s’exécute et c’est directement la suite du programme qui est exécutée. Si condition1 est fausse
alors,
• ou bien condition2 est vraie et alors instructions2 s’exécute puis la suite du programme.
• ou bien condition2 est fausse également et alors instructions_else s’exécute puis la suite du programme.
Cette solution fonctionne mais il est plus élégant et plus pratique d’utiliser une structure conditionnelle à plusieurs
branches avec elseif. La syntaxe est la suivante :
debut_du_programme
if condition1 then
instructions1
elseif condition2 then
instructions2
elseif condition3 then
instructions3
..
.
else
instructions_else
end
fin_du_programme

xexp(x) si
 x ∈ ]−∞, 0]
9πx2


Exemple : Implémentons en Scilab la fonction f : x ∈ R 7−→ cos si x ∈ ]0, 1] .

 p 2
ln(x) si x ∈ ]1, +∞[

function y=g(x)
if x<=0 then
y=x*exp(x)
elseif x>1 then
y=sqrt(log(x))
else
y=cos(9*%pi*x∧2/2)
end
endfunction
Exécutons cette fonction (appelée g.sci) sans écho dans la console et testons-là.
-->g(-2), g(0.5), g(4.5)
-->exec(’C:\Gorny\Scilab\g.sci’, -1) ans =
- 0.2706706
-->x=[-2,0.5,4.5]; g(x) ans =
ans = - 0.9238795
1. - 0.9238795 - 0.9238795 ans =
1.2264083
Notons ici un problème évoqué dans le chapitre précédent : si on veut évaluer en un vecteur une fonction
contenant des structures conditionnelles et si les instructions ne sont pas vraies pour tous les éléments du
vecteur d’entrée, alors c’est l’instruction du else qui s’appliquera à tous. Nous verrons plusieurs possibilités
pour contourner ce problème grâce aux boucles for (cf. chapitre suivant).

Chapitre 4
Structures répétitives
En programmation, une structure répétitive (ou itérative) permet d’effectuer la répétition d’instructions un certain
nombre de fois. Nous allons en distinguer deux : la boucle for (boucle pour en français) et la boucle while
(boucle tant que en français).
En général, la construction d’une structure répétitive au sein d’un programme se base sur quatre étapes :
1. On identifie les variables d’entrées (qui proviennent du début du programme, ou qui sont les variables
d’entrée d’une fonction ou encore qui sont fournies par l’utilisateur via la commande input).
2. On définit des variables qui vont être modifiées lors de la boucle for ou while. C’est l’étape d’initialisation.
3. On écrit la boucle en tant que telle (for· · · end ou while· · · end). Elle utilise les variables d’entrées et, à
chaque étape de la boucle, les variables définies à l’étape d’initialisation sont mises à jour.
4. On renvoie les variables de sorties (affichées éventuellement dans une phrase via la commande disp si c’est
un programme) qui sont en général des fonctions des quantités calculées pendant la boucle.
I Boucle For
Une boucle for permet de répéter une séquence d’instructions autant de fois qu’il y a de valeurs dans une certaine
liste. La syntaxe est la suivante :
debut_du_programme
for var=liste
instructions
end
fin_du_programme
La variable var va prendre successivement toutes les valeurs de la liste liste et, pour chacune de ses valeurs, le
bloc d’instructions instructions va être exécuter.
Remarques :
• Dans la pratique, liste est généralement un vecteur du type m:p:n avec m et n des réels et p un réel
strictement positif. Dans ce cas la variable var va prendre successivement toutes les valeurs comprises entre
m et n avec un pas de p (si le pas est de 1, alors la commande m:n suffit).
• Le bloc d’instructions instructions peut dépendre ou pas de la variable var.
Exemple : Écrivons une fonction qui demande un entier strictement positif n et un entier p et renvoie la valeur
n
X
de la somme ip .
i=1
function s=SommePuissance(n,p)
s=0;//au départ la somme vaut 0.
for i=1:n
s=s+i∧p//à l'étape i, on incrémente la somme de i∧p.
end
endfunction
Pour comprendre ce que fait la boucle for, on peut s’aider du tableau suivant : si on évalue avec n=10 et
p=2, alors

k valeur de s en début de boucle valeur de s en fin de boucle
1 0 1 = 0 + 12
2 1 5 = 1 + 22 = 0 + 1 2 + 2 2
3 5 14 = 5 + 32 = 0 + 12 + 22 + 32
.. .. ..
. . .
k 0 + 12 · · · + (k − 1)2 0 + 12 + · · · + k 2
.. .. ..
. . .
10 285 385 = 285 + 102 = 0 + 12 + · · · + 102
Testons cette fonction (enregistrée préalablement sous le nom SommePuissance.sci) sans écho dans la
console :
-->SommePuissance(127,2)
-->exec(’C:\Gorny\Scilab\SommePuissance.sci’, -1) ans =
690880.
-->SommePuissance(15,4)
ans = -->n=127; n*(n+1)*(2*n+1)/6
178312. ans =
690880.
II Boucle While
Par opposition à la boucle for, la boucle while s’emploie lorsque l’on ne connaît pas à l’avance le nombre
d’itérations à effectuer. Elle permet de répéter une séquence d’instructions tant qu’une certaine condition, appelée
test d’arrêt, est vraie. Elle s’arrête dès que cette condition est fausse. La syntaxe est la suivante :
debut_du_programme
while condition
instructions
end
fin_du_programme
L’expression condition prend pour valeur un booléen (elle soit vraie, soit fausse). Tant qu’elle est vraie le bloc
d’instruction instructions va être exécuter.
Remarques :
• Les instructions peuvent ne pas être exécutées du tout, si dès le départ condition a la valeur T.
• Il se peut aussi que la boucle ne s’arrête jamais si condition ne prend jamais la valeur F : on parle alors
de boucle infinie. Dans ce cas il faudra utiliser Ctrl + C pour arrêter la programme. Pour éviter que
cela arrive, il est impératif que condition dépendent de plusieurs variables qui sont modifiées lors des
exécutions successives de instructions.
Exemple : La fonction suivante prend en entrée deux entiers naturels a et b et renvoie le quotient et le reste de
la division euclidienne de a par b.
function [q,r]=DivEucl(a,b)
q=0;
c=b;
while c<a
c=c+b;
q=q+1;
end
r=a-q*b;
endfunction

Pour comprendre ce que fait la boucle while, on peut s’aider du tableau suivant : si l’utilisateur fournit
a=60 et b=7, alors
valeurs en début de boucle valeurs en fin de boucle
c<a
q c q c
0 7 vrai 1 14
1 14 vrai 2 21
2 21 vrai 3 28
3 28 vrai 4 35
4 35 vrai 5 42
5 42 vrai 6 49
6 49 vrai 7 58
7 56 vrai 8 63
8 63 faux 8 63
Exécutons cette fonction (appelée DivEucl.sci) sans écho dans la console :

-->exec(’C:\Gorny\Scilab\DivEucl.sci’, -1)
-->[q,r]=DivEucl(60,7)
r =
4.
q =
8.
III Calcul des termes d’une suite

Soit F une fonction définie sur R × N et à valeurs réelles. Soit (un )n∈N une suite telle que, pour tout n ∈ N,
un+1 = F (un , n). On suppose que l’on a implémenté F au préalable en Scilab sous le nom F.
1) Calculer le nième terme d’une suite

Le script suivant calcule le nième terme de la suite de terme initial x et le stocke dans u :
u=x;
for k=1:n
u=F(u,k-1);
end
Exemples :
u200 lorsque u0 = 1, u1 = 2 et
u100 lorsque u0 = 3 et u50 lorsque u0 = π et ∀n ∈ N, un+2 = 3un+1 + 5un .
∀n ∈ N, un+1 = n + e−un . ∀n ∈ N, un+1 = 2un cos(un ).
u=1; v=2;
u=3; u=%pi; for k=2:200
for k=1:100 for k=1:50 w=3*v+5*u;
u=k-1+exp(-u); u=2*u*cos(u); u=v; v=w;
end end //on renvoie v
end
Si la suite converge vers ` ∈ R alors, lorsque n est grand, on obtient une approximation de ` à ε-près, avec
ε > 0 petit (généralement on a déterminé au préalable un entier n afin que |un − `| 6 ε, par exemple à l’aide de
l’inégalité des accroissements finis.).

2) Calculer les n premiers termes d’une suite
Le script suivant calcule les n premiers termes de la suite de terme initial x et les stocke dans la liste L :
u=x; L=[u]
for k=1:n
u=F(u,k-1);
L=[L,u];//A chaque itération, on ajoute
le terme suivant à la liste L
end
3) Sommer les n premiers termes d’une suite

Le script suivant calcule la somme des n premiers termes de la suite de terme initial x et la stocke dans s :
u=x; s=u;
for k=1:n
u=F(u,k-1);
s=s+u;//A chaque itération, on ajoute
le terme suivant à la somme s
end
Exemples :
50
100 X
X (−x)k uk lorsque u2 = 5 et 200
X 1
k! k=2 u2n
k=0 ∀n ∈ N\{0, 1}, un+1 = . k2
n−1 k=1
u=1; s=u;
u=5; s=u; s=0;
for k=1:100
for k=3:50 for k=1:200
u=u*(-x)/k;
u=u∧2/(k-2); s=s+1/k∧2;
s=s+u
s=s+u; end
end
end
Remarques :
• On fait très attention au premier terme et au dernier terme de la somme.
Xn
• Si la suite un −→ S ∈ R alors, lorsque n est grand, on obtient une approximation de S.
n→+∞
k=0
• Si on désire multiplier les termes d’une suite, on remplace juste s=s+u par s=s*u dans les scripts du point
précédent.
4) Calculer le plus petit rang pour lequel la suite vérifie une condition
Il est classique de chercher à calculer le nombre d’itérations nécessaires pour obtenir une approximation de la
limite (la connaissant) d’une suite convergente avec une précision donnée. Si on connait la limite de la suite et
qu’on la stocke dans une variable lim, alors le script suivant calcule n tel que la |un − lim| 6 eps :
u=x; n=0;
while abs(u-lim)>eps
u=F(u,n);
n=n+1;//Tant que la condition est fausse,
on calcule le terme suivant.
end

n
X xk
Exemple : On montrera bientôt en cours que −→ e. Calculons le plus petit entier n pour lequel cette
k! n→+∞
somme approche e à 0, 001 près : k=0
u=1; s=u; n=1;

while abs(s-%e)>0.001
u=u/k;
s=s+u;
n=n+1;
end
Si on connait sait que la suite tend vers +∞ et si A > 0, alors le script suivant calcule n tel que la un > A :
u=x; n=0;
while u<A
u=F(u,n);
n=n+1;//Tant que la condition est fausse,
on calcule le terme suivant.
end
n
X 1
Exemple : Pour tout n ∈ N∗ ,
posons Hn = . La suite (Hn )n∈N∗ est croissante et tend vers +∞. Écrivons
k
k=1
un programme qui demande à l’utilisateur un réel strictement positif A et détermine le plus petit rang n ∈ N∗
pour lequel un > A.
n=input('Entrer un réel A strictement positif : ')
n=1; H=1;//le rang initial est n=1 la somme Hn vaut 1.
while H<A
n=n+1;//Tant que H<A, on passe au rang suivant.
H=H+1/n;//et on met à jour la valeur de H.
end
disp("Les termes de la suites sont supérieurs ou égaux à "+ string(A) + " à partir du rang "
+ string(n) + ".")
Exécutons ce programme (appelé SommeHarmonique.sce) sans écho dans la console :

-->exec(’C:\Gorny\Scilab\SommeHarmonique.sce’, -1)
Entrer un réel A strictement positif : 3
Les termes de la suites sont supérieurs ou égaux à3 àpartir du rang 11.
Cette boucle while va forcément s’arrêter puisque la suite tend vers +∞. Par contre l’exécution du
programme peut prendre beaucoup de temps même pour des valeurs faibles de A (essayez par exemple
A = 20).

Chapitre 5
Représentation graphique en Scilab

Une remarque pour commencer : lorsque l’on demande à Scilab de tracer des figures, elles s’affichent toutes par
défaut sur une seule et même fenêtre graphique. La commande clf() efface le contenu de la fenêtre graphique
active (et en ouvre une si aucune fenêtre graphique n’est déjà ouverte).
I Représentation de points dans le plan

1) Avec la fonction plot
Soient x et y deux vecteurs de même taille n > 2. Pour tout i ∈ J1, nK, notons Ai le point d’abscisse x(i) et
d’ordonnée y(i). La commande plot(x,y) trace les segments [A1 , A2 ], . . . , [An−1 , An ].
Exemple :
-->X=[-4,-3,-2,-1,0,1,2,3,4,5,6,7];
-->Y=[3,2,-1,4,3,4,2,2,0,-1,-2,0];
-->clf(); plot(X,Y)
Personnalisation des tracés : On peut ajouter des options à cette commande afin de modifier la couleur, le
marquage des points et la forme du trait qui relie les points. La commande est plot(x,y,’opt’) , où opt est
composée d’un ou plusieurs des éléments suivants :
• une lettre pour indiquer la couleur parmi
r rouge g vert b bleu c cyan
m magenta y jaune k noir w blanc
• un symbole pour indiquer le marqueur des points parmi (entre autres)
+ plus x croix o cercle · point * astérisque
• un symbole pour indiquer la forme du trait qui relie les points parmi
- ligne continue -- pointillés (du type −−−−−−)
-· pointillés (du type − · − · −·) : pointillés (du type − · · − · · − · ·)
Si on précise le marqueur des points mais pas la forme du trait, alors Scilab trace la figure sans relier les points.
Exemples :
-->clf(); plot(X,Y,’gx:’) -->clf(); plot(X,Y,’r*’)
Ces options sont d’autant plus pratiques pour différencier des tracés superposés.

Superposition de tracés : Puisque, par défaut, Scilab trace toutes les figures sur une seule fenêtre graphique, il
suffit de faire appel à la fonction plot consécutivement pour superposer des tracés. Cependant cette méthode
peut entraîner une déformation des courbes puisque l’échelle est systématique recalculée pour chaque courbe. On
préférera donc la commande plot(x1,y1,’opt1’,. . . ,xn,yn,’optn’) où x1,y1 sont les vecteurs d’abscisses
et d’ordonnées et opt1 les options pour le premier tracé,... et xn,yn sont les vecteurs d’abscisses et d’ordonnées
et optn les options pour le nième tracé (les options étant facultatives).
Si on désire tracer plusieurs courbes ayant le même vecteur d’abscisses x, et des vecteurs d’ordonnées respectives
y1,. . . ,yn (tous nécessairement de même taille que x), alors on peut utiliser la syntaxe 1 plot(x1,[y1;. . . ;yn]) .
Naturellement Scilab proposera différentes couleurs pour les tracés successifs. Avec cette syntaxe, on ne peut pas
préciser d’options différente pour chaque tracé.
Exemples :
-->S=[-4,7]; -->Z=[-1,1.5,0,2,5,0,0.7,-1.5,4,2,3,4.2];
--> clf(); plot(X,Y,’r’,S,S,’b--’) -->clf(); plot(X,[Y;Z])
2) Avec la fonction plot2d

Soient x et y deux vecteurs de même taille n > 2. Pour tout i ∈ J1, nK, notons Ai le point d’abscisse x(i) et
d’ordonnée y(i). La commande plot2d(x,y) trace les segments [A1 , A2 ], . . . , [An−1 , An ].
A première vue, la fonction plot2d semble identique à la fonction plot. Elles fonctionnent essentiellement de la
même manière mais avec des différences notables. Notamment plot2d est plus élaborée et on peut davantage la
personnaliser 2 (on peut lui ajouter plus d’options).
Personnalisation des tracés : Pour ajouter des options, la syntaxe est plot2d(x,y,options) . Les principales
options sont :
• style=k où k est un entier entre −14 et 33 qui détermine le style de tracé. Plus précisément :
— Si k ∈ J−14, 0K, les points ne sont pas reliés et le marqueur des points est modifié. Citons par exemple :
0 point -1 plus -2 croix -9 cercle -10astérique
— Si k ∈ J1, 33K, c’est la couleur qui est modifié. Citons par exemple :
1 noir 2 bleu 3 vert clair 4 cyan
5 rouge 6 magenta 13 vert foncé 7 jaune
La commande getcolor() affiche un tableau avec la liste des couleurs.

Si on superpose n tracés avec des indices de styles respectifs k1,. . . ,kn, alors on utilise la commande
style=[k1,. . . ,kn].
• rect=[xmin,ymin,xmax,ymax] décrit la zone du graphique visible (il s’agit d’un rectangle dont les coor-
données de l’angle inférieur gauche est (xmin,ymin) et celles de l’angle supérieur droit est (xmax,ymax)).
• Si on superpose n tracés, la commande leg="legende_1@. . . @legende_n" ajoute des légendes aux
différents tracés. Nous y reviendrons ultérieurement dans ce chapitre.
1. En Scilab, [y1 ;. . . ;yn] est une matrice dont les lignes sont y1,. . . ,yn. Nous y reviendrons.
2. Mais par exemple on ne peut pas faire un tracé en pointillé de façon simple...

Superposition des tracés : Pour tracer plusieurs courbes ayant le même vecteur d’abscisses x, et des vecteurs
d’ordonnées respectifs y1,. . . ,yn (tous nécessairement de même taille que x), alors on utilise la syntaxe
plot(x’,[y1’,. . . ,yn’],options)
La fonction plot2d fonctionne avec des vecteurs colonnes et non des vecteurs lignes. Ainsi, si on dispose de
vecteurs lignes (ce qui est le cas en général), il ne faut pas oublier de mettre les ’ qui permettent de les transposer
(c’est-à-dire les transformer en vecteurs colonnes).
Exemple :
-->clf();
-->plot2d(X’,[Y’,Z’],style=[5,-10],
rect=[-5.5,-2.5,7.5,6],
leg=’Courbe 1@Courbe 2’)
II Tracé de courbes représentatives de fonctions

Tracer la courbe représentative d’une fonction sur un intervalle, revient à tracer une infinité de points. Or il n’est
évidemment pas possible pour un ordinateur de réaliser une infinité d’instructions. L’approche de Scilab pour
tracer une courbe est de représenter un nombre fini de points et de les relier par une ligne continue. La puissance
de calcul des ordinateurs permet de considérer un très grand nombre de points et d’obtenir ainsi une très bonne
approximation de la courbe par une ligne brisée dont les abscisses sont très proches afin de donner l’illusion de
courbe.
Tracé avec plot ou plot2d : Supposons que l’on ait codé une fonction f en Scilab dans un script nommé
f.sci. Soient a et b des réels tels que a < b. Pour tracer la courbe représentative de f sur l’intervalle [a, b], on
peut utiliser l’une des commandes suivantes :
x=linspace(a,b,n) x=linspace(a,b,n)
plot(x,f(x),’opt’) plot(x,f,’opt’)
x=linspace(a,b,n) x=linspace(a,b,n)
plot2d(x,f(x),options) fplot2d(x,f,options)
selon que l’on désire utiliser plot ou plot2d. L’entier n détermine le nombre de points utilisés pour effectuer
le tracé. Sachant que deux points sont reliés par une ligne continue, il faut prendre n grand pour que la courbe
apparaisse suffisamment lisse.
Remarques :
• On peut remplacer linspace(a,b,n) par a:1/n:b. Ces deux commandes ne fournissent pas le même
vecteur mais, si n est grand, la différence n’est pas visible lors du tracé de la courbe par Scilab.
• Les commandes à retenir principalement sont plot(x,f(x)) et plot2d(x,f(x)). Elles permettent de faire
plus facilement le lien avec la méthode de tracé (les courbes sont approchés par des courbes de fonctions
affines par morceaux). Ces commandes sont usuelles et elles ont des analogues dans de nombreux autres
langages de programmation.
• Les commandes plot(x,f) et plot2d(x,f) sont moins universelles mais elles sont très pratiques. En
effet, si on les utilise, alors on est pas obligé de rendre compatibles les fonctions Scilab avec les opérations
vectorielles (pas besoin de .*, ./, .∧, ni de boucle for si la fonction présente des structures conditionnelles).

sin(x)
Exemple 1 : Représentons la fonction f : x 7−→ , implémentée en Scilab au chapitre 2 (et codée dans le
1 + x2
script f.sci).
-->x=linspace(-15,15,10); -->x=linspace(-15,15,30); -->x=linspace(-15,15,1000);
-->y=f(x); -->y=f(x); -->y=f(x);
-->clf(); plot(x,y,’b’) -->clf(); plot(x,y,’g’) -->clf(); plot(x,y,’r’)

xexp(x) si x ∈ ]−∞, 0]
9πx2


Exemple 2 : Représentons la fonction g : x ∈ R 7−→ cos si x ∈ ]0, 1] , implémentée en Scilab

 p 2
ln(x) si x ∈ ]1, +∞[

au chapitre 2 (et codée dans le script g.sci).
Attention, puisque cette fonction contient une structure conditionnelle,

la commande plot(x,g(x)) ne fonctionnera pas correctement. Il faudra
utiliser plot(x,g).
-->exec(’g.sci’, -1)
-->x=linspace(-3,4,1000);
-->clf(); plot(x,g)
On peut modifier le tracé pour prendre en compte la discontinuité en 0.
-->x1=linspace(-3,0,1000);
-->x2=linspace(0.01,4,1000);
-->clf(); plot(x1,g,’r’,x2,g,’r’,[0],[0],’r.’,[0],[1],’ro’)
Superposition de courbes : Si on désire superposer les courbes représentatives sur [a, b] de plusieurs fonctions
codées en Scilab par les scripts f1.sci,. . . , fk.sci, alors généralement on se donne un vecteur d’abscisses
commun x=linspace(a,b,n) puis on utilise l’une des commandes suivantes :
• plot(x,[f1(x);. . . ;fk(x)])
• plot(x,f1(x),’opt1’,. . . ,x,fk(x),’optk’)
• plot(x,f1,’opt1’,. . . ,x,fk,’optk’)
• plot2d(x’,[f1(x)’,. . . ,fk(x)’],options)

III Diagrammes à barres et histogrammes
1) Diagrammes à barres
Un diagramme à barres est un graphique permettant de représenter la répartition de données avec des barres
verticales. Plus précisément :
• chaque barre a la même largeur et son abscisse représente une catégorie,
• la hauteur d’une barre est égale à l’effectif (ou la fréquence) de la catégorie qu’elle représente.
Si x est un vecteur contenant des abscisses des catégories et si y est un vecteur contenant les effectifs respectifs
de ces catégorie, alors la syntaxe bar(x,y) permet de construire le diagramme à barre correspondant. Comme
pour plot, on peut lui ajouter des options.
Si on dispose de vecteurs y1,. . . ,yk représentant des données différentes mais relatives aux mêmes catégories
(dont les abscisses respectives sont contenues dans un vecteur x), alors on peut superposer les k diagrammes à
barres en utilisant la syntaxe bar(x,[y1’,y2’,. . . ,yk’]) . L’ajout de l’option ’stacked’ permettant d’empiler
les diagrammes.
Exemple : Le patron d’une entreprise crée en 2009 a compilé son nombre de ventes par année dans le tableau
suivant :
Année 2009 2010 2011 2012 2013 2014 2015 2016
Nb de ventes 3923 3805 4578 5814 8547 8260 7033 9665
Il trace un diagramme à barre à partir de ses données (les catégories étant les années) :
-->vente2=[3923,3805,4578,5814,
8547,8260,7033,9665];
-->clf(); bar(an,vente,’y’)
Il dispose également des effectifs moyens des entreprises de la même branche et souhaite les comparer graphiquement
avec ses propres effectifs.
-->-->vente2=[7746,7892,8003,7502,
7361,7963,6995,8561]; -->clf(); bar(an,[vente’,vente2’],’stacked’)
-->clf(); bar(an,[vente’,vente2’])
2) Histogrammes
Un histogramme est un graphique permettant de représenter la répartition de données avec des colonnes verticales.
Plus précisément, chaque colonne représente le nombre (ou la fréquence) de termes appartenant à une classe ou
une catégorie. Si les données sont des réels, alors chaque classe correspond à un intervalle de R et on représente
alors cette classe par un rectangle vertical dont l’aire est proportionnel à son effectif (et donc à sa fréquence).

Si x est un vecteur contenant des données réelles et si n est un entier naturel strictement positif, alors la syntaxe
histplot(n,x) permet de construire l’histogramme des données du vecteur x avec n classes de même amplitude.
Comme pour plot2d, on peut lui ajouter des options.
Exemples :
-->x=rand(1:50);
-->clf(); histplot(10,x,style=5)
-->clf(); histplot(20,x)
Par défaut, Scilab construit un histogramme normalisé (c’est-à-dire de telle sorte que la somme des aires des
rectangles soit égale à 1). Nous verrons dans les TP de probabilités que c’est très pratique. Néanmoins avec un
tel histogramme, on ne peut pas lire graphiquement l’effectif par classe. Pour construire un histogramme non
renormalisée on rajoutera l’option normalization=%f .
On peut également paramétrer l’amplitude de chaque classe : si a1,a2,a3,. . . ,ak sont des réels distincts rangés
dans un ordre croissant, alors histplot([a1,a2,a3,. . . ,ak],x) construit l’histogramme des données du
vecteur x avec k-1 classes d’amplitudes respectives a2-a1, a3-a2, etc.
Exemples :
-->clf();
-->histplot(10,x,normalization=%f)
-->c=[0.25,0.4,0.5,0.75,1]
-->clf();
-->histplot(c,x,normalization=%f)

Chapitre 6
Matrices avec Scilab

Scilab est un outil conçu pour effectuer des calculs numériques sur des matrices : ce sont les éléments de base du
langage.
Depuis le début de l’année, nous avons déjà manipulé des cas particuliers de matrices : les vecteurs lignes et plus
particulièrement les nombres que Scilab considère comme des matrices de taille 1 × 1.
I Création et modification d’une matrice en Scilab

1) Création d’une matrices en Scilab
a) ... par extension
Pour construire une matrice par extension en Scilab, on donne la liste des éléments de la matrice entre crochets et
en les séparant par des virgules, chaque ligne étant séparée par des points virgules. La commande [] construit
une matrice vide.
On retrouve le cas particulier des matrices lignes qui sont les vecteurs que nous manipulons depuis le début de
l’année. Si on donne une liste de nombres entre crochets et en les séparant par des points virgules, alors on obtient
une matrice colonne.
Exemples :
-->v=[2;3;-1;4;0] -->typeof(A)
-->A=[1,5,3;-2,0,-4;3,-1,6;5,-1,-1]
v = ans =
A =
2. constant
1. 5. 3.
3.
- 2. 0. - 4.
- 1. -->1==[1]
3. - 1. 6.
4. ans =
5. - 1. - 1.
0. T
La dernière commande illustre le fait que Scilab considère un nombre comme la matrice de taille 1 × 1 dont le
seul coefficient est ce nombre.
b) ... par blocs

On peut également construire une matrice de taille n × p par blocs :
• en donnant la liste des n vecteurs constituant ses lignes entre crochets et en les séparant par des points
virgules.
Exemples :
-->L1=[3,4,-1,0]; L2=[1,-1,-2,5]; L3=[2,0,0,-3];
-->A=[L1;L2;L3]
A =
3. 4. - 1. 0.
1. - 1. - 2. 5.
2. 0. 0. - 3.
• en donnant la liste des p vecteurs constituant ses colonnes entre crochets et en les séparant par des virgules.
Exemples :
-->C1=[1;3]; C2=[-1;0]; C3=[0;6]; C4=[-2;4]; C5=[3;-5];
-->A=[C1,C2,C3,C4,C5]
A =
1. - 1. 0. - 2. 3.
3. 0. 6. 4. - 5.

• Les blocs peuvent être de tailles différentes. Mais dans ce cas, il faut bien faire attention à ce que chaque
ligne (resp. chaque colonne) ait le même nombre d’éléments.
Exemples :
-->A=[[-3,5],1;[1,2;0,-4],[7;-6]]
A =
- 3. 5. 1.
1. 2. 7.
0. - 4. - 6.
c) ... avec des fonctions et opérateurs prédéfinis

On a déjà vu quelques fonctions et opérateurs prédéfinis permettant de créer des vecteurs lignes : si x et y sont
des réels, si h est un réel strictement positif et si n un entier strictement positif, alors
x:y construit un vecteur constitué des nombres de x à y par pas de 1.
x:h:y construit un vecteur constitué des nombres de x à y par pas de h.
linspace(x,y,n) construit un vecteur constitué de n nombres entre x et y, régulièrement espacés.
Si n et p sont deux entiers strictement positif et si v est un vecteur, alors

zeros(n,p) construit une matrice de taille n×p dont tous les coefficients sont nuls.
ones(n,p) construit une matrice de taille n×p dont tous les coefficients sont égaux à 1.
diag(v) construit une matrice diagonale dont les coefficients diagonaux sont les éléments du vecteur v.
eye(n,p) construit une matrice de taille n×p dont tous les coefficients sont nuls sauf sur la diagonale où
ils sont à 1.
rand(n,p) construit une matrice de taille n×p dont tous les coefficients sont des nombres tirés aléatoirement
dans ]0, 1[.
Exemples :
-->zeros(3,2)
-->ones(2,5)
ans =
ans =
0. 0.
1. 1. 1. 1. 1.
0. 0. -->rand(4,3)
1. 1. 1. 1. 1.
0. 0. ans =
0.2113249 0.6653811 0.8782165
-->eye(3,4)
-->u=[1,-2,3]; diag(u) 0.7560439 0.6283918 0.0683740
ans =
ans = 0.0002211 0.8497452 0.5608486
1. 0. 0. 0.
1. 0. 0. 0.3303271 0.6857310 0.6623569
0. 1. 0. 0.
0. - 2. 0.
0. 0. 1. 0.
0. 0. 3.
2) Accès aux éléments d’une matrices

Si A est une matrice et si i et j sont des entiers strictement positifs, alors
size(A) renvoie la taille de la matrice (sous la forme d’un vecteur ligne).
length(A) renvoie le nombre de coefficients de la matrice.
A(i,j) renvoie le coefficient d’indice (i, j) (ou un message d’erreur s’il n’y a pas de tel indice).
A(i,:) renvoie la iième ligne de la matrice.
A(:,j) renvoie la jième colonne de la matrice.
Exemples :
-->A(3,:)
-->A=[1,5,3,-2;0,-4,3,-1;6,2,-1,-1];
-->A(2,3) ans =
-->size(A)
ans = 6. 2. - 1. - 1.
ans =
3.
3. 4.
-->A(:,1)
-->A(4,2) ans =
-->length(A)
!--error 21 1.
ans =
Index invalide. 0.
12.
6.

Plus généralement, si on désire extraire les coefficients de A qui se trouvent sur les lignes i1 , . . . , ik et les colonnes
j1 , . . . , j` , alors on utilise la commande A([i1 , . . . , ik ],[j1 , . . . , j` ]) . Notons que l’ordre des indices a son
importance.
-->A([3,2],[1,2,3])
-->A([1,3],2)
ans =
ans =
6. 2. - 1.
5.
0. - 4. 3.
2.
-->A([1,1],[3,4,1])
-->A(1,2:4)
ans =
ans =
3. - 2. 1.
5. 3. - 2.
3. - 2. 1.
3) Modification d’une matrice

Soient A une matrice de taille n × p, L un vecteur ligne de longueur p et C un vecteur colonne de longueur n.
Soient i et j sont des entiers strictement positifs. Alors :
A(i,j)=x remplace le coefficient d’indice (i,j) de A par le réel x.
A=[A,C] ajoute la colonne C à la matrice A en dernière position.
A=[C,A] ajoute la colonne C à la matrice A en première position.
A=[A;L] ajoute la ligne L à la matrice A en dernière position.
A=[L;A] ajoute la ligne L à la matrice A en première position.
A(i,:)=[] supprime la iième ligne de la matrice A.
A(:,j)=[] supprime la jième colonne de la matrice A.
Exemples :
-->A=[1,2,3,4;5,6,7,8]; A(2,3)=11 -->A=[A,[-1;0]]
A = A =
1. 2. 3. 4. 1. 2. 3. 4. - 1.
5. 6. 11. 8. 5. 6. 11. 8. 0.
-->A=[[-4,-3,-2,-1,0];A]
-->A(2,:)=[]; A(:,4)=[]
A =
A =
- 4. - 3. - 2. - 1. 0.
- 4. - 3. - 2. 0.
1. 2. 3. 4. - 1.
5. 6. 11. 0.
5. 6. 11. 8. 0.
Plus généralement, si B est une matrice de taille k × `, alors la commande

A([i1 , . . . , ik ],[j1 , . . . , j` ])=B
remplace la sous-matrice formée des lignes i1 , . . . , ik et les colonnes j1 , . . . , j` par la matrice B.
Lorsqu’on désire modifier plusieurs coefficients d’une matrice avec une seule commande, il faut faire très
attention à la taille des matrices (qui doivent être de tailles égales de part et d’autre du symbole =).
Exemple :
-->B=ones(3,5); B([2,3],[2,4])=rand(2,2)
B =
1. 1. 1. 1. 1.
1. 0.2693125 1. 0.4051954 1.
1. 0.6325745 1. 0.9184708 1
II Opérations sur les matrices

1) Opérations matricielles
Scilab permet de réaliser des opérations matricielles usuelles. Si A et B sont deux matrices, si x est un réel et si k
est un entier naturel, alors :

A’ calcule la transposée de A.
x*B calcule la multiplication de la matrice A par le scalaire x.
A+B calcule la somme (si elle a un sens) des matrices A et B.
A*B calcule le produit matriciel (si il a un sens) des matrices A et B.
A∧k calcule la puissance kième de la matrice A (si c’est une matrice carrée).
Exemples :
-->B+C
ans =
-->A=[1,2,-3,0;-1,0,2,4;0,1,3,-5];
2. - 1. 8.
-->size(A);
12. 7. 1.
ans =
3. 4.
-->X=[1,0;-2,5;0,-2;4,3]; A*X
ans =
-->A’, size(A’)
- 3. 16.
ans =
15. 8.
1. - 1. 0.
- 22. - 16.
2. 0. 1.
- 3. 2. 3.
-->X*A
0. 4. - 5.
!--error 10
ans =
Multiplication incohérente.
4. 3.
-->D=[1,2;-1,3]; D∧3
-->B=[1,0,3;2,4,-6];
ans =
-->C=[1,-1,5;10,3,7];
- 9. 22.
- 11. 13.
2) Opérations terme à terme

On peut également effectuer des opérations termes à termes sur des matrices A et B de même taille :
A.*B effectue le produit terme à terme des matrices A et B.
A./B effectue la division terme à terme de la matrice A par la matrice B.
A.∧k élève chaque coefficient de la matrice A à la puissance k.
A.∧B effectue la puissance terme à terme de la matrice A par la matrice B.
Les fonctions usuelles (log, exp, sqrt, abs, floor, cos, sin, tan) s’appliquent également aux vecteurs
coordonnée par coordonnée.
Exemples :
-->E=[0,1;2,-4]; E.*D -->E./D -->cos(D)
ans = ans = ans =
0. 6. 0. 1.5 0.5403023 - 0.4161468
- 2. - 12. - 2. - 1.3333333 0.5403023 - 0.9899925
-->E*D -->D.∧3 -->sqrt(abs(E))

ans = ans = ans =
- 3. 9. 1. 8. 0. 1.7320508
6. - 8. - 1. 27. 1.4142136 2.
3) Opérateurs de comparaison sur les matrices

Les opérateurs de comparaison et les opérateurs logiques s’appliquent aussi aux matrices de même taille. Les
opérations se font terme à terme et le résultat est une matrice de même taille contenant des variables booléennes.
Rappelons les opérateurs de comparaison :
== test d’égalité > supérieur strict < inférieur strict
<> différent >= supérieur ou égal <= inférieur ou égal
et les opérateurs permettant de réaliser des tests logiques :

& opérateur et | opérateur ou ∼ opérateur non

Exemples :
-->∼(A<B)
-->A=[2,0,-4;1,-2,3];
ans =
T F F
-->B=[-3,3,1;4,5,-2];
F F T
Notons que l’on peut aussi comparer une matrice avec un nombre réel (chaque coefficient de la matrice est
comparé avec le réel et le résultat est une matrice de même taille contenant des variables booléennes).
Si M est une matrice composée de variables booléennes, alors la commande find(M) renvoie un vecteur contenant
les positions des coefficients de M ayant la valeur T.
Exemples :
-->A>0
-->find(A>0) -->length(find(A>0))
ans =
ans = ans =
T F F
1. 2. 6. 3.
T F T
Ainsi la commande length(find(M)) renvoie le nombre de coefficients de M ayant la valeur T.
4) Fonctions spécifiques sur les matrices

Terminons par quelques fonctions prédéfinies très utiles sur les matrices :
min(A) renvoie la valeur minimale des coefficients de A.
max(A) renvoie la valeur maximale des coefficients de A.
sum(A) calcule la somme de tous les coefficients de A.
prod(A) calcule le produit de tous les coefficients de A.
Dans les fonctions précédentes, on peut ajouter l’option ’c’ pour que la fonction opère sur chaque ligne (et
retourne un vecteur colonne), et l’option ’r’ pour que la fonction opère sur chaque colonne (et retourne un
vecteur ligne).
Exemples :
-->A=[1,2,-1,6;7,-3,2,-4]; -->sum(A)
-->sum(A,’r’)
-->min(A) ans =
ans =
ans = 10.
8. - 1. 1. 2.
- 4.
-->sum(A,’c’)
-->prod(A)
-->max(A) ans =
ans =
ans = 8.
- 2016.
7. 2.
III Inversion de matrices et résolution de AX = B

1) Calcul de l’inverse d’une matrice
Si A est une matrice carrée inversible, alors la commande inv(A) calcule l’inverse de A. Si A n’est pas une
matrice inversible, alors cette commande renvoie un message d’erreur.
Exemples :
-->A=[1,2,0,3;-3,-5,2,-3;2,0,1,2;-1,-7,3,-5];
-->B=[1,-1,2;3,-4,0;4,-5,2];
-->inv(A)
ans =
-->inv(B)
- 0.75 - 0.125 0.625 - 0.125
!--error 19
3.5 - 1.25 - 2.75 1.75
Le problème est singulier.
5. - 1.5 - 3.5 2.5
- 1.75 0.875 1.625 - 1.125

2) Rang et base du noyau
Si A est une matrice, alors
rank(A) renvoie le rang de la matrice A.
kernel(A) renvoie une base du noyau A.
Exemples :
-->C=[1,5,4,0;-3,2,-1,1;-2,7,3,1];
-->rank(A), rank(B)
ans =
-->rank(C)
3.
ans =
ans =
2.
2.
-->kernel(C)
-->kernel(B)
ans =
ans =
0.0120886 0.5813933
0.3764123
- 0.2680226 0.3877964
0.0684386
0.3320062 - 0.6300939
0.9239210
0.9043172 0.338493
IV Résolution de AX = B
Rappelons qu’un système de n équations à p inconnues est équivalent à résoudre AX = B avec A la matrice
associée au système et B un vecteur colonne de taille n.
Si A (resp. B) est la matrice A (resp. le vecteur colonne B) écrite en langage Scilab, alors la commande
[X0,noyau]=linsolve(A,-B)
affecte à la variable X0 une solution particulière du système AX = B (si il en existe) et à la variable noyau une
base du noyau de la matrice A. Les solutions sont les vecteurs colonnes qui s’écrivent comme la somme de X0 et
d’une combinaison linéaire des colonnes du noyau.
Si A est inversible, alors il existe une unique solution qui est donnée par le vecteur A−1 B. Ainsi la commande
inv(A)*B renvoie l’unique solution du système.
Exemples :
-->A=[1,2,0,3;-3,-5,2,-3; -->A=[1,5,4,0;-3,2,-1,1;-2,7,3,1];
2,0,1,2;-1,-7,3,-5];
-->[X0,noyau]=linsolve(A,-[-2;1;3])
-->B=[2;-7;6;1] AVERTISSEMENT : Contraintes linéaires
en conflit.
-->[X0,noyau]=linsolve(A,-B) noyau =
noyau = []
[] X0 =
X0 = []
3.
1. -->[X0,noyau]=linsolve(A,-[5;1;6])
2. noyau =
- 1. 0.5713227 - 0.1084187
0.3239782 - 0.3424330
-->inv(A)*B - 0.5478034 0.4551459
ans = 0.5182084 0.8147559
X0 =
3. - 0.0144928
1. 0.6666667
2. 0.4202899
- 1. 0.0434783

Chapitre 7
Probabilités avec Scilab
I Générateur de nombres (pseudo) aléatoires : la fonction rand

Anyone who considers arithmetical methods of producing random digits is, of course, in a state of sin.
John von Neumann 2
1) Introduction
Simuler une variable aléatoire réelle d’une loi donnée à l’aide d’un ordinateur consiste à construire un nombre réel
que l’on peut assimiler à une réalisation X(ω) d’une variable aléatoire X ayant cette loi.
Ce procédé repose en général sur deux étapes :
• Simuler des variables aléatoires indépendantes 3 de loi uniforme sur ]0, 1[.
• Réaliser des opérations sur les simulations afin d’obtenir la réalisation d’une variable aléatoire de loi voulue
(ce sera l’objet du paragraphe suivant).
La première étape pose des problèmes à la fois conceptuels et pratiques... notamment comment demander à un
ordinateur de faire un choix aléatoire, alors que celui-ci est programmé pour n’effectuer qu’une suite d’instructions
déterministes ? Aucune solution totalement satisfaisante n’a été proposée à ce jour. La plupart des générateurs
sont fondés sur des calculs de congruences sur des grands nombres de façon déterministe (mais que l’on peut
initialiser avec l’horloge de l’ordinateur pour ajouter une dose de hasard). On parle alors de générateurs de nombres
pseudo-aléatoires : les nombres générés possèdent les propriétés apparentes d’une suite de variables aléatoires
indépendantes et de loi uniforme sur [0, 1] :
• La suite de nombres se comporte de façon chaotique, de sorte que les éléments successifs de cette suite de
nombres semblent imprévisibles. Plus précisément, pour tout k ∈ N∗ , la connaissance des k − 1 premiers
termes de la suite ne semble pas nous donner d’information sur le k ième terme.
• La moyenne des premiers nombres de la suite semble se concentrer asymptotiquement (quand le nombre de
termes moyennés tend vers +∞) vers une quantité fixe.
Il existe plusieurs générateurs basés sur des phénomènes physiques (et certains sont brevetés et disponibles dans
le commerce). Ils reposent par exemple sur des capteurs de bruit thermique dans les résistances de circuits
électroniques, ou sur d’autres mécanismes basés sur la physique quantique, etc. Ces générateurs contiennent du
vrai hasard mais ils sont encombrants, pas toujours fiables, pas facilement reproductibles et ne sont pas accessibles
à une analyse mathématique rigoureuse.
2) La fonction rand
Scilab possède une fonction rand qui renvoie un nombre compris entre 0 et 1 et que l’on peut assimiler à la
réalisation d’une variable aléatoire de loi uniforme sur ]0, 1[.
rand() simule une variable aléatoire de loi uniforme sur ]0, 1[.
rand(1,n) renvoie un vecteur de taille n contenant des simulations de v.a de loi uniforme sur ]0, 1[.
rand(m,n) renvoie une matrice de taille m×n contenant des simulations de v.a de loi uniforme sur ]0, 1[.
Exemples :
-->rand()
-->rand(3,4)
ans =
ans =
0.2113249
0.0002211 0.6283918 0.8782165 0.6623569
-->rand()
0.3303271 0.8497452 0.0683740 0.7263507
ans =
0.6653811 0.6857310 0.5608486 0.1985144
0.7560439
2. John von Neumann (1903-1957) est un mathématicien et physicien américano-hongrois.

3. La notion de variables aléatoires indépendantes est au programme de deuxième année d’ECS.

Il est à noter que le générateur de Scilab produit toujours la même séquence 1 de nombre (ce n’est pas étonnant :
il est déterministe !). En effet, si on ferme Scilab et qu’on l’ouvre à nouveau, la séquence de nombres donnée par
rand() commencera encore par 0.2113249, puis 0.7560439, etc. Pour éviter cela, on peut modifier la graine du
générateur (c’est-à-dire la valeur initiale utilisée, qui vaut 0 par défaut). On peut réinitialiser aléatoirement en
utilisant par exemple la date en secondes via les commandes n=getdate(’s’); rand(’seed’,n); . On peut
revenir à la graine par défaut en utilisant la commande rand(’seed’,0);.
Exemples :
-->n=getdate(’s’); rand(’seed’,n); -->rand(’seed’,0);
-->rand() -->rand()
ans = ans =
0.8475400 0.2113249
II Simulation de variables aléatoires

1) ... à partir de la fonction rand
a) Variable aléatoire de loi uniforme sur Ja, bK
Soit U une variable aléatoire de loi uniforme sur ]0, 1[. Soit (a, b) ∈ Z2 avec a < b. Nous verrons dans le chapitre
Variables aléatoires à densité que X = b(b − a + 1)U c + a suit une loi U(Ja, bK).
Ainsi la commande X=a+floor((b-a+1)*rand()) simule la réalisation d’une variable aléatoire de loi U(Ja, bK).
Plus généralement X=a+floor((b-a+1)*rand(m,n)) renvoie une matrice de taille m × n contenant des
réalisations indépendantes de variables aléatoires de loi U(Ja, bK).
Exemples :
-->X=-3+floor(4*rand(2,7))
-->X=2+floor(5*rand())
X =
X =
- 2. - 2. - 1. - 3. 0. - 1. - 2.
4.
- 2. - 1. - 3. - 1. - 3. - 3. 0.
b) Variable aléatoire de loi de Bernoulli

Soit U est une variable aléatoire de loi uniforme sur ]0, 1[. Soient p ∈ ]0, 1[. La variable aléatoire X, définie par

1 si U (ω) < p
∀ω ∈ Ω, X(ω) = ,
0 si U (ω) > p.
suit une loi B(p) (cf. chapitre Variables aléatoires à densité).
Ainsi la commande X=(rand()<p) renvoie le booléen T avec probabilité p et le booléen F avec probabilité 1 − p.
On peut donc l’assimiler à la réalisation d’une variable aléatoire de loi B(p). Plus généralement X=(rand(m,n)<p)
renvoie une matrice de taille m × n contenant des réalisations de variables aléatoires de loi B(p).
Exemples :
-->rand()<0.2, rand()<0.2, -->rand()<0.7, rand()<0.7, -->X=(rand(3,6)<0.3)
ans = ans = X =
T T T F F F T F
ans = ans = F F T F F F
F T T F F T F T
1. La documentation de Scilab nous apprend que le générateur de nombres aléatoires utilisé par rand est de type URAND (Universal
Random Number Generator). Il utilise par défaut la suite de nombres (un )n∈N définie par
xn
∀n ∈ N, xn+1 ≡ (axn + c) [m] , un = ,
m
avec x0 = 0, m = 231 , a = 843314861, c = 453816693. On dit qu’il s’agit d’un générateur linéaire à congruence. On remarque que
c
x1 = ≈ 0.2113249.
m

Mais si on désire véritablement renvoyer des 0 et des 1, on peut procéder ainsi : X=sum(rand()<p) . En effet
la commande sum convertit en quelque sorte les T en 1 et les F en 0. Mais c’est un peu astucieux donc il est
préférable de retenir :
if rand()<p then
X=1;
else
X=0;
end
X
c) Variable aléatoire de loi binomiale

Rappelons qu’une variable aléatoire de loi binomiale de paramètres n ∈ N∗ et p ∈ ]0, 1[ compte le nombre de
succès (de 1) lors de n répétitions indépendantes d’une épreuve de Bernoulli de paramètre p. On peut donc voir 1
une variable aléatoire de loi B(n, p) comme la somme de n variables aléatoires indépendantes de loi B(p).
Nous en déduisons que la commande X=sum((rand(1,n)<p)) simule la réalisation d’une variable aléatoire de
loi B(n, p).
Exemples :
-->Z=(rand(1,15)<0.6) -->sum(rand(1,1000)<0.9)
Z = ans =
T T T F F T T F T F T T T F F 894.
-->X=sum(Z) -->sum(rand(1,1000)<0.2)
X = ans =
9. 231.
d) Variable aléatoire de loi géométrique

Rappelons qu’une variable aléatoire de loi géométrique de paramètre p ∈ ]0, 1[ compte le nombre de répétitions
d’une épreuve de Bernoulli de paramètre p nécessaires pour obtenir un succès.
Nous en déduisons les commandes suivantes
X=1; X=0;
while rand()>=p while rand()>=p
X=X+1; X=X+1;
end end
X X=X+1
simulent toutes les deux la réalisation d’une variable aléatoire de loi G(p). En effet cet algorithme consiste à
simuler des variables aléatoires de loi B(p) jusqu’à ce qu’on obtienne un succès (un 1) et à compter le nombre
d’essais.
Exemples :
-->X=1; while (rand()>=0.5); X=X+1; end; X -->Y=0; while (rand()>=0.1); Y=Y+1; end; Y=Y+1
X = Y =
3. 8.
e) Variable aléatoire de loi uniforme

Soit (a, b) ∈ R2 avec a < b. Rappelons que, si U suit une loi uniforme sur ]0, 1[, alors X = (b − a)U + a suit une
suit une loi uniforme sur ]a, b[.
Nous en déduisons que la commande X=a+(b-a)*rand() simule la réalisation d’une variable aléatoire de loi
U(]a, b[).
1. Cela sera montré rigoureusement en deuxième année.

Plus généralement X=a+(b-a)*rand(m,n) renvoie une matrice de taille m × n contenant des réalisations
indépendantes de variables aléatoires de loi U(]a, b[).
Exemples :
-->a=-100; b=2; a+(b-a)*rand() -->a=-5; b=6; X=a+(b-a)*rand(7,3)
ans = X =
- 68.731307 1.0560969 - 0.3350905 0.4304299
-->a=-4; b=10; a+(b-a)*rand() - 2.1940774 - 0.0364293 2.3119927
ans = 3.9005907 - 1.9463221 1.2518854
- 2.4738892 3.3862387 5.080067 1.8904607
-->a=3; b=8; a+(b-a)*rand() 5.0058329 4.3093667 3.7820935
ans = 1.3356004 - 1.3903816 - 2.188643
6.9479155 2.3416096 1.6902812 0.2503213
f) Variable aléatoire de loi exponentielle

Soit U une variable aléatoire de loi uniforme sur ]0, 1[. Soit a ∈ R∗+ . On a 1 − U > 0 presque sûrement et
1
X = − ln(1 − U ) suit une variable aléatoire de loi E(a) (cf. chapitre Variables aléatoires à densité).
a
Ainsi a commande X=-log(1-rand())/a simule ainsi la réalisation d’une variable aléatoire de loi G(a).
Exemples :
-->a=8; X=-log(1-rand())/a -->-log(1-rand(3,3))/0.25
X = ans =
0.2989328
-->-log(1-rand()) 1.6379744 10.693333 11.133384
ans = 2.2612048 5.7148055 4.8033538
0.2254493 1.8506441 5.1256179 3.9588708
g) Variable aléatoire de loi de Poisson

Soit a > 0. Pour tout n ∈ N∗ , donnons nous Xn une variable aléatoire de loi B(a, a/n). La suite (Xn )n∈N∗
converge en loi vers une variable aléatoire X qui suit une loi de Poisson de paramètre a (cf. chapitre Convergences
et approximations de variables aléatoires). Par conséquent, une façon de simuler une variable aléatoire de loi
(approximative) P(a), il suffit de simuler une variable aléatoire de loi B(a, a/n) avec n grand.
Ainsi la commande n=1000; X=sum(rand(1,n)<a/n) simule la réalisation d’une variable aléatoire dont la loi
suit approximativement une loi P(a).
Nous illustrerons cela graphiquement en TP.
2) ... avec la fonction grand
grand(1,1,’***’,###) simule une variable aléatoire de loi *** avec les paramètres ###
grand(1,n,’***’,###) renvoie un vecteur de taille n contenant des simulations de
variables aléatoires de loi *** avec les paramètres ###
grand(m,n,’***’,###) renvoie une matrice de taille m×n contenant des simulations
de variables aléatoires de loi *** avec les paramètres ###
a) Le cas des variables discrètes
grand(1,1,’uin’,a,b) simule une v.a.r de loi U(Ja, bK)

grand(1,1,’bin’,1,p) simule une v.a.r de loi B(p)
grand(1,1,’bin’,n,p) simule une v.a.r de loi B(n, p)
grand(1,1,’geom’,p) simule une v.a.r de loi G(p)
grand(1,1,’poi’,a) simule une v.a.r de loi P(a)

Exemples :
-->grand(4,4,’uin’,-2,2)
-->grand(1,1,’bin’,100,0.75)
ans =
ans =
2. - 2. 2. 0.
69.
- 2. - 2. - 2. - 1.
-->grand(1,1,’geom’,0.5)
1. - 2. 2. 2.
ans =
1. - 1. 2. 2.
3.
-->grand(2,4,’bin’,1,0.4)
-->grand(1,1,’poi’,10)
ans =
ans =
1. 0. 1. 0.
6.
1. 1. 0. 1.
b) Le cas des variables continues
grand(1,1,’unf’,0,1) simule une v.a.r de loi U(]0, 1[)

grand(1,1,’unf’,a,b) simule une v.a.r de loi U(]a, b[)
grand(1,1,’exp’,1/a) simule une v.a.r de loi E(a)
grand(1,1,’nor’,0,1) simule une v.a.r de loi N (0, 1)
grand(1,1,’nor’,m,s) simule une v.a.r de loi N (m, s)
Exemples :
-->grand(4,2,’unf’,-100,100) -->grand(1,1,’exp’,1/3)
ans = ans =
- 57.958185 - 92.71175 0.1959833
53.103358 - 62.625479 -->grand(1,1,’nor’,5,0.5)
- 89.756715 - 18.253768 ans =
59.039981 - 2.047121 5.4286616
-->grand(2,3,’unf’,0,1) -->grand(2,3,’nor’,0,1)
ans = ans =
0.4747587 0.4220877 0.1738652 0.4218018 0.1112611 - 0.1806437
0.3922270 0.6554779 0.1711867 1.8865999 0.7886150 0.2364817

Cours Info

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Info

Transféré par

Droits d'auteur :

Formats disponibles

Cours d’Informatique

2 Programmes et fonctions en Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

5 Représentation graphique en Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

7 Probabilités avec Scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

2) L’environnement de travail Scilab

Lycée Carnot - ECS1B 4 Matthias Gorny

II Calculs sur les nombres réels

1. Pour moi il s’agit de C:\Gorny\Scilab\

Lycée Carnot - ECS1B 5 Matthias Gorny

Scilab intègre également des fonctions prédéfinies :

Lycée Carnot - ECS1B 6 Matthias Gorny

III Création de variables par affectation

Quelques commandes utiles :

Lycée Carnot - ECS1B 7 Matthias Gorny

IV Variables booléennes et opérateurs de comparaison

Le résultat d’un test de comparaison est une variable booléenne.

Ne pas confondre l’opérateur d’égalité == et l’opérateur d’affectation =.

Lycée Carnot - ECS1B 8 Matthias Gorny

Lorsqu’une chaîne de caractère contient le caractère ’ ou le caractère ", il faut le doubler.

L’opérateur + permet de concaténer deux chaînes de caractères.

-->typeof(’20’) -->"Une valeur approchée de pi est " + string(x) + ’.’

Lycée Carnot - ECS1B 9 Matthias Gorny

Lycée Carnot - ECS1B 10 Matthias Gorny

Terminons par deux fonctions : si v est un vecteur constitué de booléens, alors

Lycée Carnot - ECS1B 11 Matthias Gorny

Programmes et fonctions en Scilab

I Introduction à l’algorithmique et la programmation

II L’éditeur de texte SciNotes

Lycée Carnot - ECS1B 12 Matthias Gorny

Lycée Carnot - ECS1B 13 Matthias Gorny

Lycée Carnot - ECS1B 14 Matthias Gorny

x=input('Entrer le terme initial de la suite géométrique :')

Exécutons ce programme (appelé SuiteGeom.sce) sans écho dans la console :

La valeur du 19-ième terme de la suite géométrique de raison -1.2

1) Création d’une fonction Scilab

Lycée Carnot - ECS1B 15 Matthias Gorny

2) Utilisation d’une fonction Scilab

-->exec(’C:\Gorny\Scilab\SuiteGeom.sci’, -1) -->SuiteGeom(15,0.6,1), SuiteGeom(15,0.6,10)

Testons cette fonction (enregistrée au préalable sous la nom SuiteGeomArith.sci).

Lycée Carnot - ECS1B 16 Matthias Gorny

N’oublions pas d’exécuter à nouveau la fonction la fonction... et testons-la :

Lycée Carnot - ECS1B 17 Matthias Gorny

Exécutons ce programme (appelé TestDiv.sce) sans écho dans la console :

Lycée Carnot - ECS1B 18 Matthias Gorny

Lycée Carnot - ECS1B 19 Matthias Gorny

Lycée Carnot - ECS1B 20 Matthias Gorny

Lycée Carnot - ECS1B 21 Matthias Gorny

Exécutons cette fonction (appelée DivEucl.sci) sans écho dans la console :

III Calcul des termes d’une suite

1) Calculer le nième terme d’une suite

Lycée Carnot - ECS1B 22 Matthias Gorny

3) Sommer les n premiers termes d’une suite

Lycée Carnot - ECS1B 23 Matthias Gorny

u=1; s=u; n=1;

Exécutons ce programme (appelé SommeHarmonique.sce) sans écho dans la console :

Lycée Carnot - ECS1B 24 Matthias Gorny

Représentation graphique en Scilab

I Représentation de points dans le plan

Lycée Carnot - ECS1B 25 Matthias Gorny

--> clf(); plot(X,Y,’r’,S,S,’b--’) -->clf(); plot(X,[Y;Z])

2) Avec la fonction plot2d

La commande getcolor() affiche un tableau avec la liste des couleurs.

Lycée Carnot - ECS1B 26 Matthias Gorny