corriges scilab - Hachette Education

Corrigés – SCILAB
Avertissement
1) Pour écrire un programme, on ouvre l'Editeur
(Applications, Editeur) et on y écrit le
programme. Les retraits gauches (indentations) se
font de façon automatique.
2) Pour exécuter le programme, on a plusieurs
possibilités :
- soit Exécuter, Charger dans Scilab ;
- soit on sélectionne la partie du programme qu'on
souhaite exécuter, on la copie, et on la colle dans
la Console.
Fonctions
10 3) On propose :
x=input("x = ? ");
if x<=10 then V=100*x;
else V=750+25*x;
end;
afficher(V,"le volume est :");
Il faut exécuter le programme un certain nombre de fois,
ce qui est un peu lourd en manipulations entre la Console
et l'Editeur. On peut alors penser à créer une fonction :
function V=volume(x)
if x<=10 then V=100*x;
else V=750+25*x;
end;
endfunction;
Il suffit de charger cette fonction dans la Console, puis de
l'appeler par l'instruction volume(5) par exemple (sans
mettre de point-virgule pour afficher le résultat).
Pour l'appeler plusieurs fois, dans la Console on utilise la
flèche du clavier ↑ pour remonter dans l'historique, et on
modifie l'argument de la fonction.
4) On teste plusieurs valeurs de x et on procède par
encadrements successifs pour trouver la valeur de x
associée à V = 625.
11 2b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
S=100;
for i=1:10
S=S+100+2*i;
end;
afficher(S,"capital :");
3) On peut commencer par faire quelques essais en
calculant des images de la fonction capital, puis
procéder par encadrements successifs :
Page 1
On peut ensuite éventuellement introduire une boucle Tant
que :
S=100;
n=0;
while S<1999
n=n+1;
S=S+100+2*n;
end;
afficher(n,"nombre d années :");
13 4) b) On transcrit l'algorithme en langage Scilab :
x=-3; x0=-3; m=34;
while x<=3
x=x+0.1;
y=3*x^2-2*x+1;
if y<m then
x0=x;
m=y;
end;
end;
afficher(m,"le min paraît être :");
afficher(x0,"il est atteint en :");
15 2) On peut commencer par faire quelques essais en
calculant des images de la fonction population, puis
procéder par encadrements successifs :
function P=population(n)
P=5000;
for i=1:n
P=P*0.95;
end;
endfunction;
On peut ensuite éventuellement introduire une boucle Tant
que :
P=5000;
n=0;
while P>2500
n=n+1;
P=P*0.95;
end;
afficher(n,"nombre d années :");
16 2) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
n=input("nombre d années = ?");
C=1000;
for i=1:n
C=1.025*C;
end;
afficher(C,"le capital est :");
function S=capital(n)
S=100;
for i=1:n S=S+100+2*i;
end;
endfunction;
3) On utilise le programme précédent en testant plusieurs
valeurs de n, et en procédant par encadrements successifs.
Pour cela, on charge cette fonction dans la Console, et on
l'appelle par l'instruction capital(12) (sans pointvirgule pour afficher le résultat).
Pour l'appeler plusieurs fois, dans la Console on utilise la
flèche du clavier ↑ pour remonter dans l'historique, et on
modifie l'argument de la fonction.
function C=capital(n)
C=1000;
for i=1:n C=1.0125*C; end;
endfunction;
Comme on souhaite exécuter le programme un certain
nombre de fois, on peut penser à créer une fonction :
Corrigés – SCILAB
Page 2
Prolongement : on peut éventuellement écrire un
algorithme avant de le transcrire en langage Scilab :
4) On utilise le programme précédent en testant plusieurs
valeurs de D et en procédant par encadrements successifs.
C=1000;
n=0;
while C<2000
n=n+1;
C=1.025*C;
end;
afficher(n,"nombre d années :");
Comme on souhaite exécuter le programme un certain
nombre de fois, on peut penser à créer une fonction :
4) On utilise le programme de la question 2) b) en testant
plusieurs valeurs de n, et en procédant par encadrements
successifs.
Comme on souhaite exécuter le programme un certain
nombre de fois, on peut préférer utiliser la fonction
capital de la question 3).
Prolongement : on peut éventuellement écrire un
algorithme avant de le transcrire en langage Scilab :
C=1000;
n=0;
S=input("somme à atteindre = ?");
while C<S
n=n+1;
C=1.025*C;
end;
afficher(n,"nombre d années :");
18 6) On transcrit l'algorithme en langage Scilab :
p=input("précision = ?");
a=-1; b=0;
while b-a>p
m=(a+b)/2;
y=m^4-4*m-1;
if y>0 then a=m;
else b=m;
end;
end;
afficher(a,"la solution est entre");
afficher(b," et");
20 3) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
D=input("durée en min = ?");
if D<=120 then A=19.5; B=22;
else
A=19.5+0.45*(D-120);
B=22+0.37*(D-120);
end;
if D<=180 then C=29;
else C=29+0.37*(D-180);
end;
if A<=B & A<=C then
afficher(A,"forfait A pour le montant :");
end;
if B<=A & B<=C then
afficher(B,"forfait B pour le montant :");
end;
if C<=A & C<=B then
afficher(C,"forfait C pour le montant :");
end;
On a groupé ici les calculs des montants des forfaits A et B
pour raccourcir la taille du programme.
function forfait(D)
if D<=120 then A=19.5; B=22;
else
A=19.5+0.45*(D-120);
B=22+0.37*(D-120);
end;
if D<=180 then C=29;
else C=29+0.37*(D-180);
end;
if A<=B & A<=C then
afficher(A,"forfait A pour le montant :");
end;
if B<=A & B<=C then
afficher(B,"forfait B pour le montant :");
end;
if C<=A & C<=B then
afficher(C,"forfait C pour le montant :");
end;
endfunction;
On peut aussi penser à tracer les courbes représentatives
des fonctions associées aux différents forfaits. Pour cela,
on crée les fonctions forfaitA, forfaitB et
forfaitC, puis on trace leurs courbes représentatives sur
l'intervalle [0 ; 200] :
function A=forfaitA(D)
if D<=120 then A=19.5;
else A=19.5+0.45*(D-120);
end;
endfunction;
function B=forfaitB(D)
if D<=120 then B=22;
else B=22+0.37*(D-120);
end;
endfunction;
function C=forfaitC(D)
if D<=180 then C=29;
else C=29+0.37*(D-180);
end;
endfunction;
x=linspace(0,200,200);
plot(x,forfaitA,"r");//en rouge
plot(x,forfaitB,"b");//en bleu
plot(x,forfaitC,"g");//en vert
On obtient dans la fenêtre graphique :
Corrigés – SCILAB
Page 3
On peut aussi résoudre des inéquations en créant les
vecteurs uA, uB et uC contenant les valeurs des montants
des forfaits A, B et C pour des durées entières inférieures à
200 minutes. Par exemple :
for n=1:200 uA(n)=forfaitA(n); end;
for n=1:200 uB(n)=forfaitB(n); end;
for n=1:200 uC(n)=forfaitC(n); end;
find(uA<=uC)//ne
pas
mettre
de
virgule pour afficher le résultat.
On obtient dans la fenêtre graphique :
point-
On obtient ainsi l'affichage de toutes les durées entières
inférieures à 200 minutes pour lesquelles le forfait A est
plus avantageux que le forfait C.
21 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
n=input("nombre de SMS = ?");
A=20;
B=0.15*n;
C=12+0.05*n;
if A<=B & A<=C then
afficher(A,"forfait A pour le montant :");
end;
if B<=A & B<=C then
afficher(B,"forfait B pour le montant :");
end;
if C<=A & C<=B then
afficher(C,"forfait C pour le montant :");
end;
3) On utilise le programme précédent en testant plusieurs
valeurs de n et en procédant par encadrements successifs.
Comme on souhaite exécuter le programme un certain
nombre de fois, on peut penser à créer une fonction :
function forfait(n)
A=20;
B=0.15*n;
C=12+0.05*n;
if A<=B & A<=C then
afficher(A,"forfait A pour le montant :");
end;
if B<=A & B<=C then
afficher(B,"forfait B pour le montant :");
end;
if C<=A & C<=B then
afficher(C,"forfait C pour le montant :");
end;
endfunction;
On peut aussi penser à tracer les représentations
graphiques des "suites" forfaitA, forfaitB et
forfaitC associées aux différents forfaits, définies par :
forfaitA(n) est le montant du forfait A pour n SMS ;
forfaitB(n) est le montant du forfait B pour n SMS ;
forfaitC(n) est le montant du forfait C pour n SMS.
On trace leurs représentations graphiques sur l'intervalle
[1 ; 200] :
for n=1:200 forfaitA(n)=20; end;
for n=1:200 forfaitB(n)=0.15*n; end;
for n=1:200 forfaitC(n)=12+0.05*n; end;
plot(forfaitA,"r");//en rouge
plot(forfaitB,"b");//en bleu
plot(forfaitC,"g");//en vert
On peut aussi résoudre des inéquations. Par exemple :
find(forfaitB<=forfaitC)//ne pas mettre de
point-virgule pour afficher le résultat.
On obtient alors l'affichage de tous les nombres de SMS
inférieurs à 200 pour lesquels le forfait B est plus
avantageux que le forfait C.
22 2) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
popA=20000; popB=80000; n=0;
while popA<popB
n=n+1; a=popA; b=popB;
popA=a*0.9+b*0.2;
popB=a*0.1+b*0.8;
end;
afficher(n,"le nombre d années nécessaires
est :");
3) On modifie le programme précédent de façon à obtenir
les tailles des populations (popA et popB) des villes A et B
en fonction du nombre d'années écoulées (n). La démarche
peut être résumée par l'algorithme :
Variables :
n,i : entier ;
popA,popB,a,b : réels ;
Début
Entrer(n) ;
popA←20000 ; popB←80000 ;
Pour i allant de 1 à n faire
a←popA ; b←popB ;
popA← a×0,9+b×0,2 ;
popB← a×0,1+b×0,8 ;
FinPour ;
Afficher("la taille de la ville A est ",popA);
Afficher("la taille de la ville B est ",popB);
Fin.
Il se transcrit en langage Scilab par :
n=input("nombre d annes = ?");
popA=20000; popB=80000;
for i=1:n
a=popA; b=popB;
popA=a*0.9+b*0.2;
popB=a*0.1+b*0.8;
end;
afficher(popA,"taille de la ville A :");
afficher(popB,"taille de la ville B :");
Corrigés – SCILAB
On teste plusieurs valeurs pour répondre aux questions.
Comme on souhaite exécuter le programme un certain
nombre de fois, on peut penser à créer une fonction :
function population(n)
popA=20000; popB=80000;
for i=1:n
a=popA; b=popB;
popA=a*0.9+b*0.2;
popB=a*0.1+b*0.8;
end;
afficher(popA,"ville A :");
afficher(popB,"ville B :");
endfunction;
On peut aussi penser à tracer les représentations
graphiques des "suites" villeA et villeB associées aux
tailles des deux villes, définies par :
villeA(n) est la taille de la ville A l'année n-1 ;
villeB(n) est la taille de la ville B l'année n-1.
On trace leurs représentations graphiques sur l'intervalle
[1 ; 40] :
villeA(1)=20000;villeB(1)=80000;
for n=1:40
villeA(n+1)=villeA(n)*0.9+villeB(n)*0.2;
villeB(n+1)=villeA(n)*0.1+villeB(n)*0.8;
end;
plot(villeA,"+r");//+ rouge
plot(villeB,"*b");//* bleu
On obtient dans la fenêtre graphique :
Page 4
Comme on souhaite exécuter le programme un certain
nombre de fois, on peut penser à créer une fonction :
function benefice(M)
if M<800 then C=5000+12*M;
else C=5000+13.2*M;
end;
if M<900 then R=20*M;
else R=20*M-100;
end;
if R>=C then
afficher("l
entreprise
réalise
des
bénéfices");
else afficher("l entreprise ne réalise pas
de bénéfice");
end;
endfunction;
On peut aussi penser à tracer les courbes représentatives
des fonctions associées aux coûts et aux recettes.
Pour cela, on crée les fonctions couts et recettes,
puis on trace leurs courbes représentatives sur l'intervalle
[0 ; 1000] :
function C=couts(M)
if M<800 then C=5000+12*M;
else C=5000+13.2*M;
end;
endfunction;
function R=recettes(M)
if M<900 then R=20*M;
else R=20*M-100;
end;
endfunction;
x=linspace(0,1000,1000);
plot(x,couts,"r");//en rouge
plot(x,recettes,"g");//en vert
On obtient dans la fenêtre graphique :
23 3) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
M=input("masse en kg = ?");
if M<800 then C=5000+12*M;
else C=5000+13.2*M;
end;
if M<900 then R=20*M;
else R=20*M-100;
end;
if R>=C then
afficher("l
entreprise
réalise
des
bénéfices");
else afficher("l entreprise ne réalise pas de
bénéfice");
end;
On teste plusieurs valeurs de M et on procède par
encadrements successifs pour résoudre le problème.
Corrigés – SCILAB
Géométrie
Page 5
30 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
c=(xB-xA)^2+(yB-yA)^2;
b=(xC-xA)^2+(yC-yA)^2;
a=(xC-xB)^2+(yC-yB)^2;
if a==b & a==c then
afficher("ABC triangle équilatéral");
afficher(3*sqrt(a),"de périmètre :");
afficher(a*sqrt(3)/4,"d aire :");
else afficher("ABC non équilatéral");
end;
26 3) c) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
a=10;
n=input("n = ?");
for i=1:n
a=sqrt((a-2)^2+4);
end;
afficher(a^2,"l aire est :");
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function A=aire(n)
a=10;
for i=1:n
a=sqrt((a-2)^2+4);
end;
A=a^2;
endfunction;
Il suffit de charger cette fonction dans la Console, puis de
l'appeler par l'instruction aire(5) par exemple (sans
point-virgule pour afficher le résultat).
Pour l'appeler plusieurs fois, dans la Console on utilise la
flèche du clavier ↑ pour remonter dans l'historique, et on
modifie l'argument de la fonction.
4) On utilise le programme de la question précédente et on
teste à l'aide de quelques valeurs.
(attention aux arrondis qui peuvent éventuellement induire
en erreur les résultats).
31 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
xD=input("xD = ?"); yD=input("yD = ?");
xI=(xA+xC)/2; yI=(yA+yC)/2;
xJ=(xB+xD)/2; yJ=(yB+yD)/2;
if xI==xJ & yI==yJ then
afficher("ABCD parallélogramme");
else afficher("ABCD non parallélogramme");
end;
ou
28 5) On peut éventuellement écrire un algorithme pour
résumer la démarche du calcul de l'aire noircie totale à
chaque étape avant de le transcrire en langage Scilab :
n=input("n = ?");
N=1; a=8; A=16*sqrt(3);
for i=2:n
N=3*N;
a=a/2;
A=A+N*a^2*sqrt(3)/4;
end;
afficher(A,"l aire noircie totale vaut :");
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function A=aire(n)
N=1; a=8; A=16*sqrt(3);
for i=2:n
N=3*N;
a=a/2;
A=A+N*a^2*sqrt(3)/4;
end;
endfunction;
On peut ensuite éventuellement introduire une boucle Tant
que :
n=1; N=1; a=8; A=16*sqrt(3);
while A<0.9*64*sqrt(3)
n=n+1; N=3*N; a=a/2;
A=A+N*a^2*sqrt(3)/4;
end;
afficher(n,"le nombre d étapes est :");
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
xD=input("xD = ?"); yD=input("yD = ?");
a=(xB-xA)^2+(yB-yA)^2;
b=(xC-xB)^2+(yC-yB)^2;
c=(xD-xC)^2+(yD-yC)^2;
d=(xD-xA)^2+(yD-yA)^2;
if a==c & b==d then
afficher("ABCD parallélogramme");
else afficher("ABCD non parallélogramme");
end;
32 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
xD=input("xD = ?"); yD=input("yD = ?");
a=(xB-xA)^2+(yB-yA)^2;
b=(xC-xB)^2+(yC-yB)^2;
c=(xD-xC)^2+(yD-yC)^2;
d=(xD-xA)^2+(yD-yA)^2;
e=(xC-xA)^2+(yC-yA)^2;
if a==c & b==d & a==b & e==a+b then
afficher("ABCD est un carré");
afficher(4*sqrt(a),"de périmètre :");
afficher(a,"et d aire :");
else afficher("ABCD n est pas un carré");
end;
Corrigés – SCILAB
Page 6
33 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
37 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
xD=input("xD = ?"); yD=input("yD = ?");
a=(xB-xA)^2+(yB-yA)^2;
b=(xC-xB)^2+(yC-yB)^2;
c=(xD-xC)^2+(yD-yC)^2;
d=(xD-xA)^2+(yD-yA)^2;
e=(xC-xA)^2+(yC-yA)^2;
if a==c & b==d & a==b then
afficher("ABCD est un losange");
else afficher("ABCD n est pas un losange");
end;
if a==c & b==d & e==a+b then
afficher("ABCD est un rectangle");
else afficher("ABCD n est pas un rectangle");
end;
if a==c & b==d & a==b & e==a+b then
afficher("ABCD est un carré");
else afficher("ABCD n est pas un carré");
end;
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
if xA==xB & xA==xC then
afficher("les points sont alignés.");
else
if xA<>xB & xA<>xC then
if (xC-xA)*(yB-yA)==(xB-xA)*(yC-yA) then
afficher("les points sont alignés.");
else afficher("les points ne sont pas
alignés.");
end;
else afficher("les points ne sont pas
alignés");
end;
end;
35 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
if xA==xB then
afficher(xA,"l équation est x = ");
else
m=(yB-yA)/(xB-xA);
p=yA-m*xA;
afficher("l équation est y = mx + p");
afficher(m,"où m vaut :");
afficher(p,"et p vaut :");
end;
36 3) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
a=input("a = ?"); b=input("b = ?");
c=input("c = ?"); d=input("d = ?");
if a==c then
if b==d then
afficher("les droites sont confondues");
else afficher("les droites sont strictement
parallèles");
end;
else
x0=(d-b)/(a-c);
y0=a*x0+b;
afficher("les droites sont sécantes au point
de coordonnées (x0;y0)");
afficher(x0,"où x0 vaut");
afficher(y0,"et y0 vaut");
end;
38 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
a=input("a = ?"); b=input("b = ?");
c=input("c = ?"); d=input("d = ?");
e=input("e = ?"); f=input("f = ?");
if a*e-b*d<>0 then
afficher("le
système
admet
un
couple
solution unique (x;y)");
afficher((c*e-b*f)/(a*e-b*d),"où x vaut :");
afficher((a*f-d*c)/(a*e-b*d),"et y vaut :");
else
afficher("le système n admet pas de solution
unique");
end;
Complément : Scilab sait résoudre des systèmes linéaires.
Par exemple pour la question 3a) :
A=[2,3;3,-1];
B=[7;5];
A\B //A\ signifie multiplication à gauche
par A^(-1) (sans point-virgule à la fin de
la ligne pour afficher le résultat)
40 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xu=input("xu = ?"); yu=input("yu = ?");
xv=input("xv = ?"); yv=input("yv = ?");
if xu*yv==xv*yu then
afficher("les vecteurs sont colinéaires");
afficher("on a v = k*u avec k égal à :");
if xu<>0 then disp(xv/xu);
else afficher(yv/yu);
end;
else afficher("les vecteurs ne sont pas
colinéaires");
end;
Corrigés – SCILAB
Page 7
41 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de la transcrire en langage
Scilab :
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
xD=input("xD = ?"); yD=input("yD = ?");
if (xB-xA)*(yD-yC)==(xD-xC)*(yB-yA) then
afficher("(AB) et (CD) sont parallèles");
else afficher("(AB) et (CD) ne sont pas
parallèles");
end;
42 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
xD=input("xD = ?"); yD=input("yD = ?");
if xB-xA==xC-xD & yB-yA==yC-yD then
afficher("ABCD parallélogramme");
else afficher("ABCD non parallélogramme");
end;
43 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xA=input("xA = ?"); yA=input("yA = ?");
xB=input("xB = ?"); yB=input("yB = ?");
xC=input("xC = ?"); yC=input("yC = ?");
if (xB-xA)*(yC-yA)==(xC-xA)*(yB-yA) then
afficher("les points sont alignés");
else
afficher("les
points
ne
sont
alignés");
end;
pas
Statistiques et probabilités
Avertissement
Scilab dispose de fonctions adaptées à la simulation, entre
autres :
• rand() retourne de façon aléatoire un nombre décimal
dans l'intervalle [0 ; 1[ ;
• tirage_entiers(N,a,b) retourne un vecteur de taille N
(entier), contenant les résultats de N tirages aléatoires
d'entiers entre a et b inclus (où a et b sont des entiers
où a ≤ b) ;
• tirage_réels(N,a,b) retourne un vecteur de taille N
(entier), contenant les résultats de N tirages aléatoires
de réels entre a et b (où a et b sont des réels où a ≤ b) ;
• frequence(i,S) retourne la fréquence de l'entier i dans
le vecteur S ;
• frequence_tirage_entier(N,a,b) retourne la suite des
fréquences d'apparition des entiers entre a et b inclus
(où a et b sont entiers où a ≤ b) lors de N tirages
aléatoires (N entier) d'entiers entre a et b inclus ;
• bar(V) affiche le diagramme en bâton du vecteur V :
en abscisse les entiers i, en ordonnée les valeurs V(i).
44 A) 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
note1=input("note 1 = ?");
note2=input("note 2 = ?");
m=(2*note1+3*note2)/5;
afficher(m,"la moyenne est :");
3) On veut exécuter le programme précédent un certain
nombre de fois, ce qui est lourd en manipulations entre la
Console et l'Editeur. On peut alors penser à créer une
fonction :
function moyenne_Kathy(note1,note2)
m=(2*note1+3*note2)/5;
afficher(m,"la moyenne est :");
endfunction;
Il suffit de charger cette fonction dans la Console, puis de
l'appeler par l'instruction moyenne_Kathy(10,11) par
exemple (sans point-virgule pour afficher le résultat). Pour
l'appeler plusieurs fois, dans la Console on utilise la
flèche du clavier ↑ pour remonter dans l'historique, et on
modifie l'argument de la fonction.
On teste quelques valeurs pour répondre aux questions.
B) 1) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
coeff1=input("coeff1 = ?");
coeff2=input("coeff2 = ?");
m=(coeff1*8+coeff2*13)/(coeff1+coeff2);
afficher(m,"la moyenne est :");
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function moyenne_Kathy_2(coeff1,coeff2)
m=(coeff1*8+coeff2*13)/(coeff1+coeff2);
afficher(m,"la moyenne est :");
endfunction;
On teste quelques valeurs en appelant dans la Console
moyenne_Kathy_2(2,3) par exemple (sans pointvirgule pour afficher le résultat).
Corrigés – SCILAB
46 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("Nombre de lancers = ?"); P=0;
for i=1:N x=rand();
if x<0.5 then P=P+1; end;
end;
afficher(P/N,"la fréquence de Pile est :");
Comme on souhaite exécuter ce programme plusieurs fois,
on peut penser à créer une fonction :
function f=lancers_piece(N)
P=0;
for i=1:N x=rand();
if x<0.5 then P=P+1; end;
end;
f=P/N;
endfunction;
Il suffit de charger cette fonction dans la Console, puis de
l'appeler par l'instruction lancer_pieces(100) par
exemple (sans point-virgule pour afficher le résultat). Pour
l'appeler plusieurs fois, dans la Console on utilise la
flèche du clavier ↑ pour remonter dans l'historique, et on
modifie l'argument de la fonction.
La simulation de N lancers d'une pièce et l'obtention de la
fréquence d'apparition de Pile peuvent aussi se faire en
utilisant les fonctionnalités de Scilab :
N=input("Nombre de lancers = ?");
S=tirage_reel(N,0,1);
P=taille(find(S<0.5))
afficher(P/N,"la fréquence de Pile est :");
On peut aussi simuler le lancer d'une pièce par un tirage
aléatoire d'un entier entre 0 et 1 (1 pour Pile, 0 pour Face) :
N=input("Nombre de lancers = ?");
S=tirage_entier(N,0,1);
P=frequence(1,S);
afficher(P,"la fréquence de Pile est :");
ou encore :
Page 8
47 2) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("Nombre de lancers du dé = ?");
for k=1:6 E(k)=0; end;
for i=1:N
k=tirage_entier(1,1,6);
E(k)=E(k)+1;
end;
afficher("les fréquences sont :");
for k=1:6 afficher([k,E(k)/N]); end;
On choisit ici de mettre les effectifs dans le vecteur E :
pour k de 1 à 6, E(k) contient l'effectif du numéro k.
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function lancers_des(N)
for k=1:6 E(k)=0; end;
for i=1:N
k=tirage_entier(1,1,6);
E(k)=E(k)+1;
end;
afficher("les fréquences sont :");
for k=1:6 afficher([k,E(k)/N]); end;
endfunction;
Il suffit de charger cette fonction dans la Console, puis de
l'appeler par l'instruction lancers_des(100) par
exemple (sans point-virgule pour afficher le résultat). Pour
l'appeler plusieurs fois, dans la Console on utilise la
flèche du clavier ↑ pour remonter dans l'historique, et on
modifie l'argument de la fonction.
La simulation de N lancers d'un dé et l'obtention des
fréquences d'apparition des numéros peuvent aussi se faire
en utilisant les fonctionnalités de Scilab :
N=input("Nombre de lancers = ?");
S=tirage_entier(N,1,6);
for i=1:6
f=frequence(i,S);
afficher([i,f]);
end;
N=input("Nombre de lancers = ?");
P=sum(tirage_entier(N,0,1));
afficher(P/N,"la fréquence de Pile est :");
ou encore :
On peut faire constater la fluctuation d'échantillonnage et
la stabilisation de la fréquence de Pile lorsque le nombre
de lancers devient assez grand en traçant la représentation
graphique de la fonction lancers_piece sur
l'intervalle [1 ; 5000]. Ainsi :
ou encore en créant le vecteur fréquence F, pour permettre
d'afficher numéro et fréquence sur la même ligne :
for i=1:5000 Pile(i)=lancers_piece(i); end;
plot(Pile,"+");
On obtient
dans la
fenêtre
graphique :
N=input("Nombre de lancers = ?");
frequence_tirage_entier(N,1,6)
N=input("Nombre de lancers = ?");
F=[frequence_tirage_entier(N,1,6)];
for i=1:6 afficher([i,F(i)]); end;
Pour constater la stabilisation des fréquences, on peut aussi
demander de tracer le diagramme en bâton des fréquences
obtenues :
N=input("Nombre de lancers = ?");
bar(frequence_tirage_entier(N,1,6));
On obtient par
exemple pour 1000
lancers dans la
fenêtre graphique :
Corrigés – SCILAB
Page 9
48 2) a) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
R=0;
for i=1:100
x=rand();
if x<0.6 then R=R+1; end;
end;
afficher(R/100,"la fréquence
des boules rouges est");
d
apparition
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function f=echantillon_boules()
R=0;
for i=1:100
x=rand();
if x<0.6 then R=R+1; end;
end;
f=R/100;
endfunction;
F=frequence_echantillon(1000);
N=taille(find(F>=0.5 & F<=0.7));
afficher(N,"le nombre de fréquences dans l
intervalle est");
d
apparition
d
apparition
ou encore :
S=tirage_entier(100,1,100);
R=taille(find(S<=60));
afficher(R/100,"la fréquence
des boules rouge est");
3) a) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
n=input("n = ?");
for k=1:n
R=0;
for i=1:100
x=rand();
if x<0.6 then R=R+1; end;
end;
F(k)=R/100;
end;
afficher(F,"la liste des fréquences
boules rouges est:");
des
On a choisi ici de placer les fréquences successives dans le
vecteur F.
Comme on souhaite exécuter plusieurs fois ce programme,
on peut penser à créer une fonction (on a utilisé ici les
fonctionnalités de Scilab) :
function F=frequence_echantillon(n)
for k=1:n
S=tirage_reel(100,0,1);
R=taille(find(S<0.6));
F(k)=R/100;
end;
endfunction;
n=input("n = ?");
N=0;
for k=1:n
R=0;
for i=1:100
x=rand();
if x<0.6 then R=R+1; end;
end;
if R>=50 & R<=70 then N=N+1; end;
end;
afficher(N,"le nombre de fréquences dans l
intervalle est");
ou encore pour 1000 échantillons :
La simulation de 100 tirages dans l'urne et l'obtention de la
fréquence d'apparition des boules rouges peuvent aussi se
faire en utilisant les fonctionnalités de Scilab :
S=tirage_reel(100,0,1);
R=taille(find(S<0.6));
afficher(R/100,"la fréquence
des boules rouge est");
Pour obtenir le nombre de fréquences appartenant à
l'intervalle de fluctuation :
Il peut être aussi intéressant, par exemple pour 2000
échantillons, de représenter graphiquement la fréquence
d'apparition des boules rouges de chaque échantillon, et de
placer les droites d'équation y = 0,5 et y = 0,7 pour
représenter l'intervalle de fluctuation. Pour cela :
function y=inf_intervalle(x)
y=0.5;
endfunction;
function y=sup_intervalle(x)
y=0.7;
endfunction;
x=linspace(0,2000,2000);
plot(x,inf_intervalle,"r");
plot(x,sup_intervalle,"r");
F=frequence_echantillon(2000);
plot(F,"+");
On obtient dans la fenêtre graphique :
Corrigés – SCILAB
49 1) c) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("N = ?");
for k=1:8 E(k)=0; end;// sécurité E(1)=0
for i=1:N
a=tirage_entier(1,1,4);
b=tirage_entier(1,1,4);
E(a+b)=E(a+b)+1;
end;
for k=2:8 afficher([k,E(k)/N]); end;
On choisit ici de mettre les effectifs dans le vecteur E :
pour k de 2 à 8, E(k) contient l'effectif de la somme k.
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
Page 10
b) On peut créer une fonction donnant le gain de Maxime
en fonction du nombre de parties :
function G=gain_Maxime(N)
G=0;
for i=1:N
S=sum(tirage_entier(2,1,4));
if S==5 then G=G-9; end;
if S==6 then G=G+10; end;
end;
endfunction;
Pour créer 2000 échantillons de taille 100 et représenter
graphiquement le gain de Maxime sur ces 100 parties :
for i=1:2000 M(i)=gain_Maxime(100); end;
plot(M,"+");
On obtient dans la fenêtre graphique :
function F=frequence_somme(N)
for k=1:8 E(k)=0; end;
for i=1:N
a=tirage_entier(1,1,4);
b=tirage_entier(1,1,4);
E(a+b)=E(a+b)+1;
end;
F=E/N;
endfunction;
Complément : en utilisant les fonctionnalités de Scilab, la
somme obtenue lors du lancer de deux dés tétraédriques
peut être obtenue par :
sum(tirage_entier(2,1,4));
2) On peut tester le programme précédent et observer la
distribution des fréquences de la somme possible.
On peut aussi représenter graphiquement cette distribution,
par exemple sur une simulation de 2000 lancers :
F=frequence_somme(2000);
bar(F);
On obtient dans la fenêtre graphique :
50 1) c) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("Nombre de parties = ?");
G=0;
for k=1:N
P=1;
for i=1:6
a=tirage_entier(1,1,6);
P=P*(a-6);
end;
if P==0 then G=G+1; end;
end;
afficher(G/N,"la fréquence de gain est");
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction.
En utilisant les fonctionnalités de Scilab :
3) a) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("Nombre de parties = ?");
J=0; M=0;
for i=1:N
S=sum(tirage_entier(2,1,4));
if S==5 then J=J+9; M=M-9; end;
if S==6 then J=J-10; M=M+10; end;
end;
afficher(J,"le gain de Julie est:");
afficher(M,"le gain de Maxime est:");
function f=frequence_gain(N)
G=0;
for k=1:N
P=prod(tirage_entier(6,1,6)-6);
if P==0 then G=G+1; end;
end;
f=G/N;
endfunction;
Pour tracer la représentation graphique de la fréquence de
gain observée en fonction du nombre de parties sur
l'intervalle [1 ; 2000] :
for i=1:2000
Gain(i)=frequence_gain(i);
end;
plot(Gain,"+");
Corrigés – SCILAB
On obtient dans la fenêtre graphique :
51 1) c) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("Nombre de lâchers = ?");
for i=1:4 numero(i)=0; end;
for k=1:N
a=tirage_entier(1,0,1);
b=tirage_entier(1,0,1);
c=tirage_entier(1,0,1);
numero(a+b+c+1)=numero(a+b+c+1)+1;
end;
afficher("les fréquences sont :");
for i=1:4
afficher([i-1,numero(i)/N]);
end;
Ici les effectifs de chaque numéro sont stockés dans le
vecteur numero.
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction.
En utilisant les fonctionnalités de Scilab :
function F=frequence_numero(N)
for i=1:4 numero(i)=0; end;
for k=1:N
i=sum(tirage_entier(3,0,1));
numero(i+1)=numero(i+1)+1;
end;
F=numero/N;
endfunction;
Page 11
52 3) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("nombre d expériences = ?");
for i=1:5 eff(i)=0; end;
for k=1:N
x=0;
for i=1:4
a=tirage_entier(1,0,1);
if a==1 then x=x+1; else x=x-1; end;
end;
if x==-4 then eff(1)=eff(1)+1; end;
if x==-2 then eff(2)=eff(2)+1; end;
if x==0 then eff(3)=eff(3)+1; end;
if x==2 then eff(4)=eff(4)+1; end;
if x==4 then eff(5)=eff(5)+1; end;
end;
afficher("les fréquences sont :");
for i=1:5 afficher([2*i-6,eff(i)/N]); end;
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut alors penser à créer une fonction :
function frequence_robot(N)
for i=1:5 eff(i)=0; end;
for k=1:N
x=0;
for i=1:4
a=tirage_entier(1,0,1);
if a==1 then x=x+1; else x=x-1; end;
end;
if x==-4 then eff(1)=eff(1)+1; end;
if x==-2 then eff(2)=eff(2)+1; end;
if x==0 then eff(3)=eff(3)+1; end;
if x==2 then eff(4)=eff(4)+1; end;
if x==4 then eff(5)=eff(5)+1; end;
end;
afficher("les fréquences sont :");
for i=1:5 afficher([2*i-6,eff(i)/N]); end;
endfunction;
Complément : on peut de façon "astucieuse" et en utilisant
les fonctionnalités de Scilab simuler l'expérience plus
rapidement :
- pour l'abscisse x après quatre pas :
x=2*sum(tirage_entier(4,0,1))-4;
- pour l'incrémentation du compteur dans le vecteur eff
en fonction de x :
i=(x+4)/2+1;
eff(i)=eff(i)+1;
- la fonction frequence_robot peut ainsi être définie :
function frequence_robot(N)
for i=1:5 eff(i)=0; end;
for k=1:N
x=2*sum(tirage_entier(4,0,1))-4;
i=(x+4)/2+1;
eff(i)=eff(i)+1;
end;
afficher("les fréquences sont :");
for i=1:5 afficher([2*i-6,eff(i)/N]); end;
endfunction;
Corrigés – SCILAB
53 2) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("nombre de parties = ?");
N1=0; N2=0; N3=0;
for i=1:N
a=tirage_entier(1,1,4);
if a==1 then N2=N2+1;
else b=tirage_entier(1,1,3);
if b==1 then N3=N3+1;
else N1=N1+1;
end;
end;
end;
afficher(N1/N,"la fréquence du gain 2€ est");
afficher(N2/N,"la fréquence du gain 1€ est");
afficher(N3/N,"la fréquence du gain -2€ est");
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function jeu(N)
N1=0; N2=0; N3=0;
for i=1:N
a=tirage_entier(1,1,4);
if a==1 then N2=N2+1;
else b=tirage_entier(1,1,3);
if b==1 then N3=N3+1;
else N1=N1+1;
end;
end;
end;
afficher(N1/N,"la fréquence du gain 2€ est");
afficher(N2/N,"la fréquence du gain 1€ est");
afficher(N3/N,"la fréquence du gain -2€ est");
endfunction;
54 1) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
xA=rand(); xB=rand()
if max(xA,xB)-min(xA,xB)>0.5 then
afficher("D est réalisé");
else afficher("D n est pas réalisé");
end;
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function distanceAB()
xA=rand(); xB=rand();
if max(xA,xB)-min(xA-xB)>0.5 then
afficher("D est réalisé");
else afficher("D n est pas réalisé");
end;
endfunction;
2) a) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("nombre d expériences = ?");
n=0;
for k=1:N
xA=rand(); xB=rand();
if max(xA,xB)-min(xA,xB)>0.5 then
n=n+1;
end;
end;
afficher(n/N,"la fréquence de D est ");
Page 12
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function f=NdistanceAB(N)
n=0;
for k=1:N
xA=rand(); xB=rand();
if max(xA,xB)-min(xA,xB)>0.5 then
n=n+1;
end;
end;
f=n/N;
endfunction;
Pour tracer la représentation graphique de la fréquence
d'apparition de D en fonction du nombre de simulations
sur l'intervalle [1 ; 5000] :
for i=1:5000 D(i)=NdistanceAB(i); end;
plot(D,"+");
On obtient dans la fenêtre graphique :
55 3) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("nombre de rendez-vous = ?");
n=0;
for i=1:N
xR=tirage_reel(1,0,60);
xJ=tirage_reel(1,0,60);
if max(xR,xJ)-min(xR,xJ)<=10 then
n=n+1;
end;
end;
afficher(n/N,"la fréquence de rencontres
est");
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function f=rencontre(N)
n=0;
for i=1:N
xR=tirage_reel(1,0,60);
xJ=tirage_reel(1,0,60);
if max(xR,xJ)-min(xR,xJ)<=10 then
n=n+1;
end;
end;
f=n/N;
endfunction;
Pour tracer la représentation graphique de la fréquence de
rencontres en fonction du nombre de simulations sur
l'intervalle [1 ; 2000] :
for i=1:2000 r(i)=rencontre(i); end;
plot(r,"+");
Corrigés – SCILAB
On obtient dans la fenêtre graphique :
Page 13
57 2) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("nombre de tirs = ?");
n=0;
for i=1:N
x=tirage_reel(1,0,1);
y=tirage_reel(1,0,1);
if x^2+y^2<=1 & (1-x)^2+(1-y)^2<=1 then
n=n+1;
end;
end;
afficher(n/N,"la fréquence d atteinte de la
partie colorée est");
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
56 2) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("nombre de tirs = ?");
n=0;
for i=1:N
x=tirage_reel(1,0,1);
y=tirage_reel(1,0,1);
if x^2+y^2<=1 then n=n+1; end;
end;
afficher(n/N,"la fréquence d atteinte de la
partie colorée est");
Comme on souhaite exécuter un certain nombre de fois ce
programme, on peut penser à créer une fonction :
function f=tir(N)
n=0;
for i=1:N
x=tirage_reel(1,0,1);
y=tirage_reel(1,0,1);
if x^2+y^2<=1 then n=n+1; end;
end;
f=n/N;
endfunction;
Pour tracer la représentation graphique de la fréquence
d'atteinte de la partie colorée en fonction du nombre de
simulations sur l'intervalle [1 ; 1000] :
for i=1:1000 t(i)=tir(i); end;
plot(t,"+");
On obtient dans la fenêtre graphique :
function f=tir(N)
n=0;
for i=1:N
x=tirage_reel(1,0,1);
y=tirage_reel(1,0,1);
if x^2+y^2<=1 & (1-x)^2+(1-y)^2<=1
n=n+1;
end;
end;
f=n/N;
endfunction;
then
Pour tracer la représentation graphique de la fréquence
d'atteinte de la partie colorée en fonction du nombre de
simulations sur l'intervalle [1 ; 1000] :
for i=1:1000 t(i)=tir(i); end;
plot(t,"+");
On obtient dans la fenêtre graphique :
Corrigés – SCILAB
58 2) b) On peut éventuellement écrire un algorithme pour
résumer la démarche avant de le transcrire en langage
Scilab :
N=input("nombre de tirs = ?");
n=0;
for i=1:N
x=tirage_reel(1,0,1);
y=tirage_reel(1,0,1);
if y<=x^2 then n=n+1; end;
end;
afficher(n/N,"la fréquence est");
Comme on souhaite exécuter ce programme un certain
nombre de fois, on peut penser à créer une fonction :
function f=tir(N)
n=0;
for i=1:N
x=tirage_reel(1,0,1);
y=tirage_reel(1,0,1);
if y<=x^2 then n=n+1; end;
end;
f=n/N;
endfunction;
Pour tracer la représentation graphique de la fréquence
d'atteinte de la partie colorée en fonction du nombre de
simulations sur l'intervalle [1 ; 1000] :
for i=1:1000 t(i)=tir(i); end;
plot(t,"+");
On obtient dans la fenêtre graphique :
Page 14