Introduction 1 Utilisation de Scilab comme une

Introduction
” Un algorithme est une suite finie de règles à appliquer dans un ordre déterminé à un nombre fini de
données pour arriver, en un nombre fini d’étapes, à un certain résultat, et cela indépendamment des données. ”
(Enc. Universalis).
Par exemple une recette de cuisine ou une notice de montage d’un meuble en kit peuvent être considérés
comme des algorithmes. On voit bien la nécessité d’un algorithme clair (compréhensible par tous), le plus général
possible (pour répondre au plus de cas possibles) et rapide (efficace).
Un programme est la traduction d’un algorithme en langage compréhensible par la machine.
Nous ne verrons que le langage Scilab, logiciel de calcul numérique gratuit disponible sur le site : http://www.scilab.org
1
Utilisation de Scilab comme une calculatrice
A l’ouverture de Scilab, la console s’ouvre et une invite de commande - -> indique que le logiciel attend les
instructions. Cette première fenêtre fonctionne comme une calculatrice et permet de manipuler les commandes
de base de Scilab.
Ne pas hésiter à utiliser la fenêtre d’aide de Scilab : cliquer sur l’icône ? ou taper - ->help dans la console.
Pour obtenir des informations sur une commande dont le nom est connu, par exemple sum, taper directement
dans la console : - -> help sum
Opérations usuelles : + - * / et ˆ (puissance)
Toutes les fonctions usuelles sont prédéfinies dans Scilab : abs (valeur absolue), sqrt(racine carrée), log (ln),
exp, cos, sin, tan , floor (partie entière), real et imag (partie réelle et imaginaire), etc.
Constantes prédéfinies : e, π et i. Taper %e, %pi et %i dans la console.
Attention, toute opération doit être précisée :
ainsi - -> 1+2%i donnera un message d’erreur contrairement à - ->1+2*%i.
Variables :
Une variable est une case mémoire de l’ordinateur à laquelle on a donné un nom. On peut affecter des valeurs à
des variables en utilisant le signe =
Par exemple - ->x=2*3+5 crée une variable appelée x et lui affecte la valeur 11.
Un nom de variable est un mot composé de lettres et de chiffres mais qui commence par une lettre (noter que
Scilab fait la différence entre les minuscules et les majuscules). En mathématiques, une variable est presque toujours désignée par une seule lettre. En informatique, on préfèrera utiliser des noms de variables plus parlants :
par exemple, si l’on calcule une moyenne, au lieu de l’appeler x ou m, on l’appellera moyenne. A la relecture, le
programme informatique n’en sera que plus clair !
Une variable peut contenir n’importe quel type d’objet : un entier, un réel, un complexe, une liste, une matrice,
un booléen (c’est-à-dire F ou T : vrai ou faux) ....
Une variable peut ensuite être utilisée dans tout calcul à l’aide de son nom et elle peut être modifiée lors d’une
nouvelle affectation : dans ce cas, la valeur initiale de la variable est écrasée par la nouvelle valeur et est perdue.
Dès qu’une variable a été créée, Scilab la conserve avec sa ”dernière” valeur jusqu’à ce que l’on quitte le logiciel :
pour libérer une variable nommée x, taper clear(x), pour les libérer toutes taper clear.
Tout calcul effectué est stocké automatiquement par Scilab dans une variable appelée ans (pour ”answer”) :
cette variable peut donc être utilisée dans la commande suivante.
Chaı̂ne de caractère : une chaı̂ne de caractère est une succession de caractères qui ne sera pas interprétée par
Scilab. Elle doit être délimitée par des guillemets ’ ... ’ ou ” ... ”. Par exemple "Bonjour".
Affichage :
Dans la console, une instruction qui se finit sans ponctuation est affichée. Pour ne pas l’afficher, mettre un ; à la fin.
Une variable y peut être affichée ultérieurement dans la console par deux moyens :
soit en l’appelant directement : - -> y soit via la commande disp : - -> disp(y)
La commande disp permet également d’afficher une chaı̂ne de caractères, et de combiner les deux : par
exemple - -> disp(y, "valeur de y") (faire attention à l’ordre des arguments de disp).
1
Enfin, on peut insérer des commentaires en mettant un // : ce qui suit ne sera pas lu par Scilab (donc ni
exécuté ni affiché).
Raccourci : pour obtenir directement une instruction tapée plus haut sans la réécrire, utiliser les touches ↑ ↓.
ATTENTION :
• Tant qu’on manipule des petits nombres, l’affichage est usuel, mais dès que le résultat est trop grand (ou
trop petit), Scilab passe en notation scientifique :
- ->17 *23
ans =
391
ce qui signifie : la réponse est 391.
- ->exp(23)
ans =
9.745D+09
ce qui signifie : e23 ' 9, 745 × 109 .
• Scilab est un logiciel de calcul numérique : il ne travaille qu’avec des valeurs approchées (contrairement
aux logiciels dits de calcul formel tel Maple). Même si sa précision relative est de l’ordre de 10−16 , il y aura
des erreurs d’arrondi dans presque tous les calculs, même dans les plus courants.
- -> sqrt(2)^ 2-2
ans =
4.441D-16
Pour enlever les erreurs d’arrondi (inférieures à 10−10 ), on peut utiliser l’instruction clean
- -> clean(sqrt(2)^ 2-2)
ans =
0
2
2.1
Programmation en scilab
Scripts en scilab
Dès que le programme est un peu long ou que l’on désire ré-exécuter plusieurs fois le même programme, la
console de Scilab n’est plus pratique. Il devient préférable de taper toutes les instructions dans un fichier à part,
que l’on nommera script , qui sera sauvegardé sur le disque dur (donc réutilisable lors d’une autre session Scilab)
et qui sera exécuté dans la console. Pour écrire un script, cliquer sur l’icône démarrer Scinotes (à gauche de la
barre d’outils) : une fenêtre s’ouvre. Taper alors votre programme, et le sauvegarder régulièrement (l’extension
.sce apparaı̂t). Pour l’exécuter, cliquer dans la fenêtre scinotes sur l’icône C
La ligne - -> exec{"répertoire script/nom script.sce"} apparaı̂t dans la console, puis les éventuels affichages ou dialogues avec l’utilisateur.
Si vous avez fait des erreurs de syntaxe dans le script, des indications assez précises apparaissent dans la console
pour vous aider à les corriger.
A savoir :
– Pour demander des données à l’utilisateur, utiliser l’instruction input.
Par exemple : la commande a=input(’Entrer un réel strictement positif’) fait apparaı̂tre la
phrase ’ Entrer un réel strictement positif’ dans la console, attend qu’une valeur soit entrée par l’utilisateur (l’utilisateur doit taper une valeur puis faire Entrée), et enfin affecte à a la valeur rentrée par
l’utilisateur.
– Attention, dans un script, même si les instructions ne finissent pas par un ; elles ne seront pas affichées
lors de l’exécution. Pour afficher, il faut rajouter la commande disp : par exemple disp(a) .
– N’hésitez pas à insérer des commentaires (après //) afin d’expliquer telle variable ou tel calcul. Ils vous
seront précieux quand vous reprendrez le script, une semaine ou un mois après.
2.2
Fonctions Scilab
Lorsqu’il est nécessaire d’exécuter plusieurs fois de suite un script, la syntaxe input,disp n’est pas la plus
agréable : il faut sans cesse changer de fenêtre pour exécuter le script (fenêtre Scinotes), puis entrer la ou les
valeurs voulues (fenêtre console) et ainsi de suite. Il est préférable dans ce cas, d’utiliser la syntaxe d’une fonction
scilab.
2
Exemple d’une fonction appelée g à un paramètre d’entrée et une variable de sortie :
y est la variable de sortie
x le paramètre d’entrée
Le paramètre d’entrée, comme la variable de sortie,
peut être de tout type (entier, réel, liste etc.).
function y= g(x)
y=log(exp(x)+3)
endfunction
Si la fonction est tapée dans scinotes, il faut commencer par exécuter le script pour ”charger” la fonction.
Cette fonction sera alors disponible jusqu’à la fin de la session Scilab.
Enfin, pour utiliser la fonction (dans la console, dans un script ou même dans une autre fonction ), il faut écrire
(on a choisi ici de remplacer le paramètre d’entrée par 3)
l’instruction suivante : –> g(3)
Réaliser que l’en-tête function y=f(x) correspond à la commande x=input(’ ’) et que la sortie y= ...
correspond à la commande disp(y). Tout le reste du code sera rigoureusement identique.
Les fonctions scilab permettent de créer une boı̂te ”noire” qui, à des paramètres d’entrée, associe une ou
plusieurs valeurs de sortie, exécute une ou plusieurs instructions etc.
Déclaration d’une fonction Scilab nommée f à 3 paramètres d’entrée nommés r,s,t
function y= f(r,s,t)
instructions ...
y=...
endfunction
Pour appeler (utiliser) la fonction dans la console ou dans une autre fonction ou script, taper :
- -> f(-1,0,0.3)
avec les valeurs choisies de r,s,t
ou
- -> a=f(-1,0,0.3) pour directement affecter le résultat à une variable nommée par exemple a
Remarques
i. Même si votre fonction ne nécessite pas de variable de sortie (dans le cas où la fonction ne fait que des
actions), garder la même syntaxe function y=g(x). Scilab considérera que y=[ ] (liste vide).
Si la fonction ne nécessite aucun paramètre d’entrée, écrire comme en-tête :
function y=g() (garder les parenthèses, même vides).
ii. Syntaxe d’une fonction avec 3 variables de sortie :
function [y1,y2,y3]= f(x)
instructions
endfunction
Et pour l’appeler :
- -> [a,b,c] = f(x) puis si besoin, afficher cette liste (si script et non console).
L’affectation est ici nécessaire, sinon scilab n’affichera qu’une sortie dans ’ans’ (la première)
iii. Toutes les variables utilisées à l’intérieur de la fonction sont locales. Elles n’existent donc pas à l’extérieur
de la fonction. (Ne pas les confondre avec les paramètres d’entrée !)
2.3
Instructions conditionnelles
Syntaxe :
if ... then, ... , else ..., end
ou
if ... then
avec le else ... qui est facultatif.
...
else ...
end
Cette instruction répond à l’attente :
si une condition est vraie (par exemple x 6= 0), alors on effectue une certaine instruction (par exemple, on divise
par x) et sinon, on en effectue une autre (par exemple on affiche un message d’erreur).
Attention : le else n’est pas suivi d’une condition, puisque le test a déjà été fait après le if !
Une condition pour Scilab est une phrase qui est vraie ou fausse (donc de type booleen) : par exemple x>0.
Signalons que les opérateurs de comparaisons qui interviennent dans les conditions sont : == (égal à),
> ou < (strictement supérieur/inférieur), >= ou <= (supérieur/inférieur ou égal), <> (différent de)
On peut également avoir besoin d’opérateurs logiques entre deux conditions : & ou and (et), | ou or (ou).
3
Attention : ne pas confondre x = 3 et x == 3 lorsque x est une variable.
x = 3 est une affectation : elle correspond à l’instruction ”donner à x la valeur 3”.
x == 3 est une condition vraie au fausse : elle correspond à la question ”x est-il égal à 3 ?”.
Plus généralement, avec des alternatives multiples, au lieu d’emboı̂ter des if ce qui exigerait de finir par
autant de end que nécessaires (càd que de if), on utilise la syntaxe elseif (attention de ne pas mettre d’espace
entre le else et le if ce qui reviendrait sinon à faire l’emboı̂tement) :
if condition1 then
instructions1
elseif condition2 then
instructions2
....
else ...
end
2.4
Boucle For
Cette instruction s’utilise pour répéter automatiquement une suite d’instructions n fois, lorsque n est connu
à l’avance. La syntaxe est la suivante :
for i=n1:pas:n2
instructions dépendant ou non de i
end
Le groupe d’instructions est effectué une première fois avec i=n1, une deuxième avec i=n1+pas,...., puis une
dernière avec i=n2 (ou la dernière valeur possible de type n1+k*pas inférieure à n2).
Remarques :
i. En général n1 et n2 sont des entiers et le pas vaut 1 donc peut être omis : l’en-tête devient for i=n1:n2
ii. Un pas négatif, par exemple -1, permet d’aller de n1 à n2 en décroissant.
iii. Si v cache une liste de nombres la syntaxe for i=v signifie :
i prend successivement (et dans l’ordre) les valeurs contenues dans v.
2.5
Boucle While
L’instruction while s’utilise pour répéter un groupe d’instructions tant qu’une condition est vraie : on ne
connaı̂t donc plus a priori le nombre de répétitions nécessaires. La syntaxe est la suivante :
while condition
instructions // tant que la condition est vraie, cette partie est exécutée en boucle
end
Remarques :
i. Le groupe d’instructions peut ne pas être exécuté du tout (si dès le départ la condition est fausse).
ii. Avant d’éxéctuer une boucle while, vérifier que la condition devient fausse au bout d’un certain temps.
Sinon, le programme ne s’arrêtera jamais.
En cas d’urgence ( !), utiliser le raccourci clavier CTRL+C puis taper abort dans l’invite de commande
-1-> qui apparaı̂t. Cette commande permet non seulement de sortir d’une boucle infinie, mais également
de stopper la commande input par exemple.
3
3.1
Listes et Matrices
Listes ou Vecteurs
– si la liste est courte, il suffit d’écrire ” à la main” les coefficients entre crochets :
- ->b=[1,4,-1,2]
– Lorsque le pas est constant, utiliser la syntaxe :valeur départ : pas : valeur fin
Par exemple, la syntaxe - -> b=-3:2:7 crée la liste -3,-1,1,3,5,7
– - ->V=[ ] représente la liste vide, et ones(1,n) (resp. zeros(1,n)) crée une liste de taille n avec
que des 1 (resp. que des 0)
4
Une fois les listes introduites, on peut à tout moment les modifier, les agrandir, en extraire une partie :
– pour accéder au ie coefficient de la liste b : - ->b(i)
– pour extraire de la liste b les coefficients de 2 à 4 : - ->b(2:4).
On pourra apprécier le symbole $ qui signifie ”jusqu’à la fin” : par exemple - ->b(3:$)
– concaténation de 2 listes a,b : - ->[a,b]
Opérations sur les listes :
i. Opérations usuelles : si a,b sont des listes de même taille a+b
a-b
a*réel .
De plus, Scilab donne un sens à l’opération ”liste + réel” : il ajoute le réel à tous les coefficients de la liste.
ii. si f est une fonction prédéfinie dans Scilab (sin, exp ..., ), et b une liste, l’instruction f(b) applique f à
chaque coefficient de b
iii. Opérations pointées : scilab permet également de faire des opérations coefficient par coefficient
.* (produit coefficient par coefficient de 2 listes),
./
(division coefficient par coefficient de 2 listes)
.ˆ (puissance coefficient par coefficient de 2 listes ou d’une liste et d’un réel).
3.2
Matrices
– Pour introduire une matrice de petite dimension, on rentre tous les coefficients à la main :
- ->A=[1,1,1;4,-1,2;-1,-1,2]
Les coefficients sont écrits entre crochets, les , (qui peuvent être remplacées par des espaces)
séparent les coefficients d’une même ligne, et les ; permettent de changer de ligne.
– Matrices prédéfinies :
[ ] : matrice vide
zeros(n,p) : matrice de taille n×p où tous les coefficients sont nuls
ones(n,p) : matrice de taille n×p où tous les coefficients sont égaux à 1
eye(n,n) matrice identité de taille n (eye est la prononciation de I en anglais)
Opérations sur les matrices :
i. opérations usuelles entre les matrices dès que les tailles sont compatibles : * (produit matriciel ou par
un réel), + et - (addition soustraction de matrices) et ˆ (puissance de matrices).
Attention, Scilab attribue à l’opération ”matrice + réel” un sens : il ajoute le réel à tous les coefficients
de la matrice.
ii. si f est une fonction prédéfinie dans Scilab (comme sin, exp ..., ) et A une matrice, l’instruction f(A)
applique f à chaque coefficient de A.
iii. opérations coefficient par coefficient (ou opérations pointées) : .* (produit coefficient par coefficient de 2 matrices),
./
(division coefficient par coefficient de 2 matrices),
.ˆ (puissance coefficient par coefficient de 2 matrices ou d’une matrice et d’un réel).
Ne pas confondre A*A et A .*A ; A^ 2 et A .^ 2 !
Une fois les matrices introduites, on peut à tout moment les modifier, les agrandir, en extraire une partie :
– pour accéder au coefficient de la matrice A situé ligne i et colonne j : - ->A(i,j)
– pour extraire de la matrice A la colonne j : A(:,j) et la ligne i : - ->A(i,:)
– plus généralement, on peut extraire la partie que l’on veut de A avec une syntaxe du type - ->A(2:4,5:6).
On pourra également utiliser le symbole $ (”jusqu’à la fin”)
– concaténation de 2 matrices A,B ayant même nombre de lignes : - ->[A,B]
concaténation de 2 matrices A,B ayant même nombre de colonnes : - ->[A;B].
Enfin :
– la transposée d’une matrice s’obtient avec ’ : - ->A’
– si la matrice est inversible, la commande - -> inv(matrice) ou - - > A^ (-1) renvoie la matrice inverse.
– la commande - -> rank(matrice) renvoie le rang de cette matrice.
– la commande - -> size(matrice) renvoie la taille de cette matrice (deux dimensions) et - -> length(matrice)
renvoie le nombre d’éléments de cette matrice.
– Plus anecdotique : - ->diag(matrice) extrait la diagonale de cette matrice et en fait une matrice colonne
et - ->diag(vecteur) crée une matrice diagonale où les coefficients diagonaux sont ceux du vecteur.
5
3.3
Résolution de systèmes
Scilab ne permet de résoudre que les systèmes de Cramer, c’est-à-dire associés à des matrices inversibles.
Pour résoudre le système AX = B d’inconnue le vecteur X, définir le vecteur B associé au second membre, et la
matrice A associée au système. L’instruction - -> A\B donne alors l’unique solution.
Moyen mnémotechnique : si AX = B, pour obtenir X, il faut multiplier à gauche par A−1 ce qui peut se visualiser comme une division à gauche par A d’où le A\B (B divisé à gauche par A).
Sinon, plus simplement taper directement - -> inv(A)*B, ou encore (A^ -1)*B !
Remarque bonus : dans le cas où la matrice associée A n’est pas inversible, l’instruction précédente de Scilab ne
résout plus le sytème mais cherche la matrice X qui minimise la différence A ∗ X − B dans un certain sens (càd
qui minimise la somme des coefficients au carré de cette différence) : c’est la méthode des moindres carrés.
4
Représentations graphiques
Scilab construit une courbe point par point et interpole entre ces points : pour faire représenter la courbe d’une
fonction à scilab, il faut donc lui préciser une liste d’abscisses x, ainsi qu’une liste d’ordonnées y, ou à défaut
une fonction g (Scilab calculera alors lui-même les ordonnées).
Rappels :
- -> x=0:0.1:1 ; construit une liste x contenant toutes les abscisses entre 0 et 1 espacées de 0.1
à savoir 0, 0.1, 0.2,...., 0.9, 1.
La syntaxe générale est : valeur départ : pas : valeur fin
Variante possible : x=linspace(0,1,11)
(en pratique, on choisira plutôt un nombre de points ”facile” : x=linspace(0,1,10)).
La syntaxe générale est : linspace(valeur départ, valeur fin, nbre points) .
- -> exp(x) est la liste des réels obtenus en appliquant successivement la fonction exponentielle aux valeurs
contenues dans x. Toutes les fonctions usuelles (prédéfinies dans scilab) acceptent une liste en entrée.
3 syntaxes à connaı̂tre :
plot(abscisses, ordonnées) ou plot2d(abscisses, ordonnées) et fplot2d(abscisses,fonction)
Variantes syntaxiques sur des exemples :
x=-2:0.1:3
y=exp(x)-2
z=2*x.^ 3+1
plot2d(x,y)
plot2d(x,z)
x=-2:0.1:3
function y=h(x)
y=x^ 2+1/x
endfunction
fplot2d(x,h)
x=1:0.1:3
function y=g(x)
y=x.^ 2+1 ./x
endfunction
plot2d(x,g(x))
Les variantes 1 et 2 sont utilisées avec des fonctions usuelles (qui acceptent des listes en entrée) ou des opérations
pointées : on crée (variante 2) ou non (variante 1) une fonction scilab.
La variante 3 crée une fonction Scilab simple (qui n’accepte pas de liste en entrée, seulement un nombre) : de ce
fait il faut utiliser la commande fplot2d au lieu de plot2d.
Dans tous les cas, une fenêtre graphique doit s’ouvrir !
Remarques :
– Si on trace successivement plusieurs courbes, elles se superposent dans la même fenêtre. Pour supprimer
les graphiques précédents, taper - -> clf; (clear figure).
– Les différences entre les instructions plot et plot2d dépassent le niveau de ce cours : elles portent essentiellement sur les options possibles (couleur des courbes, paramètres des axes, fenêtre d’affichage ..). Cette
année, les options qui nous intéressent seront directement modifiées en cliquant dans la fenêtre graphique
sur Editions puis Propriétés des axes. Par exemple, dans les onglets X et Y, choisir dans Location, origin
pour que le repère soit centré. Pour modifier l’aspect de la courbe (couleur, style de trait, interpolation
etc.) cliquer sur compound 1 puis axis(1) et changer foreground ou ...
– D’autres variantes existent : plot2d2 crée directement des fonctions en escalier, plot2d3 ou bar trace les
courbes avec des barres verticales ...
6
5
Simulations en Scilab
5.1
Simulations des lois usuelles
Scilab dispose de deux commandes pour générer des nombres pseudo-aléatoires : rand et grand
i.
rand : permet de simuler deux lois usuelles U([0, 1]) et N (0, 1)
La commande - -> A=rand(1,m) génère une liste de m simulations indépendantes de loi U([0, 1]), càd
une liste de m réels pris au hasard entre 0 et 1 et indépendamment des autres.
La commande - -> A=rand(1,m,’n’) génère une liste de m simulations de loi normale centrée réduite,
indépendantes.
ii. grand : cette commande permet de simuler toutes les lois usuelles.
Les instructions suivantes génèrent une liste de m simulations (indépendantes) de la loi correspondante.
Loi
Loi
Loi
Loi
Loi
Loi
Loi
Uniforme discrète sur [[1, n]]
Binomiale de paramètres N et p
Géométrique de paramètres p
de Poisson de paramètre λ
Uniforme à densité sur [a,b]
Exponentielle de paramètre λ
Normale de paramètres µ et σ 2
grand(1,m,’uin’,1,n)
grand(1,m,’bin’,N,p)
grand(1,m,’geom’,p)
grand(1,m,’poi’,λ)
grand(1,m,’unf’,a,b)
grand(1,m,’exp’,1/λ)
grand(1,m,’nor’,µ,σ)
Attention aux paramètres de grand notamment pour la loi normale où le second paramètre est l’écart-type
et non la variance et pour la loi exponentielle, où le paramètre est l’espérance.
Enfin, se rappeler que les chaı̂nes de caractère peuvent s’écrire indifféremment avec des ’ ’ ou des ” ”.
5.2
–
Simulations d’expériences aléatoires et compléments
Simulation d’un lancer de dé : floor(6*rand())+1
Simulation d’un événement de probabilité p (par exemple un lancer de pièce) :
if rand()<p then
... // réalisé avec proba p
else ... // réalisé avec proba 1-p
end
– Simulations de n expériences de Bernoulli (succès/echec) : - -> x=rand(1,n) liste des simulations, puis
détermination succès/échec via une contrainte (pour respecter les probabilités)
- -> (x<p) : liste de T et F, précisant pour chaque valeur de x si la condition est vraie (T) ou fausse (F).
Pour avoir le nombre de valeurs remplissant cette condition (càd le nombre de succès) , il suffit d’utiliser
ensuite sum car Scilab associe 1 à T et 0 à F : - -> sum(x<p).
Pour avoir les positions des valeurs de x remplissant la condition, utiliser find : - -> y=find(x<p).
Pour avoir la première position (temps d’attente) : - -> min(y) ou y(1)
Remarquer que length(y) revient à sum(x<p) ! Il y a bien sûr d’autres variantes encore ...
– mean calcule la moyenne (empirique) d’un échantillon, variance la variance, st deviation l’écart-type,
median la médiane et (rappel) min et max le minimum et maximum.
Toutes ces fonctions peuvent s’appliquer à une liste ou une matrice (cf aide en ligne).
– tabul : si x est une liste de simulations d’une certaine variable aléatoire discrète
(par exemple x=grand(1000,1,"uin",1,10)),
- ->M=tabul(x) renvoie une matrice à deux colonnes :
la première colonne M(:,1) est composée de toutes les valeurs apparaissant dans x
la deuxième colonne M(:,2) donne le nombre d’occurences dans x de chacune de ces valeurs.
On obtient alors un diagramme en bâtons à l’aide de l’instruction bar :
- -> bar(M(:,1), M(:,2), 0.6,’blue’)
0.6 précise l’épaisseur des bâtons : ce paramètre doit être compris entre 0 et 1.
’blue’ précise la couleur du graphique : les autres couleurs sont red, magenta, black, yellow, green...
Dans le cas où vous superposez plusieurs diagrammes en bâtons, penser à changer de couleur et à diminuer
progressivement l’épaisseur des bâtons, afin que le nouveau graphique ne recouvre pas l’ancien.
7
– Dans le cas des lois à densité, la commande tabul, comme le diagramme en bâtons n’a plus de sens puisque
aucune valeur fixée n’est prise (avec une probabilité non nulle) : il faut donc regrouper les valeurs dans des
classes c’est-à-dire des intervalles. C’est la notion d’histogramme.
Le tracé d’histogrammes s’obtient à l’aide de l’instruction histplot .
Plus précisémment, si x est une liste de données (c’est-à-dire de simulations), alors
la commande - -> histplot(n,x)
répartit les données contenues dans x en n classes de même largeur, et trace l’histogramme correspondant.
la commande - -> histplot([b1 , b2 , ..., bn ],x)
réalise l’histogramme où les classes sont les intervalles : [b1 , b2 ], ]b2 , b3 ],...,]bn−1 , bn ].
Ne pas hésiter à définir en amont le vecteur b des classes, puis à utiliser l’instruction histplot(b,x).
Attention, avec ces deux instructions, l’effectif de chaque classe est normalisé par l’effectif total * la largeur
d’une classe : autrement dit, si on réalise 1000 simulations et qu’il y a 50 données dans la première
50
de manière à ce que l’aire de ce premier rectangle de
classe, l’ordonnée sur l’histogramme sera 1000∗(b
2 −b1 )
50
l’histogramme donne 1000 qui est la proportion de données dans la première classe.
La première instruction est donc plus obscure, car on ne choisit pas les classes ni même leur largeur (cela
dépend des données extrêmes) et il est plus difficile de voir des propriétés de l’histogramme.
bonus :
l’instruction [pos,eff]=dsearch(x,b,’c’) permet de rechercher parmi les simulations de la liste x ceux
qui se trouvent dans une des classes définies par b.
pos est alors un vecteur de même taille que x qui indique le numéro de la classe à laquelle appartient
chaque élément, et eff est un vecteur qui donne l’effectif de chaque classe.
8