SCILAB

Prépas ECT
Liste des commandes scilab à connaître de la première année
(exigibles aux concours)
1) Constante. Variable crée par affectation
Valeurs approchées des réels ; e. %pi , %e
Définit une variable a par l'expression fournie,
qu'elle soit chaine de caractères, numérique ou
matricielle : a := expression
2) Opérations élémentaires
Opérations arithmétiques, valables pour les nombres et pour les matrices : +,-,*,/,^
Comparaisons, tests. == , > , < , >= , <= , <>
Connecteurs logiques : & , or
transposée de la matrice A : A’
3) Manipulations sur les matrices
 La commande M=[ a , b , c ; d , e , f ; ] par exemple crée une matrice avec un première ligne
égaleà (a b c) et une deuxième ligne égale à (d e f )
 a :p :b crée une vecteur ligne dont le premier coefficient est a, et qui avance à chaque fois de p (le
pas) jusqu'à atteindre b (très pratique pour les graphes).
 a : b crée une vecteur ligne dont le premier coefficient est a, et qui avance à chaque fois de 1 (le pas,
implicite ici, vaut 1) jusqu'à atteindre b.
 linspace(a,b,n) crée une vecteur ligne à n coefficients, dont le premier coefficient est a, le dernier
b, et qui avance à pas constant (très pratique pour les graphes).
 n=lenght(x) permet d'obtenir le nombre de lignes ou de colonnes d'un vecteur ligne ou colonne.
 [n,p]=size(M) permet d'obtenir le nombre de lignes (dans n) et de colonnes (dans p) de M.
 Les opérations M+N, M-N , M*N ,M^n , inv(M) sont les opérations habituelles sur les matrices.
 M' est la transposée de M.
 M.*N , M./N , M.^k sont les opérations composantes à composantes: le résultat est une matrice
dont les composantes sont respectivement : les produits deux à deux des composantes de M et N,
leurs quotients deux à deux (si aucun coefficient de N n'est non nul ! ! !), les puissances k-ième des
coefficients de M.
 M( :,j) (resp. M(i, :)) est la j-ème colonne de M (resp. la i-ème ligne de M).
 Si f est une fonction, f(M) est une matrice où chaque coefficient de M à été composé par f.
 zeros(n,p), ones(n,p), eye(n,n) créent respectivement la matrice nulle, une matrice avec que
des 1, et la matrice identité.
4) Fonctions élémentaires
Les fonctions exp, abs, floor, sqrt, log (qui est la fonction ln()) doivent être connues.
5) Tracé de graphiques
 plot(x,y) (resp. plot2d(x,y)) où x et y sont des vecteurs trace une courbe en joignant par des
droites les points dont les abscisses sont donnés par x et les ordonnées par y.
 plot(x,f) (resp. plot2d(x,f)) où x est un vecteur et f une fonction trace une courbe en joignant par
des droites les points dont les abscisses sont donnés par x et les ordonnées par f(x).
 plot(x,y,'+') (resp. plot2d(x,y,-1)) où x et y sont des vecteurs trace uniquement les points dont
les abscisses sont donnés par x et les ordonnées par y.
1
 bar(x,y) : renvoie un diagramme en bâton avec les éléments de x en abscisse et les valeurs
correspondantes de y en ordonnée.
 histplot(C,x) : crée un histogramme de la série statistique x avec en abscisse les classes données
dans C.
6) Entrée de données et sortie de résultat
 x=input('...........') : affiche le message entre les apostrophes demandant la valeur de x à
l'utilisateur, puis affecte la valeur donnée par l'utilisateur à la variable x.
 disp('............') : affiche le message entre les apostrophes.
 disp(x) : affiche la valeur de x.
 disp('.........'+string(x)): affiche le message entre apostrophes puis la valeur de x.
Remarque : Cette dernière structure, très étrange, est due au fait que la fonction disp ne peut écrire
sur la même ligne un message (variable chaîne de caractère, de type string) et un nombre (variable de
type réel) : on doit donc ruser en affichant, au lieu de x, string(x) qui est une chaîne de caractère
composée des chiffres et éventuellement virgule qui composent le nombre x. Enn le + sert juste à dire
qu'on affiche un message puis un autre (il n'est pas affiché).
7) Probabilités
 rand() simule la loi uniforme sur [0; 1] : elle donne un nombre pris au hasard entre 0 et 1.
 floor(n*rand()) simule la loi uniforme sur {0;…….; n-1} (crée des probabilités 1/n). Rajouter 1
pour obtenir la loi uniforme sur {1; …; n}
 rand(n,p) renvoie une matrice à n lignes et p colonnes dont chaque coefficient est une
simulation de la loi uniforme sur [0; 1].
 if rand()<p then ...... else ....... end permet de créer une probabilité p quelconque (et
également 1 - p dans le else).
 grand(m1,m2,'unf ',a,b) crée une matrice à m1 lignes et m2 colonnes dont chaque coefficient
(2,'geom',p) crée un vecteur dont chaque coefficient est une simulation de la loi G(p).
 grand(m1,m2,'poi',a) crée un vecteur dont chaque coefficient est une simulation de la loi P(a).
 grand(m1,m2,'exp',a) crée un vecteur de taille m dont chaque coefficient est une simulation de
la loi exponentielle dont l'espérance vaut a : E(1/a).
 grand(m1,m2,'nor',m,sigma) crée un vecteur de taille m dont chaque coefficient est une
simulation de la loi normale d'espérance m et d'écart-type : N(m; ).
8) Syntaxe des structures logiques:(Programation)
 if .... then ...... end
 if .... then ...... else ..... end
 if ..... then ...... elseif ..... then ...... elseif ...... then ..... else end
 for k=1 :n do ........ end
 for k=1 :2 :n do .... end (k allant de 1 à n, avec un pas de 2 : 1, puis 3, puis 5, puis 7,
etc...)
 while ...... do ....... end
Savoir-faire exigibles en ECT1 :
 Calcul des termes d'une suite. Exploiter graphiquement des résultats.
 Valeur approchée de la limite d'une suite. L'arrêt résulte d'une étude mathématique.
 Valeur approchée d'un zéro d'une fonction. Suites récursives, dichotomie ;
encadrements.
 Valeur approchée d'une intégrale. Méthode des rectangles.
 Simulation d'expériences aléatoires. Fonctions rand, grand. Lois uniformes,
binomiales.
2
 Liste des commandes scilab à connaître de la deuxième année
(exigibles aux concours)
1) Statistiques descriptives
Ces commandes figurent au programme et peuvent être nécessaires pour écrire un programme
demandé dans un exercice de concours.

 mean(x) : renvoie la moyenne du vecteur ligne, colonne ou de la matrice x, considéré comme

une série statistique.
 sum(x) : renvoie la somme des éléments de la matrice ou du vecteur x.
 cumsum(x) : renvoie la somme cumulée du vecteur, ligne ou colonne, x.
 max(x) (resp min(x)) : renvoie le plus grand élément (resp. le plus petit) de la matrice ou du
vecteur x.
 corr(X,Y,1) : renvoie la covariance des séries statistiques X et Y.

2) Tracé de graphiques

 bar(x,y) : renvoie un diagramme en bâton avec les éléments de x en abscisse et les valeurs
correspondantes de y en ordonnée.
 histplot(C,x) : crée un histogramme de la série statistique x avec en abscisse les classes
données dans C.

3) Probabilités
 grand(n,'markov',A',X0) : renvoie une simulation de la variable Xn à l'instant n (nombre
entier strictement positif) dans une chaîne de Markov de matrice de transition A (matrice
carrée, stochastique,dont on donne la transposée en argument) et d'état initial X0 (nombre
positif, numéro de l'état de départ).

Savoir-faire exigibles en ECT2 :

 Produire et interpréter des résumés numériques et graphiques d'une série statistique
(simple, double) ou d'une loi.
 Modéliser et simuler des phénomènes (aléatoires ou déterministes) et les traduire en
langage mathématique.
 Représenter et interpréter les différentes convergences.
 Utiliser a bon escient la méthode de Monte-Carlo.
 Porter un regard critique sur les méthodes d'estimation et de simulation.

3
 Exercices corrigés
1.Calcul des termes d'une suite.
Exploiter graphiquement des résultats.

u0  15

On considère la suite (un) définie par :  u n2  2
u
 n1 
 2u n
1. Ecrire un programme calculant et affichant un.
2. Etudier la complexité des algorithmes précédents.
3. Donner u10, et vérifier à la main votre résultat.
4. Utiliser le programmes afin d'avoir une idée de la limite éventuelle de la suite : l  lim un .
n
5. Créer un programme affichant graphiquement les termes de la suite.
Solution :
1.
n=input('entrez n') ;
u=15 ;
for k=1 :n ;
u=(u^2+2)/(2*u) ;
disp(u) ;
end ;
2. On a 2 affectations avant la boucle for et n affectations dans la boucle for, donc au total on a n+2
affectations. Et on a 4n opérations.
3. Exécution : donner u10
4. Graphique.
2.Valeur approchée de la limite d'une suite.
L'arrêt résulte d'une étude mathématique.
u 0  1

On considère la suite récurrente définie par  e u n  3 , pour étudier cette suite, on considére la
 n 1
u 
 2
e 3
x
u 0  1
fonction f définie par : f ( x)  , on a donc 
2 u n 1  f (u n )

On peut montrer que cette suite converge vers un réel l solution de l’équation f(x)=x, c'est-à-dire que
l vérifie f(l)=l. L'inégalité des accroissements finis nous permet aussi d'obtenir une précision de
1
l'approximation de l grâce à l'inégalité u n  l 
2n
On souhaite construire un programme approchant l à 0,001 près, càd un  l  0,001
1
1. a. Vérifier qu'il suffit que  0,001 .
2n
b. On va donc calculer les termes de la suite (un), et parallèlement les valeurs de vn  1n , jusqu'à ce
2
que cette dernière quantité soit plus petite que 0 ,001.
Quelle instruction peut-on utiliser ?
c. Dans un programme, créer la fonction f à l'aide de la commande function.
d. Compléter le programme pour qu'il renvoie une valeur approchée de l à 10-3 près.
2. Quelle est la complexité du programme.

4
Solution :

function y=f(x) ;
y=(exp(x)-3)/2 ;
endfunction ;
eps=input('entrez la précision voulue :') ;
u=-1 ;
v=1 ;
while v>eps ;
u=f(u) ;
v=v/2 ;
end ;
disp(u) ;
disp(f(u)) ;

3.Valeur approchée d'un zéro d'une fonction. Suites récursives, dichotomie ;

encadrements.
function y=f(x);y=x^2-x-1;endfunction
x=linspace(-5,5,100);
clf;plot(x,f)
a=1;b=2;
while b-a>10^(-4)
c=(a+b)/2;
if f(a)*f(c)>0 then
a=c;
else
b=c;
end
end
afficher("La solution est comprise entre :"+string(a)+" et "+string(b))

5
4.Valeur approchée d'une intégrale.
Méthode des rectangles.

6
Corrigé

On a le programme suivant :
function y=f(t) ;
y=exp(-t^2/2) ;
endfunction ;
n=108000 ;
a=-3 ;
b=3 ;
s=0 ;
for k=1 :n,
s=s+f(a+k/n*(b-a)) ;
end ;
s=s*(b-a)/n ;
disp(s) ;

5.Simulation de qq lois usuelles.

Bernoulli
//Épreuve de Bernoulli : simulation
function z = bernoulli(p)
aux = rand()
if aux < p then z = 1
else z = 0
end
endfunction

7
Loi binomial
n = input('Nombre de repetitions (entier): ')
p = input('Probabilite de succes (entre 0 et 1) : ')
nb_succes = 0
for j = [1:n]
if rand() < p then // tirage Bernoulli donnant succes
nb_succes = nb_succes + 1
end
end
disp(nb_succes)
Poisson

lambda = input('Parametre de la loi de Poisson: ')

produit = rand()
n=0
while produit > exp(-lambda)
produit = produit * rand()
n=n+1
end
disp('Tirage Poisson parametre ' + string(lambda) + ' : ' + string(n))

Géometrique
//Var suivant une loi géométrique : simulation
function rang = geometrique(p)
rang = 1
aux = bernoulli(p)
while (aux == 0)
rang = rang + 1
aux = bernoulli(p)
end
endfunction