Guide de survie Scilab pour les épreuves de maths ECT Guide de survie Scilab pour les épreuves de maths ECT
On ne va pas se mentir, Scilab, tout le monde s’en fout. Personne n’y comprend rien dans la classe et beaucoup se rassurent en... Guide de survie Scilab pour les épreuves de maths ECT

On ne va pas se mentir, Scilab, tout le monde s’en fout. Personne n’y comprend rien dans la classe et beaucoup se rassurent en se disant qu’au final, les questions sur Scilab ne sont pas si importantes et que répondre aux questions classiques, c’est déjà très bien. Et pourtant, ces questions sont loin d’être difficiles et sont, au contraire, pensées de manière à permettre aux candidats les plus faibles de gratter quelques points : « Les questions d’informatique ont été abordées par presque tous les candidats. Elles étaient assez faciles et ont souvent permis à des candidats faibles de rapporter quelques points » (rapport ESC 2016). De plus, elles représentent environ 12% de la note finale dans les sujets ESCP, ce qui n’est pas si négligeable que cela, surtout pour ceux qui auraient du mal avec les questions calculatoires classiques. A quelques jours des concours, voici donc les grands indispensables à maîtriser en ECT, à chaque fois illustrer par un exemple, pour s’en sortir plus que correctement sur n’importe quelle question d’informatique et gratter des points précieux.

 

Les règles d’écriture de base

Dans les sujets ESCP et ECRICOME, la première question est assez souvent « donnée » dans la mesure où elle nécessite presque aucune connaissance en Scilab. La simple compréhension de l’énoncé suffit à bien réponde à la question. Cependant, il existe quelques pièges dans la façon d’écrire une ligne de code Scilab dans lesquels il ne faut pas tomber pour ne pas perdre des points qui vous tendaient les bras stupidement. Les quelques subtilités sont les suivantes :

  • Pour écrire e*a ou pi*a (a étant un réel quelconque), on écrit 3*%a et pi*%a. Il ne faut pas oublier le % sinon cela ne marche pas.
  • Pour écrire Ln(a), on écrit log(a). Il faut bien faire attention à écrire Log et non pas ln car ce dernier n’existe pas sur scilab.
  • Pour écrire e^a, on écrit exp(a). Là il n’y a pas de piège, il suffit juste de savoir comment écrire l’exponentielle sur Scilab.
  • Pour écrire racine de a, on écrit sqrt(a). Là non plus aucun piège.
  • Une fraction s’écrit toujours sous la forme a/b
  • Enfin la valeur absolue de a s’écrit abs(a).

Ce sont de petites règles absolument pas difficiles à retenir mais dont il faut se souvenir le jour j car, puisque la première question informatique ne demande que de comprendre l’énoncé en général, les moindres détails concernant les écritures informatiques vous coûteront sûrement tous les points.

Prenons par exemple l’exercice 2 de l’épreuve ESCP 2016. L’énoncé nous donne une suite définie par u0 = 1 et un+1 = ln(1+un²), et nous demande de compléter le programme suivant pour afficher u à une certaine valeur de n:

n = input(‘entrer la valeur de n’)

u = …

for k = 1 : n

u = …

end

disp(u)

Comme prévu, la question n’est pas difficile et lisant simplement l’énoncé, on comprend qu’il faut écrire u0 à la deuxième ligne et un+1 à la quatrième. Cependant, là où vous êtes réellement attendu au tournant, c’est sur la manière dont vous allez écrire un+1. En reprenant les subtilités listées ci-dessus, il ne faut alors pas tomber dans le piège d’écrire u = ln(1+u^2) mais bien u = log(1+u^2). Ainsi, pour les premières questions informatiques souvent très simples qui demandent simplement de bien comprendre l’énoncé, il faut toujours bien faire attention à respecter les règles d’écriture propre à Scilab.

 

Les matrices

Dans les sujets ESC, le premier exercice dédié aux matrices fait souvent l’objet de quelques questions informatiques (mais rien n’empêche que les sujets ESCP et ECRICOME décident d’inclure désormais des questions d’informatiques dans cet exercice également). Très peu de choses sont à savoir mais elles doivent être maîtrisées. On retiendra notamment trois fonctions : zeros(a,b), ones(a,b) et eye(a,b).

  • X = zeros(2,2) donne une matrice 2*2 pleine de zéros
  • X = ones(2,2) donne une matrice 2*2 pleine de 1
  • X = eye(2,2) donne la matrice identité I de taille 2*2

Vous n’aurez normalement pas à les utiliser mais on retrouve souvent ces trois fonctions dans les programmes donc il est nécessaire de comprendre à quoi elles correspondent pour comprendre les programmes.

En revanche, ce que l’on vous demandera certainement, car cela a toujours été la première question d’informatique des sujets ESC, c’est de savoir écrire une matrice en langage Scilab. Pour cela, il suffit de connaître les règles suivantes :

  • On utilise des […] et non pas des parenthèses pour ouvrir et fermer une matrice.
  • Pour séparer les chiffres d’une même ligne, on utilise une virgule entre chaque chiffre
  • Pour passer à la ligne, on utilise un ;

Ainsi, dans l’exo 1 du sujet ESC 2016 (cliquez sur le lien pour avoir le sujet et voir à quoi ressemble vraiment la matrice sous forme de tableau), on nous demande d’écrire la matrice A dans ce programme :

A = …

U = [0 ;1 ;2]

For i = 1 :10

U=A*U

End

Disp(…)

On écrit alors A = [4, -6, 2 ; 2, -4, 2 ; -2, 2, 0] sur la première ligne.

Sur les trois épreuves, il y aura forcément un moment où l’on vous demandera d’écrire une matrice en langage Scilab donc c’est une notion à maîtriser absolument.

 

Les programmes classiques

Après vous avoir demandé une première fois de compléter un programme (de manière assez simple comme on l’a vu), la prochaine question d’informatique vous confrontera alors à un nouveau programme (parfois le même qu’auparavant mais avec des éléments supplémentaires lorsque c’est dans un seul et même exercice) qu’il faudra soit comprendre et expliquer ce qu’il fait, soit compléter. Ces questions abordent trois types de programme en ECT sur lesquels nous allons nous attarder.

Les premiers programmes sont du type « if … then … else … end ». Les mots utilisés sont très intuitifs pour comprendre le programme. Il s’agit en fait d’exprimer une alternative : si ce qui est inscrit après « if » se réalise, alors cela entraîne ce qui se trouve après le « then ». Mais si ce n’est pas le cas, alors c’est la commande qui est inscrit après le « else » qui se réalise. Prenons une question du sujet ECRICOME 2017 (exo 3 partie 2) pour illustrer. La question consiste à écrire en langage Scilab la fonction de répartition d’une variable aléatoire suivante : F(x) = 0 si x < 1, sinon F(x) = 1 – (1/x²) – (2ln(x)/x²)

On nous demande alors de compléter le programme suivant :

Function calcul = F(x)

If x < 1 then

….

Else

….

endfunction

Dès lors, pour pouvoir écrire F(x), il suffit de dire que si x < 1, alors on obtient 0 (on l’écrit en dessous du « then », mais que si x >= 0, alors on utilise l’autre équation (on l’écrit en dessous du « else »). Cela donne alors :

Function calcul = F(x)

If x < 1 then

Calcul = 0

Else

Calcul = 1 – 1/(x^2)-2*log(x)/(x^2)

End

endfunction

Le deuxième type de programme est caractérisé par l’utilisation de la fonction « while ». Encore une fois simplement traduire le nom du programme permet de le comprendre facilement. Cela consiste tout simplement à répéter une instruction tant que la proposition est vraie. Pour revenir sur l’exo 2 du sujet ESCP 2016, on nous pose ensuite la question suivante :

n = 0

u = 1

while u>= 0.0001

u = log(1+u^2)

n = n+1

end

disp(n)

Le résultat affiché est 6. Quelle est la signification de ce résultat ?

On rappelle qu’un+1 = ln(1+un²). Pour comprendre la signification de ce résultat, il suffit en fait de traduire en français la troisième et la quatrième ligne, ce qui donne : « tant que u est supérieur ou égal à 0.0001, alors on passe au rang n+1 de la suite un. Si le résultat affiché est 6, cela veut donc dire que u6 est la première valeur de u inférieur à 0.0001.

 

Enfin, les derniers types de programme utilisent une « boucle for ». C’est le type de programme le plus récurrent et le plus utilisé lorsqu’on utilise des suites car cela permet d’afficher les n valeurs d’une suite. Ce type de programme se trouve généralement dans la première question d’informatique. Dès lors, il suffit bien souvent de simplement de compléter en écrivant la relation de récurrence entre un+1 et un donnée par l’énoncé (on oublie pas de faire attention aux subtilités mentionnées en début d’article). Ainsi dans le sujet ESCP 2017 (exo 2), on nous demande de compléter ce programme pour qu’il affiche les valeurs de un et vn pour une valeur de n entrée par l’utilisateur, avec u1 = 1 et v1 = 2, et un+1 = un²/(un+vn) et et vn+1 = vn²/(un+vn) :

n = input (‘entre la valeur de n :’)

u = 1

v = 2

for k = 2 : n

a = u

u = ….

V = ….

End

Disp(u)

Disp(v)

On a bien u1 et v1 qui sont déjà présents dans le programme et la boucle for doit permettre de donner la formule permettent d’obtenir les autres termes de la suite. On comprend alors qu’il suffit simplement de compléter les lignes en écrivant correctement les relations de récurrence, c’est-à-dire u = (u^2)/(u+v) et v = (v^2)/(u+v).

 

Les graphiques

L’interprétation et la compréhension d’un graphique est souvent la partie la plus ratée dans les questions Scilab : « Comme en témoignent les nombreuses tentatives ratées, (les candidats) éprouvent de réelles difficultés à lire et interpréter un graphique. L’instruction cumsum ne semble pas avoir été assimilé par les candidats » (rapport ECRICOME 2016). Ce sont donc des questions à absolument travailler car, d’une part, elles sont discriminantes puisque souvent ratées, et surtout, elles sont présentes dans tous les sujets. Deux instructions clés sont à comprendre pour pouvoir réussir les questions sur les graphiques : l’instruction cumsum et l’instruction plot() et son équivalent plot2d().

L’instruction plot() consiste tout simplement à utiliser à créer une le graphique. A l’intérieur, on retrouve généralement deux éléments : ce que l’on va représenter dans le graphique, puis comment. Ainsi, dans le sujet ECRICOME 2016 (exo 3 question 4), on nous dit que le programme suivant affiche les probabilités P(X=k) d’une variable aléatoire X pour k entre 3 et 22 et on nous demande quelle est la valeur de X la plus probable :

For k = 3 :22

U(k) = 1/2*((4/5)^(k-2)-(2/3)^(k-2))

End

Plot(u, ‘+’)

Avec le sujet qui nous donne P(X=k) = 1/2*((4/5)^(k-2)-(2/3)^(k-2)

 

On remarque alors que la fonction plot contient u, donc les valeurs de P(X=k), et un ‘+’, qui signifie tout simplement que sur le graphique, les points seront représentés par ce +. On remarque également que sur l’axe des abscisses, on retrouve les valeurs de k entre 3 et 22 et sur l’axe des ordonnées, des données qui représentent les probabilités chaque k de X entre 3 et 22. La valeur de X la plus probable est donc celle qui se trouve tout en haut du graphique, c’est-à-dire k = 5, de probabilité 0,11. Pour bien lire un graphique, il faut donc s’intéresser à ce qui se trouve dans la fonction plot qui génère le graphique, et ce qui se trouve sur les deux axes des graphiques.

 

Abordons enfin l’instruction cumsum(). Cumsum signifie en fait « somme cumulée ». Si on pose un une suite et que l’on tape X = cumsum(un), on obtient alors un vecteur ligne de la sorte :

[u1, u1+u2, u1+u2+u3, … , u1+u2+u3…+un]. Cette instruction est très pratique pour tracer des graphiques et trouver la convergence d’une suite car, sur le graphique, une fois que l’on remarque les points n’augmentent plus, on peut en déduire que la suite converge et à partir de quel rang. Dans le sujet ESCP 2017 (le graphique qu’on va utiliser est dans l’exercice 2), on nous donne le programme suivant avec cette sortie graphique (les lignes 7 et 8 contiennent un+1 et vn+1 que l’on a vu précédemment) :

n = input (‘entrer la valeur de n : ‘)

u = 1

v = 2

s = ones(1,n)

for k = 2 :n

                a = u

                u = …

                v = …

                s(k) = u

end

disp(u)

disp(v)

x = 1:n

y = cumsum(s)

plot2d(x,y)

On nous demande alors ce que contient s et y, puis quel résultat le graphique nous permet de conjecturer.

Tout d’abord, en ce qui concerne s, on retrouve l’importance de connaître la fonction ones() car cela nous permet de comprendre que s est un vecteur ligne contenant les valeurs de un. On a s = [u1, u2, …, un].

Or, ensuite, on nous demande ce que contient y = cumsum(s). On a donc y = [u1, u1+u2, u1+u2+u3, … , u1+u2+u3…+un].

On peut ainsi lire correctement le graphique en reprenant la méthode que l’on a vu. Dans la fonction plot2d(x,y), on a d’une part les x de 1 à 10 que l’on retrouve sur l’axe des abscisses, et les y que l’on retrouve en ordonnées. Le graphique se lit alors de cette manière : on a u1 = 1, u1+u2 = 1.35, u1+u2+u3 = 1.4 puis la courbe n’augmente plus, ce qui signifie que pour tout n supérieur ou égal à 4, on a un = 0. (NB : cela correspond bien à la limite de un que l’on trouve auparavant dans l’exercice par le calcul. Bien souvent, les questions graphiques consistent à confirmer ce que vous avez trouvé par les calculs).

 

La génération de variables aléatoires

Normalement, on ne vous demandera pas de connaître par cœur comment générer telle ou telle loi usuelle. A chaque fois, lorsqu’une variable aléatoire est impliquée dans un programme, l’énoncé rappelle ce que signifie l’instruction concernée. Mais savoir tout de même ce que compose ces instructions permet de mieux les aborder le jour j :

  • Si X suit une loi binomiale de paramètre N et p, on écrit X = grand(1,1,’bin’,N,p)
  • Si X suit une loi géométrique de paramètre p, on écrit X = grand(1,1,’geom’,p)
  • Si X suit une loi de poisson de paramètre p, on écrit X = grand(1,1,’poi’, p)
  • Si X suit une loi exponentielle de paramètre p, on écrit X = grand(1,1,’exp’1/p) (et non pas p !)
  • Si X suit une loi normale d’espérance m et de variance v, on écrit X = grand(1,1,’nor’,m,v)

On retiendra essentiellement l’instruction grand et les abréviations au milieu de l’instruction qui permettent de reconnaître quelle loi usuelle est utilisée si l’énoncé ne le précise pas. On retiendra également que le/les paramètres de la variable aléatoire sont à la fin de la fonction grand().

Jean-Loup Osella

étudiant en prépa ECT à La Martinière Duchère à Lyon.