corriges scilab - Hachette Education

Corrigés – SCILAB Page 1
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 :
function S=capital(n)
S=100;
for i=1:n S=S+100+2*i;
end;
endfunction;
Pour cela, on charge cette fonction dans la Console, et on
l'appelle par l'instruction capital(12) (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 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 :");
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 C=capital(n)
C=1000;
for i=1:n C=1.0125*C; end;
endfunction;

Corrigés – SCILAB Page 2
Prolongement : on peut éventuellement écrire un
algorithme avant de le transcrire en langage Scilab :
C=1000;
n=0;
while C<2000
n=n+1;
C=1.025*C;
end;
afficher(n,"nombre d années :");
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.
4) On utilise le programme précédent en testant plusieurs
valeurs de D 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(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 point-
virgule pour afficher le résultat.
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 obtient dans la fenêtre graphique :
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 Page 4
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 :
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.
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 :

Corrigés – SCILAB Page 5
Géométrie
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.
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 :");
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;
(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
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;