Apprendre scilabà l’aide d’exercices

par Raymond Mochéancien élève de l’École normale d’instituteurs de Douai et de l’École normale supérieure de Saint Cloud

ancien professeur de l’Université des Sciences et Technologies de Lilleet des universités de Coïmbre et de Galatasaray

http ://gradus-ad-mathematicam.fr

Table des matières

1 Remarques générales 4

2 Liste des énoncés 6

3 Calculs numériques non programmés 183.1 [*] scilab utilisé comme une calculette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193.2 [*] Lignes trigonométriques remarquables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213.3 [*] Conversion de la base 2 à la base 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233.4 [*] Les erreurs de scilab . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4 Manipulations élémentaires 264.1 [*] Échanger deux nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274.2 [*] Échanger deux nombres dans une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294.3 [*] Échanger deux colonnes ou deux lignes d’une matrice . . . . . . . . . . . . . . . . . . . . . 314.4 [*] Ré-arrangement d’une suite de nombres (fantaisie) . . . . . . . . . . . . . . . . . . . . . . 334.5 [*] Combien de temps l’exécution d’un script prend-elle ? . . . . . . . . . . . . . . . . . . . . . 344.6 [***] Sur la définition du produit matriciel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364.7 [***] Calcul de nombres de dérangements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

5 Programmer une fonction scilab 395.1 [*] Volume du cône . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405.2 [*] Aire d’un trapèze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435.3 [*] Moyenne et variance empiriques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445.4 [**] Convertion de temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6 Boucles pour, graphes simples, matrices 486.1 [*] Tables de multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506.2 [*] Minimum et maximum d’une liste de nombres . . . . . . . . . . . . . . . . . . . . . . . . . 526.3 [*] Quelques produits de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546.4 [*] Construction de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 566.5 [*] Sommes de nombres entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586.6 [*] Trier un tableau numérique (fantaisie) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606.7 [*] Matrice fantaisie (boucles pour imbriquées) . . . . . . . . . . . . . . . . . . . . . . . . . . 626.8 [*] Matrices de Toeplitz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646.9 [*] Graphe de la fonction tangente entre 0 et π . . . . . . . . . . . . . . . . . . . . . . . . . . 656.10 [*] Sauts de puce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676.11 [**] Résolution graphique d’une équation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 696.12 [**] Matrice-croix (fantaisie) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 726.13 [**] Construction de matrices : matrice Zorro (fantaisie) . . . . . . . . . . . . . . . . . . . . . 736.14 [*] Construction de matrices : matrice barrée (fantaisie) . . . . . . . . . . . . . . . . . . . . . 756.15 [**] Aiguilles de l’horloge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766.16 [**] Calculs d’effectifs et de fréquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786.17 [**] Écrire à la fin le premier terme d’une liste de nombres . . . . . . . . . . . . . . . . . . . . 80

1

6.18 [*] Écrire une suite de nombres à l’envers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826.19 [***] Permutations (solution matricielle). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 836.20 [***] Matrices de permutation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 876.21 [***] Échanger deux lignes ou deux colonnes d’un tableau (produit d’une matrice par une

matrice de permutation) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 906.22 [**] Calcul matriciel de l’espérance et de la variance d’une variable aléatoire finie . . . . . . . 926.23 [***] Calcul matriciel de la covariance de 2 variables aléatoires finies . . . . . . . . . . . . . . 946.24 [***] Ranger n nombres donnés dans l’ordre croissant (tri à bulle) . . . . . . . . . . . . . . . . 986.25 [****] Ranger n nombres donnés dans l’ordre croissant . . . . . . . . . . . . . . . . . . . . . . 1006.26 [**] Trier un tableau suivant l’une de ses lignes . . . . . . . . . . . . . . . . . . . . . . . . . . 102

7 Instructions conditionnelles 1047.1 [*] Fonction valeur absolue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1067.2 [*] Calculer le maximum de 2 ou 3 nombres donnés . . . . . . . . . . . . . . . . . . . . . . . . 1087.3 [*] Ranger 2 nombres dans l’ordre croissant . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1107.4 [*] Ranger 3 nombres dans l’ordre croissant . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1117.5 [**] Sauts de kangourou . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1137.6 [**] Addition en base 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1157.7 [**] L’année est-elle bissextile ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1177.8 [**] Calcul et représentation graphique de fréquences (exercice type du Calcul des probabilités)1197.9 [**] Le point M est-il à l’intérieur du triangle ABC? . . . . . . . . . . . . . . . . . . . . . . . 1237.10 [**] Ce triangle est-il isocèle ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

8 Boucle tant que 1278.1 [*] Transformer une boucle pour en une boucle tant que . . . . . . . . . . . . . . . . . . . . 1288.2 [*] Calculer le maximum d’une liste de nombres . . . . . . . . . . . . . . . . . . . . . . . . . . 1308.3 [*] Conversion du système décimal vers le système à base b . . . . . . . . . . . . . . . . . . . 1328.4 [*] Sommes des premiers nombres impairs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1348.5 [*] Partie entière d’un nombre réel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1358.6 [*] Formule de la somme des carrés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1368.7 [**] Comptage de nombres factoriels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1378.8 [***] Ranger 3 nombres donnés dans l’ordre croissant (tri à bulle) . . . . . . . . . . . . . . . . 1398.9 [***] Ranger n nombres donnés dans l’ordre croissant . . . . . . . . . . . . . . . . . . . . . . . 1428.10 [***] Ranger n nombres donnés dans l’ordre croissant . . . . . . . . . . . . . . . . . . . . . . . 144

9 Graphes 1469.1 [*] Tracer un triangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1479.2 [***] Tracés de polygones réguliers inscrits dans un cercle . . . . . . . . . . . . . . . . . . . . 1499.3 [***] Tracer les N premiers flocons de Koch . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1519.4 [***] Visualisation du tri à bulles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

10 scilab vs Xcas 15610.1 [*] Calcul numérique avec scilab et Xcas (test d’égalité de deux nombres) . . . . . . . . . . . 15810.2 [*] Calculs en nombres rationnels avec scilab et avec Xcas . . . . . . . . . . . . . . . . . . . . 15910.3 [*] Les fonctions racine carrée et élévation au carré sont-elles inverses l’une de l’autre ? . . . . 16010.4 [*] Calcul de factorielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16110.5 [*] Longueur d’un nombre entier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16410.6 [**] Somme des chiffres d’un nombre entier. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16610.7 [*] Sommes de puissances des premiers entiers (démontrer une infinité d’égalités) . . . . . . . 16810.8 [**] Test d’isocélité et d’équilatéralité d’un triangle * . . . . . . . . . . . . . . . . . . . . . . . 17010.9 [***] Sommes d’inverses * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17310.10[****] Table ronde * . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

2

11 Plus de scilab 17811.1 [****] Crible d’Ératosthène avec scilab et Xcas . . . . . . . . . . . . . . . . . . . . . . . . . . 17911.2 [*] Test de primalité (suite de l’exercice no 11.1) . . . . . . . . . . . . . . . . . . . . . . . . . . 18511.3 [**] Nombre premier suivant (suite de l’exercice no 11.1) . . . . . . . . . . . . . . . . . . . . . 18611.4 [**] Factorisation en nombres premiers (suite de l’exercice no 11.1) . . . . . . . . . . . . . . . 18911.5 [***] Peut-on faire l’appoint ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19111.6 [***] Records . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19411.7 [***] Un problème d’arithmétique : les citrons . . . . . . . . . . . . . . . . . . . . . . . . . . . 196

Bibliographie 198

3

Chapitre 1

Remarques générales

Ceci est un ensemble d’exercices destiné aux professeurs qui pourraient être intéressés. Il est destiné soità apprendre scilab, soit à trouver une solution à un problème particulier. C’est essentiellement élémentaire,mais pas toujours. Le niveau de difficulté est évalué par des *, de [*] à [****]. Bien sûr, cette classificationest contestable.

Souvent, on commence à faire du calcul numérique électronique en grognant, parce qu’on en a eu besoinou qu’on ne pouvait faire autrement. Quand on acquiert un peu d’expérience, on se rend compte que l’onpeut, en calcul aussi, faire des astuces, des algorithmes plus ou moins bons ou plus ou moins mauvais, rapidesou non, gourmands en mémoire ou non. Et on y prend goût.

On a souvent un élément de comparaison, à savoir les algorithmes de la bibliothèque de programmes descilab. Pour en prendre connaissance ou se renseigner sur les diverses commandes, il faut avoir un manuel(nous recommandons [11] en plus de [12]) ou consulter l’aide en ligne ([1]). Pour débuter, on peut utiliser[12]. L’aide en ligne est consultable directement depuis la console (commande help).Utilisation habituelle de scilab (dans ce travail)scilab est presque toujours utilisé comme suit :- un script (ou une fonction scilab) est tapé dans l’éditeur de texte SciNotes- il est ensuite chargé dans la console de scilab avec l’option « sans écho » du menu déroulant « Exécution »de la console.- On peut taper les commandes dans la console directement dans les cas simples, mais les corrections sontdifficiles. Il vaut mieux utiliser systématiquement l’éditeur de texte.Que se passe-t-il quand on charge dans la console un script ou une fonction édités dansSciNotes ?On obtient :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)−−>� �L’invite --> indique que le calculateur scilab est disponible. Le paramètre -1 indique le mode d’exécutionchoisi, faire�−−>help mode� �dans la console et la touche Entrée, évidemment, pour obtenir la documentation. Il y a d’autres modesd’exécution, dont le pas à pas (mode 7).Sur la terminologie- Un script est une suite de commandes. Nous employons assez indifféremment les mots script, algorithme,programme. Désolé.- scilab est très à l’aise avec les matrices. Une matrice est un tableau de nombres (en général) rectangulaire

4

à n lignes et m colonnes. Si n = 1, on dit que c’est une matrice-ligne ou un vecteur ou plus simplement uneliste de nombres. Si m = 1, on dit que c’est une matrice-colonne. Si n = m = 1, c’est un nombre.- Dans ce travail, dans presque tous les cas, matrice veut dire tableau de nombres. Quand un exerciceutilise du calcul matriciel (en gros, la définition du produit de deux matrices ad hoc), on signale « produitmatriciel » dans les mots-clefs de cet exercice.Comment trouver des données à traiter ?De nombreux exercices consistent à traiter des données : par exemple, ranger une liste de 100 000 nombresdans l’ordre croissant. Pour cela, il faut commencer par produire cette liste, ce qui se fait habituellement enutilisant des générateurs de nombres aléatoires parce que c’est pratique. Il est inutile de connaître un motde Calcul des Probabilités. Il suffit de connaître la nature des nombres en question, ce qui est précisé dansles exercices concernés.Nettoyer la consoleAprès avoir fait des calculs et reçu éventuellement des messages d’erreur, on peut avoir envie d’effacer laconsole. Cela se fait avec l’option « Effacer la console » du menu déroulant « édition ». On obtient de nouveauune belle page blanche avec seulement l’invite. Mais ce qui a été tapé ou chargé dans la console n’est paseffacé. Pour effacer les variables non-protégées, on utilise la commande clear (voir l’aide pour plus dedétails).Du bon usage de scilabscilab est un excellent calculateur, bien supérieur aux calculatrices programmables dont certaines sont déjàremarquables. Faire un algorithme pour ranger 10 nombres dans l’ordre croissant est clairement une mauvaiseutilisation de scilab. Ce n’est pas intéressant et peut se faire à la main. Il faut voir grand !

5

Chapitre 2

Liste des énoncés

Chapitre 3 : Calculs numériques non programmés

Énoncé no 3.1 [*] : scilab utilisé comme une calculette.

Quelle est la valeur de π ? de e ? de π· e ? Calculer sin 3· e21 + tan π

8

·

Énoncé no 3.2 [*] : Lignes trigonométriques remarquables.

Saisir le tableau « Arcs » des angles remarquables entre 0 et π ; calculer et afficherles sinus, cosinus et tangentes de ces angles.

Énoncé no 3.3 [*] : Conversion de la base 2 à la base 10.

Soit n un entier ⩾ 1 donné sous sa forme N = [a0, a1, . . . , ap] dans le système à base 2 :a0, . . . , ap−1 sont chacun égaux à 0 ou à 1, ap = 1 et p désigne un entier ⩾ 0 tels que

n = a0 + a1· 2 + · · ·+ ap· 2p

Problème : écrire n dans le système décimal.

Énoncé no 3.4 [*] : Les erreurs de scilab.

1 - Calculer .6*9+.6.2 - Calculer floor(.6*9+.6). Comparer.

Chapitre 4 : Manipulations élémentaires

Énoncé no 4.1 : [*] Échanger deux nombres.

Soit X = [a, b] une liste (un vecteur) de deux nombres. Donner un script qui retourne [b, a].

Énoncé no 4.2 : [*] Échanger deux nombres dans une liste.

Écrire un script qui, étant donné une liste de nombres X = [x1, . . . , xn] et deux indices i et j,retourne X après avoir échangé xi et xj .

Énoncé no 4.3 : [**] Échanger deux colonnes (ou deux lignes) d’un tableau de nombres rectangulaire.

Engendrer un tableau de nombres à n lignes et m colonnes à l’aide de la commandegrand(n,m,'uin',-13,14) puis échanger les colonnes i et j (i et j donnés)

6

Énoncé no 4.4 : [**] Ré-arrangement d’une suite de nombres ( fantaisie).

Étant donné une liste de nombresX = [x1, . . . , xn], retourner la liste [x2, x4, . . . , x1, x3, . . .] (suitedes termes de rang pair de X suivis des termes de rang impair)

Énoncé no 4.5 : [*] Combien de temps l’exécution d’un script prend-elle ?

Engendrer une liste de 100 000 nombres ; inverser l’ordre de ces nombres et retourner le temps decalcul de cette inversion.

Énoncé no 4.6 : [***] Produit matriciel.

Soit A = (ai,j) et B = (bi,j) deux matrices, A ayant n lignes et m colonnes, B ayant m ligneset p colonnes (le nombre de colonnes de A est égal au nombre de lignes de B). Alors C = A·B(commande scilab : C=A*B) est la matrice à n lignes et p colonnes définies par

ci,j =∑

k=1,...,m

ai,k· bk,j

1 - Soit A=tirage_entier(0,10,7) et B=tirage_entier(-14,27,7) deux listes de 7 nombres.Peut-on effectuer le produit A*B de ces matrices ?2 - Calculer B'. Décrire cette matrice.3 - Peut-on effectuer le produit B*A ? B*A' ? Décrire B*A'.4 - Soit C=grand(7,7,"uin",-2,8) une matrice à 7 lignes et 7 colonnes (matrice carrée). Décrireles matrices A*C et C*A'.

Énoncé no 4.7 : [***] Calcul de nombres de dérangements.

Le nombre de dérangements (ou permutations sans point fixe) de la liste (1, . . . , n) est donnépar la formule

Nn = (1× · · · × n)

(1 +

n∑k=1

(−1)k

1× · · · × k

)ou Nn = n !

(1 +

n∑k=1

(−1)k

k !

)

1 - Écrire un script qui, étant donné l’entier n, retourne Nn.2 - Quelle est la plus grande valeur de n qui permet à scilab d’afficher Nn exactement (c’est àdire sans passer en notations flottantes) ? Combien Nn vaut-il alors ?

Chapitre 5 : Programmer une fonction scilab

Énoncé no 5.1 [*] : Volume du cône.

1 - Fabriquer une fonction-scilab qui calcule le volume v d’un cône de révolution de hauteur het dont la base est un disque de rayon r.2 - Cette fonction accepte-t-elle que r et h soient des listes de nombres (ce qui serait utile si onvoulait faire varier le rayon et la hauteur) ?

Énoncé no 5.2 [*] : Aire d’un trapèze.

Fabriquer une fonction-scilab qui donne l’aire d’un trapèze de bases b et B et de hauteur h.

7

Énoncé no 5.3 [*] : Moyenne et variance empiriques.

1 - Calculer la moyenne et la variance du vecteur[√3,−2.7, 42, log(7), exp(0.8),−4.2, π, 17, 13/11, cos(4), 0] .

2 - Engendrer une liste de n=50 nombres entiers entre les bornes a=-7 et b=39 à l’aide de lacommande tirage_entier(n,a,b), puis calculer sa moyenne et sa variance.

Énoncé no 5.4 [**] : Conversion de temps.

Programmer une fonction-scilab qui, étant donné une durée d en secondes, la retourne sous formed’années, mois, jours, heures, minutes et secondes.

Chapitre 6 : Boucles pour, graphes simples

Énoncé no 6.1 : [*] Tables de multiplication.

Afficher les tables de multiplication par 1, …, 9.

Énoncé no 6.2 : [*] Minimum et maximum d’une liste de nombres.

Une liste de nombres étant donnée, calculer son minimum et son maximum.

Énoncé no 6.3 : [*] Quelques produits de matrices.

1 - Sont donnés 2 vecteurs de n nombres : X = [x1, . . . , xn] et P = [p1, . . . , pn]. On demanded’expliciter les résultats des produits matriciels suivants :1.a - X*ones(n,1)1.b - X*X'1.c - X*diag(X)*ones(n,1),1.d - X*diag(P)*X',1.e - P*diag(X)*X'.2 - Calculer la valeur de ces expressions avec scilab lorsque X = [1,

√3, exp (−0.5), 2, 37 ] et

P = [12 , 0.23, log 5,π8 , 7].

Énoncé no 6.4 : [*] Construction de matrices.

1 - Écrire la matrice à n lignes et m colonnes dont la première colonne ne contient que des 1, ladeuxième colonne ne contient que des 2, etc.2 - Écrire la matrice à m lignes et n colonnes dont la première ligne ne contient que des 1, ladeuxième ligne ne contient que des 2, etc.

Énoncé no 6.5 : [*] Sommes de nombres entiers.

1 - Calculer la somme des nombres entiers de 1 à 500.2 - Calculer la somme des carrés des nombres entiers de 1 à 500.

Énoncé no 6.6 : [*] Trier un tableau numérique (fantaisie).

Trier un tableau numérique dans l’ordre décroissant (quand on le lit de la gauchevers la droite et de haut en bas, de la première à la dernière ligne).

8

Énoncé no 6.7 : [*] Matrice fantaisie (boucles pour imbriquées).

1 - Écrire la matrice (n,n) dont les éléments sont 1, 2, . . . , n2 écrits dans l’ordre habituel (surchaque ligne, de la gauche vers la droite, de la première à la dernière ligne).2 - Cette matrice étant notée M , expliquer comment se font les calculs suivants : N=M+M,Q=3*M, R=M. ̂2.

Énoncé no 6.8 : [*] Matrices de Toeplitz.

Écrire la matrice carrée de taille n comprenant des n sur la diagonaleprincipale, des n− 1 sur les deux lignes qui l’encadrent, etc.

Énoncé no 6.9 : [*] Graphe de la fonction tangente entre 0 et π.

Tracer le graphe de la fonction tangente entre 0 et π, la variable variantavec un pas de 0.1, puis 0.01, puis 0.001 et enfin 0.0001.

Énoncé no 6.10 : [*] Sauts de puce.

Une puce fait des bonds successifs indépendants les uns des autres en ligne droite.La longueur de chaque bond est aléatoire. On considère que c’est un nombre choisiau hasard dans l’intervalle [0, 5[, l’unité de longueur étant le cm. On note la distancetotale parcourue au bout de m bonds. On répète cette expérience n fois. Calculer ladistance moyenne parcourue au cours de ces n expériences.

Énoncé no 6.11 : [**] Résolution graphique d’une équation.

1 - Calculer les valeurs de f(x) =x3· cos (x) + x2 − x+ 1

x4 −√3·x2 + 127

lorsque la variable x prend successi-vement les valeurs -10, -9.2, -8.4, …, 8.4, 9.2, 10 (pas 0.8).2 - Tracer le graphe de la fonction f quand x varie entre -10 et 10 en utilisant seulement lesvaleurs de f(x) calculées précédemment.3 - Apparemment, l’équation f(x) = 0 a une solution α voisine de 2. En utilisant le zoom,proposer une valeur approchée de α.4 - Tracer de nouveau le graphe de f entre -10 et 10 en faisant varier x avec un pas de 0.05.5 - Ce nouveau graphe amène-t-il à corriger la valeur de α proposée ?

Énoncé no 6.12 : [***] Construction de matrices : matrice-croix (fantaisie).

Écrire la matrice carrée C de taille 2n+1 comportant des 1 sur la (n+1)ième ligne et la (n+1)ième

colonne et des 0 ailleurs.

Énoncé no 6.13 : [**] Construction de matrices : matrice Zorro (fantaisie).

Écrire la matrice Zorro, matrice carrée de taille n comprenant des 1 sur la première ligne, surla deuxième diagonale et sur la dernière ligne et des 0 partout ailleurs.

Énoncé no 6.14 : [**] Construction de matrices : matrice barrée (fantaisie).

Écrire la matrice carrée de taille n portant des 1 sur les 2 diagonales, des 0 ailleurs.

9

Énoncé no 6.15 : [**] Aiguilles de l’horloge.

1 - Combien de fois l’aiguille des minutes tourne-t-elle plus vite que l’aiguille desheures ?2 - Quand l’aiguille des heures a tourné de α degrés à partir de midi, l’extrémité del’aiguille des minutes est repérée sur le cadran de l’horloge par l’angle

β = 12·α− 360·[12·α360

]Tracer le graphe de β en fonction de α quand celui-ci varie de 0 à 360 degrés.3 - Combien y a-t-il de superpositions des aiguilles entre midi et minuit ? Calculerles angles correspondants.4 - Que se passe-t-il à partir de minuit ?

Énoncé no 6.16 : [**] Calculs d’effectifs et de fréquences.

Une suite S de nombres entiers étant donnée, calculer l’effectif et la fréquence de ndans cette suite, quel que soit n entre min (S) et max (S) ( min (S) ⩽ n ⩽ max (S)).

Énoncé no 6.17 : [**] Écrire à la fin le premier terme d’une liste de nombres.

Écrire un script qui associe à tout vecteur X = [x1, . . . , xn−1, xn] le vecteur Y = [x2, . . . , xn, x1].

Énoncé no 6.18 : [*] Écrire une suite de nombres à l’envers.

Écrire un script qui transforme une liste de nombres donnée X = [x1, . . . , xn] en la liste Y = [xn, . . . , x1].

Énoncé no 6.19 : [***] Permutations (solution matricielle).

Écrire toutes les permutations de 1, 2, …, n.

Énoncé no 6.20 : [***] Matrices de permutation.

1 - Une permutation σ de l’ensemble (1, 2, . . . , n) étant donnée, écrire la matrice de permutationP de σ (voir les explications ci-dessous).2 - Soit X un vecteur de longueur n. Vérifier sur un exemple que Y = X·P s’obtient enpermutant selon σ les composantes de X.3 - Quelle matrice de permutationM permet d’écrire les composantes de X dans l’ordre inverse ?

Énoncé no 6.21 : [***] Échanger deux lignes ou deux colonnes d’un tableau (produit d’une matrice parune matrice de permutation).

1 - M étant un tableau de nombres à n lignes et m colonnes,1.a - soit σ1 une permutation de (1, . . . , m) (au choix du lecteur) et P1 la matrice de permutationqui lui est associée (voir l’exercice 6.20) ; comparer M et M ∗ P1 (effet sur une matrice de lamultiplication à droite par une matrice de permutation) ;1.b - soit σ2 une permutation de (1, . . . , n) (au choix du lecteur) et P2 la matrice de permutationqui lui est associée ; comparer M et P2 ∗M (effet sur une matrice de la multiplication à gauchepar une matrice de permutation) ;2 - Engendrer un tableau de nombres entiers M à n lignes et à m colonnes à l’aide de lacommande grand(n,m,"uin",-13,14).2 .a - Échanger les lignes 2 et n− 1,2.b - Échanger les colonnes 2 et m− 1.

10

Énoncé no 6.22 : [**] Calcul matriciel de l’espérance et de la variance d’une variable aléatoire finie.

1 - Soit X une variable aléatoire ne prenant que les valeurs v1, …, vn avec respectivement lesprobabilités p1, …, pn (> 0). Exprimer matriciellement son espérance moy et sa variance var àl’aide des vecteurs V = [v1, . . . , vn] et prob = [p1, . . . , pn].2 - Application : calculer l’espérance et la variance d’une variable aléatoire suivant la loi binomialede taille 10 et de paramètres 1

3 ·

Énoncé no 6.23 : [***] Calcul matriciel de la covariance de 2 variables aléatoires finies.

Soit X et Y deux variables aléatoires finies, VX = [x1, . . . , xn] et VY = [y1, . . . , ym] les vecteurs des valeursqu’elles prennent avec des probabilités > 0. La loi du couple aléatoire (X,Y ) est décrite par la matriceP(X,Y ) = (pi,j , 1 ⩽ i ⩽ n ; 1 ⩽ j ⩽ m) où pi,j = P (X = xi , Y = yj).1 - Comment calcule-t-on la loi PX de X à partir de P(X,Y ) ? Même question pour la loi PY de Y .2 - Exprimer matriciellement les espérances mX et mY de X et Y .3 - Exprimer matriciellement la variance var (X) de X.4 - Exprimer matriciellement la covariance cov (X,Y ) de X et Y .5 - Application : Calculer les quantités ci-dessus lorsque P(X,Y ), VX et VY sont respectivement égales à :P(X,Y )=

0.002 0.012 0.004 0.005 0.017 0.012 0.004 0.001 0.003 0.001 0.005 0. 0.009 0.002 0.0010.011 0.002 0.003 0.01 0.009 0.002 0.009 0.002 0.002 0.006 0.002 0.003 0.011 0.007 0.0060.003 0.001 0.007 0.001 0.009 0.003 0.009 0.005 0.006 0.004 0.002 0.004 0.003 0.011 0.010.001 0.002 0.007 0.012 0.002 0. 0. 0.002 0.003 0.008 0.006 0.009 0.005 0.002 0.0080.01 0.011 0.001 0.01 0.004 0.004 0. 0. 0.004 0. 0.012 0. 0.005 0.01 0.0090.001 0. 0.004 0.012 0.001 0.012 0.001 0.004 0.011 0.01 0.005 0.004 0.004 0.012 0.0070.002 0.012 0.003 0.004 0.006 0.005 0. 0.01 0.004 0.012 0.003 0.004 0. 0.004 0.010.009 0.011 0.012 0.009 0.005 0.021 0.011 0.02 0.011 0.003 0.003 0.007 0.008 0.005 0.0050.006 0.005 0.001 0.004 0.008 0.012 0.007 0.008 0.012 0. 0. 0.006 0.001 0.004 0.0010. 0.006 0.012 0.01 0.002 0.011 0.006 0.011 0.023 0.023 0.009 0.003 0.011 0.01 0.0070.003 0.013 0. 0.003 0.002 0.008 0.009 0.006 0.021 0. 0.004 0.003 0.005 0.002 0.007

VX = [1., 1.3, 1.6, 1.9, 2.2, 2.5, 2.8, 3.1, 3.4, 3.7, 4.] etVY = [−4.,−3.3,−2.6,−1.9,−1.2,−0.5, 0.2, 0.9, 1.6, 2.3, 3., 3.7, 4.4, 5.1, 5.8]

Énoncé no 6.24 : [***] Ranger n nombres donnés dans l’ordre croissant (tri à bulles).

Soit une suite de nombres A = [a1, . . . , an] à ranger dans l’ordre croissant. On appellera Aneuf la suiteobtenue. Dans le tri à bulles, on fait une suite de passages sur A. Au premier passage, on considère la paire(a1, a2) que l’on met dans l’ordre croissant, ce qui modifie A, puis (a2, a3), etc. À la fin du premier passage,le dernier terme de Aneuf est placé. On continue ces passages qui placent définitivement l’avant dernierterme de Aneuf , puis le précédent, etc. Après le (n− 1)ème passage, Aneuf est obtenu.On demande une fonction scilab qui range A dans l’ordre croissant par le tri à bulles.

Énoncé no 6.25 : [****] Ranger n nombres donnés dans l’ordre croissant.

Soit une suite d’au moins 3 nombres A=[a_1,…,a_n] à ranger dans l’ordre croissant. On ap-pellera Atri la suite obtenue. Si l’on ne considère que les 2 premiers termes de la suite,Atri=[min(A([1:2]),max(A([1:2])))]. Si on tient compte du terme suivant, on va l’intro-duire dans Atri comme suit : on écrit d’abord les termes de Atri qui lui sont strictementinférieurs, puis ce nombre, puis les termes de Atri qui lui sont supérieurs ou égaux. Ceci nousfournit la nouvelles valeur de Atri. Et ainsi de suite. On demande une fonction scilab qui rangeA dans l’ordre croissant par ce procédé.

11

Énoncé no 6.26 : [**] Trier un tableau suivant l’une de ses lignes.

Voici la liste des fréquences des 26 lettres de l’alphabet dans la langue française :7.68, 0.80, 3.32, 3.60, 17.76, 1.06, 1.10, 0.64, 7.23, 0.19, 0.00, 5.89, 2.72, 7.61, 5.34, 3.24, 1.34,6.81, 8.23, 7.30, 6.05, 1.27, 0.00, 0.54, 0.21, 0.07.Le problème est de ranger ces lettres par ordre des fréquences décroissantes.Plus généralement, étant donné une matrice numériqueM à n lignes etm colonnes et un entier j,1 ⩽ j ⩽ n, ranger les colonnes de M de manière que la ligne j soit rangée dans l’ordre décroissant.

Chapitre 7 : Instructions conditionnelles

Énoncé no 7.1 : [*] Fonction valeur absolue.

1 - Programmer une fonction-scilab qui donne la valeur absolue de tout nombre réel- à l’aide d’une instruction conditionnelle avec alternative,- à l’aide d’une instruction conditionnelle sans alternative.2 - En déduire la valeur absolue de -0.87 et de

√3.

Énoncé no 7.2 : [*] Calculer le maximum de 2 ou 3 nombres donnés.

Écrire une fonction scilab qui retourne le maximum de 2 nombres x et y, puis une fonction scilab quiretourne le maximum de 3 nombres x, y et z donnés.

Énoncé no 7.3 : [*] Ranger 2 nombres dans l’ordre croissant.

Écrire une fonction scilab qui, étant donné deux nombres réels, les retourne rangés dans l’ordre crois-sant.

Énoncé no 7.4 : [*] Ranger 3 nombres dans l’ordre croissant.

Ranger trois nombres réels donnés dans l’ordre croissant.

Énoncé no 7.5 : [**] Sauts de kangourous.

Un kangourou fait habituellement des bonds de longueur aléatoire comprise entre 0 et 9 mètres.1 - Combien de sauts devra-t-il faire pour parcourir 2000 mètres ?2 - Fabriquer une fonction-scilab qui à toute distance d exprimée en mètres associe le nombrealéatoire N de sauts nécessaires pour la parcourir.3 - Calculer le nombre moyen de sauts effectués par le kangourou quand il parcourt T fois ladistance d.

Énoncé no 7.6 : [*] Addition en base 2.

Soit deux entiers n, m ⩾ 0 notés en base 2 sous la forme [a0, . . . , ak−1, ak] et [b0, . . . , bk−1, bl].Cela signifie que ce sont deux suites de 0 et de 1 qui vérifient

n = a0· 20 + a1· 21 + · · ·+ ak· 2k et m = b0· 20 + b1· 21 + · · ·+ bl· 2lLe problème posé est de calculer leur somme en travaillant dans la base 2.

Énoncé no 7.7 : [**] L’année est-elle bissextile ?

1 - L’année n est-elle bissextile ?2 - Soit n et m deux millésimes (n ⩽ m). Combien y a-t-il d’annéesbissextiles de l’année n à l’année m (années n et m comprises) ?

12

Énoncé no 7.8 : [**] Calcul et représentation graphique de fréquences (exercice type du Calcul des proba-bilités)

On tire 10000 nombres au hasard dans l’intervalle [0, 1]. À chaque tirage, on se demande si l’événementA : « le nombre tiré au hasard appartient à l’intervalle [

1

7,5

6] »

est réalisé.1 - Combien vaut la probabilité p de A ?2 - Calculer la fréquence de réalisation de A après chaque tirage. Tracer le graphe des fréquences.3 - Choisir la dernière fréquence calculée comme valeur approchée de p.

Énoncé no 7.9 : [**] Le point M est-il à l’intérieur du triangle ABC?

Étant donné un triangle A1A2A3 et un point M (par leurs coordonnées), fabriquer une fonctionqui indique si M est à l’intérieur du triangle ou non.

Énoncé no 7.10 : [**] Ce triangle est-il isocèle ?

Un triangle ABC est donné par les coordonnées de ses sommets dans un repère orthonormé.Écrire un algorithme qui permette d’en déduire qu’il est isocèle (sans être équilatéral), équilatéralou quelconque (c’est à dire, ici, ni isocèle, ni équilatéral).

Chapitre 8 : Boucle tant que

Énoncé no 8.1 : [*] Transformer une boucle pour en une boucle tant que.

Calculer le maximum d’une liste de nombres d’après la fonction Minde 6.2, puis remplacer la boucle pour par une boucle tant que.

Énoncé no 8.2 : [*] Calculer le maximum d’une liste de nombres.

On veut calculer le maximum d’une liste de nombres L donnée, de longueur au moins2, de la manière suivante : si L(2) est plus grand que L(1), on échange ces nombres ;ensuite, on efface tous les termes qui sont inférieurs ou égaux à L(1) à partir du rang 2.Ce faisant, la longueur de L diminue mais reste supérieure ou égale à 1. Si elle est encoresupérieure ou égale à 2, on recommence. Quand elle est égale à 1, le terme restant estle maximum recherché.

Énoncé no 8.3 : [*] Conversion du système décimal vers le système à base b.

Un nombre entier n ⩾ 0 est donné sous forme décimale. Le problème posé est de l’écriredans le système à base b ⩾ 2, c’est à dire sous la forme d’une liste [a0, a1, . . . , ap] de0, de 1, …, de b− 1 de sorte que n = a0· b0 + a1· b1 + · · ·+ ap· bp.

Énoncé no 8.4 : [*] Sommes de nombres impairs.

Calculer la somme S(n) des nombres impairs inférieurs ou égaux à un entier donné n.

Énoncé no 8.5 : [*] Partie entière d’un nombre réel.

Calculer la partie entière d’un nombre réel donné.

Énoncé no 8.6 : [*] Formule de la somme des carrés.

La formule 12 + · · ·+ n2 =n(n+ 1)(2n+ 1)

6est-elle vraie pour tout entier n ⩾ 1 ?

13

Énoncé no 8.7 : [**] Comptage de nombres factoriels.

1 - Combien y a-t-il de nombres factoriels inférieurs ou égaux à 106, à 109, à 1012, à (17 !) ?2 - 3 629 300 et 39 916 800 sont-ils des nombres factoriels ?

Énoncé no 8.8 : [***] Ranger 3 nombres donnés dans l’ordre croissant (tri à bulles).

Pour ranger 3 nombres donnés x, y et z dans l’ordre croissant, on considère d’abord x et y que l’on échangesi x > y ; puis on considère y et z et on fait de même ; on compte aussi le nombre de permutations de 2nombres consécutifs que l’on a réalisées au cours de ce premier passage. Si c’est 0, c’est terminé. Sinon, onfait un deuxième passage et ainsi de suite, éventuellement. On demande d’écrire la suite x, y, z dans l’ordrecroissant et d’afficher le nombre de permutations faites.

Énoncé no 8.9 : [***] Ranger n nombres donnés dans l’ordre croissant.

Programmer une fonction scilab dont l’entrée est une liste de nombres L, qui retourne cette listerangée dans l’ordre croissant, notée R, fabriquée comme suit : le premier terme de R est min(L).Ensuite, on efface de la liste L un terme égal à min(L) (il peut y en avoir plusieurs). Le secondterme de R est le minimum des termes de L restants, et ainsi de suite.

Énoncé no 8.10 : [****] Ranger n nombres donnés dans l’ordre croissant.

Programmer une fonction de tri exécutable par scilab à partir de la description suivante :Un vecteur de nombres noté A étant donné ; on appellera Aneuf ce vecteur rangé dansl’ordre croissant. On détermine d’abord le plus petit nombre m de A, on compte combiende fois n le nombre m figure dans A, on ajoute à Aneuf (vide au début) la suite m, …, m (mécrit n fois), on efface tous les m qui figurent dans A. Si A n’est pas vide, on recommence.

Chapitre 9 : Graphes

Énoncé no 9.1 : [*] Tracer un triangle.

Tracer le triangle ABC, ces points ayant respectivement pour coordonnées (1, 3), (−2, 4) et (3, 8).

Énoncé no 9.2 : [***] Tracés de polygones réguliers inscrits dans un cercle.

Tracer dans le même repère orthonormé le cercle de centre O et de rayon 1 ainsi que le triangle équilatéral,le carré et l’heptagone régulier inscrits dans ce cercle et dont un sommet est le point (1, 0).

Énoncé no 9.3 : [***] Tracer les N premiers flocons de Koch.

Tracer les N premiers flocons de Koch définis comme suit à partir de l’hexagone régulier ABCDEFA(ou K0) inscrit dans le cercle unité dont le point A de coordonnées (1, 0) est un sommet :- Construction du premier flocon de Koch K1 :• d’abord on remplace le côté AB de l’hexagone par la ligne brisée AMGNB, M étant au tiers deAB à partir de A, N étant au tiers de AB à partir de B, le triangle MNG étant équilatéral, le pointG étant à droite quand on se déplace de A à B ;• puis on fait de même avec les 5 autres côtés de K0.Le polygone à 18 côtés ainsi obtenu est appelé premier flocon de Koch, noté K1.- Construction des flocons de Koch suivants : on passe de Kn à Kn+1 comme on est passé de K0 àK1.

14

Énoncé no 9.4 : [***] Visualisation du tri à bulles.

On applique le tri à bulles à une suite donnée de n nombresX = (x1, . . . , xn) obtenue, pourfixer les idées, à l’aide de la commande tirage_reel(n,0,1), n pouvant éventuellementvarier. Représenter l’état de la suite X après chaque passage, y compris le dernier quiproduit une illustration de la suite triée, en traçant, dans un repère orthonormé, les (n−1)points (x1, x2), (x2, x3), …, ainsi que la droite y = x.

Chapitre 10 : scilab vs Xcas

Énoncé no 10.1 : [*] Calcul numérique avec scilab et Xcas (test d’égalité de deux nombres).

Vérifier si scilab et Xcas donnent à tan(π4

)et à

(√2)2 les valeurs 1 et 2 respectivement.

Énoncé no 10.2 : [*] Calculs en nombres rationnels avec scilab et avec Xcas.

Calculer1

2+

1

3+

1

4(1

2

)2

+

(1

3

)2

+

(1

4

)2 avec scilab puis Xcas.

Énoncé no 10.6 : [*] Les fonctions racine carrée et élévation au carré sont-elles inverses l’une de l’autre ?

Calculer√x2 et

√x2.

Énoncé no 10.4 : [*] Calcul de factorielles.

Calculer n ! pour n = 10, 20, 50, 100, 500, 1000 à l’aide de scilab puis de Xcas.

Énoncé no 10.5 : [*] Longueur d’un nombre entier.

Avec combien de chiffres s’écrit 500 ! ?

Énoncé no 10.6 : [**] Somme des chiffres d’un nombre entier.

Un entier n ⩾ 1 étant donné, calculer son chiffre des unités noté u (n) et la somme de ses chiffresnotée s (n).Application : démontrer que u

(32014−1

2

)= s

(s(s(s(32014−1

2

)))).

Énoncé no 10.7 : [*] Sommes de puissances des premiers entiers (démontrer une infinité d’égalités)

Peut-on démontrer que 1 + · · ·+ n =n (n+ 1)

2avec scilab ? avec Xcas ?

Quelles formules donnent la somme des carrés ? des cubes ? des puis-sances suivantes ?

Énoncé no 10.8 : [**] Test d’isocélité et d’équilatéralité d’un triangle.

Écrire un script scilab et un script Xcas qui indiquent si un triangle donné estéquilatéral, isocèle (sans être équilatéral) ou quelconque (c’est à dire non-isocèle).

15

Chapitre 11 : Plus de scilab

Énoncé no 11.1 : [****] Crible d’Ératosthène.

On demande une fonction scilab qui, à tout nombre entier n ⩾ 2 associe la liste des nombrespremiers qui lui sont inférieurs ou égaux, rangés dans l’ordre croissant.

Énoncé no 11.2 : [*] Test de primalité (suite de l’exercice 11.1)

Étant donné un entier n ⩾ 2, en utilisant la fonction Erato.sci de l’exercice 11.1 ou la com-mande liste_premiers, fabriquer un algorithme qui répond si n est ou non un nombre premier.

Énoncé no 11.3 : [**] Nombre premier suivant (suite de l’exercice 11.1).

1 - Fabriquer un algorithme qui associe à tout entier n ⩾ 2 le plus petit nombre premierPn qui lui est strictement supérieur.2 - Quel est le premier nombre premier qui suit 10 000 000 ?

Énoncé no 11.4 : [**] Factorisation en nombres premiers (suite de l’exercice 11.1).

Fabriquer un algorithme qui à tout entier n ⩾ 2 associe la suite de ses facteurspremiers et la suite de leurs puissances respectives.

Énoncé no 11.5 : [***] Peut-on faire l’appoint ?

Quelqu’un doit payer un achat. Le commerçant n’ayant pas de monnaie lui demande de fairel’appoint, c’est à dire de donner exactement la somme due. Est-ce que c’est possible ? Si oui,quelles pièces doit-il donner ?

Énoncé no 11.6 : [***] Records.

Soit S une suite de nombres entiers. On appelle record de S son premier élément ainsi que toutterme de cette suite qui est strictement plus grand que tous les termes qui le précèdent.Le problème est de produire la liste des records de S à l’aide d’un algorithme.

16

Énoncé no 11.7 : [***] Un problème d’arithmétique : les citrons.

Une paysanne indienne va au marché en bicyclette pour vendre ses citrons. Un passant distraitla bouscule. Le panier de citrons est renversé. Le fautif entreprend de ramasser les citrons.Il demande à la paysanne : « combien y en avait-il ? »Elle lui répond : « en les rangeant par deux, il en reste un ; en les rangeant par trois, il en resteun ; en les rangeant par quatre, il en reste un ; en les rangeant par cinq, il en reste un ; en lesrangeant par six, il en reste un ; mais en les rangeant par sept, il n’en reste pas. »« C’est bon » lui dit le passant, « je les ai tous ramassés ».Sachant qu’il ne pouvait pas y avoir plus de 500 citrons dans le panier (ce qui fait environ 50kg), combien y en avait-il exactement ?

17

Chapitre 3

Calculs numériques non programmés

Liste des exercices :Énoncé no 3.1 [*] : scilab utilisé comme une calculette.Énoncé no 3.2 [*] : Lignes trigonométriques remarquables.Énoncé no 3.3 [**] : Conversion de la base 2 à la base 10.Énoncé no 3.4 [*] : Les erreurs de scilab.

18

3.1 [*] scilab utilisé comme une calculette

Quelle est la valeur de π ? de e ? de π· e ? Calculer sin 3· e21 + tan π

8

·

Mots-clefs : constantes pré-enregistrées, calcul numérique, %e, %pi, sin, tan, afficher, format.

Commentaires : On utilise ici scilab comme une calculatrice ordinaire. Les règles de priorité des diffé-rentes opérations sont les règles habituelles. Quand les commandes à taper sont vraiment simples et peunombreuses, on peut utiliser directement la feuille de travail scilab (appelée console). Sinon, il vaut mieuxpasser par l’intermédiaire de son éditeur de texte SciNotes. SciNotes sait faire ce que font tous les éditeursde texte. Les corrections éventuelles sont ainsi simplifiées. De plus, il aide aussi considérablement l’utilisa-teur en complétant automatiquement certaines instructions (déclaration de fonction, boucles, instructionsconditionnelles) et en procédant à des indentations qui augmentent considérablement la lisibilité des scripts.La procédure recommandée est donc de taper le script dans SciNotes, de l’enregistrer puis de le chargerdans la console, par exemple en choisissant l’option « sans écho » du menu déroulant « Exécution » de laconsole. L’invite --> de la console indique que scilab est prêt pour exécuter de nouvelles commandes.Pour trouver la valeur approchée que scilab donne àπ avec les réglages de format d’affichage par défaut,il suffit de taper %pi juste après l’invite (−− >) de laconsole, puis d’utiliser la touche « Entrée » de votreordinateur. Nous avons tapé a=%pi parce que nousavons désiré appeler a la variable qui prendra la va-leur recherchée. Idem pour la valeur scilab par défautde e, ici nommée viventlesmaths. Nous avons ou-blié de nommer la variable qui prendra la valeur dee∗π. Ce n’est pas grave. scilab lui donne un nom pardéfaut qui est ans (pour answer). Attention : si onfait une deuxième oubli de ce genre, ans prendra la

valeur nouvellement calculée. L’ancienne valeur seraperdue. Nous avons appelée x la variable qui va por-ter la valeur de ans. Le résultat de cette commanden’apparaît pas sur la console parce que la ligne decommande a été terminée par un ;. Puis, nous avonsdéfini une matrice-ligne y de longueur 3 (ou matrice(1,3)), cf. 1. y a été affiché par défaut dans le systèmedécimal (16 signes dont + omis et le point). Ensuite,avec la commande format, nous avons affiché y dediverses façons (affichage décimal à 20 signes puis af-fichage à virgule flottante à 10 signes).

�−−>a=%pia =

3.1415926535898−−>vivent l e smaths=%evivent l e smaths =

2.718281828459−−>%e*%pians =

8.5397342226736−−>x=ans ;−−>y=[a , v ivent lesmaths , x ]y =

3.1415926535898 2.718281828459 8.5397342226736−−>format ( ’ v ’ , 2 0 ) ; yy =

3.14159265358979312 2.71828182845904509 8.53973422267356597−−>format ( ’ e ’ , 1 0 ) ; yy =

3.142D+00 2.718D+00 8.540D+00−−>

19

� �Le lecteur comprendra facilement qu’il n’est ni possible ni souhaitable de continuer à donner autant dedétails. Se reporter à un manuel, par exemple [12], et essayer d’être aidé par un(e) collègue ou lors de stages.Aide en ligneL’aide en ligne de scilab pour les lycées a beaucoup progressé et est en grande partie rédigée en français.L’aide en ligne de scilab est assez pénible, souvent mal rédigée. Il faut dire à la décharge de scilab que denombreuses commandes comprennent beaucoup d’options, ce qui n’apparaîtra pas dans cet ouvrage simple.À titre d’exemple, pour se renseigner sur la commande format (qui est un format d’affichage, à ne pasconfondre avec la précision des calculs), on tape dans la console la commande�−−> help format ;−−>� �Fin de l’exercice : pour calculer sin 3· e2

1 + tan π8

, on tape le script suivant dans SciNotes

�clearx=sin (3)*%e^2/(1+tan (%pi / 8 ) ) ;a f f i c h e r ( x )� �sin désigne ici la fonction sinus, les angles étant exprimés en radians ; tan la fonction tangente. Voir [12],qui se termine par un répertoire des « Fonctions scilab utiles au lycée ». On obtient dans la console :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)

0.7373311103637−−>� �(avec le format d’affichage par défaut).

20

3.2 [*] Lignes trigonométriques remarquables

Saisir le tableau « Arcs » des angles remarquables entre 0 et π ; calculer et afficherles sinus, cosinus et tangentes de ces angles.

Mots-clefs : saisie d’un tableau à la main, sin, cos, tan.

Dans SciNotes, on tape :�// Sinus , cos inus e t tangen te s remarquab lesArcs=[0 ,%pi/6 ,%pi/4 ,%pi/3 ,%pi/2 ,2*%pi/3 ,3*%pi/4 ,5*%pi/6 ,%pi ] ;Sin=sin ( Arcs ) ;Cos=cos ( Arcs ) ;Tan=tan ( Arcs ) ;a f f i c h e r ( ’ Les␣ va l eu r s ␣ remarquables ␣du␣ s inu s ␣ ent r e ␣0␣ et ␣ p i ␣ sont ␣ ’ )a f f i c h e r ( Sin ) ;a f f i c h e r ( ’ Les␣ va l eu r s ␣ remarquables ␣du␣ co s inus ␣ ent r e ␣0␣ et ␣ p i ␣ sont ␣ ’ )a f f i c h e r (Cos ) ;a f f i c h e r ( ’ Les␣ va l eu r s ␣ remarquables ␣de␣ l a ␣ tangente ␣ ent r e ␣0␣ et ␣ p i ␣ sont ␣ ’ )a f f i c h e r (Tan)� �ce qui donne, en chargeant ce script dans la console :�−−>exec ( ’ /Chemin␣du␣ f i c h i e r ’ , −1)Les va l eu r s remarquables du s inu s ent re 0 et p i sont

column 1 to 50 . 0 . 5 0.7071067811865 0.8660254037844 1 .

column 6 to 90.8660254037844 0.7071067811865 0 .5 1.224646799D−16

Les va l eu r s remarquables du co s inus ent re 0 et p i sontcolumn 1 to 4

1 . 0.8660254037844 0.7071067811865 0 .5column 5 to 8

6.123233996D−17 − 0 .5 − 0.7071067811865 − 0.8660254037844column 9

− 1 .Les va l eu r s remarquables de l a tangente ent re 0 et p i sont

column 1 to 40 . 0.5773502691896 1 . 1.7320508075689

column 5 to 81.633123935D+16 − 1.7320508075689 − 1 . − 0.5773502691896

column 9− 1.224646799D−16

−−>� �Commentaires sur les résultats

3 Le tableau Arcs est ici un tableau à une ligne et 9 colonnes.3 Ce tableau a été saisi à la main. Ses éléments sont séparés par des ,. Si on avait voulu l’écrire en

colonne, on aurait utilisé des ;. ; signifie un changement de ligne.

3 On aurait aimé trouver cos(π3

)=

√3

2· scilab ne sait pas faire cela ; c’est du domaine des logiciels

de calcul formel comme Xcas, qui contiennent une bibliothèque de formules, notamment les valeursremarquables des fonctions usuelles.

21

3 On remarque aussi que scilab ne donne pas la valeur 0 à cos(π2

)et donne une valeur à tan

(π2

),

parce qu’en fait, ce n’est pas le cosinus et la tangente de π

2que scilab calcule, mais celles d’un angle

voisin, cf. 3.4.3 scilab ne donne que des résultats approchés. La problème de la précision des calculs est un réel

problème pour l’utilisateur ordinaire qui ne sait pas comment scilab fait ses calculs, cf. 3.4, et quiconsidère que c’est une boîte noire : on ne sait pas ce qui se passe dedans. Difficile de faire autrement.

3 Enfin, pour calculer les sinus des éléments d’un tableau A, on voit qu’il suffit de la commande sin(A).scilab retourne le tableau de mêmes dimensions que A dont les éléments sont les sinus des élémentscorrespondants de A. On pourra dire que la commande sin est vectorisée.

3 Cette faculté de calculer les valeurs d’une fonction de la bibliothèque scilab par tableau, composantepar composante, est extrêmement pratique.

22

3.3 [*] Conversion de la base 2 à la base 10

Soit n un entier ⩾ 1 donné sous sa forme N = [a0, a1, . . . , ap] dans le système à base 2 :a0, . . . , ap−1 sont chacun égaux à 0 ou à 1, ap = 1 et p désigne un entier ⩾ 0 tels que

n = a0 + a1· 2 + · · ·+ ap· 2p

Problème : écrire n dans le système décimal.

Mots-clefs : commandes input, size(N,'c'), length, ones, sum, opérations élément par élément, fonctiond’un tableau.

L’algorithme qui suit est un peu violent. Il montre comment scilab traite les tableaux de nombres et pourquoiil permet d’écrire des algorithmes très courts.�N=input ( ’N=’ ) ;n=sum(N. * 2 . ^ ( 0 : s ize (N, ’ c ’ )−1)) ;a f f i c h e r (n ) ;� �Dans ce script, on obtient n en multipliant le vecteur N par le vecteur 2.^[0,1,...,p]=[2^0,2^1,...,2^p]composante par composante (le vecteur (0:size(N,'c')-1) est [0,1,...,p] ; il faut tenir compte de lapriorité de ^ sur *). size(N,'c') est le nombre de colonnes de N.Voici le même algorithme un peu détaillé et commenté. Nous avons remplacé size(N,'c') par length(N).�N=input ( ’N=’ ) ; // Sa i s i r N ( l i s t e des c o e f f i c i e n t s dyadiques ) .P=0 :( length (N)−1) ;// P=[0 , 1 , . . . , p ] .Q=2.^P; // Q=[2^0 ,2^1 , . . . ,2^ p ]R=N.*Q; //R=[a0*2^0 , a1 *2^1 , . . . , ap*2^p ]n=sum(R) ; // n=a0*2^0+a1*2^1+...+ap*2^pa f f i c h e r (P ) ;a f f i c h e r (Q) ;a f f i c h e r (n ) ;� �Quand on charge ce script dans la console, scilab demande de saisir N. Par exemple, si (N=[1,1,1,1,1,1,1]),on obtient :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)N=[1 , 1 , 1 , 1 , 1 , 1 , 1 ]

0 . 1 . 2 . 3 . 4 . 5 . 6 .1 . 2 . 4 . 8 . 16 . 32 . 64 .127 .

−−>� �

23

3.4 [*] Les erreurs de scilab

1 - Calculer .6*9+.6.2 - Calculer floor(.6*9+.6). Comparer.

Mots-clefs : erreur, représentation des nombres réels, dépassement de capacité (overflow), erreur d’arrondi,commandes clear, floor, constantes %eps, %nan et %inf.

Tous les manuels consacrés à scilab exhibent des calculs faux ou impossibles. Nous en avons déjà rencontrésdans l’exercice 3.2. On sait bien que diviser 1 par 0 est impossible (par exemple). Ce cas peut se produiresi le dénominateur d’un quotient non nul très proche de 0 est transformé en 0 par scilab. Ceci est dû à lareprésentation des nombres réels choisie par scilab. Ce problème s’impose de lui-même 1. Dans une machine,les nombres réels sont représentés comme des nombres flottants 2 :

x = ± 0.b1b2 . . . bt10e

La partie 0.b1b2 . . . bt s’appelle la mantisse et e l’exposant. Le nombre t s’appelle le nombre de chiffres signi-ficatifs. Scilab utilise l’arithmétique IEEE pour laquelle −308 ⩽ e ⩽ 308. Un calcul bien programmé ne peutconduire à des nombres en dehors de ces limites. Si cela arrive, il y a dépassement de capacité ou overflow. Àl’intérieur de ces limites, la machine arrondit tout résultat vers le plus proche nombre flottant. La distanceentre 1 et nombre flottant supérieur à 1 le plus proche s’appelle la précision de la machine ou ε-machine(%eps). Au voisinage de 1, l’erreur d’approximation du résultat d’un calcul par un nombre flottant est donc%esp/2.

�−−>clear−−>%eps%eps =

2.220D−16−−>1+0.5*%epsans =

1 .−−>1+0.5*%eps==1ans =T

−−>1+0.6*%epsans =

1 .−−>1+0.6*%eps==1ans =F

−−>� �On voit que 1+0.5*%eps vaut bien 1. Par contre, l’avant-dernière ligne 3 est troublante. On attendait évi-demment 1+%0.6*%eps=1+%eps.Retenons encore que dans l’arithmétique IEEE, le plus grand nombre > 0 possible est voisin de 1.797· 10308.Le plus petit nombre positif possible est de l’ordre de 10−324. Se reporter à [11], chapitre 15 - L’arithmé-tique de l’ordinateur dont ces lignes sont extraites. Le lecteur aura aussi intérêt à prendre connaissance des

1. Il est clair que l’on ne peut pas saisir dans un ordinateur un nombre irrationnel, par exemple parce que celui-ci s’écritavec une infinité de chiffres dans le système de numération en base 10.

2. nombres à virgule flottante3. contredite heuresement par la dernière ligne

24

constantes %nan et %inf, cf. [11], pp. 67-68. On doit pouvoir les éviter en classe.L’exercice suivant (cf. [11]) est également troublant :�−−>.6*9+.6ans =

6 .−−>.6*9+.6−6ans = − 8.881784197D−16

−−>f loor ( . 6*9+.6)ans =

5 .−−>� �La première réponse est 6. On s’attend que la partie entière de ce nombre soit 6. Mais scilab retourne 5(dernière ligne). Cela s’explique : pour effectuer ce calcul élémentaire pour nous, scilab ré-écrit ces nombresen base 2, ce qui entraîne des arrondis et des erreurs d’arrondis. Dans ce cas, cela se passe assez mal. Ladeuxième réponse montre que .6*9+.6 est strictement plus petit que 6 et que l’écart est plus grand quel’ε-machine. Il en résulte que la troisième réponse est fausse et que l’on ne peut pas contrer l’erreur (parexemple en considérant que des nombres dont la distance est inférieure à l’ε-machine sont en fait égaux).Cela n’est pas satisfaisant. scilab ne fait que ce qu’on lui à appris à faire lors de sa conception. Il ne faitpas d’erreur. Le problème pour les utilisateurs est qu’ils ne savent pas quels choix ont été faits. C’est trèsinconfortable.

25

Chapitre 4

Manipulations élémentaires

Liste des exercices :

énoncé no 4.1 : [*] Échanger deux nombres.Énoncé no 4.2 : [*] Échanger deux nombres dans une liste.Énoncé no 4.3 : [**] Échanger deux colonnes (ou deux lignes) d’un tableau.Énoncé no 4.4 : [**] Ré-arrangement fantaisie d’une suite de nombres.Énoncé no 4.5 : [*] Combien de temps l’exécution d’un script prend-elle ?Énoncé no 4.6 : [***] Sur la définition du produit matriciel.Énoncé no 4.7 : [***] Calcul de nombres de dérangements.

26

4.1 [*] Échanger deux nombres

Soit X = [a, b] une liste (un vecteur) de deux nombres. Donner un script qui retourne [b, a].

Mots-clefs : commandes X(B), length, afficher.

Solution no 1 : Pour échanger deux nombres, on peut utiliser une variable auxiliaire, notée c ci-dessous :�a=input ( ’ a=’ ) ;b=input ( ’b=’ ) ;X=[a , b ] ;a f f i c h e r (X) ;c=a ;X(1)=b ;X(2)=c ;a f f i c h e r (X) ;� �Ce script ayant été chargé dans la console, appliquons-le :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)a=−3/2 ;b=sqrt ( 2 ) ;

− 1 .5 1.41421356237311.4142135623731 − 1 .5

−−>� �La première ligne est la valeur originale de X ; la seconde sa valeur retournée.Solution no 2 : On peut éviter d’utiliser une variable supplémentaire. C’est l’objet du script suivant :�a=input ( ’ a=’ ) ;b=input ( ’b=’ ) ;

a=a+b ;b=a−b ;a=a−b ;X=[a , b ] ;a f f i c h e r (X) ;� �

Le tableau ci-dessous indique dans la première colonne la commande que l’on vient d’exécuter, dans ladeuxième et la troisième colonnes le contenu des variables a et b.

a ba=a+b a+b bb=a-b a+b aa=a-b b a

Solution no 3 : Même si ce n’est pas évident sur un exemple aussi simple, il vaut mieux utiliser lescommandes scilab parce qu’elles sont plus rapides (ça compte quand elles sont répétées un grand nombrede fois). Le script suivant est bien meilleur. Il utilise la commande X(B) que nous décrivons maintenant :X étant un vecteur de longueur n, B un vecteur d’entiers compris entre 1 et n, la commande X(B) retournele vecteur des éléments de X dont les indices appartiennent à B. Par exemple (ici on a travaillé directementdans la console) :�−−>X=[−2 ,1.5 ,175 ,−8 ,− .4 ] ;−−>n=length (X)

27

n =5 .

−−>B=[3 ,2 , 2 , 5 ]B =

3 . 2 . 2 . 5 .−−>X(B)

ans =175 . 1 . 5 1 .5 − 0 .4

−−>� �Cette commande est très pratique.

�a=input ( ’ a=’ ) ;b=input ( ’b=’ ) ;X=[a , b ] ;a f f i c h e r (X) ;X=X( [ 2 , 1 ] ) ;a f f i c h e r (X) ;� �

28

4.2 [*] Échanger deux nombres dans une liste

Écrire un script qui, étant donné une liste de nombres X = [x1, . . . , xn] et deux indices i et j,retourne X après avoir échangé xi et xj .

Mots-clefs : commande X(B), input, afficher.

Cet exercice contient l’exercice 4.1 comme cas particulier. La bonne solution est la seconde.Rappel : X étant un vecteur de longueur n, B un vecteur d’entiers compris entre 1 et n, la commande X(B)retourne le vecteur dont les composantes sont les éléments de X dont les indices appartiennent à B.Solution no 1 : La solution la plus simple consiste à utiliser une variable auxiliaire a.�X=input ( ’X=’ ) ;i=input ( ’ i= ’ ) ;j=input ( ’ j= ’ ) ;A=X;a=A( i ) ;A( i )=A( j ) ;A( j )=a ;Y=A;a f f i c h e r (X) ;a f f i c h e r (Y)� �On peut éviter d’introduire une variable auxiliaire comme dans la solution no2 de 4.1.On charge ce script dans la console de scilab. Traitons le cas où X est une liste de 10 nombres choisis auhasard entre 0 et 1, i=3, j=7. On constate en lisant X (première liste de nombres) et Y (deuxième liste denombres) que les termes de rang 3 et 7 ont bien été échangés.�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)X=t i r a g e_r e e l ( 1 0 , 0 , 1 ) ;i =3 ;j =7 ;

column 1 to 30.6019819397479 0.4719568016008 0.2629712824710

column 4 to 60.3402196990792 0.6540790954605 0.5298419883475

column 7 to 90.6892144982703 0.7161007095128 0.7481515908148

column 100.9883793974295

column 1 to 30.6019819397479 0.4719568016008 0.6892144982703

column 4 to 60.3402196990792 0.6540790954605 0.5298419883475

column 7 to 90.2629712824710 0.7161007095128 0.7481515908148

column 100.9883793974295

−−>� �29

Solution no 2 : Voici une deuxième solution, plus compacte, plus élégante, plus rapide :�X=input ( ’X=’ ) ;a f f i c h e r (X) ;i=input ( ’ i= ’ ) ;j=input ( ’ j= ’ ) ;X( [ i , j ])=X( [ j , i ] )a f f i c h e r (X) ;� �Chargeons ce script dans la console de scilab et appliquons-le.�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)X=t i r a g e_en t i e r ( 10 , 0 , 1 00 ) ;

column 1 to 954 . 17 . 94 . 60 . 62 . 89 . 63 . 25 . 41 .

column 1044 .

i=4j=9

column 1 to 954 . 17 . 94 . 41 . 62 . 89 . 63 . 25 . 60 .

column 1044 .

−−>� �On constate que les termes de rang 4 et 9 ont bien été échangés.Si on avait voulu supprimer les termes de rangs 3 et 5 de la liste, on aurait tapé, directement dans la console :

�−−>X( [ 3 , 5 ] ) = [ ] ;X� �et obtenir :�X =

54 . 17 . 41 . 89 . 63 . 25 . 60 . 44 .−−>� �

30

4.3 [*] Échanger deux colonnes ou deux lignes d’une matrice

Engendrer un tableau de nombres à n lignes et m colonnes à l’aide de la commandegrand(n,m,'uin',-13,14) puis échanger les colonnes i et j (i et j donnés)

Mots-clefs : Commandes input, grand(n,m,'uin',p,q), X(B) 1, afficher.

grand(n,m,'uin',-13,14), plus généralement grand(n,m,'uin',p,q), n’est pas une commande de scilabpour les lycées mais de scilab général. Il suffit de savoir qu’elle retourne ici un tableau de nombres entierscompris entre -13 et 14, bornes comprises, à n lignes et m colonnes (on ne peut pas se contenter descommandes tirage_reel(n,a,b) et tirage_entier(n,a,b) car ces commandes (de scilab pour les lycées)n’engendrent que des listes de nombres).On peut utiliser le script suivant qui rappelle la solution no2 de 4.2 :�n=input ( ’n=’ ) ;m=input ( ’m=’ ) ;X=grand (n ,m, ’ uin ’ ,−13 ,14) ;a f f i c h e r (X) ;i=input ( ’ i= ’ ) ;j=input ( ’ j= ’ ) ;X( : , [ i , j ])=X( : , [ j , i ] ) ;a f f i c h e r (X) ;� �dont voici une application :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)n=7m=9

− 13 . 10 . 6 . − 3 . 5 . − 11 . − 8 . − 13 . − 8 .9 . − 9 . − 5 . 11 . − 4 . 11 . − 10 . 11 . − 11 .

− 12 . 9 . − 13 . − 6 . − 1 . − 3 . 8 . − 11 . − 11 .1 . − 6 . 12 . 11 . − 5 . 10 . − 11 . 2 . 13 .

− 10 . 2 . 4 . − 12 . 11 . 12 . 14 . 9 . 3 .− 5 . − 13 . − 11 . − 6 . − 5 . − 2 . 0 . 1 . − 10 .− 8 . − 3 . − 10 . − 1 . 2 . 10 . − 11 . − 5 . 9 .

i=3j=4− 13 . 10 . − 3 . 6 . 5 . − 11 . − 8 . − 13 . − 8 .

9 . − 9 . 11 . − 5 . − 4 . 11 . − 10 . 11 . − 11 .− 12 . 9 . − 6 . − 13 . − 1 . − 3 . 8 . − 11 . − 11 .

1 . − 6 . 11 . 12 . − 5 . 10 . − 11 . 2 . 13 .− 10 . 2 . − 12 . 4 . 11 . 12 . 14 . 9 . 3 .− 5 . − 13 . − 6 . − 11 . − 5 . − 2 . 0 . 1 . − 10 .− 8 . − 3 . − 1 . − 10 . 2 . 10 . − 11 . − 5 . 9 .

−−>� �Les colonnes no3 et no4 de la matrice X à 7 lignes et 9 colonnes ont été échangées.Pour échanger deux lignes, problème analogue, on pourra utiliser le script suivant :

1. Voir le rappel au début de l’exercice 4.2.

31

�n=input ( ’n=’ ) ;m=input ( ’m=’ ) ;X=grand (n ,m, ’ uin ’ ,−13 ,14) ;a f f i c h e r (X) ;i=input ( ’ i= ’ ) ;j=input ( ’ j= ’ ) ;X( [ i , j ] , : )=X( [ j , i ] , : ) ;a f f i c h e r (X) ;� �dont voici une application :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=7m=9

− 2 . − 5 . − 5 . − 12 . − 1 . − 1 . 13 . 6 . 4 .5 . − 2 . 3 . 8 . − 5 . − 2 . 7 . 0 . 3 .

− 4 . − 12 . − 11 . 14 . 5 . − 9 . 7 . 4 . − 13 .13 . 3 . − 1 . 14 . 6 . 7 . 5 . 5 . − 6 .0 . − 13 . − 6 . 3 . − 11 . − 13 . − 10 . − 13 . − 1 .

− 5 . − 7 . − 5 . 5 . − 5 . − 12 . − 3 . − 6 . 4 .0 . − 4 . 14 . 1 . 4 . 11 . − 13 . 11 . 11 .

i=3j=4− 2 . − 5 . − 5 . − 12 . − 1 . − 1 . 13 . 6 . 4 .

5 . − 2 . 3 . 8 . − 5 . − 2 . 7 . 0 . 3 .13 . 3 . − 1 . 14 . 6 . 7 . 5 . 5 . − 6 .

− 4 . − 12 . − 11 . 14 . 5 . − 9 . 7 . 4 . − 13 .0 . − 13 . − 6 . 3 . − 11 . − 13 . − 10 . − 13 . − 1 .

− 5 . − 7 . − 5 . 5 . − 5 . − 12 . − 3 . − 6 . 4 .0 . − 4 . 14 . 1 . 4 . 11 . − 13 . 11 . 11 .

−−>� �Les lignes no3 et no4 ont été échangées.Si on voulait supprimer les lignes de rang impair de X, on taperait directement dans la console :�−−>X(1 :2 :n , : ) = [ ] ;X� �ce qui donnerait :�X =

5 . − 2 . 3 . 8 . − 5 . − 2 . 7 . 0 . 3 .− 4 . − 12 . − 11 . 14 . 5 . − 9 . 7 . 4 . − 13 .− 5 . − 7 . − 5 . 5 . − 5 . − 12 . − 3 . − 6 . 4 .

−−>� �On a effacé les lignes numéros 1, 3, 5 et 7. Il ne reste que les lignes de rangs 2, 4 et 6.

32

4.4 [*] Ré-arrangement d’une suite de nombres (fantaisie)

Étant donné une liste de nombresX = [x1, . . . , xn], retourner la liste [x2, x4, . . . , x1, x3, . . .] (suitedes termes de rang pair de X suivis des termes de rang impair)

Mots-clefs : Commande X(B), length, input, x :y et x :p :y.

Rappel : X étant un vecteur de longueur n, B un vecteur d’entiers compris entre 1 et n, la commande X(B)retourne le vecteur dont les composantes sont les éléments de X dont les indices appartiennent à B.x :y retourne la liste des nombres de x à y par pas de 1 ; x :p :y retourne la liste des nombres de x à y parpas de p. On peut utiliser le joli script commenté suivant :�X=input ( ’X=’ ) ; // X e s t une l i s t e de nombres .n=length (X) ; // Longueur de l a l i s t e X.B=2 :2 :n ; // L i s t e des e n t i e r s pa i r s <=n à pa r t i r de 2 .C=1 :2 :n ; // L i s t e des e n t i e r s pa i r s <=n à pa r t i r de 1 .Y=[X(B) ,X(C ) ] ;a f f i c h e r (X) ;a f f i c h e r (Y) ;� �Le script ci-dessus, qui n’est pas vraiment élémentaire, ayant été chargé dans la console, en voici uneapplication :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)X=t i r a g e_en t i e r (7 ,−3 ,6)

2 . 5 . 0 . 2 . 2 . − 3 . 3 .5 . 2 . − 3 . 2 . 0 . 2 . 3 .

−−>� �La première ligne est X, la seconde est Y. La commande Y=[X(B),X(C)] produit Y comme la liste des termesde rang pair suivie de la liste des termes de rang impair. Il n’y a pas à se soucier de la parité de n.

33

4.5 [*] Combien de temps l’exécution d’un script prend-elle ?

Engendrer une liste de 100 000 nombres ; inverser l’ordre de ces nombres et retourner le temps decalcul de cette inversion.

Mots-clefs : commande « tic(); opération; toc() », tirage_reel(100000,0,1), afficher.

Dans l’énoncé, inverser une liste de nombres signifie l’écrire en commençant par son dernier terme, puis sonavant-dernier, etc.La séquence de commandes tic(); opération; toc(); affiche le nombre de secondes nécessaires pouropération (voir l’aide en ligne). Nous allons engendrer la liste de nombres demandée à l’aide de la commandetirage_reel(100000,0,1) qui va fournir 100000 nombres réels entre 0 et 1, puis ranger ces nombres enpartant de la fin.Solution no 1 : utilisons le joli script :�X=t i r a g e_r e e l ( 100000 , 0 , 1 ) ;t i c ( ) ;Y=X(100000 :−1 :1) ;temps=toc ( ) ;a f f i c h e r ( ’ Les␣5␣ d e rn i e r s ␣ termes ␣de␣X␣ sont ’ )a f f i c h e r (X(99996 :100000) ) ;a f f i c h e r ( ’ Les␣5␣ premiers ␣ termes ␣de␣Y␣ sont ’ )a f f i c h e r (Y( 1 : 5 ) ) ;a f f i c h e r ( ’L” i nv e r s i o n ␣a␣duré␣ ’+string ( temps)+ ’ ␣ secondes . ’ )� �Les commandes d’affichage sont ici compliquées et utilisent des manipulations de chaînes de caractères. Onvoit un peu comment ça marche ; sinon, voir l’aide en ligne. On aurait pu se contenter de :�a f f i c h e r (X(99996 :100000) ) ;a f f i c h e r (Y( 1 : 5 ) ) ;a f f i c h e r ( temps )� �ou même se contenter de :�a f f i c h e r ( temps ,Y(1 : 5 ) ,X(99996 :100000) ) ;� �Le temps qui est compté est le temps d’inversion de X, sans le temps qu’il faut pour engendrer X ni le tempsd’affichage. On charge ce script dans la console. Il s’exécute automatiquement et retourne :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)Les 5 d e r n i e r s termes de X sont

column 1 to 30.0006993855350 0.7740111986641 0.5493441692088

column 4 to 50.3015413670801 0.7123542702757

Les 5 premiers termes de Y sontcolumn 1 to 3

0.7123542702757 0.3015413670801 0.5493441692088column 4 to 5

0.7740111986641 0.0006993855350L ’ i nv e r s i o n a duré 0 .003 secondes−−>� �

34

On voit ici que scilab est très rapide car on vient de manipuler 100 000 nombres !Solution no 2 : utilisons maintenant un script maladroit, voir l’exercice 6.18 :�X=t i r a g e_r e e l ( 100000 , 0 , 1 ) ;t i c ( ) ;Y=[X(100000 ) ]for i =2 :100000

Y=[Y,X(100000− i +1) ] ;endtemps=toc ( ) ;a f f i c h e r ( ’ Les␣5␣ d e rn i e r s ␣ termes ␣de␣X␣ sont ’ )a f f i c h e r (X(99996 :100000) ) ;a f f i c h e r ( ’ Les␣5␣ premiers ␣ termes ␣de␣Y␣ sont ’ )a f f i c h e r (Y( 1 : 5 ) ) ;a f f i c h e r ( ’L ’ ’ i n v e r s i o n ␣a␣duré␣ ’+string ( temps)+ ’ ␣ secondes ’ )� �Chargeons ce script dans la console. Il s’exécute automatiquement. On obtient :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)Les 5 d e r n i e r s termes de X sont

column 1 to 30.1685154619627 0.7311467428226 0.7330885585397

column 4 to 50.6812806068920 0.4993714094162

Les 5 premiers termes de Y sontcolumn 1 to 3

0.4993714094162 0.6812806068920 0.7330885585397column 4 to 5

0.7311467428226 0.1685154619627L ’ i nv e r s i o n a duré 27 .949 secondes−−>� �La lenteur du deuxième script est due à la boucle pour. Il y a peut-être une boucle pour dans le premierscript, cachée dans une commande scilab de niveau plus élevé. Si c’est le cas (?), elle a été programmée dansun langage de programmation plus efficace. On peut en tirer diverses conclusions :• il y a souvent plusieurs algorithmes solutions d’un problème donné, on peut mesurer leur vitesse d’exécutionà la milliseconde près avec les commandes tic() et toc() comme on vient de le voir ;• c’est un jeu de chercher le script le plus rapide et éventuellement de pouvoir le comparer aux algorithmesscilab, qui a une bibliothèque d’algorithmes très riche ;• il est gratifiant d’écrire un algorithme avec des commandes élémentaires uniquement, mais c’est sans espoirconcernant la vitesse d’exécution, l’occupation d’espace-mémoire, etc ; toutes les fois que c’est possible, ilfaut remplacer les séquences de commandes qui s’y prêtent par des commandes évoluées ;• enfin, il est bon d’utiliser au mieux les capacités de calcul de scilab directement sur des tableaux.

35

4.6 [***] Sur la définition du produit matriciel

Soit A = (ai,j) et B = (bi,j) deux matrices, A ayant n lignes et m colonnes, B ayant m ligneset p colonnes (le nombre de colonnes de A est égal au nombre de lignes de B). Alors C = A·B(commande scilab : C=A*B) est la matrice à n lignes et p colonnes définies par

ci,j =∑

k=1,...,m

ai,k· bk,j

1 - Soit A=tirage_entier(0,10,7) et B=tirage_entier(-14,27,7) deux listes de 7 nombres.Peut-on effectuer le produit A*B de ces matrices ?2 - Calculer B'. Décrire cette matrice.3 - Peut-on effectuer le produit B*A ? B*A' ? Décrire B*A'.4 - Soit C=grand(7,7,"uin",-2,8) une matrice à 7 lignes et 7 colonnes (matrice carrée). Décrireles matrices A*C et C*A'.

Mots-clefs : produit matriciel, transposition de matrices (commande ').

Il suffit de savoir que A=tirage_entier(0,10,7) et B=tirage_entier(-14,27,7) sont deux listes de 7entiers compris entre 0 et 10 pour la première, entre -14 et 27 pour la seconde.1 - Non, car le nombre de colonnes de A n’est pas égal au nombre de lignes de B. Voilà ce que retourne scilab(tapé directement dans la console) :�−−>A=t i r a g e_en t i e r (7 , 0 , 10 )A =

6 . 3 . 10 . 9 . 4 . 7 . 0 .−−>B=t i r a g e_en t i e r (7 ,−14 ,27)B =

− 9 . − 14 . 11 . − 1 . 3 . 4 . − 14 .−−>A*B

!−−error 10Mu l t i p l i c a t i o n incohé r ente .−−>� �2 - B' s’obtient en écrivant B en colonne. B' s’appelle la transposée de B. En tapant B' dans la console puisEntree, on obtient en effet :�−−>B’ans =− 9 .− 14 .

11 .− 1 .

3 .4 .

− 14 .−−>� �3 - Le produit matriciel B*A est impossible. B*A' est la somme des produits des composantes des rangscorrespondants de B et A. Si on avait choisi au départ des listes de 3 nombres (au lieu de 7), on aurait obtenule produit scalaire de la géométrie euclienne.�−−>A*B’

36

ans =45 .

−−>� �4 - Pour A*C, voir ci-dessous. Décrire les matrices A*C et C*A' est difficile. En pensant à la question 3, onpeut comprendre que A*C est la liste des produits scalaires de A par les colonnes successives de C. De même,C*A' est la colonne des produits scalaires des lignes successives de C par la colonne A’.�−−>C=grand (7 , 7 , ” uin ” ,−2 ,8)C =

− 2 . 3 . − 1 . 5 . 2 . − 2 . 0 .3 . 5 . 4 . 6 . 8 . 3 . 6 .0 . 6 . 4 . 5 . 3 . 0 . 0 .1 . 4 . − 2 . − 1 . 6 . 7 . − 1 .0 . 1 . 0 . 2 . 2 . 1 . 4 .5 . − 1 . − 1 . 7 . − 1 . 4 . 3 .4 . 5 . − 1 . 2 . 6 . 6 . 0 .

−−>A*Cans =

column 1 to 641 . 126 . 21 . 146 . 121 . 92 .

column 746 .

−−>C*A’ans =

26 .180 .115 .62 .36 .104 .113 .

−−>� �Bien sûr, toutes les affirmations ci-dessus se démontrent facilement en utilisant la définition du produitmatriciel rappelée dans l’énoncé.

37

4.7 [***] Calcul de nombres de dérangements

Le nombre de dérangements (ou permutations sans point fixe) de la liste (1, . . . , n) est donnépar la formule

Nn = (1× · · · × n)

(1 +

n∑k=1

(−1)k

1× · · · × k

)ou Nn = n !

(1 +

n∑k=1

(−1)k

k !

)

1 - Écrire un script qui, étant donné l’entier n, retourne Nn.2 - Quelle est la plus grande valeur de n qui permet à scilab d’afficher Nn exactement (c’est àdire sans passer en notations flottantes) ? Combien Nn vaut-il alors ?

Mots-clefs : commandes input, format, cumprod, sum, $, puissance composante par composante (.^),division composante par composante (./).

1 - Ceci est un pur exercice de calcul. Il est inutile de savoir ce que « dérangements » veut dire. Dansle script qui suit, A=1:n produit la liste ou vecteur (1, . . . , n), B=(-1).^A retourne la liste ou vecteur((−1)1, . . . , (−1)n

)à savoir −1 élevé à la puissance A composante par composante, qui a la même longueur

que A, C=cumprod(A) donne le vecteur (1 !, . . . , n !) (premier terme de A, produit des 2 premiers termes deA, …, produit des n premiers termes de A). Cette commande évite d’utiliser des boucles pour. C($) est ledernier terme de C, soit n ! et B./C est le vecteur des quotients des éléments de B par les éléments de C demême rang. Cela donne finalement un script compact inutilement compliqué car la suite (Nn, n ⩾ 1) suitune relation de récurrence qui permet de faire ces calculs plus simplement et plus rapidement.�n=input ( ’n=␣ ’ ) ;format ( ’ v ’ , 2 5 ) ; // Capaci té maximum d ’ a f f i c h a g e .A=1 :n ;B=(−1).^A; // −1, 1 , . . . , (−1)^n .C=cumprod(A) ; // 1 , 1*2 , . . . , 1* . . . * nN=C($)*(1+sum(B. /C) ) ; // C($ ) e s t l e de rn i e r terme de C.a f f i c h e r (N) ;� �2 - On trouve la plus grande valeur de n qui permet un affichage exact de Nn par tâtonnement. On obtientplus précisément :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n= 23

9510425471055776710656.−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n= 24

2.282502113053385907D+23−−>� �C’était fatal car scilab peut afficher exactement 23 ! = 1 × · · · × 23 mais passe en notations flottantes pourafficher 24 ! = 1× · · · × 24.

38

Chapitre 5

Programmer une fonction scilab

La syntaxe de la définiton d’une fonction scilab est :

function <arguments_sortie>=<nom_de_la_fonction><arguments_entrée><instructions>endfunction

(voir l’aide en ligne ou un manuel).

Liste des exercices :Énoncé no 5.1 [*] : Volume du cône.Énoncé no 5.2 [*] : Aire d’un trapèze.Énoncé no 5.3 [**] : Moyenne et variance empiriques.Énoncé no 5.4 [**] : Conversion de temps.

39

5.1 [*] Volume du cône

1 - Fabriquer une fonction-scilab qui calcule le volume v d’un cône de révolution de hauteur het dont la base est un disque de rayon r.2 - Cette fonction accepte-t-elle que r et h soient des listes de nombres (ce qui serait utile si onvoulait faire varier le rayon et la hauteur) ?

Mots-clefs : fonction scilab ; à la fin : calcul matriciel (produit, transposition d’une matrice).

On admet que la formule qui donne ce volume est v =πr2h

3·

Solution 1 : Nous pouvons faire de cette formule une fonction-scilab dans SciNotes. Ce sera une fonctionavec 2 entrées h et r et une seule sortie v, appelée volcone ci-dessous. Cette solution est élémentaire.�function v=volcone (h , r ) ; // Le nom de c e t t e f onc t i on e s t vo lcone .

v=%pi* r ^2*h/3 ;endfunction ; //Fin de l a d e f i n i t i o n de vo lcone� �Les commentaires (sur une ligne, précédés de //) sont souvent utiles mais n’ont aucune action sur l’exécutionde la fonction. Aussi, on peut se contenter de :�function v=volcone (h , r ) ;v=%pi*h* r ^2/3 ;

endfunction� �Remarques :• Quand un script est long ou compliqué, les commentaires sont presque toujours indispensables pour lecomprendre.• Enregistrons ce script (fichier de commandes) sous le nom volcone.sci. L’extension sci rappelle qu’ils’agit d’une fonction scilab. L’extension sce n’aurait pas posé de problème. C’est un simple procédé mné-motechnique pour distinguer les fonctions scilab des scripts ordinaires.• Pour utiliser cette fonction, il faut la charger dans la console de scilab, ce qui se fait avec l’option Fichiersans écho du menu Exécuter de la console.• Si on avait choisi Fichier avec écho, le script aurait été recopié sur la console de scilab, ce qui auraitnui à la clarté de l’écran. Cette option est donc à éviter.• Les variables h et r qui figurent dans le script de la fonction volcone sont ignorées quand celui-ci estchargé dans la console. Cela veut dire que l’on peut nommer h ou r d’autres variables, sans inconvénient.• On ne voit pas bien l’intérêt de définir une fonction comme volcone sauf peut-être si ce calcul est répétéun grand nombre de fois.Utiliser volcone :On charge volcone dans la console, ce qui donne :�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)−−>� �Ensuite, volcone s’utilise comme une fonction scilab ordinaire. Comme nous l’avons construite nous-mêmes,nous savons exactement quel est son domaine d’application :• Cas 1. h et r sont des nombres (⩾ 0). Par exemple, calculons le volume d’un cône de hauteur 3 et derayon

√2. Il suffit de taper la commande vol=volcone(3,sqrt(2)), si on appelle vol le volume à calculer,

ce qui retourne, après un retour-chariot :

40

�−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)−−>vol=volcone (3 , sqrt ( 2 ) )vo l =

6.2831853071796−−>� �• Cas 2. r est un nombre et h une liste de nombres. Par exemple, si l’on veut calculer les volumes de cônesde rayon

√2 et de hauteurs variant de 0 à 5 avec un pas de 0.5, on tapera les commandes :�

−−>r=sqrt ( 2 ) ;−−>h=0 :0.5 :5 ;−−>volcone (h , r )� �qui retourneront�ans =

column 1 to 30 . 1.0471975511966 2.0943951023932

column 4 to 53.1415926535898 4.1887902047864

column 6 to 75.235987755983 6.2831853071796

column 8 to 97.3303828583762 8.3775804095728

column 10 to 119.4247779607694 10.471975511966

−−>� �(ans parce que l’on a omis de donner un nom aux quantités à calculer). Ça marche parce que la commandev=%pi*h*r^2/3 est exécutable par scilab (pour multiplier une matrice, ici h par un nombre, ici r^2, onmultiplie tous les éléments de la matrice par ce nombre ; même chose pour la division de %pi*h*r^2 par 3).• Cas 3. h est un nombre et r une liste de nombres : ça ne marche pas parce que la commande r^2 n’est pasexécutable (produit de matrices impossible, sauf si r est un nombre, c’est à dire une matrice à un élément !• Cas 4. A fortiori, h et r ne peuvent pas être des listes de plus d’un nombre (car apparaît un produit de2 matrices impossible).Solution 2 : Pourtant, tous les cas fonctionnent si on modifie légèment la définition de la fonction volcone,rebaptisée volconebis, comme suit :�function v=vo l coneb i s (h , r ) ; // r e s t une matrice−colonne , h une matrice−l i g n e .v=%pi* r .^2*h/3 ;

endfunction� �r.^2 signifie que la matrice r est élevée au carré composante par composante. Si on veut faire varier r de 0à 2 avec un pas de 0.1 et h comme dans le cas 2, on tapera les commandes :�function v=vo l coneb i s (h , r ) ; //h e t r sont 2 matrices−l i g n e s .v=%pi*r ’ . ^ 2 * h/3 ;

endfunctionformat ( ’ v ’ , 5 ) ;r =0 :0.1 :1 ; //matrice−l i g n e de longueur 11.h=0 :0.5 :4 ; //matrice−l i g n e de longueur 9 .volumes=vo l coneb i s (h , r )a f f i c h e r ( volumes )� �

41

Remarques :• volconebis fait tout ce que faisait volcone car les nombres sont des matrices à une ligne et une colonne.• Ce script a été écrit entièrement dans SciNotes (c’est une variante) et chargé dans la console. Il s’exécutealors automatiquement.• Le nombre de décimales a été limité à 2 avec la commande format pour raccourcir l’affichage.• r' est matrice transposée de r : c’est une matrice-colonne.• Il en résulte que la matrice r'.^2 est composée des carrés des éléments de r écrits en colonne ; les règlesde multiplication des matrices, pour r'.^2 et h, sont bien respectées.Ce script retourne :�−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ charg \ ’ {e} ’ , ␣−1)␣␣␣␣ 0 . ␣␣␣␣ 0 . ␣␣␣␣␣␣ 0 . ␣␣␣␣␣␣ 0 . ␣␣␣␣␣␣ 0 . ␣␣␣␣␣␣ 0 . ␣␣␣␣␣␣ 0 . ␣␣␣␣␣␣ 0 . ␣␣␣␣␣␣ 0 .␣␣␣␣ 0 . ␣␣␣␣ 0 .01 ␣␣␣␣ 0 .01 ␣␣␣␣ 0 .02 ␣␣␣␣ 0 .02 ␣␣␣␣ 0 .03 ␣␣␣␣ 0 .03 ␣␣␣␣ 0 .04 ␣␣␣␣ 0 .04␣␣␣␣ 0 . ␣␣␣␣ 0 .02 ␣␣␣␣ 0 .04 ␣␣␣␣ 0 .06 ␣␣␣␣ 0 .08 ␣␣␣␣ 0 .10 ␣␣␣␣ 0 .13 ␣␣␣␣ 0 .15 ␣␣␣␣ 0 .17␣␣␣␣ 0 . ␣␣␣␣ 0 .05 ␣␣␣␣ 0 .09 ␣␣␣␣ 0 .14 ␣␣␣␣ 0 .19 ␣␣␣␣ 0 .24 ␣␣␣␣ 0 .28 ␣␣␣␣ 0 .33 ␣␣␣␣ 0 .38␣␣␣␣ 0 . ␣␣␣␣ 0 .08 ␣␣␣␣ 0 .17 ␣␣␣␣ 0 .25 ␣␣␣␣ 0 .34 ␣␣␣␣ 0 .42 ␣␣␣␣ 0 .50 ␣␣␣␣ 0 .59 ␣␣␣␣ 0 .67␣␣␣␣ 0 . ␣␣␣␣ 0 .13 ␣␣␣␣ 0 .26 ␣␣␣␣ 0 .39 ␣␣␣␣ 0 .52 ␣␣␣␣ 0 .65 ␣␣␣␣ 0 .79 ␣␣␣␣ 0 .92 ␣␣␣␣ 1 .05␣␣␣␣ 0 . ␣␣␣␣ 0 .19 ␣␣␣␣ 0 .38 ␣␣␣␣ 0 .57 ␣␣␣␣ 0 .75 ␣␣␣␣ 0 .94 ␣␣␣␣ 1 .13 ␣␣␣␣ 1 .32 ␣␣␣␣ 1 .51␣␣␣␣ 0 . ␣␣␣␣ 0 .26 ␣␣␣␣ 0 .51 ␣␣␣␣ 0 .77 ␣␣␣␣ 1 .03 ␣␣␣␣ 1 .28 ␣␣␣␣ 1 .54 ␣␣␣␣ 1 .8 ␣␣␣␣␣ 2 .05␣␣␣␣ 0 . ␣␣␣␣ 0 .34 ␣␣␣␣ 0 .67 ␣␣␣␣ 1 .01 ␣␣␣␣ 1 .34 ␣␣␣␣ 1 .68 ␣␣␣␣ 2 .01 ␣␣␣␣ 2 .35 ␣␣␣␣ 2 .68␣␣␣␣ 0 . ␣␣␣␣ 0 .42 ␣␣␣␣ 0 .85 ␣␣␣␣ 1 .27 ␣␣␣␣ 1 .7 ␣␣␣␣␣ 2 .12 ␣␣␣␣ 2 .54 ␣␣␣␣ 2 .97 ␣␣␣␣ 3 .39␣␣␣␣ 0 . ␣␣␣␣ 0 .52 ␣␣␣␣ 1 .05 ␣␣␣␣ 1 .57 ␣␣␣␣ 2 .09 ␣␣␣␣ 2 .62 ␣␣␣␣ 3 .14 ␣␣␣␣ 3 .67 ␣␣␣␣ 4 .19−−>� �Le script suivant :�format ( ’ v ’ , 5 ) ;r =0 :0.1 :1 ;h=0 :0.5 :4 ;volumes=%pi*r ’ . ^ 2 * h/3 ;a f f i c h e r ( volumes )� �a exactement le même rôle que le précédent. Il se réduit à un simple calcul matriciel.

42

5.2 [*] Aire d’un trapèze

Fabriquer une fonction-scilab qui donne l’aire d’un trapèze de bases b et B et de hauteur h.

Mots-clefs : somme de matrices terme à terme, transposition, produit matriciel.

Solution no 1 : Nous avons appelé cette fonction airtrap. Elle donnera l’aire d’un trapèze de bases b etB et de hauteur h (3 variables). Elle retourne une seule variable : l’aire.�function o l a l a=a i r t r ap (b ,B, h ) ;o l a l a=(b+B)*h/2 ;endfunction� �Chargeons cette fonction dans la console et calculons, par exemple, l’aire d’un trapèze de bases 4 et 5 et dehauteur 3 :�−−>ai r edut rapez e=a i r t r ap (4 , 5 , 3 )a i r edut rapez e =

13 .5−−>� �Solution no 2 : Comme dans l’exercice 5.1, on peut avoir envie de donner à b et B n valeurs, à h p valeurset de calculer les aires de ces trapèzes. Compte tenu de la définition du produit des matrices, il suffit demodifier comme suit la programmation de la fonction airtrap :�function o l a l a=a i r t r a p b i s (b ,B, h ) ;o l a l a=(b+B) ’*h/2 ;endfunction� �(on a simplement transposé la matrice (b+B)). Quand on exécute cette fonction, on obtient un tableau à nlignes et à p colonnes qui sont les aires recherchées. Sur les lignes de ce tableau, on lit les aires pour b et Bfixés, h variant. Sur les colonnes, c’est h qui est fixé . Par exemple :�−−>h= [ 1 , 2 . 4 , 7 ] ; b=1 :0 .3 :4 .1 ;B=1 :11 ; a i r e s d e s t r a p e z e=a i r t r a p b i s (b ,B, h)a i r e s d e s t r a p e z e =

1 . 2 .4 7 .1 .65 3 .96 11 .552 .3 5 .52 16 .12 .95 7 .08 20 .653 .6 8 .64 25 .24 .25 10 .2 29 .754 .9 11 .76 34 .35 .55 13 .32 38 .856 .2 14 .88 43 .46 .85 16 .44 47 .957 .5 18 . 52 .5

−−>� �Remarquer que l’on a saisi plusieurs commandes sur une même ligne, séparées par des ;. La fonction airtrapest devenue inutile car on peut donner à b, B et h une seule valeur et appliquer la fonction airtrapbis.

43

5.3 [*] Moyenne et variance empiriques

1 - Calculer la moyenne et la variance du vecteur[√3,−2.7, 42, log(7), exp(0.8),−4.2, π, 17, 13/11, cos(4), 0] .

2 - Engendrer une liste de n=50 nombres entiers entre les bornes a=-7 et b=39 à l’aide de lacommande tirage_entier(n,a,b), puis calculer sa moyenne et sa variance.

Mots-clefs : tirage_entier, moyenne = mean, variance = variance, afficher = disp.

1 - Le script ci-dessous, sans intérêt, montre une fonction scilab notée MV à une entrée, qui est un vecteurnumérique 1 de longueur 11 et deux sorties, qui sont des nombres 2. Nous avons rédigé la fonction et sonapplication, qui est la solution de la première question, sur un même script dans l’éditeur de texte Scinote.�function [m, v]=MV( L i s t e )

m=mean( L i s t e ) ;v=variance ( L i s t e ) ;

endfunctionL=[sqrt (3) ,−2.7 ,4^2 , log ( 7 ) ,exp (0 .8 ) , −4 .2 ,%pi , 17 ,13/11 , cos ( 4 ) , 0 ] ;[mo, va]=MV(L ) ;disp ( ’La␣moyenne␣ et ␣ l a ␣ var iance ␣de␣ l a ␣ l i s t e ␣de␣nombres␣donnee␣ sontre spect ivement ␣ e g a l e s ␣a ’ ) ;disp (mo) ;disp ( va ) ;� �Voici ce qui apparaît dans la console de scilab :�−−> exec ( ’Chemin␣du␣ s c r i p t ’ , −1)La moyenne et l a variance de l a l i s t e de nombres donnee sontre spect ivement e g a l e s a

3.243024547.767386� �

2 - Cette question requiert une fonction notée mV à trois entrées : n, a et b et trois sorties : la liste desnombres, sa moyenne et sa variance. Les fonctions utilisées tirage_entier, moyenne, variance sont desfonctions usuelles de scilab, voir [12]. Noter que [x,mo,va] est un vecteur numérique de longueur n+2.�function [ x ,mo, va]=mV(n , a , b )

x=t i r a g e_en t i e r (n , a , b ) ;mo=moyenne (x ) ;va=variance ( x ) ;

endfunction// App l i ca t i onn=50 ;a=−7 ;b=39 ;[ x ,mo, va]=mV(n , a , b ) ; // Vecteur de longueur n+2, s o i t 52.a f f i c h e r ( ’L ’ ’ e sperance ␣ et ␣ l a ␣ var iance ␣de␣ ’ ) ;a f f i c h e r ( x ) ;

1. une liste de nombres2. les commandes moyenne, variance et afficher ont dû être remplacées par les commandes en anglais correspondantes

mean, variance et disp à cause des retards habituels de scilab quand l’OS des Mac change.

44

a f f i c h e r ( ’ sont ␣ respect ivement ␣ e g a l e s ␣a ’ ) ;a f f i c h e r (mo) ;a f f i c h e r ( va ) ;−−>� �On obtient dans la console :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)L ’ esperance et l a variance de

column 1 to 130 . 21 . 30 . 30 . 30 . − 3 . 16 . 25 . − 2 . 39 . 32 .

33 . 35 .column 14 to 27

16 . 31 . 39 . 37 . 9 . 22 . − 2 . 37 . 1 . 1 . 1 . 23 .− 2 . 6 .

column 28 to 40− 6 . 35 . 39 . 29 . 39 . 25 . 37 . 36 . 10 . 1 . 36 .

13 . − 3 .column 41 to 50

− 2 . 18 . 13 . 31 . 4 . 35 . 38 . 1 . 37 . 9 .sont re spect ivement e g a l e s a

19 .6242.97959183673

−−>� �ce qui indique que la moyenne de x est approximativement 19.6, sa variance approximativement 242.98.On aurait pu tout aussi bien choisir n = 500000. Alors, scilab aurait entrepris d’afficher 500 000 nombres(affichage de x), ce qui est sans intérêt, long et parfois impossible pour des questions de taille de mémoire.On peut interrompre le processus (menu déroulant « Contrôle »). Même pour une liste de 500 000 nombres,le calcul de la moyenne et de la variance sont pratiquement instantanés.Remarques : Interprétation de la deuxième question en terme de Calcul des probabilitésSoit X une variable aléatoire prenant les valeurs -7, …, 39 avec la même probabilité 1

47 (loi uniforme surl’intervalle d’entiers [−7, . . . , 39]) 3. x peut être considéré comme un échantillon de taille 500 000 de la loide X 4. Alors mo et va sont respectivement la moyenne et la variance empiriques calculées à partir de ces 500000 tirages. Dans l’exercice 6.22, on refait la deuxième question dans un cadre plus général en n’imposantpas que la loi de X soit une loi uniforme, c’est à dire en ne supposant plus que toutes les issues possiblesayant une probabilité > 0 soient équiprobables.

3. On pourrait avec autant de raison supposer que X prend les valeurs -10, …, 50 avec la même probabilité 161

!4. ce que l’on obtient quand on tire au hasard 500 000 fois un nombre entiers compris au sens large entre -7 et 39, les tirages

ètant indépendants les uns des autres

45

5.4 [**] Convertion de temps

Programmer une fonction-scilab qui, étant donné une durée d en secondes, la retourne sous formed’années, mois, jours, heures, minutes et secondes.

Mots-clefs : division euclidienne, commandes floor, pmodulo (quotient et reste de la division euclidienne),disp (afficher) 5, facultativement concaténation de chaînes de caractères.

Est donc demandée une fonction à une entrée numérique et 6 sorties (toutes numériques). C’est un belexercice sur la division euclidienne trouvé dans [13]. En effet, si on divise d par 60, le reste sera le nombrede secondes restantes tandis que le quotient sera le nombre de minutes contenues dans d, et ainsi de suite.Cela donne la fonction-scilab suivante :

Listing 5.1 – fonction Durees�//La fonc t ion−s c i l a b ci−dessous transforme une duree exprimee en secondes en//annees , mois , jours , heures , minutes e t secondes// ( t ou t e s l e s annees ont 365 jours , l e s mois 30 jour s ) .// n e s t un en t i e r >=0.function [ a ,m, j , h ,mn, s ]=Durees (d)

s=pmodulo(d , 6 0 ) ;Mn=f loor (d /60 ) ;mn=pmodulo(Mn, 6 0 ) ;H=f loor (Mn/60) ;h=pmodulo(H, 2 4 ) ;J=f loor (H/24) ;j=pmodulo(J , 3 0 ) ;M=f loor ( J /30 ) ;m=pmodulo(M, 1 2 ) ;a=f loor (M/12) ;disp ( [ a ,m, j , h ,mn, s ] ) ;

endfunction� �Si, par exemple, on veut savoir combien font 1234567890 secondes, on chargera la fonction Durees dans laconsole puis on tapera la commande ad hac :�−−>clear−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣Durees ’ , −1)−−>D=Durees (1234567890) ;

39 . 8 . 8 . 23 . 31 . 30 .−−>� �L’affichage du résultat étant un peu rustique, on pourra préférer le script suivant :

Listing 5.2 – fonction Durees�function [ a ,m, j , h ,mn, s ]=Durees (d)

s=pmodulo(d , 6 0 ) ;Mn=f loor (d /60 ) ;mn=pmodulo(Mn, 6 0 ) ;H=f loor (Mn/60) ;

5. Ces commandes en anglais sont utilisées parce que, comme souvent, les commandes en français ne sont pas disponibles,après un changement d’OS. scilab prend son temps, beaucoup de temps.

46

h=pmodulo(H, 2 4 ) ;J=f loor (H/24) ;j=pmodulo(J , 3 0 ) ;M=f loor ( J /30 ) ;m=pmodulo(M, 1 2 ) ;a=f loor (M/12) ;disp ( [ a ,m, j , h ,mn, s ] ) ;disp ( string (d)+”␣ secondes ␣ font ␣”+string ( a)+”␣annees ␣”+string (m)+”␣mois␣”+string ( j )+”␣ j ou r s ␣”+string (h)+”␣ heures ␣”+string (mn)+”␣minutes ␣”+string ( s )+”␣ secondes . ” )

endfunction� �Les instructions d’affichage sont devenues compliquées. On affiche une chaîne de caractères obtenue enconcaténant (opérateur +) 14 chaînes de caractères. Cela donne :�−−>clear−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣Durees ’ , −1)−−>D=Durees (1234567890) ;1234567890 secondes font 39 annees 8 mois 8 j ou r s 23 heures 31 minutes30 secondes .

−−>� �

47

Chapitre 6

Boucles pour, graphes simples, matrices

Syntaxe de la boucle « pour » : for x=vecteur, instruction; endL’instruction est exécutée, x prenant successivement toutes les valeurs du vecteur.Tracés élémentaires : commande « plot »

3 Pour tracer le graphe d’une fonction, scilab calcule les coordonnées d’un certain nombre de points dece graphe et relie les points consécutifs par un segment de droite.

3 Les abscisses de ces points sont collectées dans le vecteur-ligne X, les ordonnées correspondantes dansle vecteur-ligne Y, la commande plot(X,Y) retourne alors le graphe.

3 Très souvent, Y est calculé à l’aide d’une boucle pour, c’est pourquoi il y a des graphes très élémentairesdans ce chapitre.

3 Les matrices apparaissent dans ce chapitre car elles permettent souvent d’économiser des bouclespour, de raccourcir les scripts et d’accélérer les calculs. Ce sont parfois de simples tableaux denombres qui ne demandent aucune connaissance particulière. Cela change dès que l’on multiplie desmatrices (en gros). La multiplication des matrices est en relation étroite avec la composition desapplications linéaires et les changements de base dans les espaces vectoriels.

Les exercices 6.19, 6.20 et 6.21 dépassent le niveau du bac.Liste des exercices :Énoncé no 6.1 : [*] Tables de multiplication.Énoncé no 6.2 : [*] Minimum et maximum d’une liste de nombres.Énoncé no 6.3 : [*] Quelques produits de matrices.Énoncé no 6.4 : [*] Construction de matrices.Énoncé no 6.5 : [*] Sommes de nombres entiers.Énoncé no 6.6 : [*] Trier un tableau numérique (fantaisie).Énoncé no 6.7 : [*] Matrice fantaisie (boucles pour imbriquées).Énoncé no 6.8 : [*] Matrices de Toeplitz.Énoncé no 6.9 : [*] Graphe de la fonction tangente entre 0 et π.Énoncé no 6.10 : [*] Sauts de puce.Énoncé no 6.11 : [**] Résolution graphique d’une équation.Énoncé no 6.12 : [***] Construction de matrices : matrice-croix (fantaisie).Énoncé no 6.13 : [**] Construction de matrices : matrice Zorro (fantaisie).

48

Énoncé no 6.14 : [**] Construction de matrices : matrice barrée (fantaisie).Énoncé no 6.15 : [**] Aiguilles de l’horloge.Énoncé no 6.16 : [**] Calculs d’effectifs et de fréquences.Énoncé no 6.17 : [**] Écrire à la fin le premier terme d’une liste de nombres.Énoncé no 6.18 : [*] Écrire une suite de nombres à l’envers.Énoncé no 6.19 : [***] Écrire toutes les permutations de 1 à n (solution matricielle).Énoncé no 6.20 : [***] Matrices de permutation.Énoncé no 6.21 : [***] Échanger deux lignes ou deux colonnes d’un tableau (produit d’une matrice parune matrice de permutation).Énoncé no 6.22 : [**] Calcul matriciel de l’espérance et de la variance d’une variable aléatoire finie.Énoncé no 6.23 : [***] Calcul matriciel de la covariance de 2 variables aléatoires finies.Énoncé no 6.24 : [***] Ranger n nombres donnés dans l’ordre croissant (tri à bulles).Énoncé no 6.25 : [****] Ranger n nombres donnés dans l’ordre croissant.Énoncé no 6.26 : [**] Trier un tableau suivant l’une de ses lignes.

49

6.1 [*] Tables de multiplication

Afficher les tables de multiplication par 1, …, 9.

Mots-clefs : matrice-colonne (dans la première solution), multiplication composante par composante, com-mandes ones, disp (afficher), + (concaténation de chaînes de caractères), boucle pour.

Cet exercice est avant tout un problème d’affichage. Voici un premier script convenable :�// Ecr i re l e s t a b l e s de mu l t i p l i c a t i o n par 1 , . . . , 9 .A= [ 0 ; 1 ; 2 ; 3 ; 4 ; 5 ; 6 ; 7 ; 8 ; 9 ] ;for j=1 :9

B=j *ones ( 1 0 , 1 ) ;disp ( string (A)+ ’x ’+string (B)+ ’=’+string (B)+ ’x ’+string (A)+ ’=’+string (A. *B) ) ;disp ( ’−−−−−−−−−−− ’ )

end� �Commentaires• A et B sont des colonnes à 10 lignes.• 'x' est la chaîne réduite à la lettre x utilisée comme signe de la multiplication.• On obtient la table de multiplication par j en multipliant la colonne A terme à terme par la colonne B(commande A.*B).Exécutons ce script. Pour gagner de la place, nous ne faisons apparaître ci-dessous que les tables de multi-plication par 1 et par 9.�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)!0 x1=1x0=0 !! !! 1 x1=1x1=1 !! !! 2 x1=1x2=2 !! !! 3 x1=1x3=3 !! !! 4 x1=1x4=4 !! !! 5 x1=1x5=5 !! !! 6 x1=1x6=6 !! !! 7 x1=1x7=7 !! !! 8 x1=1x8=8 !! !! 9 x1=1x9=9 !−−−−−−−−−−−! 0 x9=9x0=0 !! !! 1 x9=9x1=9 !! !! 2 x9=9x2=18 !

50

! !! 3 x9=9x3=27 !! !! 4 x9=9x4=36 !! !! 5 x9=9x5=45 !! !! 6 x9=9x6=54 !! !! 7 x9=9x7=63 !! !! 8 x9=9x8=72 !! !! 9 x9=9x9=81 !−−−−−−−−−−−−−>� �L’affichage obtenu n’est pas agréable. Le script qui suit est meilleur de ce point de vue. Il comprend uneboucle pour insérée dans un boucle pour. Il est très simple.�// Ecr i re l e s t a b l e s de mu l t i p l i c a t i o n par 1 , . . . , 9 .for i =1 :9

for j=0 :9disp ( string ( j )+ ’ x ’+string ( i )+ ’=’+string ( i )+ ’ x ’+string ( j )+’=’+string ( i * j ) )

enddisp ( ’−−−−−−−−−−− ’ )

end� �Ci-dessous, nous ne reproduisons que la table de multiplication par 9 :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)−−−−−−−−−−−0x9=9x0=01x9=9x1=92x9=9x2=183x9=9x3=274x9=9x4=365x9=9x5=456x9=9x6=547x9=9x7=638x9=9x8=729x9=9x9=81−−−−−−−−−−−−−>� �Cet affichage est satisfaisant.

51

6.2 [*] Minimum et maximum d’une liste de nombres

Une liste de nombres étant donnée, calculer son minimum et son maximum.

Mots-clefs : boucle pour, taille, min, max.

Calcul du minimumLe procédé de calcul du minimum utilisé ici est très simple : on examine un par un les termes de la liste(ou vecteur) donnée. m désigne son minimum. Après examen du premier terme, on égale m à ce terme. Aprèsexamen du second terme, on ne change pas la valeur de m si ce second terme est supérieur ou égal au premier ;sinon, on la remplace par ce second terme, et ainsi de suite. Après examen du dernier terme de la liste, mest bien son minimum. Ce procédé est traduit exactement dans le script suivant qui se présente comme unefonction scilab ayant pour entrée une liste de nombres et pour sortie son minimum :�function m=Min(A) // A e s t une l i s t e de nombres ; m sera son minimum .

m=A( 1 ) ;t=t a i l l e (A) ;for i=1 :t−1

i f m>A( i +1) thenm=A( i +1) ;

endend

endfunction� �Cette fonction étant chargée dans la console, considérons la liste de nombres définie par la commandeA=tirage_reel(10000,-2,5) (A est une liste de 10000 nombres entre -2 et 5) et calculons son minimum :�−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ charge ’ , −1)−−>A=t i r a g e_r e e l (10000 ,−2 ,5) ;−−>m=Min(A) ;−−>mm =

− 1.9999150051735−−>� �Calcul du maximumIl est clair que si M désigne le maximum de la liste de nombres donnée A, M = − (Min (−A)). Cela donne(directement dans la console à la suite du calcul précédent) :�−−>M=−(Min(−A) ) ;−−>MM =

4.9995910420548−−>� �Bien sûr, les commandes min et max de scilab sont plus rapides. Il suffit de saisir dans la console min(A) etmax(A) pour obtenir :�−−>min(A)ans =− 1.9999150051735

−−>max(A)ans =

52

4.9995910420548−−>� �Le calcul du maximum d’une liste de nombres est repris dans les exercices 8.1 et 8.2 à l’aide de boucles tantque.

53

6.3 [*] Quelques produits de matrices

1 - Sont donnés 2 vecteurs de n nombres : X = [x1, . . . , xn] et P = [p1, . . . , pn]. On demanded’expliciter les résultats des produits matriciels suivants :1.a - X*ones(n,1)1.b - X*X'1.c - X*diag(X)*ones(n,1),1.d - X*diag(P)*X',1.e - P*diag(X)*X'.2 - Calculer la valeur de ces expressions avec scilab lorsque X = [1,

√3, exp (−0.5), 2, 37 ] et

P = [12 , 0.23, log 5,π8 , 7].

Mots-clefs : produit de matrices, commandes ones, diag, ' (transposition), sum, disp.ones(n,m) est la matrice à n lignes et à m colonnes qui ne comprend que des 1 ; diag(x1, …, xn) est lamatrice (carrée) à n lignes et à n colonnes qui porte x1, …, xn sur la diagonale principale, des 0 ailleurs.

Ceci est censé être un exercice plus ou moins amusant sur le produit des matrices. Il suffit d’appliquer ladéfinition de ce produit dans la première question. Nous n’avons pas mis de parenthèses quand on multiplie3 matrices car c’est inutile puisque le produit des matrices est associatif, ce qu’il faut savoir aussi.1.a -X∗ones(n, 1) = x1+· · ·+xn. Du point de vue des dimensions, on pourrait écrire : (1, n)∗(n, 1) −→ (1, 1).Le résultat est une matrice à une ligne et une colonne, c’est à dire un nombre.1.b - X ∗X ′ = x21 + · · ·+ x2n.1.c - X ∗ diag (X) ∗ ones (n, 1) = x21 + · · ·+ x2n.1.d - X ∗ diag(P ) ∗X ′ = p1x

21 + · · ·+ pnx

2n.

1.e - P ∗ diag(X) ∗X ′ = p1x21 + · · ·+ pnx

2n.

Le lecteur débutant aura intérêt à calculer à la main X ∗ diag(P ), diag(P ) ∗ X ′, (X ∗ diag(P )) ∗ X ′ etX ∗ (diag(P ) ∗X ′), ce qui illustrera dans un cas particulier l’associativité du produit matriciel.2 - On peut utiliser le script suivant :�X=[1 , sqrt ( 3 ) ,exp ( −0 . 5 ) , 2 , 3/7 ] ;P=[1/2 ,0 .23 , log ( 5 ) ,%pi / 8 , 7 ] ;disp (X*ones ( 5 , 1 ) ) ;disp (sum(X) ) ;disp (X*X’ ) ;disp (sum(X. ^ 2 ) ) ;disp (X*diag (X)*ones ( 5 , 1 ) ) ;disp (X*diag (P)*X’ ) ;disp (sum(P. * (X. ^ 2 ) ) ) ;disp (P*diag (X)*X’ ) ;� �qui, exécuté dans la console, donne :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)

5.76715295.76715298.55155298.55155298.5515529

54

4.63858974.63858974.6385897

−−>� �

55

6.4 [*] Construction de matrices

Énoncé 6.4.1 .

1 - Écrire la matrice à n lignes et m colonnes dont la première colonne ne contient que des 1, ladeuxième colonne ne contient que des 2, etc.2 - Écrire la matrice à m lignes et n colonnes dont la première ligne ne contient que des 1, ladeuxième ligne ne contient que des 2, etc.

Mots-clefs : input, ones(p,q), boucle pour, transposition de matrices (deuxième question).

1 - On peut utiliser le script suivant qui adjoint à la colonne de 1 une colonne de 2 et ainsi de suite :�n=input ( ’n=’ ) ; // On cho i s i r a n a l ’ e xecu t ion du s c r i p t .m=input ( ’m=’ ) ; // On cho i s i r a m a l ’ execu t ion du s c r i p t .M=ones (n , 1 ) ;

for j=2 :mM=[M, j *ones (n , 1 ) ] ;

enda f f i c h e r ( ’M␣ e s t ␣ l a ␣matr ice ’ ) ;a f f i c h e r (M) ;� �Exécutons ce script pour n=5 et m=7 :�−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ charge ’ , −1)n=5m=7M es t l a matr ice

1 . 2 . 3 . 4 . 5 . 6 . 7 .1 . 2 . 3 . 4 . 5 . 6 . 7 .1 . 2 . 3 . 4 . 5 . 6 . 7 .1 . 2 . 3 . 4 . 5 . 6 . 7 .1 . 2 . 3 . 4 . 5 . 6 . 7 .

−−>� �On aurait aussi pu écrire la ligne 1 ... m puis la reproduire n fois, comme ceci :�n=input ( ’n=’ ) ; // On cho i s i r a n a l ’ e xecu t ion du s c r i p t .m=input ( ’m=’ ) ;M=1 :m

for i=2 :nM=[M;1 :m] ;

enda f f i c h e r ( ’M␣ e s t ␣ l a ␣matr ice ’ ) ;a f f i c h e r (M) ;� �Remarquer le ; dans la commande [M;1:m] qui provoque un passage à la ligne dans la construction de lamatrice.2 - On peut procéder comme précédemment, mais le plus simple est de transposer la matrice M que nousvenons d’obtenir. Dans la console, saisissons les commandes�−−>T=M’� �(T est le nom choisi pour la matrice transposée de M). On obtient :

56

�T =

1 . 1 . 1 . 1 . 1 .2 . 2 . 2 . 2 . 2 .3 . 3 . 3 . 3 . 3 .4 . 4 . 4 . 4 . 4 .5 . 5 . 5 . 5 . 5 .6 . 6 . 6 . 6 . 6 .7 . 7 . 7 . 7 . 7 .

−−>� �

57

6.5 [*] Sommes de nombres entiers

1 - Calculer la somme des nombres entiers de 1 à 500.2 - Calculer la somme des carrés des nombres entiers de 1 à 500.

Mots-clefs : Boucle pour, sum, . ̂2, afficher(A,B), afficher('A ='+string(A)).

La première solution est très élémentaire et maladroite :�// L i s t e X des 500 premiers en t i e r s , l e u r somme S .X=[ ] ; // La l i s t e e s t v i de au debut . On va l a remp l i r .S=0 ;for i =1 :500

X=[X, i ] ; // On f a b r i q u e l a l i s t e des 500 premiers e n t i e r s .S=S+i ; // On c a l c u l e l e u r somme au fur e t a mesure .

end ;// L i s t e Y des 500 premiers carres , l e u r somme T.Y=[ ] ;T=0 ;for i =1 :500

Y=[Y, i ^ 2 ] ;T=T+i ^2 ;

end ;// Af f i chagea f f i c h e r (X, S ,Y,T) ;� �On rappelle que la commande afficher(X,S,Y,T) affiche d’abord T, puis Y, S et enfin X, à l’envers. Commeil est inutile d’afficher la liste des entiers de 1 à 500 et la liste de leurs carrés, on aurait dû se contenter de :�// Af f i chagea f f i c h e r (T, S ) ;� �(pour obtenir S d’abord) auquel cas, on obtient :�

125250.41791750.� �

Les commandes d’affichage suivantes :�// Af f i chagea f f i c h e r ( ’La␣somme␣des ␣500␣ premiers ␣ e n t i e r s ␣ e s t ␣ ’+string (S ) ) ;a f f i c h e r ( ’La␣somme␣des ␣500␣ premiers ␣ c a r r e s ␣ e s t ␣ ’+string (T) ) ;� �donnent un affichage satisfaisant :�La somme des 500 premiers e n t i e r s e s t 125250La somme des 500 premiers c a r r e s e s t 41791750� �On a déjà dit que ceci est maladroit. En effet, il est tout à fait inutile de construire les suites X et Y. Ilsuffit d’utiliser les commandes X=1:n et Y=X. ̂2 (La commande . ̂2 est l’élévation au carré composante parcomposante). De plus « Pour un tableau x, y=sum(x) renvoie dans y la somme de tous les éléments de x »(d’après l’aide en ligne de scilab). On peut donc utiliser le script�X=1 :500 ;

58

Y=X.^ 2 ;S=sum(X) ;T=sum(Y) ;a f f i c h e r ( ’La␣somme␣des ␣500␣ premiers ␣ e n t i e r s ␣ e s t ␣ ’+string (S ) ) ;a f f i c h e r ( ’La␣somme␣des ␣500␣ premiers ␣ c a r r e s ␣ e s t ␣ ’+string (T) ) ;� �qui retourne les résultats avec un affichage explicite.

59

6.6 [*] Trier un tableau numérique (fantaisie)

Trier un tableau numérique dans l’ordre décroissant (quand on le lit de la gauchevers la droite et de haut en bas, de la première à la dernière ligne).

Mots-clefs : commandes trier, size(A,'r'), size(A,'c'), A(j,a: b), A(j,:), size(A), A(:) 1,matrix(A,n,m) 2, transposition de matrices.

• La commande trier trie les vecteurs, autrement dit des tableaux à une seule ligne, dans l’ordre croissantou décroissant suivant l’option choisie. Comment l’utiliser pour trier un tableau à n lignes et m colonnes ?• Dans les scripts ci-dessous, on écrit en ligne ou en colonne le tableau donné, on le trie et on le reconstitue.Script no1• size(T,'r') est le nombre de lignes de la matrice T.• T(j,:) et T(j,a: b) sont respectivement la j ème ligne de T et la partie de cette ligne située entre lescolonnes a et b (comprises).�// Ranger un ta b l e au numerique dans l ’ ordre d e c ro i s s an t .T=input ( ’T=’ ) ;n=s ize (T, ’ r ’ ) ; // Nombre de l i g n e s de T.m=s ize (T, ’ c ’ ) ; // Nombre de co lonnes de T.Ligne=T( 1 , : ) ; // On se prepare a e c r i r e T en l i g n e .for j=2 :n

Ligne=[Ligne ,T( j , : ) ] ; //On a jou t e l a l i g n e de T numero j ; noter l a v i r g u l e .endLigne=t r i e r ( Ligne , ’< ’ ) ; // Ligne e s t maintenant dans l ’ ordre d e c ro i s s an t .T=Ligne (1 ,1 :m) ;for j=2 :n

T=[T; Ligne ( 1 , ( j −1)*m+1 : j *m) ] ;enda f f i c h e r (T) ;� �En exécutant ce script, on a saisi une matrice T à la main. C’est long (habituellement, on utilise des matricesde nombres aléatoires) :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)T=[−3,sqrt (2 ) , 1 ; 0 , 1 . 17 , −63 ;15 ,%pi , 4 ; cos ( 3 ) , sin (−1) ,14 ; tan (−2) ,0 ,4 ]

15 . 14 . 4 .4 . 3 .1415926535898 2.18503986326151.4142135623731 1 .17 1 .0 . 0 . − 0.8414709848079

− 0.9899924966004 − 3 . − 63 .−−>� �Script no2On peut réaliser le même programme beaucoup plus vite en utilisant les instructions scilab ad hoc. C’estl’objet du script suivant :�T=input ( ’T=’ ) ;

1. [11], 6.32. [11], Syntaxe 6.3.3

60

a f f i c h e r (T) ;[ n ,m]= s ize (T) ; // Nombre de l i g n e s de T.C=T( : ) ; //Les co lonnes de T sont empi l ees en une s eu l e colonne .D=t r i e r (C) ; //Tri de l a colonne C dans l ’ ordre c r o i s s an t .U=matrix (D,m, n ) ’ ; // On r e c on s t i t u e l a matr ice .a f f i c h e r (U) ;� �dont voici une application :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)T= [1 , 2 , 3 , 4 , 5 ; 6 , 7 , 8 , 9 , 0 ; 9 , 8 , 7 , 6 , 5 ; 4 , 3 , 2 , 1 , 2 ]

1 . 2 . 3 . 4 . 5 .6 . 7 . 8 . 9 . 0 .9 . 8 . 7 . 6 . 5 .4 . 3 . 2 . 1 . 2 .

0 . 1 . 1 . 2 . 2 .2 . 3 . 3 . 4 . 4 .5 . 5 . 6 . 6 . 7 .7 . 8 . 8 . 9 . 9 .

−−>� �

61

6.7 [*] Matrice fantaisie (boucles pour imbriquées)

1 - Écrire la matrice (n,n) dont les éléments sont 1, 2, . . . , n2 écrits dans l’ordre habituel (surchaque ligne, de la gauche vers la droite, de la première à la dernière ligne).2 - Cette matrice étant notée M , expliquer comment se font les calculs suivants : N=M+M,Q=3*M, R=M. ̂2.

Mots-clefs : commandes input, a:b, matrix(A,n,m) 3, transposition des matrices, boucles pour imbriquées.

1 - Solution no1 : on définit la matrice M en définissant chacun de ses éléments :�n=input ( ’n=’ ) ; // On cho i s i r a n a l ’ e xecu t ion du s c r i p t .for i=1 :n

for j=1 :nM( i , j )=( i −1)*n+j ; // On d e f i n i t M( i , j ) .

endenda f f i c h e r (M) ;� �Dans le script ci-dessus, Mbis=[Mbis,(i-1)*n+j] signifie que l’on adjoint à la matrice-ligne Mbis unecomposante supplémentaire ((i-1)*n+j), ce qui est indiqué par « , » et que la nouvelle valeur de Mbis estcette matrice-ligne allongée. Au contraire, dans M=[M;Mbis], le « ; » indique que l’on ajoute une nouvelleligne à M.Pour n = 9 (on choisit n petit en pensant à l’affichage), on obtient :�−−> n=9

1 . 2 . 3 . 4 . 5 . 6 . 7 . 8 . 9 .10 . 11 . 12 . 13 . 14 . 15 . 16 . 17 . 18 .19 . 20 . 21 . 22 . 23 . 24 . 25 . 26 . 27 .28 . 29 . 30 . 31 . 32 . 33 . 34 . 35 . 36 .37 . 38 . 39 . 40 . 41 . 42 . 43 . 44 . 45 .46 . 47 . 48 . 49 . 50 . 51 . 52 . 53 . 54 .55 . 56 . 57 . 58 . 59 . 60 . 61 . 62 . 63 .64 . 65 . 66 . 67 . 68 . 69 . 70 . 71 . 72 .73 . 74 . 75 . 76 . 77 . 78 . 79 . 80 . 81 .

−−>� �Solution no2 : on fabrique M ligne par ligne. Il n’y a qu’une seule boucle pour apparente, l’autre étant priseen charge par scilab. Ce sera plus rapide.�n=input ( ’n=’ ) ; // On cho i s i r a n a l ’ e xecu t ion du s c r i p t .L=1 :n^2 ;M= [ ] ;for i=1 :n

P=L( ( i −1)*n+1 : i *n ) ;M=[M;P]

enda f f i c h e r (M) ;� �

3. [11], Syntaxe 6.3.3

62

Pour se rendre compte de la puissance et de la rapidité de scilab, le lecteur pourra tester de plus grandesvaleurs, par exemple n = 1000. Dans ce cas, l’affichage est long et peu parlant. On l’interrompra.Solution no3 : on construit ci-dessous une matrice à n lignes et à m colonnes dont la première ligne est 1,…, m, la suivante n+1, …, 2m, etc. Le script ci-dessous est rédigé de manière compacte :�n=input ( ’n=’ ) ;m=input ( ’m=’ ) ;X=matrix ( (1 : n*m) ’ ,m, n ) ’ ;a f f i c h e r (X) ;� �2 - Les calculs de la deuxième question se font composante par composante.

63

6.8 [*] Matrices de Toeplitz

Écrire la matrice carrée de taille n comprenant des n sur la diagonaleprincipale, des n− 1 sur les deux lignes qui l’encadrent, etc.

Mots-clefs : abs (fonction valeur absolue), boucles pour imbriquées.

Ceci est un cas particulier de matrice de Toeplitz, voir [17].�n=input ( ’n=’ ) ;for i=1 :n

for j=1 :nA( i , j )=n−abs ( i−j ) ;

endenda f f i c h e r (A) ;� �Cette solution ne présente aucune difficulté. C’est un script banal avec une boucle for insérée dans uneboucle for.Voici ce que l’on obtient pour n = 6 :�−−>clear−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ charge ’ , −1)n=6

6 . 5 . 4 . 3 . 2 . 1 .5 . 6 . 5 . 4 . 3 . 2 .4 . 5 . 6 . 5 . 4 . 3 .3 . 4 . 5 . 6 . 5 . 4 .2 . 3 . 4 . 5 . 6 . 5 .1 . 2 . 3 . 4 . 5 . 6 .

−−>� �

64

6.9 [*] Graphe de la fonction tangente entre 0 et π

Tracer le graphe de la fonction tangente entre 0 et π, la variablevariant avec un pas de 0.1, puis 0.01, puis 0.001 et enfin 0.0001.

Mots-clefs : plot, subplot.

Cet exercice peut servir d’introduction à la commande plot et à ses dangers. Il est très instructif.Dans le script ci-dessous, subplot(2,2,i) signifie que le tracé que l’on va faire est le i ème d’un tableau de4 graphes répartis en 2 lignes et 2 colonnes, la numérotation se faisant de gauche à droite et de haut en bas.�c l ffor i =1 :4

X=0 :10^(− i ) :%pi ;Y=tan (X) ;subplot (2 , 2 , i ) ;plot (X,Y) ;

end� �Voici ce que l’on obtient sur la fenêtre graphique de scilab :

(on a simplement ajouté un cadre à la fenêtre graphique) ce qui amène les remarques suivantes :• On rappelle que plot trace les points dont les coordonnées se trouvent dans X et Y et relie deux pointsconsécutifs par un segment de droite.• Les abscisses évitant la valeur π

2, on obtient donc des lignes polygonales. On rate donc complètement le

fait que

tgx −−−−→x→π

2−

+∞ et tgx −−−−→x→π

2+

−∞

65

Entre les deux points du graphe dont les abscisses encadrent π2, scilab ignore ce qui se passe. Plus générale-

ment, si une fonction quelconque fait des extravagances entre deux points calculés de son graphe, on ne leverra pas.• S’il y a beaucoup de points calculés, on ne verra pas les segments qui les joignent et on aura l’impressionde voir le vrai graphe de la fonction étudiée. Cette impression est trompeuse. Un graphe scilab ne peutremplacer une étude mathématique. Ouf.• Lorsque le pas vaut 0.001 ou 0.0001, on s’approche trop de π

2· La fonction tangente prend des valeurs très

grandes en valeur absolue. scilab adapte automatiquement l’échelle sur l’axe des ordonnées. Il en résulte quele graphe est écrasé sur l’axe des abscisses, sauf au voisinage de π

2· C’est très net sur le dernier graphe.

• Avec scilab, on peut tracer de nombreuses courbes (cartésiennes, paramétriques, notamment polaires) etde nombreuses surfaces et acquérir ainsi une bonne connaissance pratique des fonctions.• Avec d’autres réglages de plot et de plot2d, scilab peut produire des nuages de points(ensembles depoints).Évidemment, il n’est pas question de démontrer avec scilab qu’une fonction est continue, a fortiori qu’elleest dérivable.

66

6.10 [*] Sauts de puce

Une puce fait des bonds successifs indépendants les uns des autres en ligne droite.La longueur de chaque bond est aléatoire. On considère que c’est un nombre choisiau hasard dans l’intervalle [0, 5[, l’unité de longueur étant le cm. On note la distancetotale parcourue au bout de m bonds. On répète cette expérience n fois. Calculer ladistance moyenne parcourue au cours de ces n expériences.

Mots-clefs : Commandes rand, moyenne, stacksize('max'), Calcul des Probabilités.

Cet exercice ne pose pas de problème d’algorithmique mais demande des connaissances en Calcul des Proba-bilités. La commande rand(1,N), où N désigne un entier naturel quelconque, produit N nombres qui peuventêtre considérés comme les valeurs prises par N variables aléatoires indépendantes prenant leurs valeurs dansl’intervalle [0, 1[ en suivant la loi uniforme. Si N = m et si on multiplie ces nombres par 5, leur somme re-présente la distance parcourue par la puce au cours de m bonds. On répète n fois cette expérience aléatoire.Dans les deux scripts qui suivent, de rapidités très différentes, scilab, à l’exécution, demandera de saisir lavaleur de n, puis de m.Dans le premier script, on stocke les distances parcourues au cours des n expériences dans S à l’aide d’uneboucle pour.�n=input ( ” va l eur ␣de␣n␣ :␣” ) ;m=input ( ” va l eur ␣de␣m␣ :␣” ) ;t i c ( ) ;S= [ ] ;for j=1 :n

saut s=5*rand (1 ,m) ;S=[S ,sum( saut s ) ] ;

endMoyenne=moyenne (S ) ;temps=toc ( ) ;a f f i c h e r ( ’La␣moyenne␣des ␣ d i s t an c e s ␣ parcourues ␣ e s t ␣ ’+string (Moyenne ) ) ;a f f i c h e r ( ’ Le␣temps␣de␣ c a l c u l ␣ e s t ␣ ega l ␣a␣ ’+string ( temps ) ) ;� �Exécutons ce script. On obtient :�−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ charge ’ , −1)va l eur de n : 100000va l eur de m : 50La moyenne des d i s t an c e s parcourues e s t 124.99021173086Le temps de c a l c u l e s t ega l a 28 .256−−>� �Ce gros calcul (séries de 50 sauts répétées 100000 fois) a duré presque 30 secondes, ce qui est long et dû àla boucle pour.On peut compacter ce script en additionnant les longueurs des n × m sauts et en divisant par n. Onremarquera que l’on a dû augmenter la place allouée à la mémoire (on travaille sur une liste de 5 000 000nombres) à l’aide de la commande stacksize('max'), voir l’aide.�n=input ( ” va l eur ␣de␣n␣ :␣” ) ;m=input ( ” va l eur ␣de␣m␣ :␣” ) ;stacksize ( ’max ’ ) ;t i c ( ) ;

67

Moyenne=sum(5*rand (1 , n*m))/n ;temps=toc ( ) ;a f f i c h e r ( ’La␣moyenne␣des ␣ d i s t an c e s ␣ parcourues ␣ e s t ␣ ’+string (Moyenne ) ) ;a f f i c h e r ( ’ Le␣temps␣de␣ c a l c u l ␣ e s t ␣ ega l ␣a␣ ’+string ( temps ) ) ;� �Exécutons ce script. On obtient :�−−>clear−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ charge ’ , −1)va l eur de n : 100000va l eur de m : 50La moyenne des d i s t an c e s parcourues e s t 124.97435382959Le temps de c a l c u l e s t ega l a 0 .123−−>� �Ce calcul a donc duré un gros dizième de seconde. On remarquera que les valeurs de la distance moyenneparcourue par la puce sont différentes. C’est normal car les calculs sont basés sur des tirages aléatoiresdifférents.

68

6.11 [**] Résolution graphique d’une équation

1 - Calculer les valeurs de f(x) =x3· cos (x) + x2 − x+ 1

x4 −√3·x2 + 127

lorsque la variable x prend successi-vement les valeurs -10, -9.2, -8.4, …, 8.4, 9.2, 10 (pas 0.8).2 - Tracer le graphe de la fonction f quand x varie entre -10 et 10 en utilisant seulement lesvaleurs de f(x) calculées précédemment.3 - Apparemment, l’équation f(x) = 0 a une solution α voisine de 2. En utilisant le zoom,proposer une valeur approchée de α.4 - Tracer de nouveau le graphe de f entre -10 et 10 en faisant varier x avec un pas de 0.05.5 - Ce nouveau graphe amène-t-il à corriger la valeur de α proposée ?

Mots-clefs : commandes clf, clear, plot, subplot, résolution graphique d’une équation, zoom, annulationdu zoom.

clf nettoie la fenêtre graphique, clear supprime toutes les variables non protégées, clear a supprime lavariable a si elle n’est pas protégée. La commande subplot(121) indique que la fenêtre graphique a étédivisée en deux sous-fenêtres placées côte à côte (en ligne) et que la sous-fenêtre sélectionnée (pour le grapheà venir) est la première, voir l’aide en ligne.On rappelle que plot(X,Y) trace les points dont les abscisses sont dans X, les ordonnées dans Y et relie deuxpoints consécutifs par un segment de droite. La figure ci-dessous contient deux graphes de la même fonction.Le graphe de gauche est visiblement une ligne polygonale (le nombre de points calculés est 26) ; le second enest une aussi, mais cela n’apparaît qu’en zoomant (401 points calculés). Pour les fonctions usuelles, on peutdire que le second graphe est plus précis que le premier. On pourra utiliser le script suivant qui contient unefonction scilab :

�clear ;function y=e f f e d e (x ) ;

y=(x^3*cos ( x)+x^2−x+1)/(x^4−sqrt (3)* x^2+127) ;endfunctionX=−10 :0.8 :10 ;Y= [ ] ;for i=1 :length (X)

Y=[Y, e f f e d e (X( i ) ) ] ;end ;c l f ;subplot (121)plot (X,Y) ;X=−10 :0.05 :10 ;Y= [ ] ;for i=1 :length (X)

Y=[Y, e f f e d e (X( i ) ) ] ;end ;subplot (122)plot (X,Y) ;� �Voici la fenêtre graphique que l’on obtient :

69

On en déduit que l’on peut proposer α ≈ 2 à partir de chacun des deux graphes.De plus, en zoomant une première fois, on obtient :

ce qui amènera à proposer des valeurs différentes pour α suivant que l’on se sert du premier ou du secondgraphe. Enfin, en zoomant deux fois de plus, on arrive à :

70

On proposera α ≈ 1.88725 avec le premier graphe, α ≈ 1.9624 avec le second. On constate une fois de plusque la méthode graphique de résolution d’une équation dépend bien évidemment de la qualité du graphe.RemarquesLe script utilisé est un peu lourd. On peut transformer la fonction effede de manière à ce qu’elle acceptecomme argument un vecteur. Cela donne (en utilisant des opérations composante par composante ) :�clear ;function Y=e f f e d e (X) ;

Y=((X. ^ 3 ) . * cos (X)+X.^2−X+1)./(X.^4−sqrt ( 3 ) . * (X.^2)+127) ;endfunctionX=−10 :0.8 :10 ;Y=e f f e d e (X) ;c l f ;subplot (121)plot (X,Y) ;X=−10 :0.05 :10 ;Y=e f f e d e (X) ;subplot (122)plot (X,Y) ;� �De plus, on n’a pas vraiment besoin de effede. On peut finalement se contenter du script :�clear ;X=−10 :0.8 :10 ;Y=((X. ^ 3 ) . * cos (X)+X.^2−X+1)./(X.^4−sqrt ( 3 ) . * (X.^2)+127) ;c l f ;subplot (121)plot (X,Y) ;X=−10 :0.05 :10 ;Y=((X. ^ 3 ) . * cos (X)+X.^2−X+1)./(X.^4−sqrt ( 3 ) . * (X.^2)+127) ;subplot (122)plot (X,Y) ;� �

71

6.12 [**] Matrice-croix (fantaisie)

Écrire la matrice carrée C de taille 2n+1 comportant des 1 sur la (n+1)ième ligne et la (n+1)ième

colonne et des 0 ailleurs.

Mots-clefs : Commandes zeros(p,q), ones(p,q).

Le script qui suit, typique, est particulièrement compact (pour le plaisir). On peut faire moins bien ! Remar-quer l’usage des , et des ; dans la description de la matrice C.�n=input ( ’n=’ ) ;C=[zeros (n , n ) , ones (n , 1 ) , zeros (n , n ) ; ones (1 ,2*n+1) ;zeros (n , n ) , ones (n , 1 ) , zeros (n , n ) ] ;a f f i c h e r (C) ;� �Voici ce que l’on obtient pour n = 4 :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=4

0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .1 . 1 . 1 . 1 . 1 . 1 . 1 . 1 . 1 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .

−−>� �

72

6.13 [**] Construction de matrices : matrice Zorro (fantaisie)

Écrire la matrice Zorro Z de taille n, c’est à dire la matrice carrée de taille n comprenant des 1sur la première ligne, sur la deuxième diagonale et sur la dernière ligne et des 0 partout ailleurs.

Mots-clefs : commandes ones, zeros, eye.

La solution ci-dessous est un maniement de matrices typique de scilab. Z est abordée comme un assemblagede 3 matrices : la matrice ones(1,n), matrice à 1 ligne et n colonnes ne comportant que des 1, puis lamatrice zeros(n-2,n), matrice à n − 2 lignes et n colonnes ne comportant que des zéros et de nouveaula matrice ones(1,n). Les ; qui séparent ces matrices indiquent qu’elles sont disposées les unes en dessousdes autres (en colonne). La matrice obtenue, notée Z, n’est pas la matrice demandée mais presque. Elle a nlignes et n colonnes.Remarque : Si on avait remplaçé les ; par des,, les 3 matrices précédentes auraient dû être disposéesen ligne mais cela aurait provoqué un message d’erreur du script car on ne peut aligner que des matricesayant le même nombre de lignes (de même qu’on ne peut empiler que des matrices ayant le même nombrede colonnes).Ensuite, il reste à remplacer des zéros par des uns, en deuxième diagonale, à l’aide d’une boucle pour, ceque fait le script suivant :�n=input ( ’n=’ ) ;Z=[ones (1 , n ) ; zeros (n−2,n ) ; ones (1 , n ) ] ;for i=2 :n−1

Z( i , n−i +1)=1 ;enda f f i c h e r (Z ) ;� �Voici ce que l’on obtient pour n=7 :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=7

1 . 1 . 1 . 1 . 1 . 1 . 1 .0 . 0 . 0 . 0 . 0 . 1 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 .0 . 0 . 0 . 1 . 0 . 0 . 0 .0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 1 . 0 . 0 . 0 . 0 . 0 .1 . 1 . 1 . 1 . 1 . 1 . 1 .

−−>� �On peut préférer le script suivant dans lequel la matrice A est obtenue à partir de la matrice unité de taillen (commande eye(n,n)) en remplaçant les zéros de la première et de la dernière lignes par des uns. Ensuite,la matrice Z est obtenue en recopiant les colonnes de A de la dernière à la première.�clearn=input ( ’n=’ ) ;A=eye (n , n ) ;A(1 ,2 : n)=ones (1 , n−1) ;A(n , 1 : n−1)=ones (1 , n−1) ;a f f i c h e r (A) ;Z= [ ] ;

73

for i=1 :nZ=[Z ,A( : , n−i +1) ] ;

enda f f i c h e r (Z ) ;� �Voici une exécution de ce script pour n = 6 :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=6

1 . 1 . 1 . 1 . 1 . 1 .0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 1 . 0 . 0 . 0 .0 . 0 . 0 . 1 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 .1 . 1 . 1 . 1 . 1 . 1 .

1 . 1 . 1 . 1 . 1 . 1 .0 . 0 . 0 . 0 . 1 . 0 .0 . 0 . 0 . 1 . 0 . 0 .0 . 0 . 1 . 0 . 0 . 0 .0 . 1 . 0 . 0 . 0 . 0 .1 . 1 . 1 . 1 . 1 . 1 .

−−>� �

74

6.14 [*] Construction de matrices : matrice barrée (fantaisie)

Écrire la matrice carrée de taille n portant des 1 sur les 2 diagonales, des 0 ailleurs.

Mots-clefs : commandes eye, min.

La commande eye(n,n) donne la matrice-unité de taille n ; la commande min(A,B) prend le minimum termeà terme des matrices de même taille A et B. On peut utiliser le script suivant :�clearn=input ( ’n=’ ) ;A=eye (n , n ) ;B= [ ] ;for i=1 :n

B=[B,A( : , n+1− i ) ] ;end//La premiere colonne de B e s t l a de rn i e re de A, e t c .//B a ses 1 sur l a deuxieme d iagona l e .B=min(A+B, ones (A) ) ; // Le minimum e s t p r i s composante par composante .a f f i c h e r (B) ;� �La boucle pour produit la matrice B qui porte des 1 sur la deuxième diagonale, des 0 ailleurs. En additionnantA et B, on obtient la matrice demandée sauf si n est impair, auquel cas le terme central de la matrice A+B est2 (l’addition des matrices se fait composante par composante). On corrige ce défaut à l’aide de la commandemin (qui agit composante par composante).Voici ce que l’on obtient pour n = 9 :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=9

1 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 1 .0 . 1 . 0 . 0 . 0 . 0 . 0 . 1 . 0 .0 . 0 . 1 . 0 . 0 . 0 . 1 . 0 . 0 .0 . 0 . 0 . 1 . 0 . 1 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 1 . 0 . 1 . 0 . 0 . 0 .0 . 0 . 1 . 0 . 0 . 0 . 1 . 0 . 0 .0 . 1 . 0 . 0 . 0 . 0 . 0 . 1 . 0 .1 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 1 .

−−>� �On peut obtenir B en multipliant A par une matrice de permutation convenable, voir l’exercice 6.21.

75

6.15 [**] Aiguilles de l’horloge

1 - Combien de fois l’aiguille des minutes tourne-t-elle plus vite que l’aiguille des heures ?2 - Quand l’aiguille des heures a tourné de α degrés à partir de midi, l’extrémité de l’aiguille desminutes est repérée sur le cadran de l’horloge par l’angle

β = 12·α− 360· ksi elle a déjà fait k tours complets (les angles étant comptés en degrés.). Tracer le graphe de β enfonction de α quand celui-ci varie de 0 à 360 degrés.3 - Combien y a-t-il de superpositions des aiguilles entre midi et minuit ? Calculer les angles cor-respondants.4 - Que se passe-t-il à partir de minuit ?

Dans cet énoncé, [ ] désigne la fonction partie entière.

Mots-clefs : commandes plot(X,Y,'b'), plot(X,Y,'k--'), fonction définie par morceaux.

L’option 'b' ajoutée à la commande plot(X,Y) provoque le tracé du graphe en bleu ; le tracé se fera enpointillés noirs si on ajoute l’option 'k--' à plot(X,Y).1 - Pour parcourir le cercle de l’horloge, l’aiguille des minutes met une heure, l’aiguille des heures prend 12heures. L’aiguille des minutes tourne donc 12 fois plus vite que l’aiguille des heures. Si l’aiguille des heurestourne de α degrés, l’aiguille des minutes tourne de 12·α degrés. L’aiguille des minutes fait un tour completquand α augmente de 30 degrés.2 - Il y a évidemment superposition des aiguilles à midi. Nous comptons α à partir de ce moment. Pendant ladeuxième heure (30 ⩽ α < 60), quand l’aiguille des heures a tourné de α degrés (à partir de midi), l’aiguilledes minutes est repérée par l’angle β, 0 ⩽ β < 360, défini par β = 12·α− 360. De même, plus généralement,pendant la (k + 1)ème heure, 0 ⩽ k ⩽ 11, l’aiguille des minutes est repérée par β = 12·α − 360· k (β est lereste de la division euclidienne de 12·α par 360).Graphe de β :La partie du graphe de β correspondant à la (k+1)ème heure (quand α varie de 30· k à 30(k+1)) est le segmentqui joint les points (30· k, 0) à (30· (k + 1), 360). Le graphe de β est un ensemble de 12 segments ouvertsà droite (α variant précisément sur les intervalles [0, 30[, …, [330, 360[). Nous avons ajouté des segmentsverticaux en pointillés noirs pour améliorer la lisibilité du graphe. Deux courbes sont tracées : β en fonctionde α et α en fonction de α (en rouge).�c l f ;A= [ ] ;format ( ’ v ’ , 7 ) ;for k=0 :11

X=[k *30 , ( k+1)*30] ;Y=[0 , 360 ] ;plot (X,Y, ’b ’ ) ;plot ( [ ( k+1)*30 ,(k+1)*30 ] , [ 0 , 3 60 ] , ’ k−− ’ ) ;A=[A,360* k / 1 1 ] ;

end ;plot ( [ 0 , 3 6 0 ] , [ 0 , 3 6 0 ] , ’ r ’ ) ;a f f i c h e r ( ’ Les␣ ang l e s ␣en␣ degres ␣ou␣ l e s ␣ a i g u i l l e s ␣ se ␣ superposent ␣ sont ’ ) ;a f f i c h e r (A) ;� �Les lignes pointillées ne font pas partie du graphe. Elles ont été tracées pour le rendre plus lisible. La com-mande de tracé utilise l’option 'k--' (k avec 2 tirets), qui signifie que la ligne sera pointillée en noir (k).

76

Finalement, on obtient le graphe suivant :

3 - La superposition des aiguilles est donnée par la solution des équationsα = 12·α− 360· k ou α =

360· k11

, 0 ⩽ k ⩽ 11.ce qui fait 12 superpositions (0 ⩽ α < 360).

�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)Les ang l e s en degres ou l e s a i g u i l l e s se superposent sont

column 1 to 90 . 32 .727 65 .455 98 .182 130 .91 163 .64 196 .36 229 .09 261 .82

column 10 to 12294 .55 327 .27 360 .

−−>� �4 - À minuit, nous sommes revenus dans la configuration de midi et tout se répète.

77

6.16 [**] Calculs d’effectifs et de fréquences

Une suite S de nombres entiers étant donnée, calculer l’effectif et la fréquence de ndans cette suite, quel que soit n entre min (S) et max (S) ( min (S) ⩽ n ⩽ max (S)).

Mots-clefs : Commandes input, min et max, taille, tirage_entier, frequence, matrice zeros, find.

Dans l’algorithme ci-dessous, on calcule les minimum et maximum de S notés a et b. Il y a au plus b− a+1entiers différents dans la suite S.Solution no1 : Dans le script ci-dessous, on va stocker les effectifs des entiers de a à b dans un vecteurC de longueur b − a + 1 initialisé par la commande C=zeros(1,b-a+1);. Ensuite, on passe en revue lestermes successifs de S. Quand on s’occupe du ième terme de S, qui est S(i), on ajoute 1 à la composante deC qui compte les occurrences de la valeur de S(i), qui est la composante de C de rang S(i) − a + 1, soitC (S(i)− a+ 1). À la fin de la boucle pour, C est le vecteur des effectifs.�S=input ( ’S=’ ) ; // S e s t une s u i t e de nombres e n t i e r s .a=min(S ) ;b=max(S ) ;C=zeros (1 , b−a+1) ;N=t a i l l e (S ) ;for i=1 :N;

C(S( i )−a+1)=C(S( i )−a+1)+1 ;end ;a f f i c h e r (C) ;� �On exécute cet algorithme en le chargeant dans la console de scilab. Pour l’entrée S, nous avons choisi dansl’application ci-dessous une suite de 2011 nombres entiers tirés au hasard entre 1 et 6 (ce qui simule le lancerd’un dé 2011 fois de suite, ce qu’il est inutile de savoir). On obtient :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)S=t i r a g e_en t i e r (2011 ,1 ,6 )

356 . 325 . 315 . 334 . 334 . 347 .−−>� �On peut ajouter directement dans la console les commandes qui permettent de calculer les fréquences dea, a+1, …, b dans S, (ici, a = 1 et b = 6 puisqu’il y a 6 valeurs affichées), ce qui donne finalement, en limitantà 5 le nombre de décimales à l’affichage :�−−>F=C/N;−−>format ( ’ v ’ , 8 ) ;−−>a f f i c h e r (F ) ;

0 .17703 0.16161 0.15664 0.16609 0.16609 0.17255−−>� �Bien sûr, si on ré-exécute le script précédent, on obtiendra, avec une probabilité très forte, un résultatdifférent puisque S provient d’un tirage aléatoire.Solution no2 : la solution no1 est très bonne. La seconde utilise la commande find, voir l’aide en ligne.Cette solution est beaucoup plus directe car on se contente de compter le nombre d’occurrences de i dans Sà l’aide de la commande taille(find(S==i)), i variant de a à b.�S=input ( ’S=’ ) ; // S e s t une s u i t e de nombres e n t i e r s .a=min(S ) ;b=max(S ) ;

78

E=zeros (1 , b−a+1) ;for i=a :b

E( i−a+1)= t a i l l e ( find (S==i ) ) ;end ;a f f i c h e r (E ) ;� �Cela donne :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)S=t i r a g e_en t i e r ( 2011 , 1 , 6 ) ;

331 . 362 . 333 . 326 . 346 . 313 .−−>� �On ne retrouve pas les résultats précédents car on a fait un nouveau tirage de S. À noter l’intérêt qu’ily aurait à faire en classe les deux premières solutions. Malheureusement, la première demande beaucoupde soin. La commande find est à connaître par les élèves. Elle figure dans la liste Utilitaires du chapitreFonctions scilab utiles au lycée de [12].Solution no3 (celle que l’on préfère quand on n’a pas de temps à perdre) : on peut retrouver immédiatementles fréquences de 1, …, 6 à l’aide de la commande frequence de scilab (consulter l’aide en ligne). Par exemple,la fréquence de 1 est donnée par la commande frequence(1,S); :�−−>f1=frequence (1 , S ) ;−−>a f f i c h e r ( f 1 ) ;

0 .17703−−>� �Si on avait demandé la fréquence de 0, on aurait obtenu 0.

79

6.17 [**] Écrire à la fin le premier terme d’une liste de nombres

Écrire un script qui associe à tout vecteur X = [x1, . . . , xn−1, xn] le vecteur Y = [x2, . . . , xn, x1].

Mots-clefs : Commandes taille, ones(p,q), zeros(p,q), format, afficher, X(B) 4, $.

Solution no1 : avec une boucle pour.�X=input ( ”X=” ) ; // X e s t une l i s t e de nombres .a f f i c h e r (X) ;n=t a i l l e (X) ;for i=1 :n−1

Y( i )=X( i +1) ;endY(n)=X( 1 ) ;a f f i c h e r (Y ’ ) ; // Y’ e s t l a l i s t e demandee .� �Nous avons appliqué ce script à X=[-1,1/4,%e,%pi,5,log(2),tan(2*%pi/3)]. On a choisi ci-dessous delimiter l’affichage des réels à deux décimales à l’aide de la commande format('v',5). On obtient :�−−>format ( ’ v ’ , 5 ) ;−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)X=[−1 ,1/4 ,%e , %pi , 5 , log ( 2 ) , tan (2*%pi / 3 ) ]X =

− 1 . 0 .25 2 .72 3 .14 5 . 0 .69 − 1 .73Y =

0.25 2 .72 3 .14 5 . 0 .69 − 1 .73 − 1 .−−>� �Remarques• Un logiciel de calcul formel comme Xcas n’aurait pas écrit ces nombres en notation scientifique standard.• Dans le script, on a demandé l’affichage de Y' au lieu de Y car par défaut, la boucle pour a écrit Y encolonne. Y' est le transposé de Y, c’est à dire Y écrit en ligne, ce qui fait gagner de la place.Solution no2 La solution no1 est là car ce chapitre est consacré aux boucles pour, mais elle n’est pas bonne.Il vaut mieux manipuler des vecteurs, par exemple ajouter le premier élément de la liste X à la fin puisne retenir que les éléments de la nouvelle liste allant du rang 2 au rang n + 1, c’est à dire au dernier rangqui s’écrit $, ce qui permet d’oublier la commande n=taille(X); et par conséquent permet de raccourcirle script.�X=input ( ”X=” ) ;format ( ’ v ’ , 5 ) ;a f f i c h e r ( ”X␣=␣” ) ; a f f i c h e r (X) ;X=[X,X( 1 ) ] ;Y=X(2 : $ ) ;a f f i c h e r ( ”Y␣=␣” ) ; a f f i c h e r (Y) ;� �On peut aller un peu plus vite :�X=input ( ”X=” ) ;

4. Voir l’exercice 4.2.

80

format ( ’ v ’ , 5 ) ;a f f i c h e r ( ”X␣=␣” ) ; a f f i c h e r (X) ;Y=[X(2 : $ ) ,X( 1 ) ] ;a f f i c h e r ( ”Y␣=␣” ) ; a f f i c h e r (Y) ;� �On peut aussi utiliser un produit par la matrice de permutation ad hoc, voir l’exercice 6.20, mais c’estinutilement compliqué.

81

6.18 [*] Écrire une suite de nombres à l’envers

Écrire un script qui transforme une liste de nombres donnée X = [x1, . . . , xn] en la liste Y = [xn, . . . , x1].

Mots-clefs : commande X(B) 5, vecteur des éléments du vecteur X dont les rangs sont dans B.

Solution no1 : Voici une solution laborieuse (et lente) utilisant une boucle pour : on écrit X(n), puisX(n− 1), …, X(1).�X=input ( ’X=’ ) ;n=length (X) ;Y=[X(n ) ]for i=2 :n

Y=[Y,X(n−i +1) ] ;enda f f i c h e r (X) ;a f f i c h e r (Y) ;� �Exemple d’application :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)X=[3 ,1 ,−2 ,7 ,4 ,−9 ,6] ;

3 . 1 . − 2 . 7 . 4 . − 9 . 6 .6 . − 9 . 4 . 7 . − 2 . 1 . 3 .

−−>� �Solution no2 : Cette solution est plus rapide car elle utilise des commandes scilab plus évoluées, voir lasignification de la commande X(B) ci-dessus. Ici, B = n:-1:1, suite des entiers de n à 1 de pas -1.�X=input ( ’X=’ ) ;n=length (X) ;Y=X(n :−1 :1) ;a f f i c h e r (X) ;a f f i c h e r (Y) ;� �On peut aussi utiliser un produit par la matrice de permutation ad hoc, voir l’exercice 6.20, mais c’estinutilement compliqué.

5. Voir l’exercice 4.2.

82

6.19 [***] Permutations (solution matricielle).

Écrire toutes les permutations de 1, 2, …, n.(solution matricielle)

Mots-clefs : Commandes stacksize, size, ones(p,q), perms.

Dans le script ci-dessous, pour calculer toutes les permutations des entiers de 1 à n (qui seront écrites encolonne, ce qui donnera une matrice à n ! lignes et à n colonnes), on écrit toutes les permutations de 1, puisde (1, 2), puis de (1, 2, 3), etc,

1 −→ 2 11 2 −→

3 2 13 1 22 3 11 3 22 1 31 2 3

−→

et on s’arrête quand on a obtenu les permutations de (1, 2, . . . , n). Pour passer d’une permutation quelconquede (1, 2, . . . , k) à une permutation de (1, 2, . . . , (k+ 1)), on peut ajouter k+1 devant cette permutation, oubien après le premier terme, ou le second, etc, ou finalement après le dernier terme. Cela promet d’être long.En fait, nous allons travailler matriciellement : nous partons de la matrice 1, puis nous ajoutons 2 devant1 puis derrière 1 pour obtenir les 2 permutations de (1, 2) écrites l’une au-dessous de l’autre, puis nousconstruisons les permutations de (1, 2, 3) en partant de la matrice (2,2) que nous venons d’obtenir et enajoutant une colonne de deux 3 devant la première colonne, puis derrière la première colonne, puis derrièrela seconde. On empile les 3 matrices à 2 lignes et 3 colonnes ainsi obtenue. Et ainsi de suite. Cela conduit àla fonction scilab suivante :�function y=f_permut (M) ; // M e s t une matrice .

[ r , c ]= s ize (M) ; // r : nombre de l i gn e s , c , de co lonnes .A=(c+1)*ones ( r , 1 ) ; // Colonne de ( c+1) a r l i g n e s .y= [ ] ;for j=0 :c

B=[M( : ,1 : j ) ,A,M( : , j+1 :c ) ] ; //Matrice a r l i g n e s , c+1 co lonnes ://on a i n t e r c a l e A au debut , en t re l e s colonnes , a l a f i n .y=[y ;B ] ;

endendfunction� �On charge cette fonction dans la console de scilab. Dans le script qui suit, elle est chargée de calculer lepassage de la matrice des permutations de (1, 2, . . . , k) à la matrice des permutations de (1, 2, . . . , (k+ 1)).Le script lui-même définit la fonction scilab qui à n associe la liste des permutations de 1, …, n et le tempsdu calcul.La commande stacksize('max'); alloue le maximum de mémoire à scilab.�function l i s te_permut (n ) ; // n e s t un en t i e r >0.

t i c ( ) ;M=[1 ] ;for j=1 :n−1

M=f_permut (M) ;end ;temps=toc ( ) ;a f f i c h e r (M) ;a f f i c h e r ( ’La␣duree ␣du␣ ca l cu l , ␣en␣ secondes , ␣ e s t ␣ ’+string ( temps ) )

endfunction� �83

On charge la deuxième fonction dans la console. Voici ce que l’on obtient pour n = 4 :�−−>liste_permut (4 )

4 . 3 . 2 . 1 .4 . 3 . 1 . 2 .4 . 2 . 3 . 1 .4 . 1 . 3 . 2 .4 . 2 . 1 . 3 .4 . 1 . 2 . 3 .3 . 4 . 2 . 1 .3 . 4 . 1 . 2 .2 . 4 . 3 . 1 .1 . 4 . 3 . 2 .2 . 4 . 1 . 3 .1 . 4 . 2 . 3 .3 . 2 . 4 . 1 .3 . 1 . 4 . 2 .2 . 3 . 4 . 1 .1 . 3 . 4 . 2 .2 . 1 . 4 . 3 .1 . 2 . 4 . 3 .3 . 2 . 1 . 4 .3 . 1 . 2 . 4 .2 . 3 . 1 . 4 .1 . 3 . 2 . 4 .2 . 1 . 3 . 4 .1 . 2 . 3 . 4 .

La duree du ca l cu l , en secondes , e s t 0 .001−−>� �Quand n grandit, le temps d’affichage s’allonge très vite, le temps de calcul aussi. À partir de n = 9,l’affichage est vraiment trop long. Heureusement, il suffit souvent de calculer les permutations sans lesafficher. Supprimons donc l’affichage deM en remplaçant afficher(M); par //afficher(M); (la commanded’affichage est devenue un commentaire). Pour n = 9, puis 10, puis 11 (rappel : 9 ! = 362880, 10 ! = 3628800,11 ! = 39916800), on obtient :�−−>liste_permut (9 )La duree du ca l cu l , en secondes , e s t 0 .478

−−>liste_permut (10)La duree du ca l cu l , en secondes , e s t 5 .777

−−>liste_permut (11)!−−error 17

Ta i l l e de l a p i l e depasseeU t i l i s e z l a f on c t i on stacksize pour l ’ augmenter .Memoire u t i l i s e e pour l e s v a r i a b l e s : 119759967Memoire i n t e rmed i a i r e r e qu i s e : 159667215Memoire t o t a l e d i s p on i b l e : 268435455at l i n e 8 o f function f_permut c a l l e d by :at l i n e 5 o f function l i s te_permut c a l l e d by :l i s te_permut (11)−−>� �Cet algorithme n’écrit donc les permutations de (1, 2, . . . , n) que lorsque n ⩽ 10. Les problèmes de taille

84

de mémoire sont fréquents dans les dénombrements.Remarque : La commande perms(x) retourne toutes les permutations des composantes d’un vecteur x.Par exemple�−−>perms (1 :4)ans =

4 . 3 . 2 . 1 .4 . 3 . 1 . 2 .4 . 2 . 3 . 1 .4 . 2 . 1 . 3 .4 . 1 . 3 . 2 .4 . 1 . 2 . 3 .3 . 4 . 2 . 1 .3 . 4 . 1 . 2 .3 . 2 . 4 . 1 .3 . 2 . 1 . 4 .3 . 1 . 4 . 2 .3 . 1 . 2 . 4 .2 . 4 . 3 . 1 .2 . 4 . 1 . 3 .2 . 3 . 4 . 1 .2 . 3 . 1 . 4 .2 . 1 . 4 . 3 .2 . 1 . 3 . 4 .1 . 4 . 3 . 2 .1 . 4 . 2 . 3 .1 . 3 . 4 . 2 .1 . 3 . 2 . 4 .1 . 2 . 4 . 3 .1 . 2 . 3 . 4 .

−−>� �ou�−−>perms ( [ ’ Anatole ’ , ’ Anthelme ’ , ’ Athanase ’ , ’ Antoine ’ ] )ans =

! Antoine Athanase Anthelme Anatole !! !! Antoine Athanase Anatole Anthelme !! !! Antoine Anthelme Athanase Anatole !! !! Antoine Anthelme Anatole Athanase !! !! Antoine Anatole Athanase Anthelme !! !! Antoine Anatole Anthelme Athanase !! !! Athanase Antoine Anthelme Anatole !! !! Athanase Antoine Anatole Anthelme !! !

85

! Athanase Anthelme Antoine Anatole !! !! Athanase Anthelme Anatole Antoine !! !! Athanase Anatole Antoine Anthelme !! !! Athanase Anatole Anthelme Antoine !! !! Anthelme Antoine Athanase Anatole !! !! Anthelme Antoine Anatole Athanase !! !! Anthelme Athanase Antoine Anatole !! !! Anthelme Athanase Anatole Antoine !! !! Anthelme Anatole Antoine Athanase !! !! Anthelme Anatole Athanase Antoine !! !! Anatole Antoine Athanase Anthelme !! !! Anatole Antoine Anthelme Athanase !! !! Anatole Athanase Antoine Anthelme !! !! Anatole Athanase Anthelme Antoine !! !! Anatole Anthelme Antoine Athanase !! !! Anatole Anthelme Athanase Antoine !−−>� �La commande perms pose les mêmes problèmes de dépassement de capacité que précédemment.

86

6.20 [***] Matrices de permutation

1 - Une permutation σ de l’ensemble (1, 2, . . . , n) étant donnée, écrire la matrice de permutationP de σ (voir les explications ci-dessous).2 - Soit X un vecteur de longueur n. Vérifier sur un exemple que Y = X·P s’obtient enpermutant selon σ les composantes de X.3 - Quelle matrice de permutationM permet d’écrire les composantes de X dans l’ordre inverse ?

Mots-clefs : eye(n,n), produit matriciel (dont la définition est rappelée à l’exercice 4.6).

Explications : Une permutation σ de (1, . . . , n) peut être décrite par le vecteur sigma des images successivesdes nombres 1, . . . , n par σ. Une matrice de permutation de taille n est une matrice carrée à n ligneset colonnes, chacune d’elles comprenant un 1 et n−1 zéros. Nous disposons d’une excellente matrice depermutation de taille n, à savoir la matrice-unité I donnée par la commande eye(n,n). Nous allons voir quela matrice de permutation P de σ s’obtient à partir de I en remplaçant sa première colonne par la colonnede rang σ (1) de I, sa deuxième colonne par la colonne σ (2) de I, etc. Cela veut dire que si X est un vecteurde longueur n, Y = X·P est le vecteur obtenu en effectuant la permutation σ sur les composantes de X.scilab nous permet de constater cela sur des exemples. La démonstration, qui s’appuie sur la définition duproduit des matrices, est évidente.La fonction matpermut ci-dessous a pour entrée n et sigma et retourne la matrice P que nous venons dedécrire :�function P=matpermut (n , sigma )

I=eye (n , n ) ;P= [ ] ;for i=1 :n

P=[P, I ( : , sigma ( i ) ) ] ;end

endfunction� �Nous répondons maintenant à la question 3, donc aussi à la question 2. La permutation à utiliser estσ = n, n − 1, . . . , 1. Pour n = 15, X étant une liste de 15 nombres entiers choisis au hasard entre -3 et 7,cela donne, la fonction matpermut - téléchargeable - ayant été chargée dans la console :�−−>n=15 ;−−>sigma=n :−1 :1 ;−−>P=matpermut (n , sigma )P =

column 1 to 100 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 1 .0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 1 . 0 .0 . 0 . 0 . 0 . 0 . 0 . 0 . 1 . 0 . 0 .0 . 0 . 0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 1 . 0 . 0 . 0 . 0 . 0 . 0 .

87

0 . 0 . 1 . 0 . 0 . 0 . 0 . 0 . 0 . 0 .0 . 1 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 .1 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 . 0 .

column 11 to 150 . 0 . 0 . 0 . 1 .0 . 0 . 0 . 1 . 0 .0 . 0 . 1 . 0 . 0 .0 . 1 . 0 . 0 . 0 .1 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .0 . 0 . 0 . 0 . 0 .

−−>X=t i r a g e_en t i e r (15 ,−3 ,7)X =

column 1 to 103 . 0 . 7 . 6 . 1 . 4 . − 3 . 3 . 2 . 1 .

column 11 to 15− 1 . 0 . 0 . 5 . − 3 .

−−>Y=X*PY =

column 1 to 10− 3 . 5 . 0 . 0 . − 1 . 1 . 2 . 3 . − 3 . 4 .

column 11 to 151 . 6 . 7 . 0 . 3 .

−−>� �M est donc la matrice qui porte des 1 sur la diagonale non-principale, des 0 ailleurs.Remarques :• Cet exercice fournit une nouvelle solution de l’exercice 4.2 : il suffit d’utiliser la permutation σ donnée par�sigma=[1 : i −1, j , i+1 :j −1, i , j+1 :n ] ;� �(si l’on suppose i < j) ;• cet exercice fournit aussi une nouvelle solution de l’exercice 6.18.Solution no3 : avec une matrice de permutation. C’est la meilleure solution dans le cas de calculs ultérieurs.Voir l’exercice 6.20 pour les matrices de permutation. La matrice M du script ci-dessous est la matrice depermutation de taille n qui réalise la transformation X = [x1, . . . , xn−1, xn] donne Y = [x2, . . . , xn, x1] parle produit matriciel Y = X·M .�X=input ( ”X=” ) ;format ( ’ v ’ , 5 ) ;a f f i c h e r ( ”X␣=␣” ) ; a f f i c h e r (X) ;n=t a i l l e (X) ;M=[zeros (1 , n−1) ,1 ;eye (n−1,n−1) , zeros (n−1 ,1 ) ] ;Y=X*M;a f f i c h e r ( ”Y␣=␣” ) ; a f f i c h e r (Y) ;

88

Z=X*M^n ;a f f i c h e r ( ”Z␣=␣” ) ; a f f i c h e r (Z ) ;� �Nous avons appliqué ce script à X=[-1,1/4,%e,%pi,5,log(2),tan(2*%pi/3)] (n = 7). Nous avons calculéen plus Z = X·M7. On constate qu’en appliquant la transformation 7 fois, on trouve Z = X·M7 = X, cequi était attendu car M7 est évidemment la matrice-identité de taille 7.�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)X=[−1 ,1/4 ,%e , %pi , 5 , log ( 2 ) , tan (2*%pi / 3 ) ]X =

− 1 . 0 .25 2 .72 3 .14 5 . 0 .69 − 1 .73Y =

0.25 2 .72 3 .14 5 . 0 .69 − 1 .73 − 1 .Z =

− 1 . 0 .25 2 .72 3 .14 5 . 0 .69 − 1 .73−−>� �

89

6.21 [***] Échanger deux lignes ou deux colonnes d’un tableau (produitd’une matrice par une matrice de permutation)

1 - M étant un tableau de nombres à n lignes et m colonnes,1.a - soit σ1 une permutation de (1, . . . , m) (au choix du lecteur) et P1 la matrice de permutationqui lui est associée (voir l’exercice 6.20) ; comparer M et M ∗ P1 (effet sur une matrice de lamultiplication à droite par une matrice de permutation) ;1.b - soit σ2 une permutation de (1, . . . , n) (au choix du lecteur) et P2 la matrice de permutationqui lui est associée ; comparer M et P2 ∗M (effet sur une matrice de la multiplication à gauchepar une matrice de permutation) ;2 - Engendrer un tableau de nombres entiers M à n lignes et à m colonnes à l’aide de lacommande grand(n,m,"uin",-13,14).2 .a - Échanger les lignes 2 et n− 1 de M ,2.b - Échanger les colonnes 2 et m− 1 de M .

Mots-clefs : matrices de permutation, multiplication à gauche et à droite.

Ce problème a déjà été traité, voir l’exercice 4.3. Ici, on utilise des matrices de permutation. Les matricesde permutation P1 et P2 seront calculées à l’aide de la fonction scilab matpermut.sci téléchargeable, voirl’exercice 6.20. Il convient donc de charger cette fonction dans la console. On utilisera le script suivant :�n=input ( ’n=’ ) ;m=input ( ’m=’ ) ;M=grand (n ,m, ” uin ” ,−13 ,14) ;s1=input ( ’ s1=’ ) ; //Permutation de ( 1 , . . . ,m) .P1=matpermut (m, s1 ) ;a f f i c h e r (M) ;a f f i c h e r (M*P1 ) ;s2=input ( ’ s2=’ ) ; //Permutation de ( 1 , . . . , n ) .P2=matpermut (n , s2 ) ;a f f i c h e r (M) ;a f f i c h e r (P2*M) ;� �Lors de l’exécution de ce script, le logiciel demandera quelles valeurs ont été choisies pour n, m, s1 (pour σ1)et plus tard s2 (pour σ2). Ci-dessous, on a choisi respectivement 5, 9, [1, 8, 3, 4, 5, 6, 7, 2, 9] et [1, 4, 3, 2, 5].Cela donne finalement�−−>exec ( ’Chemin␣de␣matpermut . s c i ’ , −1)−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=5m=9s1 =[1 , 8 , 3 , 4 , 5 , 6 , 7 , 2 , 9 ]

2 . − 11 . 9 . 12 . 8 . 2 . − 1 . 8 . 4 .9 . − 11 . − 2 . 7 . 8 . 6 . 6 . − 13 . 14 .1 . 13 . 1 . 4 . − 2 . 10 . − 6 . − 5 . 7 .

− 5 . 3 . − 4 . 9 . − 10 . 1 . 0 . − 1 . 6 .− 8 . − 10 . − 10 . − 3 . − 10 . 5 . − 3 . − 1 . 10 .

2 . 8 . 9 . 12 . 8 . 2 . − 1 . − 11 . 4 .

90

9 . − 13 . − 2 . 7 . 8 . 6 . 6 . − 11 . 14 .1 . − 5 . 1 . 4 . − 2 . 10 . − 6 . 13 . 7 .

− 5 . − 1 . − 4 . 9 . − 10 . 1 . 0 . 3 . 6 .− 8 . − 1 . − 10 . − 3 . − 10 . 5 . − 3 . − 10 . 10 .

s2 =[1 , 4 , 3 , 2 , 5 ]

2 . − 11 . 9 . 12 . 8 . 2 . − 1 . 8 . 4 .9 . − 11 . − 2 . 7 . 8 . 6 . 6 . − 13 . 14 .1 . 13 . 1 . 4 . − 2 . 10 . − 6 . − 5 . 7 .

− 5 . 3 . − 4 . 9 . − 10 . 1 . 0 . − 1 . 6 .− 8 . − 10 . − 10 . − 3 . − 10 . 5 . − 3 . − 1 . 10 .

2 . − 11 . 9 . 12 . 8 . 2 . − 1 . 8 . 4 .− 5 . 3 . − 4 . 9 . − 10 . 1 . 0 . − 1 . 6 .

1 . 13 . 1 . 4 . − 2 . 10 . − 6 . − 5 . 7 .9 . − 11 . − 2 . 7 . 8 . 6 . 6 . − 13 . 14 .

− 8 . − 10 . − 10 . − 3 . − 10 . 5 . − 3 . − 1 . 10 .−−>� �On constate que M ∗ P1 est obtenu à partir de M en échangeant les colonnes no2 et no8. De même, P2 ∗Mest obtenu à partir de M en échangeant les lignes no2 et no8. Ce choix des permutations σ1 et σ2 fait que ladeuxième question a été traitée en même temps que la première.Il est facile de démontrer, en appliquant seulement la définition du produit des matrices, que multiplier àdroite par une matrice de permutation revient à faire cette permutation sur les colonnes et que multiplier àgauche revient à faire la permutation sur les lignes. Dans le cas n = 1, on retrouve l’exercice 6.20.

91

6.22 [**] Calcul matriciel de l’espérance et de la variance d’une variablealéatoire finie

1 - Soit X une variable aléatoire ne prenant que les valeurs v1, …, vn avec respectivement lesprobabilités p1, …, pn (> 0). Exprimer matriciellement son espérance moy et sa variance var àl’aide des vecteurs V = [v1, . . . , vn] et prob = [p1, . . . , pn].2 - Application : calculer l’espérance et la variance d’une variable aléatoire suivant la loi binomialede taille 10 et de paramètres 1

3 ·

Mots-clefs : calcul des probabilités, calcul matriciel, espérance, variance, commandes : loi_binomiale(n,p),afficher.

Cet exercice montre le grand intérêt du calcul matriciel. Les calculs sont explicites et rapides. On n’a pasbesoin d’utiliser les commandes moyenne_ponderee et variance_ponderee de scilab.1 - Par définition de la moyenne d’une variable aléatoire finie,

moy = p1v1 + · · ·+ pnvn

ce qui signifie, par définition du produit des matrices, que

moy = prov·V ′

si l’on note V ′ la matrice transposée de V , qui est le vecteur V écrit en colonne. De même,

var = p1(v1 −moy)2 + · · ·+ pn(vn −moy)2 ou var = prov·W

où W est la matrice-colonne dont les éléments sont successivement (v1−moy)2, . . . , (vn−moy)2. Se rappelantque .^2 est la commande d’élévation au carré terme à terme des éléments d’une matrice, on en déduit lafonction-scilab MoyVar suivante qui, à partir de toute variable aléatoire dont la loi est donnée par V et prob,retourne son espérance et sa variance.

Listing 6.1 – Fonction MoyVar�function [m, v]=MoyVar(V, prob )

m=prob*V ’ ;v=prob *( (V−m) . ^ 2 ) ’ ;

endfunction� �Au lieu de ((V-m).^2)', on aurait pu écrire ((V-m*ones(n,1)).^2)'. On aurait pu aussi intervertir latransposition et l’élévation au carré terme à terme. Cette question n’a évidemment rien à voir avec scilab.2 - Le script suivant répond à la deuxième question :�function [m, v]=MoyVar(V, prob )

m=prob*V ’ ;v=prob *( (V−m) . ^ 2 ) ’ ;

endfunctionn=10 ;p=1/3 ;proba=lo i_b inomia l e (n , p ) ; //Vecteur des p r o b a b i l i t e s i n d i v i d u e l l e s de B(n , p ) .va l =0 :10 ;[ Moyenne , Variance ]=MoyVar( val , proba ) ;a f f i c h e r ( ’La␣moyenne␣ et ␣ l a ␣ var iance ␣de␣ c e t t e ␣ l o i ␣ b inomia le ␣ sont ␣ re spect ivemente g a l e s ␣a ’ ) ;

92

a f f i c h e r ( [ Moyenne , Variance ] ) ;mo=n*p ;va=n*p*(1−p ) ;a f f i c h e r ( ’ Conf irmation ’ ) ;a f f i c h e r ( [mo, va ] ) ;� �Les 4 dernières lignes calculent directement la moyenne et la variance de la loi binomiale de taille n et deparamètre p 6. On peut ainsi les comparer aux résultats précédents. L’exécution de ce script retourne :�−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣MoyVar ’ , −1)La moyenne et l a variance de c e t t e l o i b inomia le sont re spect ivemente g a l e s a

3.3333333333333 2.2222222222222Conf irmation

3.3333333333333 2.2222222222222−−>� �

6. On sait que la moyenne et la variance de la loi binomiale de taille n et de paramètre p sont respectivement np et np(1−p).

93

6.23 [***] Calcul matriciel de la covariance de 2 variables aléatoires finies

Soit X et Y deux variables aléatoires finies, VX = [x1, . . . , xn] et VY = [y1, . . . , ym] les vecteurs des valeursqu’elles prennent avec des probabilités > 0. La loi du couple aléatoire (X,Y ) est décrite par la matriceP(X,Y ) = (pi,j , 1 ⩽ i ⩽ n ; 1 ⩽ j ⩽ m) où pi,j = P (X = xi , Y = yj).1 - Comment calcule-t-on la loi PX de X à partir de P(X,Y ) ? Même question pour la loi PY de Y .2 - Exprimer matriciellement les espérances mX et mY de X et Y .3 - Exprimer matriciellement la variance var (X) de X.4 - Exprimer matriciellement la covariance cov (X,Y ) de X et Y .5 - Application : Calculer les quantités ci-dessus lorsque P(X,Y ), VX et VY sont respectivement égales à :P(X,Y )=

0.002 0.012 0.004 0.005 0.017 0.012 0.004 0.001 0.003 0.001 0.005 0. 0.009 0.002 0.0010.011 0.002 0.003 0.01 0.009 0.002 0.009 0.002 0.002 0.006 0.002 0.003 0.011 0.007 0.0060.003 0.001 0.007 0.001 0.009 0.003 0.009 0.005 0.006 0.004 0.002 0.004 0.003 0.011 0.010.001 0.002 0.007 0.012 0.002 0. 0. 0.002 0.003 0.008 0.006 0.009 0.005 0.002 0.0080.01 0.011 0.001 0.01 0.004 0.004 0. 0. 0.004 0. 0.012 0. 0.005 0.01 0.0090.001 0. 0.004 0.012 0.001 0.012 0.001 0.004 0.011 0.01 0.005 0.004 0.004 0.012 0.0070.002 0.012 0.003 0.004 0.006 0.005 0. 0.01 0.004 0.012 0.003 0.004 0. 0.004 0.010.009 0.011 0.012 0.009 0.005 0.021 0.011 0.02 0.011 0.003 0.003 0.007 0.008 0.005 0.0050.006 0.005 0.001 0.004 0.008 0.012 0.007 0.008 0.012 0. 0. 0.006 0.001 0.004 0.0010. 0.006 0.012 0.01 0.002 0.011 0.006 0.011 0.023 0.023 0.009 0.003 0.011 0.01 0.0070.003 0.013 0. 0.003 0.002 0.008 0.009 0.006 0.021 0. 0.004 0.003 0.005 0.002 0.007

VX = [1., 1.3, 1.6, 1.9, 2.2, 2.5, 2.8, 3.1, 3.4, 3.7, 4.] etVY = [−4.,−3.3,−2.6,−1.9,−1.2,−0.5, 0.2, 0.9, 1.6, 2.3, 3., 3.7, 4.4, 5.1, 5.8]

Mots-clefs : espérance, variance, covariance, lois marginales, commandes sum(M,"c"), sum(M,"r"), diag.

Cet exercice suppose connues certaines notions élémentaires du Calcul des probabilités. Pour l’espérance etla variance d’une variable aléatoire finie, on peut se reporter à 6.22.1 - On peut supposer que Y ne prend pas d’autres valeurs que celles de VY . Dans ces conditions,

(X = xi) =

m∪j=1

(X = xi , Y = yj)

Cette réunion étant disjointe et la probabilité étant additive,

P (X = xi) =

m∑j=1

P (X = xi , Y = yj)

La ième probabilité de la loi de X s’obtient donc en additionnant les éléments de la matrice P(X,Y ) qui sontsitués sur sa ième ligne. Les sommes sur toutes les lignes formeront un vecteur-colonne qu’il faudra transposerpour obtenir un vecteur-ligne (commande PX=(sum(PXY,"c"))'; dans le script ci-dessous). De même, la loide Y s’obtient en additionnant les colonnes (commande PY=sum(PXY,"r"); dans le script ci-dessous) 7.2 et 3 - D’après l’exercice 6.22, mX = PX ∗ (VX)′, mY = PY ∗ (VY )

′. et var (X) = PX ∗ W où W est lamatrice-colonne dont les éléments sont successivement (x1 −mX)2, . . . , (xn −mX)2.4 - Par définition, la covariance de X et Y est l’espérance de la variable aléatoire (X − mX)· (Y − mY ).Comme cette variable aléatoire prend les valeurs (xi −mX)(yj −mY ) avec les probabilités pi,j ,

cov (X,Y ) =

n∑i=1

m∑j=1

pi,j · (xi −mX)(yj −mY ) = (X −mX) ·P(X,Y )· (Y −mY )

7. PX et PY s’appellent les lois marginales de (X,Y ).

94

5 - Voir le script ci-dessous et son application.

Listing 6.2 – Covariance de X et Y (téléchargeable)�clear ;PXY=[2 , 12 , 4 , 5 , 17 , 12 , 4 , 1 , 3 , 1 , 5 , 0 , 9 , 2 , 1 ;11 , 2 , 3 , 10 , 9 , 2 , 9 , 2 , 2 , 6 , 2 , 3 , 11 , 7 , 6 ;3 , 1 , 7 , 1 , 9 , 3 , 9 , 5 , 6 , 4 , 2 , 4 , 3 , 11 , 10 ;1 , 2 , 7 , 1 2 , 2 , 0 , 0 , 2 , 3 , 8 , 6 , 9 , 5 , 2 , 8 ;10 , 11 , 1 , 10 , 4 , 4 , 0 , 0 , 4 , 0 , 12 , 0 , 5 , 10 , 9 ;1 , 0 , 4 , 12 , 1 , 12 , 1 , 4 , 11 , 10 , 5 , 4 , 4 , 12 , 7 ;2 , 12 , 3 , 4 , 6 , 5 , 0 , 10 , 4 , 12 , 3 , 4 , 0 , 4 , 10 ;9 , 11 , 12 , 9 , 5 , 21 , 11 , 20 , 11 , 3 , 3 , 7 , 8 , 5 , 5 ;6 , 5 , 1 , 4 , 8 , 1 2 , 7 , 8 , 12 , 0 , 0 , 6 , 1 , 4 , 1 ;0 , 6 , 12 , 10 , 2 , 11 , 6 , 11 , 23 , 23 , 9 , 3 , 11 , 10 , 7 ;3 , 13 , 0 , 3 , 2 , 8 , 9 , 6 , 21 , 0 , 4 , 3 , 5 , 2 , 7] / 1000 ;disp (PXY) ;VX=1 :0.3 :4 ; //10 va l e u r s .disp ( ’ Les␣ va l eu r s ␣ p r i s e s ␣par␣X␣ sont ’ ) ;disp (VX) ;VY=−4 :0.7 :6.4 ;//15 va l eu r s .disp ( ’ Les␣ va l eu r s ␣ p r i s e s ␣par␣Y␣ sont ’ ) ;disp (VY) ;PX=(sum(PXY, ” c ” ) ) ’ ; //On o b t i e n t une l i g n e .disp ( ’La␣ l o i ␣de␣X␣ e s t ’ ) ;disp (PX) ;PY=sum(PXY, ” r ” ) ; //Idemdisp ( ’La␣ l o i ␣de␣Y␣ e s t ’ ) ;disp (PY) ;EX=PX*(VX’ ) ;disp ( ’L ’ ’ e sperance ␣de␣X␣ e s t ’ ) ;disp (EX) ;EY=PY*VY’ ;disp ( ’L ’ ’ e sperance ␣de␣Y␣ e s t ’ ) ;disp (EY) ;VarX=PX*((VX−EX) . ^ 2 ) ’ ;disp ( ’La␣ var iance ␣de␣X␣ e s t ’ ) ;disp (VarX ) ;CovXY=(VX−EX)*PXY*((VY−EY) ’ ) ;disp ( ’La␣ covar iance ␣de␣X␣ et ␣Y␣ e s t ’ ) ;disp (CovXY) ;// Autre c a l c u l de l a var iance de X :PXX=diag (PX) ;A=(VX−EX)*PXX*((VX−EX) ’ ) ;disp ( ’La␣ var iance ␣de␣X␣ e s t ’ ) ;disp (A) ;� �Application :

Listing 6.3 – Calculs�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)

column 1 to 70 .002 0 .012 0 .004 0 .005 0 .017 0 .012 0 .004

95

0 .011 0 .002 0 .003 0 .01 0 .009 0 .002 0 .0090 .003 0 .001 0 .007 0 .001 0 .009 0 .003 0 .0090 .001 0 .002 0 .007 0 .012 0 .002 0 . 0 .0 .01 0 .011 0 .001 0 .01 0 .004 0 .004 0 .0 .001 0 . 0 .004 0 .012 0 .001 0 .012 0 .0010 .002 0 .012 0 .003 0 .004 0 .006 0 .005 0 .0 .009 0 .011 0 .012 0 .009 0 .005 0 .021 0 .0110 .006 0 .005 0 .001 0 .004 0 .008 0 .012 0 .0070 . 0 .006 0 .012 0 .01 0 .002 0 .011 0 .0060 .003 0 .013 0 . 0 .003 0 .002 0 .008 0 .009

column 8 to 140 .001 0 .003 0 .001 0 .005 0 . 0 .009 0 .002

0 .002 0 .002 0 .006 0 .002 0 .003 0 .011 0 .0070 .005 0 .006 0 .004 0 .002 0 .004 0 .003 0 .0110 .002 0 .003 0 .008 0 .006 0 .009 0 .005 0 .0020 . 0 .004 0 . 0 .012 0 . 0 .005 0 .010 .004 0 .011 0 .01 0 .005 0 .004 0 .004 0 .0120 .01 0 .004 0 .012 0 .003 0 .004 0 . 0 .0040 .02 0 .011 0 .003 0 .003 0 .007 0 .008 0 .0050 .008 0 .012 0 . 0 . 0 .006 0 .001 0 .0040 .011 0 .023 0 .023 0 .009 0 .003 0 .011 0 .010 .006 0 .021 0 . 0 .004 0 .003 0 .005 0 .002

column 150 .001

0 .0060 .010 .0080 .0090 .0070 .010 .0050 .0010 .0070 .007

Les va l eu r s p r i s e s par X sontcolumn 1 to 9

1 . 1 . 3 1 .6 1 .9 2 .2 2 .5 2 .8 3 .1 3 .4column 10 to 11

3 .7 4 .Les va l eu r s p r i s e s par Y sont

column 1 to 9− 4 . − 3 .3 − 2 .6 − 1 .9 − 1 .2 − 0 .5 0 .2 0 .9 1 . 6

column 10 to 152 .3 3 . 3 . 7 4 .4 5 .1 5 .8

La l o i de X e s tcolumn 1 to 7

0 .078 0 .085 0 .078 0 .067 0 .08 0 .088 0 .079column 8 to 11

0 .14 0 .075 0 .144 0 .086La l o i de Y e s t

column 1 to 70 .048 0 .075 0 .054 0 .08 0 .065 0 .09 0 .056

96

column 8 to 140 .069 0 .1 0 .067 0 .051 0 .043 0 .062 0 .069

column 150 .071

L ’ esperance de X e s t2 .624

L ’ esperance de Y e s t0 .881

La variance de X e s t0 .896

La covar iance de X et Y e s t0 .039

La variance de X e s t0 .896� �

Remarque : cov (X,X) = E ((X −mX) (X −mX)), soit cov (X,X) = var (X).Si on veut calculer la variance de X de cette manière, il faut calculer PX,X . Comme P (X = xi, X = xj) vaut0 si xi ̸= xj , P (X = xi) sinon, PX,X est la matrice diagonale dont les éléments diagonaux sont les élémentsde PX (commande diag(PX)). Ceci fait l’objet des 3 dernières lignes du script.

97

6.24 [***] Ranger n nombres donnés dans l’ordre croissant (tri à bulle)

Soit une suite de nombres A = [a1, . . . , an] à ranger dans l’ordre croissant. On appellera Aneuf la suiteobtenue. Dans le tri à bulles, on fait une suite de passages sur A. Au premier passage, on considère la paire(a1, a2) que l’on met dans l’ordre croissant, ce qui modifie A, puis (a2, a3), etc. À la fin du premier passage,le dernier terme de Aneuf est placé. On continue ces passages qui placent définitivement l’avant dernierterme de Aneuf , puis le précédent, etc. Après le (n− 1)ème passage, Aneuf est obtenu.On demande une fonction scilab qui range A dans l’ordre croissant par le tri à bulles.

Mots-clefs : « tic();opération;toc() », tirage_entier, taille, boucles pour imbriquées.

On peut utiliser la fonction suivante :�function Aneuf=Tr iBu l l e s (A)

B=A;n=t a i l l e (A) ;for k=1 :(n−1)

for j =1 :(n−k )B( [ j , j +1])=[min(B( j ) ,B( j +1)) ,max(B( j ) ,B( j +1) ) ] ;

endendAneuf=B;

// a f f i c h e r (A) ;// a f f i c h e r (Aneuf ) ;endfunction� �Ce script tient compte des remarques suivantes : à la fin du (k− 1)ème passage, les k− 1 derniers termes deAneuf sont placés. Pour le kème passage, il suffit donc d’examiner les paires (a1, a2), …, (an−k−1, an−k). Etbien sûr, k − 1 passages suffisent. Voici une application de cette fonction.�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)−−>A=t i r a g e_r e e l ( 10000 , 0 , 1 ) ;−−>t i c ( ) ; Aneuf=Tr iBu l l e s (A) ; temps=toc ( ) ;−−>tempstemps =

391.183−−>A(1 :5)ans =

column 1 to 20.8147236919031 0.1354770041071

column 3 to 40.9057919341139 0.8350085897837

column 50.1269868118688

−−>Aneuf (1 :5)ans =

column 1 to 20.0000121421181 0.0002310688142

column 3 to 40.0003260960802 0.0003414633684

column 50.0005223751068

98

−−>A(9996 :10000)ans =

column 1 to 20.1593243696261 0.9299520466011

column 3 to 40.4512528912164 0.2819604331162

column 50.9601144108456

−−>Aneuf (9996 :10000)ans =

column 1 to 20.9994916191790 0.9997731263284

column 3 to 40.9997925662901 0.9998612964991

column 50.9999415774364

−−>� �Ces résultats font apparaître les 5 premiers (et les 5 derniers) termes de A et de Aneuf. Le tri seul a pris391.183 secondes, ce qui est abominablement long. Il aurait été pratiquement instantané avec la commandetri de scilab.Autres solutions : Voir les exercices 6.25, 8.9 et 8.10. Ils proposent d’autres tris, tous plus rapides que letri à bulles, qui n’est pas un bon tri.

99

6.25 [****] Ranger n nombres donnés dans l’ordre croissant

Soit une suite d’au moins 3 nombres A=[a_1,…,a_n] à ranger dans l’ordre croissant. On ap-pellera Atri la suite obtenue. Si l’on ne considère que les 2 premiers termes de la suite,Atri=[min(A([1:2])),max(A([1:2]))]. Si on tient compte du terme suivant, on va l’intro-duire dans Atri comme suit : on écrit d’abord les termes de Atri qui lui sont strictementinférieurs, puis ce nombre, puis les termes de Atri qui lui sont supérieurs ou égaux. Ceci nousfournit la nouvelles valeur de Atri. Et ainsi de suite. On demande une fonction scilab qui rangeA dans l’ordre croissant par ce procédé.

Mots-clefs : « tic();opération;toc() », tirage_reel, taille, find, boucle pour.

On peut utiliser la fonction suivante :�function Bof=Tr ie r3 (A) // A e s t une s u i t e d ’ au moins 3 nombres

t=t a i l l e (A) ;Atr i=[min(A( [ 1 , 2 ] ) ) ,max(A( [ 1 , 2 ] ) ) ] ;for i=3 :t

B=Atr i ;C=find (B<A( i ) ) ;B(C)= [ ] ;D=find ( Atri>=A( i ) ) ;Atr i (D)= [ ] ;Atr i=[Atri ,A( i ) ,B ] ;

endBof=Atr i ;

endfunction� �Voici deux applications de cette fonction (tri de 10000 nombres entre 0 et 1, puis tri de 100000 nombreségalement entre 0 et 1 ; on a affiché pour chacun de ces deux tris le temps mis, les 10 premiers et les 10derniers nombres de A et de Atri).�−−>clear ;−−>exec ( ’Chemin␣de␣Bof ’ , −1)−−>A=t i r a g e_r e e l ( 10000 , 0 , 1 ) ;−−>t i c ( ) ; Atr i=Tr ie r3 (A) ; temps=toc ( ) ; a f f i c h e r ( temps ) ; a f f i c h e r ( Atr i ( 1 : 1 0 ) ) ;a f f i c h e r ( Atr i (9990 :10000) ) ;

5 .092

column 1 to 50.0000110080000 0.0001033612061 0.0002221900504 0.0003911894746

0.0008971169591column 6 to 10

0.0009051819798 0.0010192452464 0.0010214892682 0.00116301584060.0011716762092

column 1 to 50.9992581047118 0.9993214600254 0.9993323672097 0.9994070082903

0.9995183185674column 6 to 10

0.9996201740578 0.9996497405227 0.9996856176294 0.99979588249700.9999444757123

100

column 110.9999806743581

−−>A=t i r a g e_r e e l ( 100000 , 0 , 1 ) ;−−>t i c ( ) ; Atr i=Tr ie r3 (A) ; temps=toc ( ) ; a f f i c h e r ( temps ) ; a f f i c h e r ( Atr i ( 1 : 1 0 ) ) ;a f f i c h e r ( Atr i (99990 :100000) ) ;

602 .528

column 1 to 50.0000210860744 0.0000264451373 0.0000351499766 0.0000357083045

0.0000372761860column 6 to 10

0.0000668293796 0.0000717386138 0.0000732627232 0.00007700989950.0000860642176

column 1 to 50.9998367871158 0.9998749606311 0.9998786845244 0.9998902815860

0.9998920490034column 6 to 10

0.9998978190124 0.9999217658769 0.9999401415698 0.99995120801030.9999596350826

column 110.9999762303196

−−>� �Autres solutions : Voir les exercices 6.24, 8.9 et 8.10. Ce tri est un mauvais tri, très lent. La commandetrier de scilab est de loin plus rapide.

101

6.26 [**] Trier un tableau suivant l’une de ses lignes

Voici la liste des fréquences des 26 lettres de l’alphabet dans la langue française :7.68, 0.80, 3.32, 3.60, 17.76, 1.06, 1.10, 0.64, 7.23, 0.19, 0.00, 5.89, 2.72, 7.61, 5.34, 3.24, 1.34,6.81, 8.23, 7.30, 6.05, 1.27, 0.00, 0.54, 0.21, 0.07.Le problème est de ranger ces lettres par ordre des fréquences décroissantes.Plus généralement, étant donné une matrice numériqueM à n lignes etm colonnes et un entier j,1 ⩽ j ⩽ n, ranger les colonnes de M de manière que la ligne j soit rangée dans l’ordre décroissant.

Mots-clefs : fonction scilab, boucles pour, manipulations élémentaires de tableaux, commandes min, max,taille, find, exec, asciimat.

Commençons par rentrer les données dans un tableau. Nous optons pour un tableau numérique en reportantnon pas les lettres de l’alphabet mais leurs codes ASCII [14]. Nous transformons ainsi la liste A,…, Z en levecteur 65 : 90.

Listing 6.4 – Les lettres et leurs fréquences�l e t =[65 :90 ] ;Freq = [ 7 . 6 8 , 0 . 8 0 , 3 . 3 2 , 3 . 6 0 , 1 7 . 7 6 , 1 . 0 6 , 1 . 1 0 , 0 . 6 4 , 7 . 2 3 , 0 . 1 9 , 0 . 0 0 , 5 . 8 9 , 2 . 7 2 , 7 . 6 1 ,5 . 3 4 , 3 . 2 4 , 1 . 3 4 , 6 . 8 1 , 8 . 2 3 , 7 . 3 0 , 6 . 0 5 , 1 . 2 7 , 0 . 0 0 , 0 . 5 4 , 0 . 2 1 , 0 . 0 7 ] ;T=[ l e t ; Freq ] ;� �On voit que la cinquième colonne 8 devra prendre la place de la première, que la dix-neuvième 9 devra veniren deuxième position, etc. Le mieux est de traiter le problème général : étant donné une matrice numériqueM à n lignes et m colonnes et un entier j, 1 ⩽ j ⩽ n, de ranger les colonnes de M de manière que la ligne jsoit rangée dans l’ordre décroissant. La fonction TriCol ci-dessous réalise cette tâche :

Listing 6.5 – Fonction TriCol�//Le fonc t i on TriCol ordonne l e s co lonnes d ’ une matrice numerique de maniere//qu ’ une l i g n e donnee s o i t rangee dans l ’ ordre d e c ro i s s an t .function MTriee=TriCol (M, l i g n e )

//M=Matrice dont l e s co lonnes do i ven t e t r e ordonnees .// l i g n e=ind i c e de l a l i g n e a ordonner .MTriee = [ ] ;A=M( l i gne , : ) ; //Ligne a ranger .minA=min(A) ;t=t a i l l e (A) ;for j=1 :t

maxA=max(A) ;k=max( find (A==maxA) ) ; //maxA peut appara i t r e p l u s i e u r s f o i s .On c h o i s i t// a r b i t r a i r emen t c e l u i qu i a l e rang l e p l u s e l e v e .MTriee=[MTriee ,M( : , k ) ] ; //On p lace l a colonne s e l e c t i o nn e e a l a s u i t e// des au t r e s .A(k)=minA−1 ;// Cet te co lonne n ’ i n t e r v i end ra p lu s . On aura i t pu// l ’ e f f a c e r .j=j+1 ;

endendfunction� �

8. colonne de code ASCII 69, soit E9. colonne de code ASCII 83, soit S

102

Ci-dessous, nous avons regroupé toutes les commandes, y compris le chargement de la fonction TriCol dansun seul script appelé TriColonnes ;

Listing 6.6 – Script TriColonnes�l e t =[65 :90 ] ;Freq = [ 7 . 6 8 , 0 . 8 0 , 3 . 3 2 , 3 . 6 0 , 1 7 . 7 6 , 1 . 0 6 , 1 . 1 0 , 0 . 6 4 , 7 . 2 3 , 0 . 1 9 , 0 . 0 0 , 5 . 8 9 , 2 . 7 2 , 7 . 6 1 , 5 . 3 4 , 3 . 2 4 , 1 . 3 4 , 6 . 8 1 , 8 . 2 3 , 7 . 3 0 , 6 . 0 5 , 1 . 2 7 , 0 . 0 0 , 0 . 5 4 , 0 . 2 1 , 0 . 0 7 ] ;T=[ l e t ; Freq ] ;exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣TriCol . s c i ’ , −1) ;TTriee=TriCol (T, 2 ) ;LetTr i ee s=TTriee ( 1 , : ) ;a lphTr ie=asc i imat ( LetTr i ee s ) ;a f f i c h e r ( ’ Vo ic i ␣ l ’ ’ a lphabet ␣ range ␣dans␣ l ’ ’ ordre ␣des ␣ f r equence s ␣ d e c r o i s s a n t e s ␣ : ’ ) ;a f f i c h e r ( a lphTr ie )� �qui a conduit au résultat suivant :

Listing 6.7 – Résultat�−−>clear−−>exec ( ’Chemin␣du␣ s c r i p t ␣TriColonnes . s c e ’ , −1)Vo ic i l ’ a lphabet range dans l ’ ordre des f r equence s d e c r o i s s a n t e s :ESANTIRULODCPMQVGFBHXYJZWK

−−>� �Variante de la fonction TriColDans la fonction TriCol, les termes déjà traités étaient rendus inopérants par la commande A(k)=minA-1.Dans TriCol2, on les efface à l’aide de la commande A2(k)=[]. La boucle pour a été remplacée par uneboucle tant que.

Listing 6.8 – Fonction tricol�//Le fonc t i on TriCol ordonne l e s co lonnes d ’ une matrice numerique de maniere//qu ’ une l i g n e donnee s o i t rangee dans l ’ ordre d e c ro i s s an t .function MTriee=TriCol2 (M, l i g n e )

//M=Matrice dont l e s co lonnes do i ven t e t r e ordonnees .// l i g n e=ind i c e de l a l i g n e a ordonner .MTriee = [ ] ;A2=M( l i gne , : ) ; //Ligne a ranger .while t a i l l e (A2)>0

k=max( find (A2==max(A2 ) ) ) ; //maxA peut appara i t r e p l u s i e u r s f o i s .//On c h o i s i t a r b i t r a i r emen t c e l u i qu i a l e rang l e p l u s e l e v e .MTriee=[MTriee ,M( : , k ) ] ;A2(k )= [ ] ;

endendfunction� �Pour appliquer cette fonction, il suffit de remplacer TriCol par TriCol2 dans le script 6.6.

103

Chapitre 7

Instructions conditionnelles

Syntaxe de l’instruction conditionnelle if-then-else

3 Instruction conditionnelle sans alternative

if conditions theninstructions ;end

3 Instruction conditionnelle avec alternative simple

if conditions theninstructions ;elseinstructions ;end

3 Instruction conditionnelle avec alternative complexe

if conditions theninstructions ;elseif conditions theninstructions ;....elseinstructions ;end

Liste des exercices :

énoncé no 7.1 : [*] Fonction valeur absolue.énoncé no 7.2 : [*] Calculer le maximum de 2 ou 3 nombres donnés.énoncé no 7.3 : [*] Ranger 2 nombres dans l’ordre croissant.énoncé no 7.4 : [*] Ranger 3 nombres dans l’ordre croissant.énoncé no 7.5 : [**] Sauts de kangourous.énoncé no 7.6 : [**] Addition en base 2.énoncé no 7.7 : [**] L’année est-elle bissextile ?

104

énoncé no 7.8 : [**] Calcul et représentation graphique de fréquences (exercice type du Calcul des proba-bilités).énoncé no 7.9 : [**] Le point M est-il à l’intérieur du triangle ABC?énoncé no 7.10 : [**] Ce triangle est-il isocèle ?

105

7.1 [*] Fonction valeur absolue

1 - Programmer une fonction-scilab qui donne la valeur absolue de tout nombre réel- à l’aide d’une instruction conditionnelle avec alternative,- à l’aide d’une instruction conditionnelle sans alternative.2 - En déduire la valeur absolue de -0.87 et de

√3.

Mots-clefs : instruction conditionnelle, commandes sqrt, abs.

La commande abs de scilab a pour argument un vecteur ou liste de nombres réels et retourne la liste desvaleurs absolues de ces nombres, par exemple :�−−>abs ( [ −0 .87 , sqrt ( 3 ) ] )ans =

0.87 1.7320508075689−−>� �1 - La fonction valeur absolue se programme avec une instruction conditionnelle sans alternative (fonctionvalabs1 ci-dessous). On peut aussi l’écrire avec une instruction conditionnelle avec une alternative tout àfait inutile (fonction valabs2). Ces fonctions admettent comme argument un nombre réel et retourne savaleur absolue. Elles font donc moins bien que la commande abs.�function y = valabs1 (x )

y=x ;i f x<0 then

y=−x ; // pas d ’ a l t e r n a t i v eend

endfunctionfunction y = valabs2 (x )

i f x<0 theny=−x ;

else // a l t e r n a t i v ey=x ;

endendfunction� �2 - Chargeons ces fonctions dans la console et appliquons les fonctions précédentes au calcul des valeursabsolues de -0.87 et de

√3. On obtient :�

−−>exec ( ’Chemin␣du␣ f i c h i e r ’ , −1)−−>a1=valabs1 (−0.87) ; a2=valabs2 (−0.87) ;−−>a f f i c h e r ( a1 , a2 ) ;

0 .870 .87

−−>b1=valabs1 ( sqrt ( 3 ) ) ; b2=valabs2 ( sqrt ( 3 ) ) ;−−>a f f i c h e r (b1 , b2 ) ;

1 .73205080756891.7320508075689

−−>� �106

On aurait pu programmer la fonction valabs1 de manière à ce qu’elle admette une liste de nombres commeargument.

107

7.2 [*] Calculer le maximum de 2 ou 3 nombres donnés

Écrire une fonction scilab qui retourne le maximum de 2 nombres x et y, puis une fonction scilab quiretourne le maximum de 3 nombres x, y et z donnés.

Mots-clefs : instruction conditionnelle if.

Les fonctions scilab max2 et max3 du script ci-dessous conviennent. Elles retournent m qui est le maximumde x et y dans le premier cas, le maximum de x, y et z dans le second. On utilise une condition if sansalternative.�function m=max2(x , y )

m=x ;i f y>m then

m=y ;end

endfunction

function m=max3(x , y , z )m=max2(x , y ) ;i f z>m then

m=zend

endfunction� �Application numérique :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)−−>x=sin (%pi /5 ) ; y=exp (−0.15) ; z=−0.590 ;−−>m=max2(x , y )m =

0.8607080−−>m=max3(x , y , z )m =

0.8607080−−>� �Voici le même problème traité avec Python 3 (cf. [3], Exercice 1, p.17). On utilise une condition if avec uneseule alternative pour la première fonction ; la seconde utilise la première.�de f max2(x , y ) :

i f y>x : return yelse : return x

de f max3(x , y , z) :# u t i l i s e l a f on c t i on max2 .return max2(x ,max2(y , z ) )� �

Application numérique :�=============== RESTART : /Users /raymondmoche/Desktop/cbcc_1 . py ===============>>> x , y , z=−1/2 ,0.7 ,−4>>> max2(x , y )0 . 7

108

>>> max3(x , y , z )0 . 7>>>� �

109

7.3 [*] Ranger 2 nombres dans l’ordre croissant

Écrire une fonction scilab qui, étant donné deux nombres réels, les retourne rangés dans l’ordre crois-sant.

Mots-clefs : instruction conditionnelle, min, max, trier.

La commande trier de scilab permet de trier très vite, dans l’ordre croissant, de très longues listes denombres. C’est une commande opaque, c’est à dire qu’on ne sait pas comment elle effectue ces tris. Elleest très efficace. Ci-dessous, nous allons programmer explicitement une fonction qui permet de ranger deuxnombres dans l’ordre croissant.Solution no 1, avec une instruction conditionnelle :�function A=ranger (x , y ) ;

i f x>y then// i n s t r u c t i o n c on d i t i o nn e l l e sans a l t e r n a t i v e .z=x ;x=y ;y=z ;

end ;A=[x , y ] ;

endfunction� �On charge la fonction dans la console. Si par exemple on désire ranger dans l’ordre croissant %pi/3 etsqrt(2) que l’on veut afficher avec 10 décimales (car scilab effectuera automatiquement les calculs), ontapera directement dans la console :�−−>format ( ’ v ’ , 1 3 ) ; x=%pi /3 ; y=sqrt ( 2 ) ; ranger (x , y )ans =

1.0471975512 1.4142135624−−>� �Solution no 2 : Si on s’autorise les commandes min et max, il y a une solution explicite évidente. Pourranger 3 nombres dans l’ordre croissant, on pourra biaiser de même (voir l’exercice 7.4).�−−>format ( ’ v ’ , 1 3 ) ; x=%pi /3 ; y=sqrt ( 2 ) ;B=[min(x , y ) ,max(x , y ) ]B =

1.0471975512 1.4142135624−−>� �Solution no 3 : Utiliser la commande trier de scilab :�−−>x=%pi /3 ; y=sqrt ( 2 ) ; t r i e r ( [ x , y ] )ans =

1.0471975512 1.4142135624−−>� �

110

7.4 [*] Ranger 3 nombres dans l’ordre croissant

Ranger trois nombres réels donnés dans l’ordre croissant.

Mots-clefs : instruction conditionnelle, min, max, find, sum, trier.

Les données sont ici fabriquées par la commande tirage_reel(3,a,b), a < b, qui produit 3 nombres réelsentre a et b. Ranger 3 nombres dans l’ordre croissant est aussi traité dans l’exercice 8.8.Solution no 1 : Résoudre le problème posé à l’aide d’instructions conditionnelles est évidemment maladroitcar cela revient à passer en revue tous les cas possibles. Voici un tel script :�L=input ( ’L=’ ) ;R=L ;i f (L(1)<=L(2))&(L(2)>L(3 ) ) then

i f L(3)<=L(1) thenR=[L(3 ) ,L(1 ) ,L ( 2 ) ] ;

elseR=[L(1 ) ,L(3 ) ,L ( 2 ) ] ;

ende l s e i f (L(1)>L(2))&(L(2)<=L(3 ) ) then

i f L(3)<=L(1) thenR=[L(2 ) ,L(3 ) ,L ( 1 ) ] ;

elseR=[L(2 ) ,L(1 ) ,L ( 3 ) ] ;

ende l s e i f (L(1)>L(2))&(L(2)>L(3 ) ) then

i f L(1)>L(3) thenR=[L(3 ) ,L(2 ) ,L ( 1 ) ] ;

endenda f f i c h e r (R,L)� �C’est pénible à écrire et d’exécution lente. Cette solution ne peut pas se développer pour ranger dans l’ordrecroissant plus de 3 nombres. En voici un exemple d’application :�−−>clear−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)L=t i r a g e_r e e l (3 , −1 .97 ,3 .44)

2.4376551731955 − 1.2370694077807 2.9303343635565− 1.2370694077807 2.4376551731955 2.9303343635565

−−>� �Solution no 2 : Comme on l’a signalé à l’exercice 7.3, il y a une solution explicite. Dans le script qui suit,on a de plus demandé un affichage des nombres avec 2 décimales :�format ( ’ v ’ , 5 )A=t i r a g e_r e e l (3 ,−1 ,2) ;B(1 ,1)=min(A) ;B(1 ,3)=max(A) ;B(1 ,2)=sum(A)−(B(1)+B( 3 ) ) ;a f f i c h e r (A,B) ;� �

111

Voici une exécution de ce script :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)

− 0 .34 0 .90 1 .741 .74 − 0 .34 0 .90

−−>� �On rappelle que afficher(A,B) affiche B puis A. Cette solution ne conduit pas non plus à une solution quipermettrait de ranger au moins 4 nombres dans l’ordre croissant.Solution no 3 : il s’agit de la solution no 1 sans calcul. En effet, dans la solution no 1, le terme médian aété calculé. Il peut en résulter une erreur infime, ce que l’on évite ici :�A=t i r a g e_r e e l (3 ,−1 ,2) ;B=A;I1=find (B==min(B) ) ;I2=find (B==max(B) ) ;B( 1 , [min( I1 ) ,max( I2 ) ] ) = [ ] ;C=[min(A) ,B,max(A ) ] ;a f f i c h e r (C,A) ;� �Voici une exécution de ce script avec les réglages par défaut de l’affichage :�−−>clear−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)

1 .74 − 0 .34 0 .90− 0 .34 0 .90 1 .74

−−>� �L’affichage est cette fois dans le bon ordre : A puis B.Solution no 4 : Voir le tri à bulles, 6.24.Solution no 5 : Voir l’exercice 6.25.Solution no 6 : Voir l’exercice 8.9.Solution no 7 : Voir l’exercice 8.10.Solution no 5 : Utiliser la commande trier de scilab. C’est évidemment la bonne solution.

112

7.5 [**] Sauts de kangourou

Un kangourou fait habituellement des bonds de longueur aléatoire comprise entre 0 et 9 mètres.1 - Combien de sauts devra-t-il faire pour parcourir 2000 mètres ?2 - Fabriquer une fonction-scilab qui à toute distance d exprimée en mètres associe le nombrealéatoire N de sauts nécessaires pour la parcourir.3 - Calculer le nombre moyen de sauts effectués par le kangourou quand il parcourt T fois ladistance d.

Mots-clefs : boucles tant que et pour, tirage_reel( , , ), moyenne, afficher, tic(), toc().

1 - On remarquera que l’énoncé est incorrect car il est incomplet. Il est en fait sous-entendu que la longueurde chaque bond est la valeur prise par une variable aléatoire qui suit la loi uniforme entre 0 et 9. Il est aussisous-entendu, comme d’habitude, que si on considère des sauts successifs, les variables aléatoires qui leursont associées sont indépendantes.�D=0 ;// d i s t ance parcourue avant l e premier saut .N=0 ;// nombre de sau t s e f f e c t u e s avant l e premier saut .while D<2000 then

D=D+t i r a g e_r e e l ( 1 , 0 , 9 ) ;N=N+1 ;

enda f f i c h e r ( ’ Le␣nombre␣de␣ saut s ␣ n e c e s s a i r e s ␣pour␣ pa r cou r i r ␣2000␣m␣a␣ ete ␣ ’+string (N)+ ’ . ␣La␣ d i s t ance ␣ r e e l l e ␣ parcourue ␣a␣ e te ␣ ’ +string (D)+ ’ ␣metres . ’ ) ;� �Exécution du script :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)Le nombre de saut s n e c e s s a i r e s pour pa r cou r i r 2000 m

a ete 459 . La d i s t ance r e e l l e parcourue a e te 2003.3149584748 metres .−−>� �2 - Compte tenu du script précédent, on choisira évidemment comme fonction la fonction kangourou sui-vante :�function N=kangourou (d)

D=0 ;N=0 ;while D<d then

D=D+t i r a g e_r e e l ( 1 , 0 , 9 ) ;N=N+1 ;

end ;endfunction ;� �3 - Utilisons le script suivant (qui produit aussi le temps de calcul) :�d=input ( ’La␣ d i s t ance ␣a␣ pa r cou r i r ␣ e s t ␣ ega l e ␣a␣ ’ ) ;T=input ( ’ Le␣nombre␣de␣ t r a j e t s ␣ e s t ␣ ’ ) ;t i c ( ) ;NSauts = [ ] ;for j=1 :T

NSauts=[NSauts , kangourou (d ) ] ;

113

end ;Moyenne=moyenne (NSauts ) ;toc ( ) ;a f f i c h e r ( ’ Le␣nombre␣moyen␣de␣ saut s ␣quand␣ l e ␣kangourou␣ parcourt ␣ ’+string (T)+’ ␣ f o i s ␣au␣moins␣ ’+string (d)+ ’ ␣metres ␣ e s t ␣ ’+string (Moyenne)+ ’ . ’ ) ;a f f i c h e r ( ’ Duree␣du␣ c a l c u l ␣ :␣ ’+string ( toc ( ) ) ) ;� �Exécution du script dans le cas de 600 parcours de 2500 m :�−−>clear−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣kangourou ’ , −1)−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)La d i s t anc e a pa r cou r i r e s t e ga l e a 2500Le nombre de t r a j e t s e s t 600Le nombre moyen de saut s quand l e kangourou parcourt 600 f o i s au

moins 2500 metres e s t 556 .25166666667 .Duree du c a l c u l : 15 .79

−−>� �On pourrait évidemment prolonger cet exercice par une illustration de la loi des grands nombres.

114

7.6 [**] Addition en base 2

Soit deux entiers n, m ⩾ 0 notés en base 2 sous la forme [a0, . . . , ak−1, ak] et [b0, . . . , bk−1, bl].Cela signifie que ce sont deux suites de 0 et de 1 qui vérifient

n = a0· 20 + a1· 21 + · · ·+ ak· 2k et m = b0· 20 + b1· 21 + · · ·+ bl· 2lLe problème posé est de calculer leur somme en travaillant dans la base 2.

Mots-clefs : boucle pour, instruction conditionnelle if (conditions) then (instructions) elseif(conditions) then (instructions) elseif (conditions) then (instructions) else (instructions)end, opérateurs logiques & (et), | (ou).

Il n’y a pas d’inconvénient à supposer que ces listes sont de même longueur, parce que l’on peut toujoursajouter des 0 à la liste la plus courte, si nécessaire. Par exemple, si on veut additionner 5 et 3 en base 2, onécrira 5 sous la forme [1, 0, 1] et 3 sous la forme [1, 1, 0] au lieu de [1, 1].Rappelons la table d’addition en base 2 :

+ 0 10 0 11 1 10

Posonsn+m = s0· 20 + s1· 21 + · · ·+ sk+1· 2k+1

Au début du calcul, il n’y a pas de retenue. On conviendra qu’il y en a une qui est r0 = 0. On calcule ensuitele coefficient si de 2i dans la somme n + m et la retenue à venir ri+1 successivement pour i = 1, . . . , k entenant compte de la retenue ri. Les différents résultats possibles sont résumés dans le tableau suivant :

Nbre de 1 si+1 ri+1

0 0 01 1 02 1 03 1 1

Cela permet de programmer la somme de 2 entiers en base 2, donnés sous la forme de listes de 0 et de 1. Lafonction proposée ci-dessous est appelée somme2. Elle est téléchargeable sur le site. Les premières instructionsont pour but d’ajouter si nécessaire des zéros à droite de la liste la plus courte afin qu’elles aient la mêmelongueur. Le résultat S sera de longueur minimum, c’est à dire sans zéros à droite inutiles.�function S=somme2(n ,m) // N e t M sont donnes sous l a forme de 2 l i s t e sde 0 et de 1 : N=[a0 , . . . , a_k ] et M=[b0 , . . . , b l ] .

k=t a i l l e (N)−1 ; l=t a i l l e (M)−1 ;N=[N, zeros (1 , l−k ) ] ;M=[M, zeros (1 , k−l ) ] ; // e g a l i s a t i o n des longueurs .k=max(k , l ) ; // N e t M ont k comme longueur commune .

// Debut de l ’ add i t i on en base 2 .r=0 ;//La premiere re tenue e s t n u l l e .S= [ ] ; // Pour l e s t ockage de l a somme .for i=0 :k

a=N( i +1) ;b=M( i +1) ;c=a+b+r ;i f c==0 then

s=0 ; r=0 ;e l s e i f c==1 then

s=1 ; r=0 ;

115

e l s e i f c==2 thens=0 ; r=1 ;

elses=1 ; r=1 ;

endS=[S , s ] ;

endi f r==1 then

S=[S , r ] ;end

endfunction� �Utilisons cette fonction à titre d’exemple :�−−>clear−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣somme2 ’ , −1)−−>N=[0 , 1 , 1 , 0 , 1 , 1 , 1 , 0 , 0 , 0 , 1 ] ;M=[1 , 1 , 0 , 0 , 0 , 0 , 1 , 0 , 1 , 0 , 1 ] ;−−>S=somme2(N,M)S =

column 1 to 101 . 0 . 0 . 1 . 1 . 1 . 0 . 1 . 1 . 0 .

column 11 to 120 . 1 .

−−>n=sum(N. * 2 . ^ ( 0 : t a i l l e (N)−1))n =

1142 .−−>m=sum(M. * 2 . ^ ( 0 : t a i l l e (M)−1))m =

1347 .−−>s=sum(S . * 2 . ^ ( 0 : t a i l l e (S)−1))s =

2489 .−−>� �Cela veut dire que

[0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1] + [1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1] = [1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1]

Le passage de l’écriture en base 2 à l’écriture en base 10 a fait l’objet de l’exercice 3.3. On vérifie de tête,en base 10, que le résultat est exact !

116

7.7 [**] L’année est-elle bissextile ?

1 - L’année n est-elle bissextile ?2 - Soit n et m deux millésimes (n ⩽ m). Combien y a-t-il d’annéesbissextiles de l’année n à l’année m (années n et m comprises) ?

Mots-clefs : fonction-scilab, instructions conditionnelles, compteur, %f (faux), %t (vrai), reste, opérateurslogiques | (ou), & (et), == (=).

L’intérêt de cet exercice est surtout de prendre la négation d’une proposition (logique).1 - On définit ci-dessous une fonction estbissextile dont l’argument est n, qui retourne %t ou %f suivantque l’année n est bissextile ou non. Ce programme traduit la définition des années bissextiles :

n est bissextile si et seulement si (r = 0 et s > 0) ou (t = 0)où r, s et t désignent successivement les restes dans la division euclidienne de n par 4, 100 et 400 (c’est ladéfinition des années bissextiles).�function [ t r u e f a l s e ]= e s t b i s s e x t i l e (n)

r=r e s t e (n , 4 ) ;s=r e s t e (n , 1 0 0 ) ;t=r e s t e (n , 4 0 0 ) ;t r u e f a l s e=%f ;i f ( ( ( r==0)&(s >0)) | ( t==0)) then

t r u e f a l s e=%t ;end ;

endfunction ;� �Utilisons cette fonction pour savoir si les 2047, 2048, 2100 et 2400 sont bissextiles :�−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣ e s t e l l e b i s s e x t i l e ’ , −1)−−>e s t b i s s e x t i l e (2047)ans =F

−−>e s t b i s s e x t i l e (2048)ans =T

−−>e s t b i s s e x t i l e (2100)ans =F

−−>e s t b i s s e x t i l e (2400)ans =T

−−>� �En prenant la négation de la définition des années bissextiles :

n n’est pas bissextile si et seulement si (r > 0 ou s = 0) et (t = 0)on peut programmer une fonction estvraimentbissextile qui a la même entrée et la même sortie queestbissextile :�function [ t r u e f a l s e ]= e s t v r a im en t b i s s e x t i l e (n) // fonc t i on i d en t i q u e a l a// precedente .

r=r e s t e (n , 4 ) ;

117

s=r e s t e (n , 1 0 0 ) ;t=r e s t e (n , 4 0 0 ) ;t r u e f a l s e=%t ;i f ( ( r >0) | ( ( s==0)&(t >0))) then

t r u e f a l s e=%f ;end ;

endfunction ;� �2 - Pour traiter la seconde question, il suffit d’un compteur, ce qui donne le script suivant :�n=input ( ’n=’ ) ;m=input ( ’m=’ ) ; // n<=m.C=0 ;// I n i t i a l i s a t i o n du compteurfor i=n : m

i f e s t b i s s e x t i l e ( i )==%t thenC=C+1 ;

endenda f f i c h e r ( ’ Le␣nombre␣d ’ ’ annees ␣ b i s s e x t i l e s ␣ recherche ␣ e s t ␣ ’+string (C) ) ;� �Exemple : trouver le nombre d’années bissextiles de 2014 à 2500.�−−>clear−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣ e s t b i s s e x t i l e ’ , −1)−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=2014m=2500Le nombre d ’ annees b i s s e x t i l e s r echerche e s t 118

−−>� �

118

7.8 [**] Calcul et représentation graphique de fréquences (exercice typedu Calcul des probabilités)

On tire 10000 nombres au hasard dans l’intervalle [0, 1]. À chaque tirage, on se demande si l’événementA : « le nombre tiré au hasard appartient à l’intervalle [

1

7,5

6] »

est réalisé.1 - Combien vaut la probabilité p de A ?2 - Calculer la fréquence de réalisation de A après chaque tirage. Tracer le graphe des fréquences.3 - Choisir la dernière fréquence calculée comme valeur approchée de p.

Mots-clefs : boucle pour, commandes tirage_reel(p,a,b), plot(X), plot(X,Y,'r'), plot(X,Y,'r+')et commandes analogues, grand(m,n,'bin',N,p), compteur, nuage de points.

Ceci est un exercice standard sur l’illustration par le calcul de la loi des grands nombres du Calcul desProbabilités. Nous insistons sur les différentes représentations possibles, correctes ou non, de la suite desfréquences calculées. Dans la section Pour aller plus loin, nous montrons comment on peut raccourcir lesalgorithmes avec un peu plus de Calcul des probabilités.1 - L’énoncé est clairement incorrect car il ne précise pas selon quel hasard les nombres sont tirés dansl’intervalle [0, 1]. En fait, il est sous-entendu qu’ils sont tirés selon la loi uniforme sur [0, 1]. Dans cesconditions, par définition de cette loi, la probabilité de l’événement A est la longueur de [1/7 , 6/7], soitp = 5/6− 1/7 = 29/42.2 & 3 - On peut utiliser le script commenté ci-dessous.�clear ;c l f ;T i rages=t i r a g e_r e e l ( 10000 , 0 , 1 ) ; // L i s t e de 10000 nombres t i r e s//au hasard su i van t l a l o i uniforme sur [ 0 , 1 ] .p=5/6−1/7 ;a f f i c h e r ( ’La␣ va l eur ␣ exacte ␣de␣p␣ e s t ␣ ’+string (p ) ) ;C=0 ;// I n i t i a l i s a t i o n du compteur des r e a l i s a t i o n s de A.Frequences = [ ] ; // I n i t i a l i s a t i o n du vec t eur des f r equence s .for i =1 :10000

i f (1/7<=Tirages ( i ))&( Tirages ( i )<=5/6) thenC=C+1 ;// Si A se r e a l i s e , l e compteur augmente de 1 .

end ;Frequences=[Frequences ,C/ i ] ;

end ;plot ( [ 0 , 1 0 0 0 0 ] , [ p , p ] , ’ r ’ ) ; // Ligne ho r i z on t a l e d ’ ordonnee p , en rouge .plot ( Frequences ) ;a f f i c h e r ( ’La␣ va l eur ␣ approchee ␣de␣p␣par␣ l e s ␣ f r equence s ␣ e s t ␣ ’+string ( Frequences ( 1 0 0 0 0 ) ) ) ;� �On remarquera que l’appartenance de Tirages(i) à l’intervalle [0, 1] est décrite comme la conjonction (&)des conditions 1/7<=Tirages(i) et Tirages(i)<=5/6. Voici ce que l’on obtient sur la console :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)La va l eur exacte de p e s t 0.6904761904762La va l eur approchee de p par l e s f r equence s e s t 0 .6904−−>� �

119

Le graphique correspondant est (à gauche) :

Ce graphique est parfois considéré comme satisfaisant par des professeurs. Mais un agrandissement (à droite)rappelle qu’il s’agit d’une ligne polygonale (la commande plot trace des lignes polygonales, voir l’aide enligne). Or ce qu’on demande est un nuage de points, formé des points d’abscisse i et d’ordonnée C/i, pouri variant de 1 à 10000. Le graphique obtenu est donc mauvais.Pour obtenir le nuage de points désiré, on peut remplacer dans le script précédent plot(Frequences) par lacommande plot(Frequences,'+b'). Les points du nuage sont alors représentés par des + en bleu et ne sontpas joints par des segments, voir l’aide en ligne. Cela donne une grosse limace bleue qui ne fait pas penserà un nuage de points. On peut se convaincre que c’en est un en agrandissant plusieurs fois une portion dugraphe, voir la figure de droite.

Finalement, la meilleure solution est sans doute de choisir les points que l’on va tracer, mais c’est plusdifficile à expliquer aux élèves. Ci-dessous, on a tracé seulement les points d’abscisse 400, 800, …,10000 àl’aide du script :�clearc l fT i rages=t i r a g e_r e e l ( 10000 , 0 , 1 ) ;p=5/6−1/7 ;a f f i c h e r ( ’La␣ va l eur ␣ exacte ␣de␣p␣ e s t ␣ ’+string (p ) ) ;C=0 ;Frequences = [ ] ;

120

for i =1 :10000i f (1/7<=Tirages (1 , i ))&( Tirages (1 , i )<=5/6) then

C=C+1 ;end ;Frequences=[Frequences ,C/ i ] ;

end ;a f f i c h e r ( ’La␣ va l eur ␣ approchee ␣de␣p␣par␣ l e s ␣ f r equence s ␣ e s t ␣ ’+string ( Frequences ( 1 0 0 0 0 ) ) ) ;a b s c i s s e s =400 :400 :10000 ;f r equence s=Frequences ( a b s c i s s e s ) ;a=gca ( ) ; a . data_bounds=[ −0 .1 , −0 .1 ;10100 ,1 .1 ] ; // r e g l a g e du graphe .plot ( [ 0 , 1 0 0 0 0 ] , [ p , p ] , ’ r ’ ) ;plot ( ab s c i s s e s , f r equences , ’b* ’ ) ;� �(nuage de ∗ bleus). On obtient le graphe suivant, qui est très satisfaisant :

Pour aller plus loin :1 - On est ici dans le schéma de la répétition à l’identique d’une expérience aléatoire, les répétitions étantindépendantes les unes des autres. Plus précisément, on a fait intervenir 10000 variables aléatoires indépen-dantes et suivant la loi uniforme sur l’intervalle [0 , 1]. Ces variables aléatoires étant notées X1, . . . , X10000,si pour i = 1, . . . , 10000, on appelle Yi la variables aléatoire qui vaut 1 si l’événement {1/7 ⩽ Xi ⩽ 5/6} estréalisé, 0 sinon (Yi s’appelle la fonction indicatrice de cet événement), les variables aléatoires Y1, . . . , Y10000sont indépendantes et suivent la même loi : elles prennent la valeur 1 avec la probabilité p = 29/42, la valeur0 sinon. Comme on s’intéresse en réalité aux variables Yi (plutôt qu’aux variables Xi), on peut simulerdirectement celles-ci et utiliser un script sans instruction conditionnelle.�clear ;c l f ;T i rages=grand (1 ,10000 , ” bin ” , 1 , 29/42 ) ;p=29/42 ;C=0 ;Frequences = [ ] ;for i =1 :10000

C=C+Tirages ( i ) ;Frequences=[Frequences ,C/ i ] ;

121

end ;a b s c i s s e s =400 :400 :10000 ;f r equence s=Frequences ( a b s c i s s e s ) ;a=gca ( ) ; a . data_bounds=[ −0 .1 , −0 .1 ;10100 ,1 .1 ] ; // r e g l a g e du graphe .plot ( [ 0 , 1 0 0 0 0 ] , [ p , p ] , ’ r ’ ) ;plot ( ab s c i s s e s , f r equences , ’ g . ’ ) ;� �(nuage de points verts). grand(m,n,'bin',N,p) est une commande de scilab qui fonctionne avec scilab pourles lycées. Elle produit une matrice à m lignes et n colonnes de nombres tirés selon la loi binomiale de tailleN et de paramètre p. C’est la loi commune des variables aléatoires Yi pour N=1 et p=29/42. Évidemment,m=1 et n=10000. On obtient le graphe de gauche :

2 - En fait, les lois binomiales de taille 1 sont appelées habituellement lois de Bernoulli. Mais cela donne unenouvelle idée de simplification. Les sommes des paquets successifs de 400 variables aléatoires Y1, . . . , Y10000forment une famille de 25 variables aléatoires Z1, . . . , Z25 indépendantes et suivant la loi binomiale de taille400 et de paramètre p. Comme en fait on ne s’intéresse qu’à elles, on peut les simuler directement, selon lescript suivant :�clear ;c l f ;T i rages=grand (1 ,25 , ” bin ” ,400 ,29/42) ;p=29/42 ;C=0 ;Frequences = [ ] ;for i =1 :25

C=C+Tirages ( i ) ;Frequences=[Frequences ,C/(400* i ) ] ;

end ;a b s c i s s e s =400 :400 :10000 ;a=gca ( ) ; a . data_bounds=[ −0 .1 , −0 .1 ;10100 ,1 .1 ] ; // r e g l a g e du graphe .plot ( [ 0 , 1 0 0 0 0 ] , [ p , p ] , ’ r ’ ) ;plot ( ab s c i s s e s , Frequences , ’ ks ’ ) ;� �ce qui produit le graphe de droite ci-dessus (nuage de carrés noirs).

122

7.9 [**] Le point M est-il à l’intérieur du triangle ABC?

Étant donné un triangle A1A2A3 et un point M (par leurs coordonnées), fabriquer une fonctionqui indique si M est à l’intérieur du triangle ou non.

Mots-clefs : fonction-scilab, instruction conditionnelle, « input », « exec ».

1 - Rappels : Soit A et B deux points distincts (on ne peut avoir en même temps xA = xB et yA = yB).Posons

f(x, y) = (y − yA)(xB − xA)− (yB − yA)(x− xA)

L’équation de la droite [AB] est f(x, y) = 0 (un point M de coordonnées (x, y) appartient à [AB] si etseulement si f(x, y) = 0). De plus, M se trouve dans l’un des demi-plans (ouverts) définis par [AB] sif(x, y) > 0 ; sinon, il se trouve dans l’autre. Par conséquent, deux points donnés M et M ′ appartiennent aumême demi-plan si et seulement si f(x, y)· f(x′, y′) > 0.On en déduit une fonction scilab : memecote retourne 1 si deux points P et Q sont strictement du mêmecôté de [AB], 0 sinon (un point M quelconque se note maintenant [M(1),M(2)]).�function R=memecote (A,B,P,Q)

R=0 ;i f ( ( (P(2)−A(2 ) ) * (B(1)−A(1))−(B(2)−A(2 ) ) * (P(1)−A(1 ) ) )* ( (Q(2)−A(2 ) ) * (B(1)−A(1))−(B(2)−A(2 ) ) * (Q(1)−A(1))) >0) thenR=1 ;end ;

endfunction� �2 - Solution algorithmique :On propose ci-dessous une fonction scilab inttriangle qui, étant donné un vrai triangle A1A2A3 (ces pointssont distincts) et un point M qui n’est sur aucun côté de ce triangle retourne M est à l'intérieur dutriangle ou M n'est pas à l'intérieur du triangle suivant le cas. Pour exécuter cette fonction, onaura chargé les fonctions memecote et inttriangle dans la console.�function A=i n t t r i a n g l e (A1 ,A2 ,A3 ,M)

c=memecote (A1 ,A2 ,A3 ,M) ;a=memecote (A2 ,A3 ,A1 ,M) ;b=memecote (A3 ,A1 ,A2 ,M) ;i f ( a*b*c==1) then

A=’M␣ e s t ␣a␣ l ’ ’ i n t e r i e u r ␣du␣ t r i a n g l e ’ ;else

A=’M␣n ’ ’ e s t ␣pas␣a␣ l ’ ’ i n t e r i e u r ␣du␣ t r i a n g l e ’ ;end ;

endfunction ;� �Le script qui suit permet de saisir les données, d’exécuter la fonction inttriangle et d’afficher la réponseà la question posée :�A1=input ( ’A1=’ ) ;A2=input ( ’A2=’ ) ;A3=input ( ’A3=’ ) ; /M=input ( ’M=’ ) ;Verd ict=i n t t r i a n g l e (A1 ,A2 ,A3 ,M) ;a f f i c h e r ( Verd ict ) ;� �

123

Application :�−−>clear−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣memecote ’ , −1)−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣ i n t t r i a n g l e ’ , −1)−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)A1=[1 ,1 ]A2= [3 , 3 . 7 ]A3=[2 ,−4.3]M=[1 . 5 , 1 ]

M e s t a l ’ i n t e r i e u r du t r i a n g l e−−>� �

124

7.10 [**] Ce triangle est-il isocèle ?

Un triangle ABC est donné par les coordonnées de ses sommets dans un repère orthonormé.Écrire un algorithme qui permette d’en déduire qu’il est isocèle (sans être équilatéral), équilatéralou quelconque (c’est à dire, ici, ni isocèle, ni équilatéral).

Mots-clefs : instruction conditionnelle if then elseif then end, test ==, commande trier, opé-rateurs logiques & et |, afficher une chaîne de caractères.

Tester si un triangle ABC donné est isocèle ou équilatéral revient à comparer les longueurs de ses côtés,donc à tester plusieurs fois l’égalité de deux nombres. Le script ci-dessous permet de saisir les coordonnéesdes sommets de ABC, de calculer les carrés des longueurs des côtés AB, BC et CA, carrés notés x, y et zdans le script et de tester de deux façons l’égalité de ces longueurs.Remarques• Comparer les carrés des longueurs des côtés (au lieu de comparer les longueurs) permet d’éviter le calculde racines carrées, ce qui induirait des approximations de calcul supplémentaires.• Le script ci-dessous contient deux solutions.• La première solution serait impeccable si scilab était capable de calculer x, y et z exactement. Comme cen’est pas le cas, scilab peut se tromper, voir l’exécution du script ci-dessous.• La deuxième solution considère que x = y si |x − y|/(x + y) est < %eps (et de même pour les autrescouples de côtés), autrement dit si le nombre |x− y|/(x+ y) est considéré comme nul par scilab, ce qui neveut pas dire qu’il est effectivement nul. C’est pratiquement ce que l’on peut faire de mieux.• %eps est très petit : c’est en effet le plus petit nombre > 0 reconnu par scilab.• %eps=2.220446049D-16, voir un manuel.Le script :�A=input ( ”Coordonnees␣de␣A␣=␣” ) ; // [ ab s c i s s e , ordonnee ]B=input ( ”Coordonnees␣de␣B␣=␣” ) ; // idemC=input ( ”Coordonnees␣de␣C␣=␣” ) ; // idemx=(B(1)−A(1))^2+(B(2)−A(2 ) )^2 ; // x=AB^2y=(C(1)−A(1))^2+(C(2)−A(2 ) )^2 ; //y=AC^2z=(C(1)−B(1))^2+(C(2)−B(2 ) ) ^2 ; // z=BC^2// Test ne tenant pas compte des approximat ions de c a l c u l .i f x==y & y==z then

disp ( ”ABC␣ e s t ␣ e q u i l a t e r a l ” )e l s e i f x==y | y==z | z==x then

disp ( ”ABC␣ e s t ␣ i s o c e l e ” )else

disp ( ”ABC␣n ’ ’ e s t ␣ n i ␣ e qu i l a t e r a l , ␣ n i ␣ i s o c e l e ” )end// Test tenant compte des approximat ions de c a l c u l e t de %eps .i f abs (x−y )/( x+y)<%eps & abs (y−z )/ ( y+z)<%eps then

disp ( ”ABC␣ e s t ␣ e q u i l a t e r a l ” )e l s e i f abs (x−y )/( x+y)<%eps | abs (y−z )/ ( y+z)<%eps | abs ( z−x )/ ( z+x)<%eps then

disp ( ”ABC␣ e s t ␣ i s o c e l e ” )else

disp ( ”ABC␣n ’ ’ e s t ␣ n i ␣ e qu i l a t e r a l , ␣ n i ␣ i s o c e l e ” )end� �

125

Une exécution du script :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)Coordonnees de A = [−23/15 ,−36/35]Coordonnees de B = [13/15 ,76/35 ]Coordonnees de C = [−89/15 ,167/35]ABC n ’ e s t n i e q u i l a t e r a l , n i i s o c e l eABC es t i s o c e l e� �

La première réponse est fausse, la seconde est exacte car un calcul à la main ou avec Xcas, qui fait descalculs exacts en nombres rationnels, donne

x = 16, y = 53, z = 53

Ce qu’il faut retenir est que les réponses données par le script ne sont pas sûres, deux longueurs en réalitéégales pouvant être considérées comme différentes par scilab, deux longueurs en réalité différentes pouvantêtre considérées comme égales.Finalement, le principal intérêt de cet exercice est le maniement d’opérateurs logiques.

126

Chapitre 8

Boucle tant que

Syntaxe des boucles tant que

while conditionsinstructions ;end

Tant que les conditions sont vérifiées, les instructions sont répétées.

Liste des exercices :

Énoncé no 8.1 : [*] Transformer une boucle pour en une boucle tant que.Énoncé no 8.2 : [*] Calculer le maximum d’une liste de nombres.Énoncé no 8.3 : [*] Conversion du système décimal vers le système à base b.Énoncé no 8.4 : [*] Sommes de nombres impairs.Énoncé no 8.5 : [*] Partie entière d’un nombre réel.Énoncé no 8.6 : [*] Formule de la somme des carrés.Énoncé no 8.7 : [**] Nombres factoriels.Énoncé no 8.8 : [***] Ranger 3 nombres donnés dans l’ordre croissant (tri à bulles).Énoncé no 8.9 : [***] Ranger n nombres donnés dans l’ordre croissant.Énoncé no 8.10 : [****] Ranger n nombres donnés dans l’ordre croissant.

127

8.1 [*] Transformer une boucle pour en une boucle tant que

Calculer le maximum d’une liste de nombres d’après la fonction Minde 6.2, puis remplacer la boucle pour par une boucle tant que.

Mots-clefs : Maximum, liste de nombres, commandes max, tic, toc, disp (afficher).

On peut toujours transformer une boucle pour (fonction maxxx1, analogue à la fonction Min de 6.2) en uneboucle tant que (fonction maxxx2 ci-dessous). Il suffit d’ajouter un compteur. C’est l’objet de cet exercice.�// So lu t i on avec une bouc l e pour .function m=maxxx1(L) // L e s t une l i s t e de nombres ; m sera son maximum.

m=L( 1 ) ;n=length (L ) ;for i=1 :n−1

i f m<L( i +1) thenm=L( i +1) ;

endend

endfunction// Transformation de l a bouc l e pour en une bouc l e tan t que .function m=maxxx2(L) // L e s t une l i s t e de nombres ; m sera son maximum.

j =1 ;// Compteur .m=L( 1 ) ;while j<length (L)

i f m<L( j+1) thenm=L( j +1) ;

endj=j+1 ;// Incrément de 1 du compteur .

endendfunction� �Essai numérique :�−−>clear−−>exec ( ’Chemin␣des ␣ f on c t i o n s ␣maxxx1␣ et ␣maxxx2 ’ , −1)−−>L=grand (1 ,80000 , ’ uin ’ ,−250000 ,100000) ; // Échan t i l l on de t a i l l e 80000 de// l a l o i uniforme sur l ’ i n t e r v a l l e d ’ e n t i e r s [−250000 ,100000].−−>t i c ( ) ; disp (maxxx1(L ) ) ; disp ( toc ( ) ) ;

99999 .0 .066

−−>t i c ( ) ; disp (maxxx2(L ) ) ; disp ( toc ( ) ) ;99999 .0 .176

−−>t i c ( ) ; disp (max(L ) ) ; disp ( toc ( ) ) ;99999 .0 .003

−−>� �Cet essai suggère que la boucle pour est plus rapide que la boucle tant que, sans doute parce qu’il y a, engros, deux fois plus de tests dans ce cas. La commande scilab max est bien sûr hors concours. Cette remarque

128

est confirmée par l’essai suivant, où L est un échantillon de la loi uniforme sur l’intervalle [−250000, 100000[.�−−>exec ( ’Chemin␣des ␣ f on c t i o n s ␣maxxx1␣ et ␣maxxx2 ’ , −1)−−>L = grand (1 ,80000 , ’ unf ’ , −250000 ,100000) ;−−>t i c ( ) ; disp (maxxx1(L ) ) ; disp ( toc ( ) ) ;

99993.2360 .06

−−>t i c ( ) ; disp (maxxx2(L ) ) ; disp ( toc ( ) ) ;99993.2360 .177

−−>t i c ( ) ; disp (max(L ) ) ; disp ( toc ( ) ) ;99993.2360 .003� �

129

8.2 [*] Calculer le maximum d’une liste de nombres

On veut calculer le maximum d’une liste de nombres L donnée, de lon-gueur au moins 2, de la manière suivante : si L(2) est plus grand queL(1), on échange ces nombres ; ensuite, on efface tous les termes qui sontinférieurs ou égaux à L(1) à partir du rang 2. Ce faisant, la longueur deL diminue mais reste supérieure ou égale à 1. Si elle est encore supérieureou égale à 2, on recommence. Quand elle est égale à 1, le terme restantest le maximum recherché.

Mots-clefs : boucle tant que, maximum, appel d’une fonction scilab, instruction conditionnelle if…then…end, commandes length, find, tic() …toc().

La solution normale est d’utiliser la commande max de scilab. Ce qui suit est un exercice sur les bouclestant que.La méthode imposée dans l’énoncé, appelée maxxi ci-dessous, devrait améliorer la vitesse de la fonctionmaxxx2 de l’exercice 8.1.�function m=maxxi (L) //L : l i s t e d ’ au moins 2 nombres ; m sera son maximum.

n=length (L ) ;while n>=2

i f L(1)<L(2) thenL( [ 1 , 2 ] )=L ( [ 2 , 1 ] ) ; // Si néces sa i re , on échange l e s 2 premiers// termes de L .

endM=L(2 :n ) ; //On va e f f a c e r tous l e s termes de M qui sont <= L(1)M( find (M<=L( 1 ) ) )= [ ] ; // Au moins un terme e s t e f f a c é .L=[L(1 ) ,M] ; // La longueur de L r e s t e >= 1.n=length (L ) ; // La bouc l e wh i l e s ’ a r r ê t e ra l o r s qu e n=1.

endm=L( 1 ) ;endfunction� �Les essais ci-dessous (voir aussi l’exercice 8.1) montrent que la fonction maxxi est plutôt rapide.�clear−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣maxxi ’ , −1)−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣maxxx2 ’ , −1)−−>L = grand (1 ,80000 , ’ uin ’ , −250000 ,100000) ;−−>t i c ( ) ; disp (maxxi (L ) ) ; disp ( toc ( ) ) ;

99999 .0 .008

−−>t i c ( ) ; disp (maxxx2(L ) ) ; disp ( toc ( ) ) ;99999 .0 .173

−−>L = grand (1 ,80000 , ’ unf ’ , −250000 ,100000) ;−−>t i c ( ) ; disp (maxxi (L ) ) ; disp ( toc ( ) ) ;

99998.1710 .008

−−>t i c ( ) ; disp (maxxx2(L ) ) ; disp ( toc ( ) ) ;99998.171

130

0 .179−−>� �

131

8.3 [*] Conversion du système décimal vers le système à base b

Un nombre entier n ⩾ 0 est donné sous forme décimale. Le problème posé est de l’écriredans le système à base b ⩾ 2, c’est à dire sous la forme d’une liste [a0, a1, . . . , ap] de0, de 1, …, de b− 1 de sorte que n = a0· b0 + a1· b1 + · · ·+ ap· bp.

Mots-clefs : boucle tant que, commandes input, reste, quotient.

Cas b = 2 : Ce cas n’est pas un cas particulier. Voici une ancienne rédaction consacrée à ce cas. On sait queles coefficients a0, . . . , ap s’obtiennent par des divisions successives par 2, ce qui donne :�n=input ( ’n=’ ) ; // n e s t un en t i e r >0.A=[ ] ;m=0 ;c=0 ;p=n ;while m<n

a=r e s t e (p , 2 ) ;A=[A, a ] ;m=m+a*2^c ;p=quot i ent (p−a , 2 ) ;c=c+1 ;

enda f f i c h e r (A,m)� �La commande input permet de saisir la valeur de n dans la console. Dans l’exemple ci-dessous, on a choisin=123 456 789. Afficher m permet de vérifier le calcul car m est le résultat de la conversion de n du systèmeà base 2 vers le système décimal. On revient au point de départ. Voici ce que l’on obtient :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=123456789

123456789.column 1 to 14

!1 0 1 0 1 0 0 0 1 0 1 1 0 0 !column 15 to 27

!1 1 1 1 0 1 1 0 1 0 1 1 1 !−−>� �En fait, on a affiché non pas le vecteur A qui ne serait pas bien lisible (une ligne, 27 colonnes), mais la chaînede caractères associée. Bien sûr, c’est A=[1 0 1 0 1 0 0 0 1 0 1 1 0 0 1 1 1 1 0 1 1 0 1 0 1 1 1]que l’on aurait aimé afficher.Cas général b ⩾ 2 : utilisons le script suivant�// Conver t i t en base b un en t i e r e c r i t en base 10function B=convert ion10b (n , b) // n>=0,b>=2, e n t i e r s .

q=n ,B= [ ] ;while q>=b

B=[B, r e s t e (q , b ) ] ;q=quot i ent (q , b ) ;

end

132

B=[B, q ] ;a f f i c h e r (B) ;

endfunction� �Exemples : 6 882 309 est-il divisible par 7 ?�−−>clear−−>exec ( ’Chemin␣de␣ convert ion10b . s c i ’ , −1)−−>B=convert ion10b (6882309 ,7 ) ;

0 . 2 . 0 . 3 . 3 . 3 . 2 . 1 . 1 .−−>n=sum(B. * 7 . ^ ( 0 : t a i l l e (B)−1))n =

6882309.−−>� �Le chiffre des unités dans la base b (à gauche) est 0, donc 6 882 309 est divisible par 7. Bien sûr, si on saitcomment faire une division par 7, c’est quand même plus rapide. Le calcul de n ci-dessus (voir l’exercice 3.3)est une vérification inutile.On peut aussi se demander si 6 882 309 est divisible par 17 comme précédemment :�−−>clear−−>exec ( ’Chemin␣de␣ convert ion10b . s c i ’ , −1)−−>B=convert ion10b (6882309 ,17) ;

12 . 3 . 14 . 6 . 14 . 4 .−−>� �Le reste de la division de 6 882 309 par 17 est 12.

133

8.4 [*] Sommes des premiers nombres impairs

Calculer la somme S(n) des nombres impairs inférieurs ou égaux à un entier donné n.

Mots-clefs : boucle tant que, commandes input, sum.

Cet exercice est élémentaire. On peut utiliser le script ci-dessous. On remarquera l’affichage : il est constituéde 4 chaînes de caractères (deux chaînes limitées par le signe ' et 2 chaînes string()). Les 3 signes +concatènent ces 4 chaînes.�n=input ( ’n=’ ) ;S=0 ; // I n i t i a l i s a t i o n de l a sommei =1 ;while (2* i−1)<= n// debut de l a bouc l e .

S=S+2*i −1 ;i=i +1 ;

end// Fin de l a bouc l e .a f f i c h e r ( ’La␣somme␣des ␣ impai r s ␣<=␣ ’+string (n)+ ’ ␣ e s t ␣ ’+string (S ) ) ;� �La commande input permet de saisir la valeur de n, ici 500, dans la console.�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=500

La somme des impai r s <= 500 e s t 62500−−>� �On peut faire beaucoup mieux, par exemple directement dans la console :�−−>sum(1 :2 :500)ans =

62500.−−>� �En effet, la commande 1:2:n retourne la liste des nombres (1, 3, . . . , n) si n est impair, (1, 3, . . . , n− 1) sinon,tandis que sum(V) retourne la somme d’une liste (ou d’une matrice) de nombres V.Solution mathématique : soit S(n) la somme des n premiers entiers. En général, on sait que

S (n) =n (n+ 1)

2·

On en déduit, dans le cas où n est impair, noté n = 2p+ 1 :

S (n) = S(2p+ 1)− 2· S (p) = (n+ 1)2

2d’où l’on déduit, si n est pair :

S(n) = S(n− 1) =n2

2·

On ne peut pas démontrer de telles formules littérales avec scilab. C’est possible avec un logiciel de calculformel comme Xcas.

134

8.5 [*] Partie entière d’un nombre réel

Calculer la partie entière d’un nombre réel donné.

Mots-clefs : instruction conditionnelle avec alternative, boucles tant que, commandes input, floor,afficher.

La partie entière d’un réel donné x est le plus grand entier n tel que n ⩽ x, autrement dit, l’unique entiern qui vérifie n ⩽ x < n + 1. Le script ci-dessous est très intéressant du point de vue de l’apprentissage descilab.�clearx=input ( ’ x=’ ) ;y=0 ;//On va d i s t i n g u e r l e s cas x<0 e t x>=0.i f y>x// Cas x<0.while y>x theny=y−1 ;

end ;else // Cas x>=0.while y<=x theny=y+1 ;

endy=y−1 ;

end ;a f f i c h e r ( ’La␣ pa r t i e ␣ e n t i e r e ␣de␣x␣ e s t ␣ ’+string ( y ) ) ;� �L’exécution de ce script pour trouver la partie entière de x = −2.117 donne :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)x=−2.117La pa r t i e e n t i e r e de x e s t −3

−−>f loor (−2.117)ans =− 3 .

−−>� �Nous avons confirmé le résultat obtenu à l’aide de la commande floor qui est justement la fonction partieentière de scilab. Nous aurions pu transformer le script proposé en fonction-scilab et oublier floor. Ce seraitidiot, évidemment.

135

8.6 [*] Formule de la somme des carrés

La formule 12 + · · ·+ n2 =n(n+ 1)(2n+ 1)

6est-elle vraie pour tout entier n ⩾ 1 ?

Mots-clefs : boucle tant que, abandon d’un calcul.

On sait que cette formule est vraie quel que soit l’entier n ⩾ 1, c’est à dire que si l’on pose

∀n ∈ N∗, S (n) = 12 + · · ·+ n2 et T (n) =n(n+ 1)(2n+ 1)

6

S (n) = T (n) quel que soit l’entier n ⩾ 1. Essayons de vérifier cela à l’aide d’un script :• Il est évident que c’est vrai pour n = 1.• Augmentons n de 1 et vérifions que S (n) = T (n).• Si oui, on itère l’étape précédente ; sinon, on arrête.Le script suivant cherche en fait le premier entier n pour lequel S (n) ̸= T (n) :�n=1 ;S=1 ;T=1 ;while S=T

n=n+1 ;S=S+n^2 ;T=n*(n+1)*(2*n+1)/6 ;

enda f f i c h e r (+string (n)+ ’ ␣ e s t ␣ l e ␣ p lus ␣ p e t i t ␣ e n t i e r ␣pour␣ l e qu e l ␣ l a ␣ formuleproposee ␣ e s t ␣ f au s s e ’ ) ;� �C’est angoissant parce que l’on sait que les calculs ne vont pas s’arrêter ! Lançons (quand même) l’exécutionde l’algorithme, sachant que l’on pourra de toute façon abandonner les calculs (Contrôle>Abandonner).Voilà ce que l’on obtient :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)208065 e s t l e p lus p e t i t e n t i e r pour l e q u e l l a

formule proposee e s t f au s s e−−>� �Cette erreur de scilab est probablement dûe au fait que sa capacité à traiter exactement ces nombres entiersa été dépassée (ils ont été transformés en nombres flottants approximatifs).De plus, il est clair a priori qu’un calculateur numérique ne peut pas être utilisé pour démontrer qu’uneinfinité d’égalités sont satisfaites.

136

8.7 [**] Comptage de nombres factoriels

1 - Combien y a-t-il de nombres factoriels inférieurs ou égaux à 106, à 109, à 1012, à (17 !) ?2 - 3 629 300 et 39 916 800 sont-ils des nombres factoriels ?

Mots-clefs : boucles pour et tant que, instruction conditionnelle, prod, factorielle, format.

Les scripts ci-dessous, rédigés de manière un peu compacte, appellent des commentaires :• Comme on demande 4 fois de compter des nombres factoriels, on a intérêt à programmer une fonction-scilab qui associe à tout entier p ⩾ 1 le nombre nf (p) de nombres factoriels ⩽ p. C’est l’objet du premierscript. Cette fonction a été appelée nombfact.• Le nombre factoriel p ! est calculé à l’aide de la commande prod([1: p]). On aurait pu utiliser directementla commande scilab factorielle(p).• format('v',25) empêche scilab, dans cet exercice, d’afficher certains grands entiers comme 17 ! en no-tation scientifique standard. Sinon, 17 ! serait affiché 3.556874281D+14 au lieu de 355687428096 (en fait,355687428096. car scilab ne connaît pas les nombres entiers : le point qui suit 355687428096 est le pointqui sépare la partie entière de la partie décimale de 17 ! en notation scientifique standard).• p ⩾ 2 est un nombre factoriel si et seulement si nf (p− 1) ̸= nf (p).

Listing 8.1 – Fonction nombfact�function n=nombfact (p)C=1 ; // C vaudra 1 , 2 , 3 , . . .f a c t =1 ; // l e s v a l e u r s de f a c t se ron t l e s nombres f a c t o r i e l s s u c c e s s i f swhile f ac t<=p then

C=C+1 ;f a c t=f a c t *C;

endn=C−1 ;endfunction� �Chargeons nombfact dans la console. Nous répondrons aux deux questions à l’aide du script :

Listing 8.2 – Compter et reconnaître des factoriels�// Comptage de f a c t o r i e l l e sformat ( ’ v ’ , 2 5 ) ;P=[10^6 ,10^9 ,10^(12) ,prod ( [ 1 : 1 7 ] ) ] ;for i =1 :4

NF=nombfact (P( i ) ) ;a f f i c h e r ( ’ Le␣nombre␣de␣nombres␣ f a c t o r i e l s ␣<=␣ ’+string (P( i ))+ ’ ␣ e s t ␣ ’+string (NF) ) ;

end ;// n es t− i l un nombre f a c t o r i e l ?n=[3629200 ,39916800 ] ;for i =1 :2

i f ( nombfact (n( i )−1)==nombfact (n( i ) ) ) thena f f i c h e r ( string (n( i ))+ ’ ␣n ’ ’ e s t ␣pas␣un␣nombre␣ f a c t o r i e l . ’ ) ;

elsea f f i c h e r ( string (n( i ))+ ’ ␣ e s t ␣un␣nombre␣ f a c t o r i e l ’ )

end ;end ;

137

� �ce qui donne :�−−>exec ( ’Chemin␣de␣nombfact ’ , −1)Le nombre de nombres f a c t o r i e l s <= 1000000 e s t

9Le nombre de nombres f a c t o r i e l s <= 1000000000 e

s t 12Le nombre de nombres f a c t o r i e l s <= 100000000000

0 e s t 14Le nombre de nombres f a c t o r i e l s <= 355687428096

000 e s t 173629200 n ’ e s t pas un nombre f a c t o r i e l .39916800 e s t un nombre f a c t o r i e l

−−>� �

138

8.8 [***] Ranger 3 nombres donnés dans l’ordre croissant (tri à bulle)

Pour ranger 3 nombres donnés x, y et z dans l’ordre croissant, on considère d’abord x et y que l’on échangesi x > y ; puis on considère y et z et on fait de même ; on compte aussi le nombre de permutations de 2nombres consécutifs que l’on a réalisées au cours de ce premier passage. Si c’est 0, c’est terminé. Sinon, onfait un deuxième passage et ainsi de suite, éventuellement. On demande d’écrire la suite x, y, z dans l’ordrecroissant et d’afficher le nombre de permutations faites.

Mots-clefs : instructions conditionnelles if …then …end, boucle tant que, trier, « exécution pas à pas ».

Ce problème a déjà été traité (mieux) dans l’exercice 7.4.Solution no 1 : Le script ci-dessous traduit exactement le procédé de tri décrit dans l’énoncé. C’est unscript maladroit. On peut passer directement à la solution no 2.�x=input ( ”x=” )y=input ( ”y=” )z=input ( ” z=” )S=1 ;NP=0 ;while S>0 then

i f x>y thenS1=1 ;t=x ;x=y ;y=t ;

elseS1=0 ;

end ;i f y>z then

S2=1 ;t=y ;y=z ;z=t ;

elseS2=0 ;

end ;S=S1+S2 ;NP=NP+S ;

end ;A=[x , y , z ] ;a f f i c h e r (A) ;a f f i c h e r ( ’ Le␣nombre␣de␣ permutat ions ␣ e f f e c t u e e s ␣ e s t ␣ ’+string (NP) ) ;� �• L’intérêt du script ci-dessus est qu’on peut le généraliser facilement pour un nombre quelconque de nombres(à partir de 4 nombres, trier est compliqué à programmer). Le tri utilisé ici s’appelle « tri à bulle ».• Il existe beaucoup d’autres types de tri, dont la fonction trier de scilab, voir l’aide en ligne ou un manuel.Voici une exécution du script ci-dessus :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)x=−1.17y=−2.34

139

z=−4.71− 4 .71 − 2 .34 − 1 .17Le nombre de permutat ions e f f e c t u e e s e s t 3

−−>� �En utilisant la commande trier de scilab, on aurait obtenu :�−−>t r i e r ( [−1.17 ,−2.34 ,−4.71])ans =

− 4 .71 − 2 .34 − 1 .17−−>� �Solution no 2 : En fait, on peut compacter le script ci-dessus. On est sûr qu’après 2 passages, les nombresdonnés sont rangés dans l’ordre croissant. Par conséquent, quitte à perdre un peu de temps, faisons ces 2passages sans compter le nombre des permutations. De plus, remplaçons systématiquement les couples denombres successifs examinés par leur minimum suivi de leur maximum. Cela donne le script :�A=input ( ”A=” ) // A e s t une l i s t e de 3 nombres c on s t i t u an t l e s donnees .Atr i=A; // Pour conserver l a va l eu r de A.for i =1 :2Atr i ( [ 1 , 2 ] )= [min( Atr i ( 1 ) , Atr i ( 2 ) ) ,max( Atr i ( 1 ) , Atr i ( 2 ) ) ]Atr i ( [ 2 , 3 ] )= [min( Atr i ( 2 ) , Atr i ( 3 ) ) ,max( Atr i ( 2 ) , Atr i ( 3 ) ) ]enda f f i c h e r ( ’ Le␣ t r i p l e t ␣ i n i t i a l ␣ e s t ␣ ’ )a f f i c h e r (A)a f f i c h e r ( ’ Le␣ t r i p l e t ␣ f i n a l ␣ e s t ␣ ’ )a f f i c h e r ( Atr i )� �Traitons l’exemple où A est obtenu avec la commande tirage_entier(2,-15,8) et choisissons le moded’exécution 7 (exécution pas à pas). Cela donne :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , 7)step−by−s tep mode : en te r c a r r i a g e return to proceed>>>>A=input ( ”A=” ) // A e s t une l i s t e de 3 nombres c on s t i t u an t l e s donnees .A=t i r a g e_en t i e r (3 ,−15 ,8)A =

− 6 . − 11 . − 4 .>>>>Atr i=A; // Pour conserver l a va l eu r de A.>>>>for i =1 :3>>Atr i ( [ 1 , 2 ] )= [min( Atr i ( 1 ) , Atr i ( 2 ) ) ,max( Atr i ( 1 ) , Atr i ( 2 ) ) ]>>Atr i ( [ 2 , 3 ] )= [min( Atr i ( 2 ) , Atr i ( 3 ) ) ,max( Atr i ( 2 ) , Atr i ( 3 ) ) ]>>endAtr i =

− 11 . − 6 . − 4 .Atr i =

− 11 . − 6 . − 4 . // Fin du premier passage .Atr i =

− 11 . − 6 . − 4 .Atr i =

− 11 . − 6 . − 4 . // Fin du deuxieme passage .>>>>a f f i c h e r ( ’ Le␣ t r i p l e t ␣ i n i t i a l ␣ e s t ␣ ’ )

140

Le t r i p l e t i n i t i a l e s t>>>>a f f i c h e r (A)

− 6 . − 11 . − 4 .>>>>a f f i c h e r ( ’ Le␣ t r i p l e t ␣ f i n a l ␣ e s t ␣ ’ )Le t r i p l e t f i n a l e s t>>>>a f f i c h e r ( Atr i )

− 11 . − 6 . − 4 .>>−−>� �Pour aller plus loin (un peu de Calcul des probabilités) :1 - Quelles valeurs NP peut-elle prendre ?Pour compter les permutations, on peut imaginer que l’on a tiré 1, 2 et 3 (seules interviennent les inégalités),ce qui donne le tableau :

NP

1 2 3 01 3 2 12 1 3 12 3 1 23 1 2 23 2 1 3

2 - Avec quelles probabilités ces valeurs sont-elles prises ?De simples considérations de symétrie indiquent que la loi de NP est

NP 0 1 2 3probabilités 1/6 1/3 1/3 1/6

Plus précisément, le volume de ((x, y, z) ; 0 < x < y < z < 1) est 1/6 parce qu’il y a 6 tétraèdres de ce typequi remplissent le cube unité (à des ensembles de volume nul près) et que ces tétraèdres ont le même volumepar raison de symétrie.

141

8.9 [***] Ranger n nombres donnés dans l’ordre croissant

Programmer une fonction scilab dont l’entrée est une liste de nombres L, qui retourne cette listerangée dans l’ordre croissant, notée R, fabriquée comme suit : le premier terme de R est min(L).Ensuite, on efface de la liste L un terme égal à min(L) (il peut y en avoir plusieurs). Le secondterme de R est le minimum des termes de L restants, et ainsi de suite.

Mots-clefs : commandes min, find, trier.

La fonction scilab qui range selon la méthode imposée dans l’énoncé peut être programmée ainsi :�function R=t t r i e r (L) // L : l i s t e de nombres .

R=[ ] ; // Future l i s t e ordonnee .while t a i l l e (L)>0

R=[R,min(L ) ] ;L(min( find (L==min(L ) ) ) ) = [ ] ;

endendfunction� �Utilisons cette fonction ainsi que la commande trier et comparons les temps de calcul du tri :�−−>clear−−>exec ( ’Chemin␣de␣ l a ␣ f onc t i on ␣ t t r i e r ’ , −1)−−>L=t i r a g e_r e e l ( 100000 , 0 , 1 ) ;−−>t i c ( ) ;−−>R=t t r i e r (L ) ; toc ( ) ; // t r i de L avec t t r i e r .−−>temps=toc ( ) // temps de c a l c u l du t r i avec t t r i e r .temps =

236 .−−>format ( ’ v ’ , 8 ) ; // a f f i c h a g e a 5 dec imales .−−>a f f i c h e r (R(1 :10) ,L(1 : 10 ) ) // 10 premiers termes de L e t de R.

column 1 to 50.96769 0.15761 0.72584 0.97059 0.98111

column 6 to 100.95717 0.10986 0.48538 0.79811 0.80028

column 1 to 50.00001 0.00001 0.00005 0.00005 0.00007

column 6 to 100.00007 0.00007 0.00007 0.00007 0.00009

−−>a f f i c h e r (R(99991 :100000) ,L(99991 :100000)) // 10 de rn i e r s termes de L e t de R.column 1 to 5

0.58883 0.41749 0.14204 0.16188 0.29871column 6 to 10

0.02526 0.15916 0.71615 0.49549 0.51918column 1 to 5

0.99991 0.99992 0.99993 0.99993 0.99994column 6 to 10

0.99995 0.99997 0.99997 0.99997 0.99998−−>t i c ( ) ; S=t r i e r (L ) ; toc ( ) ; // t r i avec t r i e r .−−>a f f i c h e r ( toc ( ) ) // temps de c a l c u l du t r i avec t r i e r .

39 .225−−>

142

� �On constate que la commande trier de scilab est beaucoup plus rapide.Autres solutions : Voir les exercices 6.24, 6.25 et 8.10.

143

8.10 [***] Ranger n nombres donnés dans l’ordre croissant

Progammer une fonction de tri exécutable par scilab à partir de la description suivante :Un vecteur de nombres noté A étant donné ; on appellera Aneuf ce vecteur rangé dansl’ordre croissant. On détermine d’abord le plus petit nombre m de A, on compte combiende fois n le nombre m figure dans A, on ajoute à Aneuf (vide au début) la suite m, …, m (mécrit n fois), on efface tous les m qui figurent dans A. Si A n’est pas vide, on recommence.

Mots-clefs : commande find.

Cet exercice est une variante de 8.9L’énoncé se traduit par l’algorithme suivant :�function Aneuf=Tr i e r (A) // A e s t une s u i t e de nombres .

Aneuf = [ ] ;while s ize (A)>0

m=min(A) ;B=find (A==m) ;A(1 ,B)= [ ] ;Aneuf=[Aneuf ,m*ones (B ) ] ;

end// a f f i c h e r (”La l i s t e A dans l ’ ’ ordre c r o i s s an t s ’ ’ e c r i t :”) ;// a f f i c h e r (Aneuf ) ;

endfunction� �Appliqué par exemple à une suite de 10 entiers tirés au hasard entre -1 et 4 selon la loi uniforme, cela donne :�exec ( ’Chemin␣de␣Tr i e r ’ , −1)−−>A=t i r a g e_en t i e r (10 ,−1 ,4)A =

4 . 0 . 4 . 0 . − 1 . 1 . 3 . 2 . 3 . 4 .−−>Aneuf=Tr i e r (A) ;La l i s t e A dans l ’ ordre c r o i s s a n t s ’ e c r i t :− 1 . 0 . 0 . 1 . 2 . 3 . 3 . 4 . 4 . 4 .

−−>� �On pourrait aussi bien trier des nombres réels. Dans l’exemple qui suit, on trie 100000 nombres réels avec lafonction Trier puis avec la commande trier de scilab. On affiche le temps pris par le tri en secondes danschaque cas ainsi que les 5 derniers termes triés.�−−>clear ;−−>exec ( ’Chemin␣de␣Tr i e r ’ , −1)−−>X=t i r a g e_r e e l (100000 ,−1 ,4) ;−−>t i c ( ) ; Xneuf=Tr i e r (X) ; temps=toc ( ) ; a f f i c h e r ( temps ) ;265 .225−−>t i c ( ) ; Xtr i=t r i e r (X) ; temps=toc ( ) ; a f f i c h e r ( temps ) ;

0 .053−−>Xneuf (99996 :100000)ans =

3.99976324616 3.9999442009721 3.9999521544669 3.9999772896993.9999918183312−−>Xtr i (99996 :100000)

144

ans =3.99976324616 3.9999442009721 3.9999521544669 3.999977289699

3.9999918183312−−>� �La commande trier de scilab est beaucoup plus rapide.Autres solutions : Voir les exercices 6.24, 6.25 et 8.9.

145

Chapitre 9

Graphes

Pour plot2d, on consultera de préférence [11], chapitre 19. Sauf erreur, [12] ne parle pas de cette commande.[1] est très indigeste.

Liste des exercices :

Énoncé no 9.1 : [*] Tracer un triangle.Énoncé no 9.2 : [***] Tracés de polygones réguliers inscrits dans un cercle.Énoncé no 9.3 : [***] Tracer les N premiers flocons de Koch.Énoncé no 9.4 : [***] Visualisation du tri à bulles.

146

9.1 [*] Tracer un triangle

Tracer le triangle ABC, ces points ayant respectivement pour coordonnées (1, 3), (−2, 4) et (3, 8).

Mots-clefs : commandes clf, plot, orthonorme(), plot2d, a=gca ( ), a.isoview="on", axesflag =0,a.axes\_visible=["off","off","off"].

On utilise le vecteur des abscisses des points A, B, C et A puis le vecteur de leurs ordonnées, dans le mêmeordre. Le repère est orthonormé.�c l f ;X=[1 ,−2 ,3 ,1 ] ;Y= [3 , 4 , 8 , 3 ] ;plot (X,Y) ;� �Ce script particulièrement simple conduit au tracé de gauche. Le repère est choisi par scilab. On constatequ’il n’est pas orthonormé. On peut imposer qu’il le soit en imposant la commande orthonorme() 1, ce quidonne le script suivant et le trac� de droite :�c l f ;X=[1 ,−2 ,3 ,1 ] ;Y= [3 , 4 , 8 , 3 ] ;orthonorme ( ) ;plot (X,Y) ;� �

Remarques sur les scripts précédents :• La commande clf nettoie la fenêtre graphique. Elle est indispensable si on a déjà fait des tracés dans lamême session. Sans elle, les tracés se superposeraient.• On remarque que le triangle a été fermé en répétant les coordonnées de A.On pourrait aussi faire disparaître les axes, encadrer le tracé par souci esthétique, épaissir les traits, lescolorer, ajouter des légendes, etc. Pour cela, il vaut mieux utiliser les commandes plot2d et gca(), cettedernière ayant énormément d’options, voir l’aide en ligne, bon courage.

1. Ne pas oublier ().

147

Dans le graphe ci-dessous, le repère orthonormé a été imposé par l’instruction a.isoview="on"; au lieu de lacommande orthonorme(), l’effacement des axes par la commande a.axes_visible=["off","off","off"];.�c l f ;X=[1 ,−2 ,3 ,1 ] ;Y= [3 , 4 , 8 , 3 ] ;plot (X,Y) ;a=gca ( ) ;a . ax e s_v i s i b l e =[” o f f ” , ” o f f ” , ” o f f ” ] ; // Les axes sont e f f a c e s .a . isoview=”on” ; // Le repere sera orthonorme .� �Ce script retourne la figure de gauche ci-dessous. Pour encadrer le triangle par un carré (déterminé enbricolant, à la main), on peut exécuter le script qui suit :�U=[ −2 .5 ,3 .5 ,3 .5 , −2 .5 , −2 .5 ] ;V= [ 2 . 5 , 2 . 5 , 8 . 5 , 8 . 5 , 2 . 5 ] ;plot (U,V) ;� �Ce script ne comportant pas la commande clf, on constate comme prévu que le carré vient se superposerau tracé existant.

Remarque :On peut aussi obtenir la figure de droite ci-dessus avec le listing�c l f ;f=s c f ( ) ;orthonorme ( ) ;X=[1 ,−2 ,3 ,1 ] ;Y= [3 , 4 , 8 , 3 ] ;plot2d (X,Y, a x e s f l a g =0) ;U=[ −2 .5 ,3 .5 ,3 .5 , −2 .5 , −2 .5 ] ;V= [ 2 . 5 , 2 . 5 , 8 . 5 , 8 . 5 , 2 . 5 ] ;plot2d (U,V, a x e s f l a g =0) ;� �scilab et la géométrie :scilab n’est pas un logiciel de géométrie. Les logiciels de géomśtrie sont bien meilleurs. Néanmoins, danscertains calculs avec illustration géom’etrique, les capacit�s graphiques de scilab pourront �́viter d’ouvrir uneapplication de géomśtrie.

148

9.2 [***] Tracés de polygones réguliers inscrits dans un cercle

Tracer dans le même repère orthonormé le cercle de centre O et de rayon 1 ainsi que le triangle équilatéral,le carré et l’heptagone régulier inscrits dans ce cercle et dont un sommet est le point (1, 0).

Mots-clefs : plot, plot2d, orthonorme(), help getcolor, style=i, axesflag=0.

Cet exercice est intéressant. Pour tracer un polygone régulier à n côtés inscrits dans le cercle unité etadmettant (1, 0) comme sommet, il suffit d’exécuter le script suivant :�c l f ;orthonorme ( ) ;n=input ( ’n=’ ) ;X=cos (2*%pi/n* [0 : n ] ) ;Y=sin (2*%pi/n* [0 : n ] ) ;plot (X,Y) ;� �Ce polygone sera bien fermé. On aura sans doute envie de rendre le repère orthonormé et d’effacer les axes,voir plus loin. En effet, quand on exécute ce script,�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=7−−>� �on obtient la figure de gauche, très peu satisfaisante (il s’agit d’un heptagone) :

Lorsque n sera grand, ce polygone sera indistinguable à nos yeux du cercle-unité. On pourrait construire lecercle-unité autrement, mais ce sera toujours en réalité un tel polygone régulier. Il peut être utile de fairegrandir le nombre de côtés et de trouver à partir de quelle valeur de n on voit un cercle, puis de vérifier quec’est un polygone à l’aide du zoom.

149

Pour le tracé de la figure de droite ci-dessus, nous avons choisi n=100 et nous avons allongé X et Y en ajoutantles coordonnées des sommets du triangle, du carré et de l’heptagone demandés.�c l f ;orthonorme ( ) ;X=cos ( [ 2 *%pi /100* [0 :100 ] , 2*%pi /3* [ 0 : 3 ] , 2 *%pi /4* [ 0 : 4 ] , 2 *%pi / 7 * [ 0 : 7 ] ] ) ;Y=sin ( [ 2 *%pi /100* [0 :100 ] , 2*%pi /3* [ 0 : 3 ] , 2 *%pi /4* [ 0 : 4 ] , 2 *%pi / 7 * [ 0 : 7 ] ] ) ;plot2d (X,Y, a x e s f l a g =0) ;� �Colorions les 4 courbes tracd́es à l’aide du script :�c l f ;orthonorme ( ) ;X100=cos (2*%pi / 1 0 0* [ 0 : 1 0 0 ] ) ’ ;Y100=sin (2*%pi / 1 0 0* [ 0 : 1 0 0 ] ) ’ ;plot2d (X100 , Y100 , s t y l e =1, a x e s f l a g =0) ;X3=cos (2*%pi / 3 * [ 0 : 3 ] ) ;Y3=sin (2*%pi / 3 * [ 0 : 3 ] ) ;plot2d (X3 ,Y3 , s t y l e =2, a x e s f l a g =0) ;X4=cos (2*%pi / 4 * [ 0 : 4 ] ) ;Y4=sin (2*%pi / 4 * [ 0 : 4 ] ) ;plot2d (X4 ,Y4 , s t y l e =32, a x e s f l a g =0) ;X7=cos (2*%pi / 7 * [ 0 : 7 ] ) ;Y7=sin (2*%pi / 7 * [ 0 : 7 ] ) ;plot2d (X7 ,Y7 , s t y l e =5, a x e s f l a g =0) ;� �On obtient :

On peut obtenir beaucoup plus simplement cette figure à l’aide d’un logiciel de géométrie comme, parexemple, GeoGebra.

150

9.3 [***] Tracer les N premiers flocons de Koch

Tracer les N premiers flocons de Koch définis comme suit à partir de l’hexagone régulier ABCDEFA(ou K0) inscrit dans le cercle unité dont le point A de coordonnées (1, 0) est un sommet :- Construction du premier flocon de Koch K1 :• d’abord on remplace le côté AB de l’hexagone par la ligne brisée AMGNB, M étant au tiers deAB à partir de A, N étant au tiers de AB à partir de B, le triangle MNG étant équilatéral, le pointG étant à droite quand on se déplace de A à B ;• puis on fait de même avec les 5 autres côtés de K0.Le polygone à 18 côtés ainsi obtenu est appelé premier flocon de Koch, noté K1.- Construction des flocons de Koch suivants : on passe de Kn à Kn+1 comme on est passé de K0 àK1.

Mots-clefs : plot, plot2d, orthonorme(), help getcolor, style=i, axesflag=0.

L’énoncé étant un peu rapide, on pourra se reporter à [4] pour plus de précisions. Le script ci-dessous produitle tracé de K0 en noir, sans les axes, dans un repère orthonormé :�c l f ;orthonorme ( ) ;X=cos (%pi / 3 * [ 0 : 6 ] ) ;Y=sin (%pi / 3 * [ 0 : 6 ] ) ;plot2d (X,Y, s t y l e =1, a x e s f l a g =0) ;� �Pour remplacer le segment AB par la ligne brisé AMGNB, opération qui sera ensuite répétée sans cesse, onutilisera la fonction-scilab que nous avons appelée Machinekoch ainsi définie :�function Q=Machinekoch (P) // P a pour co lonnes l e s coordonnees de A, pu i s de B.

R=[P( : , 1 ) , 2/3*P( : ,1)+1/3*P( : , 2 ) , 1/3*P( : ,1)+2/3*P( : , 2 ) ,P ( : , 2 ) ] ;S=1/3*[1/2 , sqrt (3)/2 ;− sqrt ( 3 ) /2 , 1 /2 ] * (P( : ,2)−P( : ,1))+R( : , 2 ) ;Q=[R( : , 1 : 2 ) , S ,R( : , 3 : 4 ) ] ;

endfunction� �Cette fonction étant chargée dans la console, le script qui vient superposera à K0 la ligne brisée AMGNBen bleu :�P=[X( 1 : 2 ) ;Y( 1 : 2 ) ] ;Q=Machinekoch (P) ;plot2d (Q(1 , : ) ,Q(2 , : ) , s t y l e =2, a x e s f l a g =0) ;� �ce qui donne la figure de gauche ci-dessous :

151

Il est dès lors facile d’obtenir K1 en ajoutant une boucle pour au script précédent qui devient :�for i =1 :6

P=[X( i : i +1) ;Y( i : i +1) ] ;Q=Machinekoch (P) ;plot2d (Q(1 , : ) ,Q(2 , : ) , s t y l e =2, a x e s f l a g =0) ;

end� �et retourne la figure de droite ci-dessus. Finalement, pour calculer KN , N ⩾ 1 donné, on calcule successive-ment K1, …, KN , à l’aide d’une nouvelle boucle pour. Le programme suivant rassemble toutes les étapes dela construction de KN . Il retourne aussi le temps de calcul de KN :�c l f ;N=input ( ’N=’ ) ;t i c ( ) ;XY=[cos (%pi / 3 * [ 0 : 6 ] ) ; sin (%pi / 3 * [ 0 : 6 ] ) ] ;function Q=Machinekoch (P)

R=[P( : , 1 ) , 2/3*P( : ,1)+1/3*P( : , 2 ) , 1/3*P( : ,1)+2/3*P( : , 2 ) ,P ( : , 2 ) ] ;S=1/3*[1/2 , sqrt (3)/2 ;− sqrt ( 3 ) /2 , 1 /2 ] * (P( : ,2)−P( : ,1))+R( : , 2 ) ;Q=[R( : , 1 : 2 ) , S ,R( : , 3 : 4 ) ] ;

endfunctionfor j=1 :N

n=6*4^( j −1) ;// Nombre de co t e s de K_( j −1).xy = [ ] ;for i=1 :n

P=XY( : , i : i +1) ;Q=Machinekoch (P) ;xy=[xy ,Q( : , 1 : 4 ) ] ;

endXY=[xy ,Q( : , 5 ) ] ;

endorthonorme ( ) ;plot2d (XY(1 , : ) ,XY(2 , : ) , s t y l e =2, a x e s f l a g =0) ;temps=toc ( ) ;a f f i c h e r ( temps ) ;� �Les calculs sont assez rapides jusque’à K6 (moins de une seconde pour K6). Le calcul de K7 nécessite presque20 secondes ; on peut remarquer à ce sujet que K7 a 98304 côtés. Voici ce flocon :

152

153

9.4 [***] Visualisation du tri à bulles

On applique le tri à bulles à une suite donnée de n nombresX = (x1, . . . , xn) obtenue, pourfixer les idées, à l’aide de la commande tirage_reel(n,0,1), n pouvant éventuellementvarier. Représenter l’état de la suite X après chaque passage, y compris le dernier quiproduit une illustration de la suite triée, en traçant, dans un repère orthonormé, les (n−1)points (x1, x2), (x2, x3), …, ainsi que la droite y = x.

Mots-clefs : clf, sleep, repère orthonormé, nuage de points : commande plot(X,Y,"*b").

L’exercice 6.24 est consacré au tri à bulles que nous allons illuster maintenant, suivant l’exemple de [16].Pour visualiser le tri à bulles, on peut utiliser le script commenté suivant :�clear ; // Effacement des v a r i a b l e s non−pro t e g e e s .c l f ; // Effacement de l a f e n e t r e graph ique .n=input ( ’n=’ ) ; // Choix de n .L=t i r a g e_r e e l (n , 0 , 1 ) ;c=1 ;// Pour d e c r i r e au moins une f o i s l a bouc l e su i van t e .while c>0

c=0 ;for k=1 :(n−1)// K indexe l e s passages .

for j =1 :(n−k )i f L( j )>L( j +1) then

c=c+1 ;aux=L( j ) ;L( j )=L( j +1) ;L( j+1)=aux ;

endendplot ( [ 0 , 1 . 1 ] , [ 0 , 1 . 1 ] , ”b” ) ; // Graphe de y=x .a=gca ( ) ;a . isoview=”on” ; // Repere orthonorme .X=L(1 :n−1)// Vecteur des a b s c i s s e s .Y=L(2 :n ) ; // Vecteur des ordonnees .plot (X,Y, ”*b” ) // Chaque po in t e s t une e t o i l e b l eue .s l e e p (1000 ) ; // On at t end une seconde avant l ’ e v en tu e l passage su i van t .i f c>0 then

c l fend

endend// Le dern i e r graphe qu i appara i t e t r e s t e r ep r e s en t e l a s u i t e t r i e e .� �On obtient sur la console, en donnant la valeur 40 à n :�−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ charge ’ , −1)n=40−−>� �Voici le graphe qui représente la suite triée issue de X, à gauche :

154

Remarques :• Tous les points sont évidemment au-dessus du graphe de la droite y = x parce que les nombres étantrangés dans l’ordre croissant, l’ordonnée est toujours supérieure ou égale à l’abscisse.• S’il y a beaucoup de points (si n est grand), il y a peu d’écart entre l’abscisse et l’ordonnée des pointsreprésentés. On a l’impression qu’ils sont alignés sur la droite y = x. On peut alors faire usage du zoom. Legraphe de droite ci-dessus correspond au choix n = 100.

155

Chapitre 10

scilab vs Xcas

Liste des exercices :

Énoncé no 10.1 : [*] Calcul numérique avec scilab et Xcas (test d’égalité de deux nombres).Énoncé no 10.2 : [*] Calculs en nombres rationnels avec scilab et avec Xcas.Énoncé no 10.3 : [*] Les fonctions racine carrée et élévation au carré sont-elles inverses l’une de l’autre ?Énoncé no 10.4 : [*] Calcul de factorielles.Énoncé no 10.5 : [*] Longueur d’un nombre entier.Énoncé no 10.6 : [**] Somme des chiffres d’un nombre entier.Énoncé no 10.7 : [*] Sommes de puissances des premiers entiers (démontrer une infinité d’égalités)Énoncé no 10.8 : [**] Test d’isocélité et d’équilatéralité d’un triangle.Énoncé no 10.9 : [***] Sommes d’inverses.

Ce qui suit est une comparaison très sommaire des capacités de calcul et d’affichage de scilab et de Xcas.Ce sont des logiciels de calcul très vastes qui, même si on se limite au calcul numérique, fonctionnent trèsdifféremment.• scilab est perfectionné et étendu depuis plusieurs dizaines d’années. Il contient de nombreux développe-ments spécialisés qui ne nous concernent pas. Il est employé notamment dans des bureaux d’étude industriels.Il est rapide et doué pour le calcul matriciel. Il travaille essentiellement en format scientifique standard. Par

exemple, calculons(π − 1

π + 1

)2

:�−−>((%pi−1)/(%pi+1))^2ans =

0.2673861903466−−>b=ans^2b =

0.0714953747880−−>� �• Même en calcul numérique pur, Xcas ne travaille pas du tout comme scilab. Il utilise ses capacités decalcul formel pour calculer en mode exact. Par exemple, recalculons les quantités précédentes avec Xcas :a:=(%pi-1)/(%pi+1);b:=a**2;evalf(b);

π − 1

π + 1,(π − 1

π + 1

)2

, 0.267386

156

(on peut afficher plus de décimales). On a d’abord obtenu b sous forme exacte puis en notation scientifiquestandard. Cette forme n’est pas une valeur exacte. C’est cette valeur approchée que scilab donne directement.Xcas travaille en mode exact quand les données sont fractionnaires, ce qui est pratiquement toujours le casau lycée, notamment en calcul des probabilités. C’est, pour le professeur, un avantage fabuleux.scilab et Xcas n’ont pas non plus les mêmes capacités d’affichage. Un logiciel peut parfaitement calculerun nombre sans pouvoir l’afficher ou en l’affichant de manière déficiente. Par exemple, scilab affichera ennotation scientifique standard un nombre entier qu’il vient de calculer exactement parce qu’il est trop grand.Xcas peut calculer tout nombre entier. Mais il y aura aussi des restrictions d’affichage. Les capacités de Xcasdans ce domaine sont impressionnantes.Cette comparaison de scilab et de Xcas s’approfondira dans les exercices suivants. Il sera évidemmentnécessaire de se reporter aux manuels. Nous recommandons [11] pour scilab (en plus de [12]) et [10] pourXcas.

157

10.1 [*] Calcul numérique avec scilab et Xcas (test d’égalité de deuxnombres)

Vérifier si scilab et Xcas donnent à tan(π4

)et à

(√2)2 les valeurs 1 et 2 respectivement.

Mots-clefs : Test « == ».

scilabscilab ne peut pas vraiment tester l’égalité de deux nombres, sauf cas particulier. En effet, si deux nombressont considérés par scilab comme des nombres réels et s’ils ne sont pas décimaux, ils ont une infinité de déci-males. scilab n’en gardera qu’une partie en tronquant leurs développements décimaux. Sauf cas particulier,scilab ne donne donc pas aux nombres réels leur valeur exacte mais une valeur approchée. Cela amène à deserreurs. Voici deux exemples de test d’égalité de deux nombres où scilab se trompe :�−−>tan (%pi/4)==1ans =

F−−>(sqrt (2))^2==2ans =

F� �Ce constat est assez accablant. Mais quand on a un outil, on essaie de l’utiliser au mieux. On peut voir dansl’exercice 10.8 comment on teste quand même et de manière imparfaite l’égalité de 2 nombres avec scilab.XcasXcas ne calcule pas tan

(π4

), sauf erreur, car ce logiciel contient les formules usuelles de trigonométrie ainsi

que les valeurs remarquables des sin, cos, etc. Cela donne1 tan(%pi/4);

1

Xcas donnera aussi la valeur exacte de√22. En effet,

2 sqrt(2)^2;

2

158

10.2 [*] Calculs en nombres rationnels avec scilab et avec Xcas

Calculer1

2+

1

3+

1

4(1

2

)2

+

(1

3

)2

+

(1

4

)2 avec scilab puis Xcas.

Mots-clefs : Calcul numérique, nombres rationnels.

Solution scilab

-->(1/2+1/3+1/4)/((1/2)^2+(1/3)^2+(1/4)^2)ans =

2.5573770491803

Solution Xcas1 a:=(1/2+1/3+1/4)/((1/2)^2+(1/3)^2+(1/4)^2);

156

61

2 evalf (a);

2.557377

Xcas donne une solution exacte puis, à la demande (commande evalf), une solution approchée (on peutafficher plus de décimales). On pourrait obliger scilab à effectuer exactement le calcul, mais il n’est pas faitpour ça.

159

10.3 [*] Les fonctions racine carrée et élévation au carré sont-elles in-verses l’une de l’autre ?

Calculer√x2 et

√x2.

Mots-clefs : Commande @ (composition des fonctions).

Solution scilabIl n’y a pas de solution scilab. Tout au plus peut-on vérifier que pour des valeurs particulières de x,

√x2 = x

et√x2= x.

Solution XcasXcas sait que les fonctions considérées sont des fonctions réciproques :3 f(x):=sqrt(x);

(x)->sqrt(x)

(f est définie comme la fonction « racine carrée »).4 g(x):=x^2;

(x)->x^2

(g est définie comme la fonction « élévation au carré »)5 (g@f)(x);

x

• L’utilisateur est sensé connaître le domaine de validité de ce résultat (à savoir ]0,+∞[).6 (f@g)(x)

abs (x)

• L’utilisateur est sensé savoir que ceci est vrai pour tout réel x.• Bien sûr, la fin de ce calcul est typiquement du calcul formel.

160

10.4 [*] Calcul de factorielles

Calculer n ! pour n = 10, 20, 50, 100, 500, 1000 à l’aide de scilab puis de Xcas.

Mots-clefs : calcul de grands nombres entiers, calcul exact, calcul approché, notation scientifique standard.

Calcul scilab�// Ca lcu l e t a f f i c h a g e de nombres f a c t o r i e l s .clear ;format ( 2 5 ) ; //Cet te commande permet l ’ a f f i c h a g e l e p l u s long .f a c t o r i e l l e (10)f a c t o r i e l l e (20)f a c t o r i e l l e (23)f a c t o r i e l l e (24)f a c t o r i e l l e (50)f a c t o r i e l l e (100)f a c t o r i e l l e (500)f a c t o r i e l l e (1000)� �Nous avons calculé en plus 23 ! et 24 ! parce que 23 ! est le plus grand nombre factoriel qui peut être affichéexactement (au format d’affichage le plus long), à savoir : 23 ! = 25852016738884978212864. Les réponsesmontreront pourquoi nous avons aussi ajouté le calcul de 170 ! et de 171 !

Voici la réponse de scilab à l’exécution de ce script :

-->// Calcul et affichage de nombres factoriels.-->clear;-->format(25);//Cette commande permet l'affichage le plus long.-->factorielle(10)ans =

3628800.-->factorielle(20)ans =

2432902008176640000.-->factorielle(23)ans =

25852016738884978212864.-->factorielle(24)ans =

6.204484017332394100D+23-->factorielle(50)ans =

3.041409320171337558D+64-->factorielle(100)ans =

9.33262154439441021D+157-->factorielle(170)ans =

7.25741561D+306-->factorielle(171)ans =

161

Inf-->factorielle(500)ans =

Inf-->factorielle(1000)ans =

Inf

On peut imaginer (?) que scilab calcule exactement 24 !, 50 !, 100 !, 170 ! mais ne les affiche pas bien (passageen notation scientifique standard) et qu’à partir du calcul de 171 !, ses capacités ont été dépassées (les calculsde 500 ! et de 1000 ! étaient, par conséquent, inutiles). Au contraire, Xcas n’a pas de limitation de calcul ennombres entiers.Calcul Xcas1 10!

3628800

2 100!

9332621544394415268169923885626670049071596826438162146859296389521759999322991560

8941463976156518286253697920827223758251185210916864000000000000000000000000

3 1000!

4023872600770937735437024339230039857193748642107146325437999104299385123986290205

9204420848696940480047998861019719605863166687299480855890132382966994459099742450

4087073759918823627727188732519779505950995276120874975462497043601418278094646496

2910563938874378864873371191810458257836478499770124766328898359557354325131853239

5846307555740911426241747434934755342864657661166779739666882029120737914385371958

8249808126867838374559731746136085379534524221586593201928090878297308431392844403

2812315586110369768013573042161687476096758713483120254785893207671691324484262361

3141250878020800026168315102734182797770478463586817016436502415369139828126481021

3092761244896359928705114964975419909342221566832572080821333186116811553615836546

9840467089756029009505376164758477284218896796462449451607653534081989013854424879

8495995331910172335555660213945039973628075013783761530712776192684903435262520001

5888535147331611702103968175921510907788019393178114194545257223865541461062892187

9602238389714760885062768629671466746975629112340824392081601537808898939645182632

4367161676217916890977991190375403127462228998800519544441428201218736174599264295

6581746628302955570299024324153181617210465832036786906117260158783520751516284225

5402651704833042261439742869330616908979684825901254583271682264580665267699586526

8227280707578139185817888965220816434834482599326604336766017699961283186078838615

0279465955131156552036093988180612138558600301435694527224206344631797460594682573

1037900840244324384656572450144028218852524709351906209290231364932734975655139587

2055965422874977401141334696271542284586237738753823048386568897646192738381490014

0767310446640259899490222221765904339901886018566526485061799702356193897017860040

8118897299183110211712298459016419210688843871218556461249607987229085192968193723

8864261483965738229112312502418664935314397013742853192664987533721894069428143411

8520158014123344828015051399694290153483077644569099073152433278288269864602789864

3211390835062170950025973898635542771967428222487575867657523442202075736305694988

162

2508796892816275384886339690995982628095612145099487170124451646126037902930912088

9086942028510640182154399457156805941872748998094254742173582401063677404595741785

1608292301353580818400969963725242305608559037006242712434169090041536901059339838

3577793941097002775347200000000000000000000000000000000000000000000000000000000000

0000000000000000000000000000000000000000000000000000000000000000000000000000000000

0000000000000000000000000000000000000000000000000000000000000000000000000000000000

00000000000000000000000000

C’est étonnant !

163

10.5 [*] Longueur d’un nombre entier

Avec combien de chiffres s’écrit 500 ! ?

Mots-clefs : calcul de grands nombres entiers.

Il vaut mieux programmer la solution du problème plus général : avec combien de chiffres s’écrit un entiernaturel A ⩾ 1 donné ?Solution scilabL’exercice 10.4 laisse prévoir que scilab n’aura pas de problème tant que A ⩽ 170 et qu’il sera impuissantsinon.�−−>// La fonc t i on qu i s u i t donne l e nombre de c h i f f r e s avec l e s q u e l s//s ’ e c r i t un en t i e r donne A.−−>function nn=NC(A) ;−−> n=0 ;−−>while 10^n<=A−−> n=n+1 ;−−>end−−>nn=n ;−−>a f f i c h e r ( ”A␣s ’ e c r i t ␣ avec ␣”+string (nn)+”␣ c h i f f r e s ” ) ;−−>endfunction� �On charge cette fonction, puis on l’applique pour diverses valeurs de A :�−−>NC( f a c t o r i e l l e ( 23 ) )A s ’ e c r i t avec 23 c h i f f r e sans =

23 .−−>NC( f a c t o r i e l l e ( 24 ) )A s ’ e c r i t avec 24 c h i f f r e sans =

24 .−−>NC( f a c t o r i e l l e ( 50 ) )

A s ’ e c r i t avec 65 c h i f f r e sans =

65 .−−>NC( f a c t o r i e l l e ( 100 ) )

A s ’ e c r i t avec 158 c h i f f r e sans =

158 .−−>NC( f a c t o r i e l l e ( 150 ) )

A s ’ e c r i t avec 263 c h i f f r e sans =

263 .−−>NC( f a c t o r i e l l e ( 160 ) )

A s ’ e c r i t avec 285 c h i f f r e sans =

285 .

−−>NC( f a c t o r i e l l e ( 170 ) )

164

A s ’ e c r i t avec 307 c h i f f r e sans =

307 .−−>NC( f a c t o r i e l l e ( 171 ) )

Abandon du c a l c u l .� �Le calcul de 171 ! a été abandonné au bout de 6 minutes.Solution Xcas1

// Avec combien de chiffres s'ecrit 500 ! ?NombredeChiffres(A):={local n;n:=1;tantque 10^n<=A fairen:=n+1;ftantque;retourne n;}:;

// Parsing NombredeChiffres// Success compiling NombredeChiffres

Done2 NombredeChiffres(170!)

307

3 NombredeChiffres(200!)

375

4 NombredeChiffres(500!)

1135

5 NombredeChiffres(1000!)

2568

6 NombredeChiffres(5000!)Evaluation time : 2.34

16326

7 NombredeChiffres(10000!)Evaluation time : 14.54

35660

8 NombredeChiffres(15000!)Evaluation time : 42.8

56130

On peut ajouter que le calcul du nombre de chiffres de 171 ! est instantané.

165

10.6 [**] Somme des chiffres d’un nombre entier.

Un entier n ⩾ 1 étant donné, calculer son chiffre des unités noté u (n) et la somme de ses chiffresnotée s (n).Application : démontrer que u

(32014−1

2

)= s

(s(s(s(32014−1

2

)))).

Mots-clefs : calcul de grands nombres entiers.

Solution scilab• On ne peut calculer s(n) avec scilab que si n est donné, bien entendu. Aussi, dans le script ci-dessous, oncommence par demander la valeur de n. Ce script est élémentaire. Il donne au passage le nombre de chiffresde n, autrement dit, il résout au passage l’exercice 10.5.�n=input ( ’n=’ ) ;r=r e s t e (n , 1 0 ) ; // c h i f f r e des un i t e s de n .C= [ ] ; // f u t u r e l i s t e des c h i f f r e s de n .while n>0

r=r e s t e (n , 1 0 ) ;C=[C, r ] ;n=(n−r )/10 ;

endt=t a i l l e (C) ;a f f i c h e r ( ’ Le␣nombre␣de␣ c h i f f r e s ␣de␣n␣ e s t ␣ ’+string ( t ) )s=sum(C) ;a f f i c h e r ( ’La␣somme␣des ␣ c h i f f r e s ␣de␣n␣ e s t ␣ ’+string ( s ) )� �• Appliquons ce script quand n vaut 32014−1

2 = s(s(s(s(32014−1

2

))))1. Cela donne :�

−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=(3^2014−1)/2!−−error 10000

Les arguments de l a f on c t i on ” r e s t e ” do ivent e t r e des e n t i e r s .at l i n e 5 o f function r e s t e c a l l e d by :r=r e s t e (n , 1 0 ) ; // c h i f f r e des un i t e s de n .at l i n e 2 o f exec f i l e c a l l e d by :’Chemin␣du␣ s c r i p t ’ , −1−>� �À la suite de ce message d’erreur bizarre, calculons n. On obtient :�−>n=(3^2014−1)/2n =

In f−>� �Effectivement, inf n’est pas un nombre entier.• On peut démontrer que u

(32014−1

2

)= s

(s(s(s(32014−1

2

))))de manière presque purement arithmétique.

Évidemment, cela demande de l’astuce. En fait, la bonne solution (la plus facile) de ce problème est la solutionXcas :

1. Ceci est un exercice de la rubrique « De-ci, de-là » du Bulletin vert no510 posé par Michel Lafond.

166

Solution XcasNous proposons l’algorithme suivant qui donne la somme des chiffres, le nombre des chiffres (dont on n’apas besoin) et le chiffre des unités de n.1

SommedesChiffres(n):={local s,C,r,u,l;s:=0;//Future somme des chiffres de n.C:=[];//Future liste des chiffres de n.tantque n>0 faire

r:=irem(n,10);// Chiffre successifs.u:=r;// Chiffre des unites de n.C:=append(C,r);s:=s+r;n:=(n-r)/10;

ftantque;l:=size(C);

retourne(s,l,u);}:;

// Parsing SommedesChiffres// Success compiling SommedesChiffres

Done

2 SommedesChiffres((3^2014-1)/2);

4306, 961, 4

3

On applique ensuite cet algorithme à n = 32014−12 · On trouve que la somme de ses chiffres est 4306 et que 4

est son chiffre des unités. On calcule enfin de tête la somme des chiffres de 4306 qui est 13, puis la sommedes chiffres de 13 qui est 4 et la somme des chiffres de 4 qui est 4, ce qui est bien le chiffre des unités de n.En se basant sur cet algorithme Xcas, on peut se poser d’autres problèmes arithm�tiques.

167

10.7 [*] Sommes de puissances des premiers entiers (démontrer une in-finité d’égalités)

Peut-on démontrer que 1 + · · ·+ n =n (n+ 1)

2avec scilab ? avec Xcas ?

Quelles formules donnent la somme des carrés ? des cubes ? des puis-sances suivantes ?

Mots-clefs : Calcul formel.

Solution scilabscilab ne peut trouver la formule demandée mais on peut chercher à la vérifier. Cependant, comme n prendune infinité de valeurs, il faudrait effectuer une infinité de calculs, ce qui est impossible. La formule donnéen’est donc pas démontrable avec scilab. Le script ci-dessous permet de vérifier l’égalité quand n varie de pà q :�//Quelques v e r i f i c a t i o n s de l a formule 1+..+n=n(n+1)/2.function S=SommesDentiers (p , q )

s=sum( linspace (1 , p−1,p−1)) ; // s=1+...+p−1.t e s t =1 ;for j=p :q

s=s+j ;i f 2* s<>j *( j +1) then

t e s t =0 ;S=’La␣ formule ␣ e s t ␣ f au s s e ’ ;break ;

endendi f t e s t==1 then

S=’La␣ formule ␣ e s t ␣ exacte ␣pour␣n␣ var i ant ␣de␣ ’+string (p)+ ’ ␣a␣ ’+string ( q ) ;

end ;endfunction� �Vérifions ainsi que la formule est exacte quand n ⩽ 106 :

-->SommesDentiers(1,1000000)ans =La formule est exacte pour n variant de 1 a 1000000

Solution Xcas

Nous avons calculé ci-dessous successivementn∑

k=1

k,n∑

k=1

k2,n∑

k=1

k3,n∑

k=1

k4,n∑

k=1

k5,n∑

k=1

k10,n∑

k=1

k20. Les for-

mules obtenues doivent être considérées comme démontrées 2. Le calcul den∑

k=1

k50, trop long, a été aban-

donné. La première formule est en général connue. La deuxième et la troisième sont un peu moins connues.Elles peuvent toutes être démontrées à la main par récurrence, à condition de deviner la formule de récur-rence !

2. Ceux qui douteraient pourraient utiliser les formules données ci-dessus par Xcas pour faire une démonstration par récur-rence dans les règles de l’art. Ce serait facile car le plus difficile est justement de deviner la relation de récurrence.

168

1 factor(simplify(sum(n,n,1,n)));n : recursive definition

n(n+ 1)

22 factor(simplify(sum(n^2,n,1,n)))n : recursive definition

n(n+ 1)(2 · n+ 1)

63 factor(simplify(sum(n^3,n,1,n)))n : recursive definition

n2 (n+ 1)2

44 factor(simplify(sum(n^4,n,1,n)))n : recursive definition

n(n+ 1)(2 · n+ 1)(3n2 + 3 · n− 1)

305 factor(simplify(sum(n^5,n,1,n)))n : recursive definition

n2 (n+ 1)2 (2n2 + 2 · n− 1)

126 factor(simplify(sum(n^10,n,1,n)))n : recursive definitionEvaluation time : 0.45

n(n+ 1)(2 · n+ 1)(n2 + n− 1)(3n6 + 9n5 + 2n4 − 11n3 + 3n2 + 10 · n− 5)

667 factor(simplify(sum(n^20,n,1,n)))n : recursive definitionEvaluation time : 31.64

n(n+ 1)

6930(2 · n+ 1)(165n18 + 1485n17 + 3465n16 − 5940n15 − 25740n14 + 41580n13 + 163680n12

− 266310n11 − 801570n10 + 1335510n9 + 2806470n8 − 4877460n7 − 6362660n6 + 11982720n5

+ 7591150n4 − 17378085n3 − 1540967n2 + 11000493 · n− 3666831)

169

10.8 [**] Test d’isocélité et d’équilatéralité d’un triangle *

Écrire un script scilab et un script Xcas qui indiquent si un triangle donné estéquilatéral, isocèle (sans être équilatéral) ou quelconque (c’est à dire non-isocèle).

Mots-clefs : Test « == », test conditionnel.

Tester si un triangle ABC donné est isocèle ou équilatéral revient à comparer les longueurs de ses côtés.On a donc à tester plusieurs fois l’égalité de deux nombres.Script scilabLe script scilab ci-dessous permet de saisir les coordonnées des sommets de ABC, calcule les carrés deslongueurs AB, BC et CA notés x, y et z et teste de deux façons l’égalité de ces longueurs.• Comparer les carrés des longueurs des côtés permet d’éviter le calcul de racines carrées, qui induirait denouvelles approximations.• Le premier test serait impeccable si scilab était capable de calculer ces longueurs exactement. Comme cen’est pas le cas, il se trompe quand on l’applique aux points A = [−23/15, − 36/35], B = [13/15,76/35] etC = [−89/15,− 167/35] (parce que ABC est un triangle isocèle).• Le deuxième test considère que x = y si |x − y|/(x + y) est < %eps (et de même pour les autres couplesde côtés), autrement dit si le nombre |x− y|/(x+ y) est considéré comme nul par scilab, ce qui ne veut pasdire qu’il est effectivement nul.• %eps est très petit : c’est en effet le plus petit nombre > 0 reconnu par scilab.• %eps=2.220446049D-16, voir un manuel.�A=input ( ”Coordonnees␣de␣A␣=␣” ) ; // sous l a forme [ ab s c i s s e , ordonnee ]B=input ( ”Coordonnees␣de␣B␣=␣” ) ; // idemC=input ( ”Coordonnees␣de␣C␣=␣” ) ; // idemx=(B(1)−A(1))^2+(B(2)−A(2 ) )^2 ; // x=AB^2y=(C(1)−A(1))^2+(C(2)−A(2 ) )^2 ; //y=AC^2z=(C(1)−B(1))^2+(C(2)−B(2 ) ) ^2 ; // z=BC^2// Test ne prenant pas en compte l e s t r onca tu r e s de r e e l si f x==y & y==z then

disp ( ”ABC␣ e s t ␣ e q u i l a t e r a l ” )e l s e i f x==y | y==z | z==x then

disp ( ”ABC␣ e s t ␣ i s o c e l e ” )else

disp ( ”ABC␣n ’ ’ e s t ␣ n i ␣ e qu i l a t e r a l , ␣ n i ␣ i s o c e l e ” )end// Test tenant compte des t ronca tu re s de r e e l s e t de %epsi f abs (x−y )/( x+y)<%eps & abs (y−z )/ ( y+z)<%eps then

disp ( ”ABC␣ e s t ␣ e q u i l a t e r a l ” )e l s e i f abs (x−y )/( x+y)<%eps | abs (y−z )/ ( y+z)<%eps | abs ( z−x )/ ( z+x)<%eps then

disp ( ”ABC␣ e s t ␣ i s o c e l e ” )else

disp ( ”ABC␣n ’ ’ e s t ␣ n i ␣ e qu i l a t e r a l , ␣ n i ␣ i s o c e l e ” )end� �

Voici ce que répond scilab pour le triangle ABC défini ci-dessus ://Test d'isocelite et d'equilateralite d'un triangle ABC-->A=input("Coordonnees de A = ");

170

Coordonnees de A = [-23/15,-36/35]-->B=input("Coordonnees de B = ");// idemCoordonnees de B = [13/15,76/35]-->C=input("Coordonnees de C = ");// idemCoordonnees de C = [-89/15,167/35]-->// Test ne prenant pas en compte les troncatures de reelsABC n'est ni equilateral, ni isocele

-->// Test tenant compte des troncatures de reels et de %epsABC est isocele

La réponse du premier test est fausse, la réponse du second test est exacte mais à prendre avec réserve parceque l’égalité des longueurs est testée de manière approximative.Script XcasNatureDuTriangle( a,b,c,d,f,g):={// a,b,c,d,f,g signifie x_A,y_A,x_B,y_B,x_C,y_Clocal u,v,w;u:=(a-c)^2+(b-d)^2;v:=(c-f)^2+(d-g)^2;w:=(f-a)^2+(g-b)^2;if simplify(u)==simplify(v) and simplify(v)==simplify(w) then

afficher("Ce triangle est \'{e}quilat\'{e}ral");elif simplify(u)==simplify(v)orsimplify(v)==simplify(w)or

simplify(w)==simplify(u)thenafficher("Ce triangle est isocele");

elseafficher("Ce triangle n'est ni equilateral, ni isocele");

endreturn simplify(u),simplify(v),simplify(w);}:;

// Parsing NatureDuTriangle// Success compiling NatureDuTriangle

Done

2 NatureDuTriangle(-23/15,-36/35,13/15,76/35,-89/15,167/35)Ce triangle est isocèle

16, 53, 53

3 NatureDuTriangle(evalf(-23/15,-36/35,13/15,76/35,-89/15,167/35))Ce triangle est isocèle

16.000000, 53.000000, 53.000000

Dans ce calcul, les coordonnées rationnelles des points A, B et C ont tout de suite été transformées ennombres réels. Il en résulte que Xcas a travaillé en nombres réels mais répond correctement.4 NatureDuTriangle(-1/2,2/3,9/10,77/15,-24/5,-7/8*17^(1/7))Ce triangle n’est ni équilatéral, ni isocèle

986

45,11025

(17

17

)2+ 129360 · 17

17 + 847312

14400,11025

(17

17

)2+ 16800 · 17

17 + 272656

14400

La réponse est exacte. Pour s’en convaincre, voir l’essai suivant.

171

5 NatureDuTriangle(evalf(-1/2,2/3,9/10,77/15,-24/5,-7/8*17^(1/7)))Ce triangle n’est ni équilatéral, ni isocèle

21.911111, 74.026584, 22.403361

Dans ce calcul, les coordonnées rationnelles des points A, B et C ont tout de suite été transformées ennombres réels. Xcas a travaillé en nombres réels. On constate que les 3 longueurs sont différentes.

6 NatureDuTriangle(4,3,6,5,5-sqrt(3),4+sqrt(3))Ce triangle est équilatéral

8, 8, 8

Xcas n’a pas transformé√3 en nombre réel. Il a calculé formellement. Le résultat est exact et est exprimé

en nombres entiers.7 NatureDuTriangle(evalf(4,3,6,5,5-sqrt(3),4+sqrt(3)))Ce triangle est équilatéral

8.000000, 8.000000, 8.000000

On a obligé à travailler Xcas en nombres réels. Le résultat est exact et est exprimé en nombres réels.

172

10.9 [***] Sommes d’inverses *

On calcule sn = 1 +1

2+ · · ·+ 1

npour des valeurs croissantes de n.

1 - Pour quelle valeur de n scilab cesse-t-il de donner un résultat exact ?2 - Même question pour Xcas.

Mots-clefs : calcul exact, calcul approché, calcul en nombres rationnels, notation scientifique standard.

Solution scilabscilab considérant par défaut tous les nombres comme des réels, le résultat retourné n’est pas exact dèsn = 3, mais approché, exprimé comme un nombre décimal (de 16 signes dont le + qui n’apparaît pas, cf. lacommande format(16)), à cause du 1

3 · Ci-dessous, on a calculé sn pour n valant 10, 102, …, 106 à l’aide del’algorithme :�function y=SomInv (n)

y=0 ;for j=1 :n

y=y+1/ j ;end

endfunction ;S= [ ] ;format ( 1 6 ) ;for j=1 :6

S=[S , SomInv(10^ j ) ] ;enddisp (S)� �

scilab a retourné les résultats suivants :

column 1 to 4

2.9289682539683 5.1873775176396 7.4854708605503 9.7876060360443

column 5 to 6

12.090146129863 14.392726722865

Solution Xcas

Dans le programme Xcas qui suit, f(n) désigne la somme 1 +1

2+ · · ·+ 1

n·

1f(n):={local j,s;s:=0;pour j de 1 jusque n faires:=s+1/j;fpour;retourne s;}:;

173

// Parsing f// Success compiling f

DoneNous avons calculé successivement f(100), f(1000), f(10000) et f(100000). On obtient des résultats exactssous forme de fraction (sauf f(100000) qui n’a pas pu être affiché) dont on a demandé une évaluation (àl’aide de la commande evalf).

2 s100:=f(100)

14466636279520351160221518043104131447711

2788815009188499086581352357412492142272

3 evalf(s100)

5.1873775176396202

4 s1000:=f(1000)

Xcas retourne une fraction s1000 dont le numérateur est53362913282294785045591045624042980409652472280384260097101349248456268889497101757506097901985035691409088731550468098378442172117885009464302344326566022502100278425632852081405544941210442510142672770294774712708917963967779610453224692426866468888281582071984897105110796873249319155529397017508931564519976085734473014183284011724412280649074307703736683170055800293659235088589360235285852808160759574737836655413175508131522517et le dénominateur est71288652746650930531663841557142729206683588618858930404520019911543240875811114994764441519138715869117178170195752565129802640676210092514658710043051310726862681432001966099748627459371883437050154344525237397452989631456749821282369562328237940110688092623177088619795407912477545580493264757378299233527517967352480424636380511370343312147817468508784534856780218880753732499219956720569320290993908916874876726979509316035200005 evalf(s1000)

7.4854708605503451

6 s10000:=f(10000)Evaluation time : 1.18

Integer too large for displayInteger too large for display

7 evalf(s10000)

(10.9.1) 9.7876060360443820

8 s10000:=f(100000)Evaluation time : 91.91

Integer too large for displayInteger too large for display

174

9 evalf(s100000)

(10.9.2) s100000

On constate que• - Pour n = 10000, la valeur exacte de la somme est calculée mais ne s’affiche pas ; une valeur approchéeest donnée sous forme décimale. On pourrait demander plus de décimales.• - Pour n = 100000, la valeur exacte de la somme est calculée mais ne s’affiche pas ; Xcas ne donne pas nonplus de valeur approchée.

• - Il est difficile d’après ces tests numériques d’imaginer que sn −−−−→n→+∞

+∞ !

• - scilab est meilleur ici que Xcas. Il donne des valeurs approchées des termes de rang 10000, 100000 et1000000 de la suite (f(n), n ⩾ 1).• - Quand on étudie la convergence d’une suite numérique avec très peu de connaissances mathématiques,une idée naturelle est de calculer ses premiers termes et de voir si on peut conjecturer le comportementasymptotique de ladite suite. On voit qu’ici ça ne marche pas du tout. Après avoir ajouté les inverses desentiers de 1 à 106, on obtient moins de 15. Difficile d’imaginer que la suite tend vers +∞.• - à noter (en exécutant soi-même l’algorithme) la rapidité des calculs de scilab.• - Un peu de réflexion montre que la contre-performance de « Xcas » est due au fait que le calcul a étéfait en nombres rationnels. Si on supprime cette contrainte, quitte à perdre l’exactitude des résultats, onretrouve des performances comparables à celles de scilab. Il suffit d’utiliser la commande evalf :1

f(n):={local j,s;s:=0;pour j de 1 jusque n faires:=evalf(s+1/j);fpour;retourne s;}:;

// Parsing f// Success compiling f

Done

2 f(1000000)Evaluation time : 16.24

0.14392726722865995e2

La réponse a été donnée en notation scientifique standard. Il s’agit de 14,392726722865995 sous formedécimale.

175

10.10 [****] Table ronde *

Quelle est la probabilité p pour que n couples placés au hasard autour d’une tableronde soient tous séparés ?

Mots-clefs : très grands nombres entiers.

• On considérera que deux configurations sont identiques quand chacune des 2n personnes a le mêmevoisin à droite et le même voisin à gauche. Il s’agit des configurations qui se déduisent l’une de l’autre parune rotation autour de la table ronde.• Ce difficile problème de combinatoire connu comme « le problème des ménages » a reçu une solution ainsique des problèmes voisins comme « Quelle est la probabilité pour que les sexes soient alternés quand onplace n couples au hasard autour d’une table ronde (à couples séparés ou non ? ».• Nous allons tenter une solution triviale qui consiste à écrire toutes les configurations possibles et à comptercelles qui ne séparent pas tous les couples.• Appelons les participants 1, −1, 2, −2, . . . , n, −n. Nous verrons plus loin l’intérêt de ce codage.• Pour fabriquer toutes les configurations possibles, nous commencerons toujours par placer 1 devant unechaise donnée, puis nous placerons les 2n − 1 personnes restantes en tournant autour de la table, dans lesens direct par exemple. Cela montre que le nombre total de configurations est N = (2n − 1) ! (c’est unnombre d’arrangements).• Bien sûr, ces configurations sont équiprobables puisque les personnes sont placées au hasard autour de latable. C’est pourquoi ce problème est un problème de combinatoire.Solution scilab• Dans l’algorithme scilab ci-dessous, nous partons de la suite 2, . . . , n, −n, . . . , −1 dont nous écrivonstoutes les permutations à l’aide de la commande « perms », puis nous écrivons toutes les configurationspossibles en ajoutant à gauche une colonne de 1, etc.�n=input ( ’n=’ ) ;stacksize ( ’max ’ ) ;Assemblee=[2 :n,−n :−1] ;N=f a c t o r i e l l e (2*n−1) ;A=[ones (N, 1 ) , perms ( Assemblee ) ] ; // Perms( Assemblee ) e s t une matrice a N// l i g n e s e t 2n−1 co lonnes .B=[A( : ,2 :2*n ) , ones (N, 1 ) ] ;C=A+B; // Si une l i g n e de C con t i en t un zero , un coup le de l a// con f i g u r a t i on concernee n ’ e s t pas separe .compteur=0 ;for i=1 :N

i f prod (C( i , :))==0 thencompteur=compteur+1 ;

end ;end ;p=1−compteur/N;a f f i c h e r ( ”La␣ p r o b ab i l i t e ␣pour␣que␣ l e s ␣”+string (n)+”␣ coup l e s ␣ s o i e n ts epa r e s ␣ e s t ␣ ega l e ␣a␣”+string (p ) ) ;� �

Cet algorithme est correct mais ne pourra s’appliquer qu’à de petites valeurs de n car il nécessiteénormément de calcul puisqu’il utilise N boucles « pour » contenant un test.

176

n 1 2 3 4 5 6N 1 6 120 5040 362880 39916800p 0 1/3 0.267 0.295 0.310 ?

177

Chapitre 11

Plus de scilab

Liste des exercices :

Énoncé no 11.1 : [****] Crible d’ératosthène (scilab et Xcas).Énoncé no 11.2 : [*] n est-il premier ? (suite de l’exercice 11.1)Énoncé no 11.3 : [**] Nombre premier suivant (suite de l’exercice 11.1).Énoncé no 11.4 : [**] Factorisation en nombres premiers (suite de l’exercice 11.1).Énoncé no 11.5 : [***] Peut-on faire l’appoint ?Énoncé no 11.6 : [***] Records.Énoncé no 11.7 : [***] Un problème d’arithmétique : les citrons.

178

11.1 [****] Crible d’Ératosthène avec scilab et Xcas

On demande une fonction scilab qui, à tout nombre entier n ⩾ 2 associe la liste des nombrespremiers qui lui sont inférieurs ou égaux, rangés dans l’ordre croissant.

Mots-clefs : boucles tant que, commandes taille, pmodulo, find, reste, liste_premiers ou primes,A($).

Cet exercice (et quelques exercices suivants) concerne les nombres premiers, plus généralement l’arithmé-tique. C’est une branche extraordinaire des mathématiques qui impose des calculs en nombres premiers. Lesnombres premiers, concernés par le crible d’Ératosthène, restent assez mystérieux. Par exemple, si on lesnote p1 = 2, p2 = 3, p3, …, il n’existe pas de formule qui, étant donné n, permette de calculer pn.Solution no 1 : la commande liste_premiers(n) (n spécifié, ⩾ 2) fournit en sortie la liste des nombrespremiers compris au sens large entre 2 et n et répond donc exactement au problème posé. C’est une com-mande de scilab pour les lycées. Elle est identique à la commande primes de scilab. L’argument de cescommandes ne peut pas être trop grand. Sinon, scilab envoie le message d’erreur : Taille de la piledépassée.Exemples : pour n = 100,�−−>l i s t e_pr em i e r s (100)ans =

column 1 to 112 . 3 . 5 . 7 . 11 . 13 . 17 . 19 . 23 . 29 . 31 .

column 12 to 2137 . 41 . 43 . 47 . 53 . 59 . 61 . 67 . 71 . 73 .

column 22 to 2579 . 83 . 89 . 97 .

−−>� �On voit qu’il y a 25 nombres premiers entre 2 et 100 et que p25 = 97. Pour n = 107, puis n = 108 :�−−>clear−−>primes (10000000) ;−−>s ize (ans , ’ c ’ )ans =

664579.−−>clear ; stacksize ( ’max ’ ) ; primes (100000000) ;!−−error 17

Ta i l l e de l a p i l e depasseeU t i l i s e z l a f on c t i on stacksize pour l ’ augmenter .Memoire u t i l i s e e pour l e s v a r i a b l e s : 100009787Memoire i n t e rmed i a i r e r e qu i s e : 200000006Memoire t o t a l e d i s p on i b l e : 268435455at l i n e 31 o f function primes c a l l e d by :clear ; stacksize ( ’max ’ ) ; primes (100000000) ;−−>� �On lit qu’il y a 664579 nombres premiers inférieurs ou égaux à 107.Solution no 2 : crible d’Ératosthène À la main, lorsque n est petit, on détermine habituellement cetteliste à l’aide du crible d’Ératosthène 1. Tant que n n’est pas trop grand, on pourra utiliser la fonction

1. Le crible d’Ératosthène supposé connu.

179

Erato.sci ci-dessous dont l’algorithme est explicite mais qui est moins rapide que liste_premiers(n),comme on le constatera plus tard.Le crible d’Ératosthène est typiquement un algorithme.Objet du crible d’Ératosthène : le crible d’Ératosthène associe à tout entier n supérieur ou égal à 2 la listedes nombres premiers inférieurs ou égaux à n.Description du crible d’Ératosthène : il consiste en un certain nombre de passages au crible, nombre contrôlépar une boucle tant que.• A désignant la liste des entiers de 2 à n, on pose k = 1.• Début de la boucle : Si A(k)2 ⩽ A($) et tant que cette inégalité reste vraie, on efface de A les multiplesstricts de A(k) (il y en a au moins un, à savoir A(k)2). On continue d’appeler A la liste ainsi obtenue, onremplace k par k + 1 et on revient au début de la boucle.• Fin de la boucle• Si B désigne l’état final de A, B est la liste des nombres premiers ⩽ n.Justification : On sait que B(1) = 2 est premier. De plus, si l’on a démontré que B(1), B(2), . . . , B(k − 1)sont des nombres premiers, ce sont les seuls nombres premiers < B(k) parce que tout nombre qui a étéeffacé est un multiple, donc n’est pas premier. Si B(k) n’était pas premier 2, il serait un multiple de l’un desnombres B(1), B(2), . . . , B(k− 1), ce qui est absurde car il aurait été effacé. Le même raisonnement montreque le premier multiple de B(k) qui ne peut pas avoir été effacé est B(k)2. Par conséquent, on peut arrêterla boucle si B(k)2 > A($) car on n’effacera plus rien. Finalement, B est bien la liste des nombres premiers⩽ n.La fonction téléchargeable Erato.sci ci-dessous reproduit exactement ce crible.Remarques sur le script :• Pour repérer la liste I des rangs des multiples d’un entier a dans une liste d’entiers L, on utilise la commandefind et la commande pmodulo, ligne 5.• La commande pmodulo est une commande de scilab qui contrairement à reste admet un vecteur d’entierscomme premier argument. reste est une commande de scilab pour les lycées.• On efface les termes de L dont le rang appartient à I à l’aide de la commande L(I)=[ ] (ligne 10).

Listing 11.1 – Erato.sci�function A=Erato (n)A=2 :n ; // n en t i e r >=2.k=1 ;// k compte l e s nombres premiers decouver t s .while A(k)^2<=A($ )

I=find (pmodulo(A(k+1 : t a i l l e (A) ) ,A(k))==0) ;// On repere l e s mu l t i p l e s de A( k ) apres A( k ) .A(k+I )= [ ] ; // On a e f f a c e l e s mu l t i p l e s de A( k ) .k=k+1 ;

end ;endfunction� �On s’attend bien sûr à ce que liste_premiers soit plus rapide que Erato.sci (et s’applique à des entiersn plus grands). Calculons le temps de calcul de la liste des nombres premiers ⩽ 106 à l’aide de Erato.sci,puis à l’aide de liste_premiers :�−−>clear−−>exec ( ’Chemin␣de␣Erato . s c i ’ , −1)−−>t i c ( ) ;A=Erato (1000000) ; temps=toc ( ) ; a f f i c h e r ( temps ) ;

2 .612−−>t i c ( ) ;A=l i s t e_pr em i e r s (1000000) ; temps=toc ( ) ; a f f i c h e r ( temps ) ;

2. Tout entier ⩾ 2 est soit premier, soit divisible par un nombre premier strictement plus petit que lui.

180

0 .122−−>� �Le plus grand nombre premier ⩽ 106 est :�−−>A($ )ans =

999983.−−>� �Si l’on tente n = 107, il faut augmenter la taille de la mémoire affectée au calcul quand on se sert de lafonction Erato.sci ou de la commande primes :�−−>clear−−>exec ( ’Chemin␣de␣Erato . s c i ’ , −1)−−>stacksize ( ’max ’ ) ; t i c ( ) ;A=Erato (10000000) ; temps=toc ( ) ; a f f i c h e r ( temps ) ;

62 .529−−>clear−−>t i c ( ) ;A=l i s t e_pr em i e r s (10000000) ; temps=toc ( ) ; a f f i c h e r ( temps ) ;

1 .279−−>� �On obtient aussi :�−−>t a i l l e (A)ans =

664579.−−>A($ )ans =

9999991.−−>� �On constate que le crible d’Ératosthène a établi la liste des nombres premiers inférieurs à 107 en 63 secondes,la commande liste_premiers en 1.3 secondes. Il y a 664579 nombres premiers ⩽ 107. Le plus grand estp664579 = 9999991.La conclusion attendue est qu’il vaut lieux utiliser la commande liste_premiers ou la commande primes !Notes diversesOn sait qu’il y a une infinité de nombres premiers, depuis longtemps, voir les Élements d’Euclide ([18]). Cesnombres deviennent très vite difficiles à calculer. Le 25 janvier 2013, le plus grand nombre premier connuétait p = 257 885 161 − 1, qui s’écrit avec 17 425 170 chiffres. L’exposant 57 885 161 est lui-même un nombrepremier (voir l’exercice 11.2), si bien que p est un nombre de Mersenne (les nombres premiers records sontsouvent des nombres de Mersenne).Établir qu’un nombre est premier nécessitait autrefois de nombreuses divisions à la main. Les progrès sontvenus de l’utilisation de machines : calculatrices mécaniques, ordinateurs et enfin réseaux d’ordinateurs.Solution no3, avec XcasNous ne détaillerons pas cette solution qui consiste en une fonction-Xcas appelée encore Erato qui est testéeci-dessous pour calculer la liste des nombres premiers de 2 à n, n prenant successivement les valeurs 102,103, 104, 105 106 et 107. Elle n’a pas pu venir à bout du cas n = 108. La fonction crible de [8], qui a lemême rôle, paraît moins bonne qu’Erato.1

Erato(n):={local A,j,k,t,a,B,x;

181

A:=[j$(j=2..n)];k:=0;t:=length(A)-1;while(A[k]^2<=A[t]){a:=A[k];B:=A[(k+1)..t];B:=remove(x->(irem(x,a)==0),B);A:=concat(A[0..k],B);k:=k+1;t:=length(A)-1;}return A;}:;

// Warning : a, declared as global variable(s)// Parsing Erato// Success compiling Erato

Done

2 P100:=Erato(100);

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

3 P1000:=Erato(1000);

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,

131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,

257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389,

397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541,

547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677,

683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839,

853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]

4 P10000:=Erato(10000);

Done

5 P100000:=Erato(100000);Evaluation time : 6.43

Done6 l:=length(P100000);P100000[l-1];

9592, 99991

7 P1000000:=Erato(1000000);Evaluation time : 126.29

Done

182

8 r:=length(P1000000);P1000000[r-1];

78498, 999983

9 P10000000:=Erato(10000000);Evaluation time : 2682.93

Done10 s:=length(P10000000);P10000000[s-1];

664579, 9999991

11

//renvoie la liste des nombres premiers<=n selon eratosthenecrible(n):={local tab,prem,p,j;//on ecrit dans trab la liste des entiers de 0 a ntab:=makelist(x->x,0,n);//1 n’est pas premier donc on met 0 ds tab[1]tab[1]:=0;p:=2;//on barre les multiples de p qui sont compris entre p*p et n//en mettant 0 dans la case correspondantetantque (p*p<=n) faire

pour j de p*p jusque n pas p fairetab[j]:=0;

fpour;p:=p+1;//on cherche le premier element non barre dans tabtantque ((p*p<=n) et (tab[p]==0)) fairep:=p+1;

ftantque;ftantque;//on remplit la liste prem avec les elements non nuls de tabprem:=[];pour j de 2 jusque n faire

si (tab[j]!=0) alorsprem:=append(prem,j);

fsi11fpourretourne(prem);

}:;

// SuccessWarning, step is not numeric p// Parsing crible// Warning : x, declared as global variable(s) compiling crible

Done

183

12 C100:=crible(100);

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

13 C1000:=crible(1000);

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,

131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251,

257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389,

397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541,

547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677,

683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839,

853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]

14 C10000:=crible(10000);Evaluation time : 6.22

Done

15 C100000:=crible(100000);Evaluation time : 676.56

Done16 l1:=length(C100000);C100000[l1-1];

9592, 99991

17

184

11.2 [*] Test de primalité (suite de l’exercice no 11.1)

Étant donné un entier n ⩾ 2, en utilisant la fonction Erato.sci de l’exercice 11.1 ou la com-mande liste_premiers, fabriquer un algorithme qui répond si n est ou non un nombre premier.

Mots-clefs : commande liste_premiers.

C’est assez évident. Voici un script solution basé sur la remarque : si n est le dernier terme de la liste desnombres premiers ⩽ n, alors n est premier et réciproquement.�n=input ( ’n=’ ) ;A=l i s t e_pr em i e r s (n ) ;i f n==A($ ) then

a f f i c h e r (+string (n)+ ’ ␣ e s t ␣un␣nombre␣ premier . ’ ) ;else

a f f i c h e r (+string (n)+ ’ ␣n ’ ’ e s t ␣pas␣un␣nombre␣ premier . ’ ) ;end� �Ce script étant chargé dans la console, en voici deux exécutions :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=1234567912345679 n ’ e s t pas un nombre premier .

−−>� �puis�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n=5788516157885161 e s t un nombre premier .

−−>� �Cela confirme que le nombre p = 257 885 161 − 1 de l’exercice 11.1 est bien un nombre de Mersenne.Tester si un nombre est premier ou non s’appelle tester sa primalité. Il y a d’autres tests de primalité, voir[18], le but étant de faire le moins de calculs possible.

185

11.3 [**] Nombre premier suivant (suite de l’exercice no 11.1)

1 - Fabriquer un algorithme qui associe à tout entier n ⩾ 2 le plus petit nombre premierPn qui lui est strictement supérieur.2 - Quel est le premier nombre premier qui suit 10 000 000 ?

Mots-clefs : commande liste_premiers, boucle tant que, find, extraction d’un sous-vecteur, effacementde composantes dans un vecteur.

Solution no 1 :1 - On peut s’appuyer sur la commande liste_premiers ou, à la rigueur, sur la fonction Erato.sci del’exercice 11.1. La commande liste_premiers(k) retourne la liste des nombres premiers compris entre 2et k (au sens large). Il suffit donc de donner à k les valeurs n, n+1, etc jusqu’à ce que la longueur de la listedes nombres premiers augmente de 1. Alors, on sait que le dernier nombre de la liste est le nombre premiersuivant.

�n=input ( ’n=’ ) ;t i c ( ) ;stacksize ( ’max ’ ) ;A=l i s t e_pr em i e r s (n ) ;r=t a i l l e (A) ;p=A($ ) ; // p : p l u s grand nombre premier <=n .q=n+1 ;B=l i s t e_pr em i e r s ( q )s=t a i l l e (B) ;while r==s

q=q+1 ;B=l i s t e_pr em i e r s ( q ) ;s=t a i l l e (B) ;

end ;temps=toc ( ) ;a f f i c h e r ( ’ Le␣ p lus ␣grand␣ e n t i e r ␣ i n f e r i e u r ␣ou␣ ega l ␣a␣ ’+string (n ) ) ;a f f i c h e r ( ’ e s t ␣ ’+string (p ) ) ;a f f i c h e r ( ’ Son␣ rang␣dans␣ l a ␣ l i s t e ␣des ␣nombres␣ premiers ␣ e s t ␣ ’+string ( r ) ) ;a f f i c h e r ( ’ Le␣ p lus ␣ p e t i t ␣nombre␣ premier ␣>n␣ e s t ␣ ’+string ( q ) ) ;a f f i c h e r ( ’ Le␣ c a l c u l ␣a␣dure␣ ’+string ( temps ) ) ;a f f i c h e r ( ’ secondes . ’ ) ;� �Ce script exécute la commande liste_premiers (q-n+1) fois, nombre qui conditionne fortement le tempsde calcul, voir la question no 2.2 - Exécutons ce script pour n=10 000 000 :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)n= 10000000Le p lus grand e n t i e r i n f \ ’ {e} r i e u r ␣ou␣\ ’ {e} ga l \ ‘{ a} 10000000e s t 9999991Son rang dans l a l i s t e des nombres premiers e s t 664579Le p lus p e t i t nombre premier >n e s t 10000019Le c a l c u l a dur\ ’ {e}␣ 25 .781

␣ secondes .

186

−−>� �Le premier nombre premier après 10 000 000 est donc 10000019. C’est le 664 580ème nombre premier.La commande liste_premiers a fonctionné 20 fois. Quand on calcule le premier nombre premier après20 000 000, elle n’intervient que 4 fois, ce qui fait que le temps de calcul est plus court. On s’attend àce que dans les cas usuels, la commande liste_premiers soit peu utilisée (car les nombres premiers sontnombreux). C’est un avantage de ce script.

�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)Le p lus grand e n t i e r i n f e r i e u r ou ega l a 20000000e s t 19999999Son rang dans l a l i s t e des nombres premiers e s t 1270607Le p lus p e t i t nombre premier >n e s t 20000003Le c a l c u l a dure 10 .778secondes .

−−>� �On aurait pu répondre à la question no 1 à l’aide de la fonction nps.sci suivante qui, pour l’entrée n,retourne le plus petit nombre premier strictement plus grand que n.

�function q=nps (n)

A=l i s t e_pr em i e r s (n ) ;r=t a i l l e (A) ;q=n+1 ;B=l i s t e_pr em i e r s ( q )s=t a i l l e (B) ;while r==s

q=q+1 ;B=l i s t e_pr em i e r s ( q ) ;s=t a i l l e (B) ;

end ;endfunction� �Utilisons nps.sci pour calculer le premier nombre entier après 50 000 000 :�−−>exec ( ’ chemin␣de␣nps . s c i ’ , −1)−−>nps (50000000)ans =

50000017.−−>� �Le calcul est long.Solution no 2 : Le problème est de savoir où chercher le premier nombre premier après n. D’après unthéorème de P. Tchebyschev (1850, [18]), pour tout entier n ⩾ 2, il existe au moins un nombre premier ptel que n < p < 2n. Il suffit donc d’exécuter la commande liste_premiers(2*n-1) et d’extraire le nombrerecherché dans la liste obtenue, ce qui est facile. Malheureusement, si par exemple n = 50000000, il faudracalculer la liste des nombres premiers ⩽ 99999999, trop grand nombre qui provoque un message d’erreurpour dépassement de capacité. La deuxième solution paraît donc meilleure mais elle ne l’est pas. Voici lescript correspondant :

187

�clear ;stacksize ( ’max ’ ) ;n=input ( ’n=’ ) ; //n en t i e r super i eur ou e ga l a 2 .L=l i s t e_pr em i e r s (2*n−1) ;A=find (L>n ) ;L=L(A) ;p=min(L ) ;a f f i c h e r ( ’ Le␣ p lus ␣ p e t i t ␣nombre␣ premier ␣>n␣ e s t ␣ ’+string (p ) ) ;� �

188

11.4 [**] Factorisation en nombres premiers (suite de l’exercice no 11.1)

Fabriquer un algorithme qui à tout entier n ⩾ 2 associe la suite de ses facteurs premiers et lasuite de leurs puissances respectives.

Mots-clefs : commandes liste_premiers, find, extraction d’un sous-vecteur, effacement de composantesdans un vecteur.

L’algorithme ci-dessous est très simple : on passe en revue la liste des nombres premiers ⩽ n obtenue à l’aidede la fonction Erato.sci (à charger dans la console) ou à l’aide de la commande liste_premiers, puis onregarde jusqu’à quelle puissance chacun d’eux divise n (si un nombre premier ne divise pas n, il le divise avecla puissance 0). On efface ces facteurs parasites avant d’obtenir le résultat définitif, qui est présenté sur laforme d’un tableau à 2 lignes, la première étant la ligne des facteurs, la seconde la ligne de leurs puissances.�// Charger l a f onc t i on Erato . s c i .function F=f a c t o r i s a t i o n (n)Facteurs=Erato (n ) ;Pu i s sances = [ ] ;for i=1 : t a i l l e ( Facteurs )

j =1 ;while r e s t e (n , Facteurs ( i )^ j )==0

j=j+1endPuis sances=[Puissances , j −1] ;

endK=find ( Pu i s sances==0) ;Facteurs (K)= [ ] ;Pu i s sances (K)= [ ] ;F=[Facteurs ; Pu i s sances ] ;endfunction� �Exemple : mettre 12345 sous la forme d’un produit de nombres premiers :On charge dans la console Erato.sci puis factorisation.sci (téléchargeable sur le site) et on saisit dansla console la commande ad hoc :�−−>clear−−>exec ( ’Chemin␣de␣Erato . s c i ’ , −1)−−>exec ( ’Chemin␣ d e f a c t o r i s a t i o n . s c i ’ , −1)−−>f a c t o r i s a t i o n (12345)ans =

3 . 5 . 823 .1 . 1 . 1 .

−−>� �La décomposition de 12345 en un produit (unique) de facteurs premiers est donc : 12345 = 3· 5· 823, ce quel’on peut vérifier à l’aide du script suivant (cette vérification est inutile mais amusante) :�m=prod (F( 1 , : ) . ^F ( 2 , : ) ) ;i f n==m then

a f f i c h e r ( ’Ce␣ r e s u l t a t ␣ e s t ␣ exact ’ )else

a f f i c h e r ( ’Ce␣ r e s u l t a t ␣ e s t ␣ faux ’ )

189

end� �Exécutons le script :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)Ce r e s u l t a t e s t exact−−>� �

190

11.5 [***] Peut-on faire l’appoint ?

Quelqu’un doit payer un achat. Le commerçant n’ayant pas de monnaie lui demande de fairel’appoint, c’est à dire de donner exactement la somme due. Est-ce que c’est possible ? Si oui,quelles pièces doit-il donner ?

Mots-clefs : pour la solution no 2, commandes find, diag, produit de 2 matrices, extraction de sous-matrices.

Solution no 1 : Les données sont décrites dans les commentaires de la fonction aptt.sci (téléchargeablesur le site) ci-dessous, solution de ce problème. C’est un algorithme trivial dans sa conception : on calculetoutes les sommes que l’on peut payer avec les pièces disponibles. Quand on rencontre la somme requise, onnote les pièces utilisées. aptt.sci retourne une matrice éventuellement vide dont chaque ligne décrit unesolution.�function s o l u t i o n s=aptt (p , a , b , c , d , e , f , g , h )// a , b , c , d , e , f , g , h de s i gnen t re spec t i v ement l e s//nombres de p i e c e s de 1 c , 2 c , 5 c , 10 c , 20 c , de 50 c , de 1 euro e t//de 2 euros d i s p o n i b l e s pour l ’ achat ( nombres e n t i e r s >=0) ; p des i gne// l e p r i x de l ’ achat ( en cent imes ) .s o l u t i o n s = [ ] ;for j a=0 :a

for jb=0 :bfor j c=0 :c

for jd=0 :dfor j e=0 :e

for j f =0 : ffor j g=0 :g

for jh=0 :hs=200* jh+100* jg+50* j f +20* j e+10* jd+5* j c+2*jb+ja ;i f s==p then

s o l u t i o n s =[ s o l u t i o n s ; [ ja , jb , jc , jd , je , j f , jg , jh ] ] ;end ;

end ;end ;

end ;end ;

end ;end ;

end ;end ;endfunction� �Voici une exécution de ce script :�−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ aptt . s c i ’ , −1)−−>aptt ( 12 , 0 , 6 , 2 , 0 , 2 , 3 , 1 , 0 )ans =

column 1 to 70 . 1 . 2 . 0 . 0 . 0 . 0 .0 . 6 . 0 . 0 . 0 . 0 . 0 .

column 8

191

0 .0 .

−−>� �Cela signifie qu’il y a 2 façons de payer un achat de 12 centimes. La première consiste à donner une piècede 2 centimes et 2 pièces de 5 centimes. Au contraire, avec les mêmes pièces, on ne peut pas payer un achatde 13 centimes :�−−>exec ( ’Chemin␣du␣ f i c h i e r ␣ aptt . s c i ’ , −1)−−>so l u t i o n s=aptt ( 13 , 0 , 3 , 2 , 0 , 2 , 3 , 1 , 0 )s o l u t i o n s =

[ ]−−>� �Pour payer 7,49 euros avec la répartition [a, b, c, d, e, f, g, h] = [3, 4, 5, 3, 7, 2, 8, 2], il y a trop de solutions.Dans le script ci-dessous, nous avons supprimé l’affichage des solutions ( ; à la fin de la ligne de commande)et demandé combien il y a de solutions. On en trouve 372 :�−−>so l u t i o n s=aptt ( 749 , 3 , 4 , 5 , 3 , 7 , 2 , 8 , 2 ) ;

−−>s ize ( s o l u t i on s , ” r ” )ans =

372 .−−>� �Solution no 2 : La fonction aptm.sci (téléchargeable sur le site) calcule aussi tous les paiements exactspossibles. L’algorithme repose sur du calcul matriciel.�function Sol=aptm(p , a , b , c , d , e , f , g , h )

E=[a , b , c , d , e , f , g , h ] ;// a , b , c , d , e , f , g , h de s i gnen t re spec t i vement l e s nombres de p i e c e s de//1 c , 2 c , 5 c , 10 c , 20 c , de 50 c , de 1 euro e t de 2 euros// d i s p o n i b l e s pour l ’ achat ( nombres e n t i e r s >=0) ; p des i gne l e p r i x//en c .

A=[0 :E ( 1 ) ] ’ ;for i =2 :8

B= [ ] ;r=s ize (A, ’ r ’ ) ;for j=0 :E( i )

C=[A, j *ones ( r , 1 ) ] ;B=[B;C ] ;

endA=B;

endva l=diag ( [ 1 , 2 , 5 , 1 0 , 2 0 , 5 0 , 1 0 0 , 2 0 0 ] ) ;sommes=sum(A*val , ” c ” ) ;l i g n e s s o l=find ( sommes==p*ones ( sommes ) ) ;So l=A( l i g n e s s o l , : )endfunction� �Cet algorithme est plus difficile que le premier mais n’est pas très bon. La matrice A a

(a+ 1)(b+ 1)(c+ 1)(d+ 1)(e+ 1)(f + 1)(g + 1)(h+ 1)

lignes et 8 colonnes. Le nombre de lignes de A peut être grand. Par exemple, dans le cas du paiement de 7,49euros avec la répartition [a, b, c, d, e, f, g, h] = [3, 4, 5, 3, 7, 2, 8, 2], il retourne un message de dépassement de

192

capacité, ce qui n’est pas étonnant car A a alors 311 040 lignes. Néanmoins, ça marche si on alloue davantaged’espace pour le calcul à l’aide de la commande stacksize('max').

193

11.6 [***] Records

Soit S une suite de nombres entiers. On appelle record de S son premier élément ainsi que toutterme de cette suite qui est strictement plus grand que tous les termes qui le précèdent.Le problème est de produire la liste des records de S à l’aide d’un algorithme.

Mots-clefs : Boucles tant que et pour, commande find, criblage.

La solution présentée ci-dessous est un criblage inspiré par le crible d’ératosthène (voir 11.1). On garde lepremier élément qui est par définition un record et on supprime tous les termes de S qui lui sont inférieursou égaux parce qu’ils ne peuvent pas être des records. Dans l’algorithme, ce nouvel état de S s’appelle encoreS. Si sa longueur est 1, on arrête : il y a un seul record. Si c’est au moins 2, son deuxième élément est unrecord. Si la longueur de S est exactement 2, on arrête : il y a 2 records. Sinon, on crible S de nouveauà partir du deuxième record, comme on l’a fait précédemment à partir du premier record. On réitère leprocédé si c’est nécessaire. On s’arrête quand le dernier record obtenu est le dernier terme de S qui est alorsla liste des records.�S=input ( ’S=’ ) ; // S e s t une l i s t e de nombres e n t i e r s .i =1 ;while i<t a i l l e (S)

J=find (S( i+1 : t a i l l e (S))<=S( i ) ) ;S ( i+J )= [ ] ;i=i +1 ;

enda f f i c h e r ( ’La␣ l i s t e ␣des ␣ r e co rd s ␣de␣S␣ e s t ␣ ’ ) ;a f f i c h e r (S ) ;� �Voici une exécution de cet algorithme : trouver la liste des records d’une suite de 1000 nombres entiersengendrée à l’aide de la commande tirage_entier(1000,-13,67) qui retourne 1000 nombres entiers tirésau hasard (suivant la loi uniforme) entre -13 et 67 :�−−>clear−−>exec ( ’Chemin␣du␣ f i c h i e r , ␣−1)S=t i r a g e_en t i e r (100 ,−13 ,67)␣La␣ l i s t e ␣ des ␣ r e co rd s ␣de␣S␣ e s t␣␣␣␣ 16 . ␣␣␣␣ 38 . ␣␣␣␣ 40 . ␣␣␣␣ 47 . ␣␣␣␣ 64 . ␣␣␣␣ 66 .−−>� �On constate que cette liste de 1000 nombres entiers ne comporte que 6 records (dans ce cas, le nombre derecords est au moins 1 et au plus 81 ; c’est un nombre aléatoire).Transformons cet algorithme en une fonction scilab que nous appellerons records.sci dont l’argument estune liste d’entiers L, cette fonction retournant le nombre de records de L :�function R=nbrec (L)

i =1 ;while i<t a i l l e (L)

J=find (L( i+1 : t a i l l e (L))<=L( i ) ) ;L( i+J )= [ ] ;i=i +1 ;

endR=t a i l l e (L ) ;

194

endfunction� �Application : calculons le nombre de records de 3 tirages au hasard de 100000 nombres entiers entre -13 et67 :�−−>clear−−>exec ( ’Chemin␣de␣ r e co rd s . s c i ’ , −1)−−>L=t i r a g e_en t i e r (100000 ,−13 ,67) ;−−>R=nbrec (L)R =

3 .−−>L=t i r a g e_en t i e r (100000 ,−13 ,67) ;−−>R=nbrec (L)R =

5 .−−>L=t i r a g e_en t i e r (100000 ,−13 ,67) ;−−>R=nbrec (L)R =

6 .� �La fonction records.sci est téléchargeable sur le site.

195

11.7 [***] Un problème d’arithmétique : les citrons

Une paysanne indienne va au marché en bicyclette pour vendre ses citrons. Un passant distraitla bouscule. Le panier de citrons est renversé. Le fautif entreprend de ramasser les citrons.Il demande à la paysanne : « combien y en avait-il ? »Elle lui répond : « en les rangeant par deux, il en reste un ; en les rangeant par trois, il en resteun ; en les rangeant par quatre, il en reste un ; en les rangeant par cinq, il en reste un ; en lesrangeant par six, il en reste un ; mais en les rangeant par sept, il n’en reste pas. »« C’est bon » lui dit le passant, « je les ai tous ramassés ».Sachant qu’il ne pouvait pas y avoir plus de 500 citrons dans le panier (ce qui fait environ 50kg), combien y en avait-il exactement ?

Mots-clefs : commandes string, ensemble, intersection, find, criblage, critères de divisibilité.

On est sûr que ce problème a au moins une solution. Le résoudre de manière algorithmique est contre-naturecar avec un peu d’arithmétique, il y a une solution rapide. Dans ce cas, l’algorithmique permet d’être à peuprès parfaitement ignorant.Solution algorithmique no 1 : On écrit la liste des nombres entiers de 1 à 500. On la transforme enensemble dont on prend l’intersection avec l’ensemble des nombres de 1 à 500 de la forme 2 ∗ p+1, 3 ∗ p+1,etc.�clear ;e1=i n t e r s e c t i o n ( ensemble ( string (1 : 2 : 500) ) , ensemble ( string ( 1 : 3 : 5 0 0 ) ) ) ;e2=i n t e r s e c t i o n ( ensemble ( string (1 : 4 : 500) ) , ensemble ( string ( 1 : 5 : 5 0 0 ) ) ) ;f 1=i n t e r s e c t i o n ( e1 , e2 ) ;f 2=i n t e r s e c t i o n ( f1 , ensemble ( string ( 1 : 6 : 5 0 0 ) ) ) ;g=i n t e r s e c t i o n ( f2 , ensemble ( string ( 7 : 7 : 5 0 0 ) ) ) ;a f f i c h e r ( ’L ’ ’ ensemble ␣des ␣ s o l u t i o n s ␣ p o s s i b l e s ␣ e s t ␣ ’ ) ;a f f i c h e r ( g ) ;� �Voici l’exécution de ce script :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)L ’ ensemble des s o l u t i o n s p o s s i b l e s e s t{301}

−−>� �Solution algorithmique no 2 : C’est la même que précédemment, en manipulant des vecteurs au lieud’ensembles. On écrit la liste des nombres entiers de 1 à 500 puis on garde ceux qui, diminués de 1, sontdivisibles par 2, etc. On passe donc ces nombres au crible. On ne manipule que des listes dans cette solution.�clearV1=1 :500 ;V2=V1( find ( (V1−1)−2* f loor ( (V1−1)/2)==0)) ;V3=V2( find ( (V2−1)−3* f loor ( (V2−1)/3)==0)) ;V4=V3( find ( (V3−1)−4* f loor ( (V3−1)/4)==0)) ;V5=V4( find ( (V4−1)−5* f loor ( (V4−1)/5)==0)) ;V6=V5( find ( (V5−1)−6* f loor ( (V5−1)/6)==0)) ;V=V6( find (V6−7* f loor (V6/7)==0)) ;a f f i c h e r ( ’La␣ l i s t e ␣des ␣ s o l u t i o n s ␣ p o s s i b l e s ␣ e s t ␣ ’ ) ;a f f i c h e r (V) ;� �

196

Voici l’exécution de ce script :�−−>exec ( ’Chemin␣du␣ s c r i p t ’ , −1)La l i s t e des s o l u t i o n s p o s s i b l e s e s t

301 .−−>� �Solution arithmétique : Un peu d’arithmétique nous dit que le (ou les nombres) recherché est de la forme60 ∗ p+1 et est divisible par 7. C’est donc celui (ou ceux) des nombres 61, 121, 181, 241, 301, 361, 421, 481,541 qui est divibible par 7, ce qui conduit à une solution unique : 301.

197

Bibliographie

[1] Aide en ligne Scilabhttp://help.scilab.org/docs/5.4.1/fr_FR/

[2] Michaël Baudin. Introduction à « Scilab », Jérôme Briot traducteur. Mis en ligne en mars 2013.http://scilab.developpez.com/tutoriels/introduction-scilab

[3] Alexandre Casamayou-Boucau, Pascal Chauvin, Guillaume Connan Programmation en Py-thon pour les mathématiques, 2ème édition, Dunod Éditeur (2016).https://irem.univ-lille1.fr/activites/spip.php?article264

[4] Flocons de Koch, activité pour la classe de Première Shttp://www.gradus-ad-mathematicam.fr/Premiere_Algorithmique1.htm

[5] Claude Gomez Le calcul numérique : pourquoi et comment ?http://www.scilab.org/fr/community/education/maths/doc

[6] Renée De Graeve, Bernard Parisse, B. Ycart Tutoriel « Xcas » : Démarrer en calcul formel,http://www-fourier.ujf-grenoble.fr/~parisse/giac/doc/fr/tutoriel/index.html

[7] Reneé De Graeve, et Bernard Parisse Tutoriel « Xcas » : « Xcas » au lycée,http://www-fourier.ujf-grenoble.fr/~parisse/giac/troussesurvie_fr.pdf

[8] Reneé De Graeve, et Bernard Parisse Correction avec Xcas du stage algorithmique de l’IREMde Grenoble, 17 janvier 2010, 7. Le crible d’Ératosthènehttp://www-fourier.ujf-grenoble.fr/~parisse/irem/Algocas.pdf

[9] Bernard Parisse et Renée De Graeve Giac/Xcas, version 1.1.2 (2014)http://www-fourier.ujf-grenoble.fr/~parisse/giac_fr.html

[10] Thomas Rey Pour commencer avec « Xcas »,http://reymarlioz.free.fr/spip.php?article150

[11] G. Sallet Initiation à scilab, agrégation de mathématiques, INRIA, Université de Metz, 2006-2007http://poncelet.sciences.univ-metz.fr/~sallet/Scilab_intro_agreg.pdf

[12] Scilab pour l’enseignement des mathématiques, 2ème édition, 2013http://www.scilab.org/fr/community/education/maths/doc

[13] Gérard Swinnen Apprendre à programmer avec Python 3, Eyrolles Éditeur, 3ème édition (2016)disponible en ligne :https://fr.m.wikibooks.org/wiki/Apprendre_à_programmer_avec_Python/Licence

[14] Wikipedia. American Standard for Information Interchangehttps://fr.wikipedia.org/wiki/American_Standard_Code_for_Information_Interchange

[15] Wikipedia Crible d’Ératosthènehttp://fr.wikipedia.org/wiki/Crible_d'Eratosthene

[16] Wikipedia Le tri à bulleshttps://fr.wikipedia.org/wiki/Tri_a_bulles

[17] Wikipedia Matrices de Toeplitzhttp://fr.wikipedia.org/wiki/Matrice_de_Toeplitz

198

[18] Wikipedia Nombre premierhttp://fr.wikipedia.org/wiki/Nombre_premier

199