Cours Info
Cours Info
Cours Info
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
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
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.
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
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).
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)
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].
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.
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.
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
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
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
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
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
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
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.
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.
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.
Exemple : (dans la console)
-->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.
Exemple : (dans la console)
-->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.
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).
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 : Testons la fonction précédemment implémentée (on l’a au préalable enregistré sous le nom SuiteGeom.sci).
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
-->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
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
-->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.
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
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
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).
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
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
-->[q,r]=DivEucl(60,7)
r =
4.
q =
8.
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.).
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
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
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) + ".")
-->exec(’C:\Gorny\Scilab\SommeHarmonique.sce’, -1)
Entrer un réel A strictement positif : 10
Les termes de la suites sont supérieurs ou égaux à10 àpartir du rang 12367.
-->exec(’C:\Gorny\Scilab\SommeHarmonique.sce’, -1)
Entrer un réel A strictement positif : 15
Les termes de la suites sont supérieurs ou égaux à15 àpartir du rang 1835421.
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).
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.
— 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
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...
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’)
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).
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).
-->exec(’g.sci’, -1)
-->x=linspace(-3,4,1000);
-->clf(); plot(x,g)
-->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)
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).
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)
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.
• 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.
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.
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.
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.
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.
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
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
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.
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
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
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
if rand()<p then
X=1;
else
X=0;
end
X
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.
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 ###
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