Guide du calcul avec des logiciels libres : xcas,scilab,bc,gp,gnuplot,maxima, mupad

GUIDE DU CALCUL AVEC LES LOGICIELS LIBRES XCAS, Scilab, Bc, Gp, GnuPlot, Maxima, MuPAD

GUIDE DU CALCUL AVEC LES LOGICIELS LIBRES XCAS, Scilab, Bc, Gp, GnuPlot, Maxima, MuPAD

Guillaume Connan Professeur agrégé de mathématiques au lycée Jean Perrin (Rezé)

Stéphane Grognet Maître de conférences à l’Université de Nantes et directeur de l’IREM des Pays de la Loire

Illustration de couverture : Digital vision

© Dunod, Paris, 2008 ISBN 978-2-10-053934-5

Table des matières

I NTRODUCTION 1

2 3 4

Généralités a. Public visé b. Organisation Pourquoi des logiciels libres ? Liste des logiciels abordés Vive le calcul !

1 1 1 1 2 2 3

Partie I INTERFACE C HAPITRE 1 : A IDE 1.1 Installer les logiciels 1.2 Obtenir de l’aide a. Aide en ligne de commande b. Aide en ligne locale c. Aide en ligne par internet d. Documentation internet 1.3 Promenade avec bc 1.4 Promenade avec XCAS

C HAPITRE 2 : C OMMUNICATION 2.1 Communiquer avec un logiciel de calcul a. Écriture des nombres b. Saisie des instructions au clavier c. Mise en forme des résultats au format instruction 2.2 Obtenir des sorties compatibles avec le logiciel de typographie LATEX a. LATEX et les calculs avec XCAS b. LATEX et les sorties graphiques de XCAS c. LATEX et GnuPlot d. Combiner Bc, GnuPlot et LATEX 2.3 Utiliser des logiciels de calcul avec TeXmacs 2.4 Utiliser les logiciels de calcul en mode texte sous Emacs 2.5 Faire communiquer deux logiciels de calcul

5 7 7 7 7 8 8 8 8 9 13 13 13 13 14 15 15 18 20 23 26 27 29

     a. Le copier-coller à la souris b. Communication via des fichiers c. Appel à l’interpréteur de commandes du système (shell) d. Un bon outil : la gestion des chaînes de caractères 2.6 Programmation interactive

C HAPITRE 3 : L A PROGRAMMATION 3.1 Avec XCAS a. Les procédures b. for c. while d. if e. Listes,ensembles et chaînes f. Programmation en français Pour tantque si 3.2 Avec MuPAD a. Les procédures b. for c. while d. if e. Listes, ensembles et chaînes 3.3 Avec Scilab

Partie II CALCUL C HAPITRE 4 : A RITHMÉTIQUE 4.1 Calcul en précision arbitraire a. Avec Bc b. Avec XCAS c. Avec Maxima d. Avec gp e. Avec Yacas 4.2 Erreurs d’arrondi avec GnuPlot 4.3 Changement de base avec Bc 4.4 Congruences 4.5 Nombres premiers a. Théorème des nombres x premiers 1 b. La fonction Li :x → dt et les nombres premiers 2 ln t 4.6 Nombres p-adiques

C HAPITRE 5 : É QUATIONS 5.1 Avec XCAS

vi

29 29 29 30 30 31 31 31 32 33 33 33 36 36 36 36 37 37 38 39 39 39 41

43 45 45 45 46 46 46 46 47 48 49 50 50 52 53 55 55

     5.2 Avec MuPAD

C HAPITRE 6 : P OLYNÔMES 6.1 6.2 6.3 6.4 6.5

58 61

Avec Scilab Avec Maxima Avec XCAS Avec Gp Avec Yacas

61 62 63 64 65

C HAPITRE 7 : F ONCTIONS

67

7.1 Avec Gp 7.2 Avec Maxima 7.3 Avec XCAS a. Cas général b. Définir des fonction non numériques : un exemple en géométrie en classe de Seconde 7.4 Avec Bc 7.5 Avec Scilab a. Cas général b. Évaluation en rafale 7.6 Avec Yacas 7.7 Avec Octave

C HAPITRE 8 : A LGÈBRE LINÉAIRE 8.1 Avec Scilab a. Opérations élémentaires b. Résolution d’un système d’équations linéaires c. Réduction d’endomorphismes 8.2 Avec Octave 8.3 Avec Maxima 8.4 Avec XCAS, au gré d’activités diverses a. Déterminer un projecteur b. Puissances de matrices c. Inverse de matrices d. Trouver l’inverse d’une matrice avec la méthode de Gauss-Jordan e. Chaînes de Markov f. Chiffrement de Hill Codage Décodage

C HAPITRE 9 : G ÉOMÉTRIE AFFINE 9.1 Avec Scilab a. Équation de droite dans le plan b. Équation de plan dans l’espace tridimensionnel 9.2 Avec XCAS a. Propriétés géométriques

67 67 68 68 69 72 72 72 73 73 74 75 75 75 76 76 77 77 78 78 79 79 80 83 86 87 88 91 91 91 91 91 92

vii

     Dans le plan Dans l’espace b. Une activité de 2nde 9.3 Avec GnuPlot

92 93 95 96

C HAPITRE 10 : S TATISTIQUES

99

10.1 Des statistiques sans tableur... a. Le problème du Duc de Toscane Un peu de (petite) histoire Simulation de l’expérience Simulation à grande échelle b. Lancers de dés c. Un problème d’ivrogne 10.2 Générateurs aléatoires 10.3 Régression linéaire 10.4 Statistiques 10.5 Application a. Loi uniforme b. Loi normale c. Pile ou face d. Jeu de dés

C HAPITRE 11 : C ALCUL DIFFÉRENTIEL 11.1 Premiers contacts a. Avec Scilab b. Avec Maxima c. Avec XCAS d. Avec Gp e. Avec Yacas 11.2 Calcul différentiel multidimensionnel 11.3 Courbes 11.4 Surfaces 11.5 Étude métrique des surfaces 11.6 Extrema d’une fonction de R2 dans R avec XCAS a. Extremum sous contrainte et multiplicateur de Lagrange b. Condition nécessaire et suffisante d’existence d’un extremum

C HAPITRE 12 : I NTÉGRATION 12.1 Primitives a. Avec Yacas b. Avec Maxima c. Décomposition en éléments simples d. Avec Scilab e. Avec XCAS f. Avec MuPAD 12.2 Changement de variable et intégration par parties

viii

99 99 99 99 100 101 103 105 105 105 106 106 108 109 110 113 113 113 114 114 116 116 116 117 119 125 132 132 135 139 139 139 139 140 142 143 143 144

     a. Avec XCAS Changement de variables Intégration par parties Intégrale de Wallis b. Avec MuPAD 12.3 Calcul approché d’intégrales a. Méthode des rectangles avec XCAS b. Application au calcul d’une approximation de π avec XCAS

C HAPITRE 13 : D ÉVELOPPEMENTS LIMITÉS 13.1 13.2 13.3 13.4

Avec Yacas Avec Gp Avec Maxima Avec XCAS a. Généralités b. Visualisation de l’approximation d’une fonction par le polynôme de Taylor

C HAPITRE 14 : É QUATIONS DIFFÉRENTIELLES ORDINAIRES 14.1 Avec Scilab a. Résolution d’une équation du premier ordre unidimensionnelle b. Résolution d’une équation du premier ordre multidimensionnelle c. Résolution d’une équation du deuxième ordre unidimensionnelle d. Résolution d’une équation d’ordre et de dimension quelconques 14.2 Avec Octave 14.3 Avec XCAS a. Résolution exacte b. Résolution approchée c. Méthode d’Euler : cas général d. Méthode d’Euler et exponentielle : TP en Terminale S Approximation affine Subdivision Tracé d’une ligne brisée Tracé en boucle Procédure À vous de jouer Estimation de l’erreur 14.4 Résolution exacte avec Maxima 14.5 Avec MuPAD

C HAPITRE 15 : T RANSFORMÉE DE L APLACE 15.1 Avec Maxima 15.2 Avec XCAS

144 144 144 145 147 148 148 149 153 153 153 154 154 154 155 157 157 157 157 160 161 161 161 161 162 162 163 163 163 163 164 164 165 165 166 167 169 169 170

ix

    

Partie III THÈMES T HÈME 1 : XCAS AU LYCÉE ?

173

1.1 XCAS et la géométrie dynamique au lycée 1.2 XCAS et les suites 1.3 Ce que ni le tableur, ni un logiciel de géométrie ne peuvent faire a. Preuve d’un théorème b. Illustration graphique c. Bilan de cette activité 1.4 Moralité...

T HÈME 2 : L OGIQUE ÉLÉMENTAIRE 2.1 Premiers contacts 2.2 Algèbre de Boole 2.3 Le raisonnement par l’absurde

T HÈME 3 : T HÉORÈMES DE M ÉNÉLAÜS ET PAPPUS 3.1 Coordonnées barycentriques a. Une condition d’alignement b. Une démonstration rapide du théorème de Ménélaüs 3.2 Problème du Monde 3.3 Cercles de Pappus a. Approche historique b. Résolution astucieuse de représentations paramétriques et d’une inversion

T HÈME 4 : S UITES ET CHAOS 4.1 4.2 4.3 4.4

185 185 185 186 189 189 189 190 192 193 193 196

200 200 201 203

T HÈME 5 : C ONIQUES

205

5.1 Étude algébrique des coniques a. Étude mathématique au niveau Bac+1 Premier cas : ab = 0 second cas : ab = 0 b. Étude mathématique au niveau Bac+2 Écriture matricielle de l’équation Exemple c. Étude informatique 5.2 Étude analytique des coniques x2 a2

y2

+ b2 = 1 x2 a2

y2 b2

b. Hyperbole d’équation − = 1 5.3 Ensemble des points M du plan tels que MF = eMH 5.4 Foyer et directrice d’une conique

x

173 173 179 179 182 183 183

199

Modélisation Observation chiffrée Observation graphique Diagramme de bifurcation

a. Ellipse d’équation

171

205 205 205 206 208 208 209 210 211 211 213 214 214

     a. Cas de l’ellipse b. Cas de l’hyperbole 5.5 Construction de la tangente à une conique a. Le théorème b. L’observation par XCAS c. La preuve par XCAS 5.6 Activités géométriques sur les paraboles a. Tracé d’une parabole à la règle et au compas b. Pourquoi les antennes paraboliques sont-elles paraboliques ? 5.7 Coniques et cônes a. Section d’un cône par un plan d’équation x = t b. Section d’un cône par un plan d’équation x = t + k · z

214 215 215 215 215 217 218 218 219 220 221 222

T HÈME 6 : S ÉRIES DE F OURIER

225

6.1 Exploration 6.2 Interprétation physique 6.3 Phénomène de Gibbs

225 228 229

T HÈME 7 : M USIQUE 7.1 Construction d’une gamme avec Scilab a. Génération de gammes candidates b. Élimination des permutations circulaires de colonnes c. Fonction principale : mode d’emploi 7.2 Fabrication de sons

235 235 235 236 237 238

T HÈME 8 : C ARRÉS MAGIQUES

241

T HÈME 9 : C ODES CORRECTEURS D ’ ERREURS

247

9.1 Méthode naïve a. Liste des éléments de Fk2 b. Distance de Hamming c. La procédure de test et de correction d. Code t-correcteur 9.2 Codes cycliques et polynôme générateur 9.3 Corps de Galois - Création de polynômes générateurs

T HÈME 10 : S URFACES DONT LA PROJECTION EST IMPOSÉE 10.1 Introduction 10.2 Construction du polynôme adapté a. Définition mathématique b. Construction informatique 10.3 Définition semi-algébrique d’un polygone convexe régulier a. Le polygone a un nombre pair de côtés b. Le polygone a un nombre impair de côtés c. Traduction informatique 10.4 Construction de l’ensemble algébrique à partir de la définition semi-algébrique

248 248 248 249 251 253 255 259 259 260 260 260 262 262 263 264 265

xi

     a. Carré b. Hexagone 10.5 Prolongements

T HÈME 11 : TACHES DES ANIMAUX 11.1 11.2 11.3 11.4 11.5

Introduction Affichage des données Construction sur un rectangle Construction sur un tore Construction sur un cylindre

Partie IV ANNEXES

265 266 267 269 269 270 273 276 277

279

TABLEAUX COMPARATIFS

281

B IBLIOGRAPHIE

289

I NDEX GÉNÉRAL

291

I NDEX DES COMMANDES

297

xii

Remerciements

Je remercie chaleureusement Bernard PARISSE, d’une part pour développer de manière si active le logiciel XCAS, et d’autre part pour avoir bien voulu relire et améliorer bon nombre des algorithmes présents dans cet ouvrage. Je tiens également à m’excuser auprès de Claire, Marie, François, Suzanne et Rose à qui j’ai tourné le dos tant de jours pour faire face à mon écran et les remercie pour leur patience. Guillaume C ONNAN

Introduction  



  

Cet ouvrage aborde les niveaux :

➥

collège

➥

lycée

➥

supérieur

tant pour les notions mathématiques que pour les capacités informatiques nécessaires. L’ouvrage est destiné :

➥

à l’élève ou l’étudiant qui cherche une vision différente des notions abordées en cours, ou qui désire se cultiver,

➥

à l’enseignant qui cherche une aide soit pour préparer des illustrations pour son cours, soit pour préparer des activités sur machine en travaux pratiques,

➥

au candidat professeur qui souhaite illustrer une leçon mathématique en utilisant des programmes de quelques lignes sans rentrer dans une programmation fastidieuse,

➥

au technicien et au scientifique de n’importe quelle discipline qui souhaite manipuler les objets mathématiques dont il a besoin.



  

Cet ouvrage aborde trois domaines de travail :

➥

Comment utiliser le plus confortablement possible les logiciels de calcul ?

➥

Quelles sont les connaissances de bases qui permettent à un non-initié d’aborder chaque logiciel ?

➥

Comment traiter avec les machines quelques thèmes mathématiques un peu plus élaborés ?

Les textes de confort découlent de notre pratique ; ils sont destinés à ceux qui s’intéressent aux mathématiques sans expérience de la programmation et correspondent à la partie 4. Les textes de recettes de base de la partie 3.3 répondent aux questions que nous nous sommes nous-mêmes posées : pour illustrer tel ou tel domaine des mathématiques, quels logiciels choisir, quels sont les outils minimums qu’on peut acquérir sans gros travail d’apprentissage pour manipuler les objets mathématiques ?

   Les thèmes d’étude de la partie 15.2 nous paraissent instructifs pour plusieurs raisons. On peut utiliser les logiciels de calcul pour faciliter le travail dans un domaine mathématique que l’on connaît. Mais il apparaît que les logiciels libres disponibles sont suffisamment riches et suffisamment documentés pour qu’on puisse aussi découvrir un domaine mathématique à travers eux. La manière de penser l’échange de connaissances s’en trouve modifiée. L’utilisation d’un logiciel pour résoudre un problème ambitieux mène à une utilisation poussée : le logiciel libère sa puissance ; des routines sont créées, qui peuvent être utilisées dans bien d’autres situations ; la solution apportée fait naître d’autres envies et apporte de fécondes suggestions.

        Les logiciels libres publient les sources de leur programmes, ce qui leur offre différents avantages. Le fait que tout un chacun puisse apporter des corrections est un gage de stabilité. Le développement de certains logiciels peut être repris par de nouvelles équipes sans que le savoir-faire ne soit perdu : c’est un gage de pérennité. Leurs concepteurs visent la compatibilité avec les versions antérieures et le respect des normes informatiques. Les logiciels libres sont destinés à communiquer entre eux, et le fait de pouvoir cumuler la puissance de plusieurs logiciels pour un projet de calcul est précieux. Le fait de pouvoir les dupliquer légalement est bénéfique pour le budget de l’État ou des entreprises.

       

Plusieurs logiciels sont utilisés dans cet ouvrage. Nous pointons les différences de syntaxe ; elles ne doivent pas rebuter le néophyte car elles ont leur raison d’être, et le fait d’apprendre plusieurs logiciels de calcul en même temps apporte un recul profitable à l’assimilation des règles d’utilisation. Des tableaux comparatifs sont présentés en annexe page 281. Les logiciels libres présentés ici sont bien dans la philosophie des logiciels libres et des systèmes d’exploitation libres de la lignée UNIX ; à l’opposé de la stratégie commerciale des logiciels propriétaires, les logiciels libres ne cherchent pas à tout faire, mais à agir dans un domaine déterminé le plus proprement possible : ce qu’ils font, ils le font bien. Toujours dans la philosophie UNIX, les logiciels utilisent des modes de communication ouverts (ils peuvent lire et écrire des fichiers texte ou dans des formats ouverts, lancer des commandes système et donc n’importe quel autre logiciel), et collaborent entre eux. Tel logiciel de calcul formel utilise un autre logiciel de dessin pour ses graphismes, et un autre logiciel de calcul numérique pour ses calculs approchés. Cette coopération apporte une puissance et un confort d’utilisation introuvables dans les logiciels propriétaires.

2

   Fonctionne

Logiciel

Type

Fonctionne

en mode

en mode

Licence

texte

graphique

oui

Bc

calculette en précision arbitraire

GPL

GnuPlot

traceur de figures mathématiques

GPL

Gp(pari)

calculateur formel orienté corps de nombres

GPL

oui

Maxima

calculateur formel

GPL

oui

MuPAD

calculateur formel

Propriétaire

Octave

calculateur numérique matriciel

GPL

oui

Scilab

calculateur numérique matriciel

cecill

oui

oui oui

oui

oui oui

XCAS(giac)

calculateur formel

GPL

oui(iacas)

Yacas

calculateur formel

GPL

oui

  Logiciels abordés Les logiciels qui fonctionnent en mode texte présentent deux avantages : ils peuvent être installés et (modérément) utilisés sur des machines peu performantes, et peuvent être utilisés à distance par ssh via une liaison lente. Ils fonctionnent évidemment sur un terminal en mode graphique. Les relations des logiciels de calcul avec le logiciel de typographie LATEX sont abordées ici.

     Nous remercions les auteurs des logiciels libres qui diffusent leur savoir à l’ensemble de l’humanité depuis des décennies. Les systèmes libres Linux et *BSD sont des outils de travail remarquables. Nous remercions l’IREM des Pays de la Loire, le Département de mathématiques de l’Université de Nantes, le laboratoire Jean Leray pour leurs aides diverses. Nous remercions Bernard Parisse pour ses réponses aux questions sur XCAS. Nous aurions aimé aborder d’autres logiciels, tels que geogebra, axiom, xfig, R. . . Cet ouvrage vise à encourager les utilisateurs à parcourir la riche documentation des logiciels libres, il ne vise surtout pas à la remplacer. Nous espérons que le lecteur prendra autant de plaisir que nous à découvrir les logiciels libres de calcul mathématique, et utilisera ce livre en expérimentant directement les logiciels de calcul sur sa machine, en n’oubliant pas son éditeur de texte préféré pour créer et ajuster ses propres programmes.

3

Première partie

INTERFACE

 Aide Logiciel(s) abordé(s) : Bc GnuPlot Gp Maxima Octave Scilab XCAS Yacas

Problématique : Comment obtenir le mode d’emploi ?



    

À part MuPAD, les logiciels décrits ici sont libres, c’est-à-dire librement copiables avec leurs programmes-sources. Ils sont souvent dans l’arborescence de logiciels disponibles sous votre système d’exploitation Linux ou *BSD préféré. Sous MacOSX, il est bon d’utiliser Fink, qui les place dans le répertoire \sw. Mais certains logiciels ne sont pas disponibles par Fink : ils sont souvent sur internet sous forme déjà compilée pour MacIntosh. Sous Microsoft Windows, les logiciels sont à télécharger sur internet. On peut avoir besoin d’un simulateur UNIX comme CygWin. Dans tous les cas, il ne faut pas hésiter à consulter les sites internet correspondants et à télécharger la documentation.

     

     

Certains logiciels fournissent une aide sommaire en ligne de commande avec une instruction du type programme -h : ou programme -help. bc --help gnuplot --help gp --help maxima --help octave --help scilab --help

Ceci peut varier suivant la version du logiciel installé sur la machine.

      Certains fournissent une aide dans la norme UNIX avec la commande man de l’interpréteur de commande (Shell) : man programme.

    

bc gnuplot gp maxima octave

Quelques logiciels fournissent une aide substantielle avec la commande info du shell :

  



gnuplot maxima octave

    

Certains logiciels offrent une aide en ligne, soit en appuyant un bouton en mode graphique, soit en tapant une commande du type help, comme Octave, Maxima, Scilab, un point d’interrogation, comme GnuPlot, XCAS, Yacas, deux points d’interrogation, comme Gp. Par exemple le programme Yacas lance le navigateur en mode texte  ; le logiciel Gp avec deux points d’interrogation lance le visualiseur  sur un document d’aide (en mode graphique). Il arrive que l’aide fournisse une précieuse recherche par mot-clé.



     

Certains logiciels proposent leur aide en ligne par un navigateur qui va chercher ses données sur le réseau. Ceci pose problème quand on travaille hors ligne. . .



   

Une grande quantité de documents est disponible sur internet dans de nombreuses langues. Il est intéressant de télécharger ces documents et de les consulter en travaillant.

     Pour obtenir l’aide de Bc taper dans un terminal : man bc

on obtient une réponse du genre : Réponse du logiciel bc(1)

bc(1)

NAME bc - An arbitrary precision calculator language

8

    

SYNTAX bc [ -lwsqv ] [long-options] [

file ... ]

VERSION This man page documents GNU bc version 1.04. DESCRIPTION bc is a language that supports arbitrary precision numbers with interactive execution of statements. There are some similarities in the syntax to the C programming language. A standard math library is available by command line option. If requested, the math library is defined before processing any files. bc starts by processing code from all the files listed on the command line in the order listed. After all files have been processed, bc reads from the standard input. All code is executed as it is read. (If a file contains a command to halt the processor, bc will never read from the standard input.) This version of bc contains several extensions beyond traditional bc implementations and the POSIX draft standard. Command line options can cause these extensions to print a warning or to be rejected. This document describes the language accepted by this processor. Extensions will be identified as such. OPTIONS -l

Define the standard math library.

-w

Give warnings for extensions to POSIX bc.

-s

Process exactly the POSIX bc language.

-q

Do not print the normal GNU bc welcome.

-v

Print the version number and copyright and quit.

--mathlib Define the standard math library. --warn Give warnings for extensions to POSIX bc. --standard Process exactly the POSIX bc language.

On se déplace dans le visualiseur avec ↑ , ↓ , ou bien quitte le visualiseur en tapant  .

,



,



-



,



-



. On

    !"#$ L’aide est très fournie sur XCAS.

➥

Il existe tout d’abord un index des commandes qui donne un rapide résumé des fonctionnalités. Par exemple, pour se rappeler la syntaxe de   , on tape limite puis → −− − −− −→

On obtient :

9

     

➥ ➥

Pour une aide plus détaillée, on peut cliquer sur Détails si on avait déjà ouvert l’index d’aide ; on peut y accéder directement en tapant  puis en indiquant la notion qui nous intéresse dans la fenêtre. Pour une aide plus générale, il existe des manuels d’aide sur les grands sujets généraux. Par exemple, si on clique sur l’icône interface du menu d’Aide, on obtient le résumé suivant à la section... Aide : Réponse du logiciel

LE MENU AIDE Ce menu contient les différentes formes d’aide possible. * INTERFACE contient ce manuel, donc l’aide concernant l’interface de Xcas. * MANUELS 1. CALCUL FORMEL contient l’aide générale qui concerne toutes les fonctions de calcul formel, de géométrie, de statistiques mais qui ne concerne pas les instructions de programmation, ni les instructions déplaçant la tortue.

10

    

2. ALGORITHMES décrit une partie des mathématiques utilisées pour programmer un logiciel de calcul formel 3. GÉOMÉTRIE contient une aide plus détaillée pour certaines commandes car cette aide est illustrée par des exercices (mais on n’a pas toutes les fonctions de géométrie !). 4. PROGRAMMATION contient une aide détaillée des instructions de programmation. Dans cette partie vous trouverez l’écriture de plusieurs algorithmes avec la traduction de ces algorithmes en langage Xcas MapleV MuPAD TI89/92. 5. TABLEUR,STATISTIQUES contient une aide détaillée concernant le tableur et les fonctions de statistiques ainsi que leurs utilisations dans le tableur. 6. TORTUE contient l’aide concernant les instructions qui sont utilisées dans l’écran de dessin Tortue. Dans cette partie vous trouverez plusieurs activités que l’on peut faire avec des enfants (du CP au CM2) dans le but de leur faire faire des mathématiques. 7. AMUSEMENTS contient de nombreux exercices mathématiques originaux traités avec XCAS. * INTERNET 1. FORUM permet d’accéder à un forum de discussion. 2. SITE LYCÉE G. CONNAN renvoie vers un site merveilleux... 3. RESSOURCES BAC S renvoie vers les sujets de l’épreuve expérimentale du Bac S. 4. RESSOURCES AGRÉGATION renvoie vers les thèmes utiles aux agrégatifs. 5. METTRE À JOUR L’AIDE permet de mettre l’aide à jour. * INDEX donne toutes les commandes utilisables classées par ordre alphabétique avec une ligne d’entrée qui permet de se déplacer facilement dans cette liste : il suffit de taper le début d’un nom dans cette ligne pour avoir le curseur à cet endroit dans la liste, vous pouvez ainsi aller directement à une lettre ou à une commande. En cliquant sur l’une de ces commandes, vous avez une aide succincte qui s’affiche dans le bandeau général à l’endroit des messages, des exemples que l’on peut copier en cliquant sur l’un d’eux et le nom des commandes proches ou des synonymes. Pour avoir une aide plus complète, cliquez sur le bouton Détails L’aide s’affiche soit dans un navigateur (par défaut Mozilla sous Linux, Internet Explorer sous Windows), soit dans une fenêtre à part. Sous Linux, il est commode d’ouvrir Mozilla et de l’icônifier pour pouvoir ouvrir cette aide lorsque cela est nécessaire. Vous pouvez aussi taper ?nom_de_commande pour avoir en réponse l’aide succincte sur cette commande. Notez qu’en tapant sur le bouton bleu ? situé en bas à gauche dans le bandeau général, on ouvre l’Index et, notez aussi qu’en tapant le début d’une commande dans une ligne de commandes puis sur la touche de tabulation ou sur le bouton bleu ?, on ouvre l’Index à la commande commençant par ce début. * TROUVE recherche le mot demandé dans toutes les pages du manuel Calcul formel.

Tout est dit...

11



Communication Logiciel(s) abordé(s) : Bc GnuPlot Gp Maxima Octave Scilab XCAS Yacas

Problématique : Mettre en forme les productions des logiciels. Faire communiquer les logiciels entre eux.

 

"

      

     

En notation scientifique, les nombres apparaisent sous la forme suivante, et ils sont à saisir de même : -1.23456e-7

représente le nombre −1, 23456 · 10−7 dans plusieurs logiciels. Le symbole de la partie exponentielle varie suivant les logiciels.

   Notation scientifique logiciels

symboles acceptés pour la partie exponentielle

Bc Yacas Gp GnuPlot XCAS Maxima Scilab Octave



e,E d,D,e,E

         

La plupart des logiciels de calcul obéissent à une ligne de commande que l’utilisateur saisit avec le clavier. La commande n’est exécutée que quand on appuie sur la touche   . Éditer une commande, c’est modifier la ligne que l’on est en train de saisir. Certains logiciels présentent des facilités dans ce domaine. La plupart accepte d’effacer le caractère à gauche du curseur quand on appuie sur la touche d’effaçage vers la gauche.

       Dans certains logiciels, en utilisant les flèches du clavier, on peut rappeler une commande précédente. Des raccourcis-clavier autrefois introduits dans l’interpréteur de commande C-shell ou l’éditeur de textes Emacs, et maintenant devenus habituels, sont parfois repris :

➥



-



pour effacer toute la ligne,

➥



-



pour effacer le reste de la ligne à droite du curseur,

➥



-



pour placer le curseur en début de ligne,

➥



-

pour placer le curseur en fin de ligne,

➥



-



pour effacer le caractère à droite du curseur

et caetera. L’effet de ces commandes peut varier d’un logiciel à l’autre : il est recommandé de faire des essais. Ces commandes sont tellement pratiques qu’il serait dommage de s’en passer. Beaucoup de logiciels sont sensibles à la hauteur de casse : dans le logiciel Scilab, l’instruction

(1) fonctionne mais l’instruction Sin(1)

ne fonctionne pas.



               

Pour utiliser le résultat obtenu dans un logiciel comme entrée dans un autre, comme dans la section a. page 29, il faut que la mise en forme du résultat soit compatible avec la saisie des instructions. La ligne de commande permet de modifier à la volée les différences mineures de notation d’un logiciel à l’autre. En copier-coller à la souris, on peut utiliser l’étape intermédiaire d’un éditeur de texte pour nettoyer l’instruction. En demandant aux logiciels d’écrire et de lire dans un fichier, il est possible d’utiliser des éditeurs de texte automatisés tels que sed, awk, Perl. . .

  

opération Logiciel Scilab

Maxima

obtenir la sortie au format de l’entrée

   ;

exemple x= (0,’x’) p=xˆ2+1 (p) xˆ2+1;

   xˆ2+1;

14

Mise en forme du résultat obtenir la sortie au format enjolivé

exemple

il n’y a rien à faire

 ;

xˆ2+1;

 ; xˆ2+1;

              

  

Mise en forme du résultat

opération Logiciel

obtenir la sortie au format de l’entrée

Gp

il n’y a rien à faire

il n’y a rien à faire

Yacas

il n’y a rien à faire

 

XCAS

il n’y a rien à faire

il n’y a rien à faire

exemple

obtenir la sortie au format enjolivé

exemple

PrettyForm(%)

  Chaînes de caractères et instructions Voici un exemple (Figure 2.2) d’aller-et-retour entre les chaînes de caractères et les instructions dans Scilab.

   

   %       &% %' ()! 

       

Il est possible de demander à XCAS de calculer à partir d’un fichier LATEX. Pour cela, il faut commencer par indiquer à LATEX qu’on l’autorise à exécuter des tâches externes en modifiant le fichier ( ou l’équivalent sur des systèmes non libres ) /usr/share/texmf/web2c/texmf.cnf. Il suffit d’y remplacer shell_escape=f par shell_escape= t.

15

       Une manière moins drastique est de spécifier à son éditeur ( Kile, TeXmaker...) de compiler le fichier avec l’option shell_escape : latex --shell-escape fichier.tex

Si on travaille sous Emacs avec AucTeX, il suffit de rajouter à la toute fin du fichier : %%%

Local

%%% m o d e :

Variables : latex

%%% T e X − m a s t e r :

−− s h e l l − e s c a p e

t

%%% E n d :

Ensuite, voici le code LATEX à placer en préambule : \   [12pt]{article} \  {fancyvrb} \

   

%c o m m a n d e

pour

faire

appel

à

giac

\   {\executGiac}[1]{ \  \ 18{giac Session->giac > int(sqrt(1-x^2),x,0,1) 1 4 ×π La commande s’affiche en bleu et le résultat en noir avec de belles polices. Notez qu’un menu giac apparaît avec les principales commandes.

AVEC M AXIMA Il en va de même avec Maxima : (%i1) integrate(sqrt(1-x^2),x,0,1) (%o1) π4

c What You See Is What You Get

26



      !   " ! 



On peut également obtenir une sortie graphique avec GnuPlot : Réponse du logiciel

Il faut toutefois noter que TeXmacs est gourmand en mémoire et provoque des crashs inopinés. L’export LATEX n’est pas optimum. Il peut cependant rendre de bons services lorsqu’il s’agit de créer une feuille de TD utilisant l’un des logiciels implantés.

 *         ) 

 + 



Plutôt que d’utiliser les éditeurs livrés avec les logiciels (quand il y en a), on peut préférer rester à l’intérieur de son éditeur préféré, Emacs, qui possède des modes permettant d’ouvrir

27

       des sessions XCAS ( en fait giac ), Maxima, MuPAD, Yacas... Par exemple, pour utiliser Maxima sous Emacs on installe maxima-emacs.el. Les heureux utilisateurs de distributions Debian ou Ubuntu peuvent par exemple lancer dans un Shell en mode super-utilisateur :

apt-get install maxima-emacs

Pour XCAS, on installera mupacs.el et on regardera l’aide sur le site XCAS. Une session XCAS sous Emacs ressemble donc à ça :

Réponse du logiciel

Giac CAS for mupacs, released under the GPL license 2.0 | (c) 2007 B. Parisse & al (giac), F.Maltey & al (mupacs) | >> TEXTWIDTH:=148: // :2: syntax error, unexpected T_END_INPUT at end of input 148:undef >> int(ln(x),x,1,e) ; 1 >> nextprime(1234894343132) ; 1234894343159 >> A:=[[1,2],[3,4]] ; [[1,2],[3,4]] >> A^2 ; [[7,10],[15,22]] >> eigenvals(A) ; (-sqrt(33)+5)/2,(sqrt(33)+5)/2 >>

Il ne faut pas s’occuper des 5 premières lignes. Pour éditer une saisie précédente, on tape

Pour Maxima, cela donne :

28



- ↑ .

# $  ! %! !"     ! Réponse du logiciel

Maxima restarted. (%i1) S(x):=1/(x^3+x^2+x+1); 1 S(x) := --------------3 2 x + x + x + 1

(%o1)

(%i2) partfrac(S(x),x);

(%o2)

, - 

1 x - 1 --------- - ---------2 (x + 1) 2 2 (x + 1)

 +    

C’est nécessaire quand on a besoin à la fois de calcul formel et de calcul numérique sophistiqué. En général quand on utilise simultanément deux domaines des mathématiques éloignés, chacun des deux étant traité par deux logiciels distincts, il est nécessaire de les faire communiquer.



  & '   

La souris est utilisable aussi sans environnement graphique (sous UNIX). Les résultats doivent être au même format que les instructions (voir la section c. page 14) dans la mesure où les instructions voulues coïncident entre les deux logiciels ! Pour changer commodément les hauteur de casse d’une chaîne de caractères, on pourra passer par l’intermédiaire d’un éditeur de texte comme Emacs.



    (!

Beaucoup de logiciels fournissent des instructions pour lire ou écrire des données dans un fichier texte. En écrivant le résultat obtenu par un logiciel dans un fichier, et en lisant ce fichier avec un autre logiciel, on réalise une communication entre logiciels.



 ' )       * + , !-

L’interpréteur de commande des systèmes UNIX est particulièrement adapté à la communication entre les logiciels grâce au tubage de processus. Certains logiciels de calcul présentent

29

       des commandes pour faire exécuter des instructions par le Shell. Par exemple Scilab fournit la commande  . L’instruction :

 (’ls’) fonctionne souvent mieux que la commande interne  sur certains systèmes. On peut aussi augmenter la précision du calcul. . . unix_w("echo ’’4*a(1)’’ | bc -l")

 ("echo

’’4*a(1)’’ | bc -l")

Il faut noter la manière dont les apostrophes sont protégées ici.



.   /     ! 0   + 

Pour fabriquer des noms de fichiers où écrire, pour fabriquer des instructions GnuPlot (par exemple) à placer dans un fichier, pour utiliser ce qui précède en général, il est pratique de manipuler les chaînes de caractères dans le logiciel de calcul. Par exemple dans Scilab : un="echo ’’" deux="*a(1)’’ | bc -l" x=12 y=3 z= (x/y) chaine=[’#/bin/sh’; un+z+deux; ’exit 0’] instr="date +%d:%m:%Y-%H:%M:%S" D= (instr); nom=’essai’+D+’sh’  (nom,chaine)  (’sh ’+nom)

Pour inclure la date et l’heure dans le nom du script, on utilise l’instruction 

.  

.

     

Des fichiers spéciaux qui ne sont pas des fichiers réguliers sont bien utiles : les entrées-sorties standard. On les obtient par les variables #$%& ; #$'& dans Scilab; elles peuvent être utilisées dans un script Shell par exemple par la commande   . L’intérêt n’est pas que cosmétique : quand on veut tester beaucoup de paramètres différents pour un calcul donné cela fait gagner beaucoup de temps !

30

  La programmation Logiciel(s) abordé(s) : MuPAD Scilab XCAS

Problématique : Description des techniques de contrôle de flux dans les instructions et de quelques astuces.

 

# !"#$    

La syntaxe est proche de celle du langage C++ :a Nom_de_la_procedure(variables):{

.

le programme proprement dit

. }

On commence par ouvrir une session programme en tapant simultanément sur par le menu Edit->Ajouter->Programme. On accède ainsi à l’éditeur de programme. On rentre :



et



ou

double(x):{  (2*x) }

On clique sur OK pour vérifier si tout va bien. Normalement, on obtient un message encourageant : Réponse du logiciel Success // Success compiling double

Dans une session de calcul, on rentre alors a XCAS est écrit en C++, ce qui le rend beaucoup plus maniable et rapide : il peut être facilement exécuté par un autre

programme et est donc directement compilé par les librairies C++ de l’ordinateur, sans passer par un noyau propre comme MuPAD ou MAPLE.

         double(37)

et on obtient le résultat escompté... On peut rendre le résultat plus convivial : double(x):{ "Le double de "+x+" est "+ 2*x }

 

On concatène ainsi des chaînes avec un « + ».





La syntaxe suit le même principe : p:1; / / i n i t i a l i s a t i o n ( k:1; kxx+y); L3:L1.L2; / / p o u r c o n c a t é n e r ➥

les chaînes de caractères C:"è-&èçé_eàhdslqjbch123+4/*5-6* ^"; K:"tralala"; F:", pouet pouet !"; H:"" G:K.F.H

 (C,5,2) renvoie une partie de la chaîne C de longueur 2 à partir du 6e caractère :

 ("123456789",4,

2)

Pour des utilisations particulières, je vous renvoie à l’aide. Voici un petit programme qui transforme un nombre entier en une chaîne de lettres qui peut servir pour le décodage RSA. alph:(n) / / on  l,L;   L:[];l: ' (n); formés

des

chiffres

rentre

un

entier

// de

L

est

n

une

 k  0    (l)-1   2  L:L.[ ' ( (l,k,2))] la

chaîne

en

 : 40

l

la

chaîne

//

text2expr

transforme

nombre

 :  -- .(L); lettres

liste ,

n

//

la

liste

L

est

transformée

en

chaîne

de

&&     

 # $ Pour exécuter un fichier dans Scilab, on peut taper  nomDuFichier. Le logiciel Scilab n’aime pas les appels récursifs à des fichiers pour les exécuter dans des procédures : sa pile sature. Il vaut mieux tout placer dans des fonctions. On exécute les fichiers juste pour définir les fonctions, qui, elles, peuvent être appelées dans des procédures intriquées. Les instructions de contrôle de flux de Scilab sont décrites dans le chapitre Programming de l’aide en ligne. La syntaxe n’a rien de surprenant. Voici une boucle qui stocke des nombres dans un tableau vertical, en affichant l’élément à chaque étape. t1:3 T[]  it,

(i,’i’); T[T;i];



T

On construit maintenant une fonction test qui effectue différentes procédures suivant les valeurs de la variable. Il faut noter la manière dont sont protégées les apostrophes dans les chaînes de caractères. La première boucle  est tout ordinaire.

  ytest(x) a"C’’est l’’étape" b’trois’ yx  x3  

(b,a) ;



 or([xt])   ;

 y (x)+" n’’appartient



  

pas à t"

La seconde boucle  permet de terminer la fonction rapidement si la variable x appartient au tableau t déja défini. Elle peut être écrite aussi bien

 and([x~t])   y (x)+" n’’appartient



pas à t"

Pour exploiter la fonction test, il suffit d’exécuter la boucle

 i[3*t

t],

test(i)



Le logiciel Scilab travaille essentiellement avec des fonctions, des nombres réels en virgule flottante, des chaînes de caractères, des tableaux formés à partir de ces éléments, et des fonctions. En général, il n’y a pas à déclarer de types de variables.

41

Deuxième partie

CALCUL

 Arithmétique Logiciel(s) abordé(s) : Gp Yacas XCAS Scilab Octave Maxima Bc GnuPlot

 

"  %       $

Pour calculer π avec 1000 décimales, taper dans un terminal : bc -;

on obtient une réponse du genre : Réponse du logiciel bc 1.05 Copyright 1991, 1992, 1993, 1994, 1997, 1998 Free Software Foundation, Inc. This is free software with ABSOLUTELY NO WARRANTY. For details type ‘warranty’.

Il suffit de taper

 1000 pour obtenir la précision voulue en ajustant la variable  , et 4*(1)

pour obtenir le quadruple d’Arctan(1) : Réponse du logiciel 3.141592653589793238462643383279502884197169399375105820974944592307\ 81640628620899862803482534211706798214808651328230664709384460955058\ 22317253594081284811174502841027019385211055596446229489549303819644\ 28810975665933446128475648233786783165271201909145648566923460348610\ 45432664821339360726024914127372458700660631558817488152092096282925\ 40917153643678925903600113305305488204665213841469519415116094330572\ 70365759591953092186117381932611793105118548074462379962749567351885\ 75272489122793818301194912983367336244065664308602139494639522473719\ 07021798609437027705392171762931767523846748184676694051320005681271\ 45263560827785771342757789609173637178721468440901224953430146549585\ 37105079227968925892354201995611212902196086403441815981362977477130\

       99605187072113499999983729780499510597317328160963185950244594553469\ 08302642522308253344685035261931188171010003137838752886587533208381\ 42061717766914730359825349042875546873115956286388235378759375195778\ 18577805321712268066130019278766111959092164201988

Le temps de réponse est variable suivant les machines, et augmente fortement quand on augmente encore la précision. Le résultat est-il juste ?



   

On règle la précision avec /  ou /01023 qui doit être un nombre entre 1 et 1000

/ :1000:; 4* ( (1)) Voir aussi 5.1 page 56.



   3

On règle la précision avec  , puis on utilise  :

  : 1000;  (4*atan(1));



  

La précision d’affichage est donnée ou fixée par l’instruction \. \p

4 4* (1) \p 1000

4

Le résultat est-il le même que pour Bc ?



  4 

La précision des calculs approchés est donnée par l’instruction

1 4 () Pour obtenir ponctuellement des calculs en précision arbitraire, il suffit de le demander lors du calcul approché.

((4,1000) Pour basculer la valeur de la précision, taper

46

 ! )    * !

4 (1000) ((4) Pour revenir à la précision précédente, taper

4 (10) ((1/4) ((4) Mais la précision maximale est conservée pour la valeur π.

 )      Le logiciel GnuPlot pose quelques problèmes avec des nombres trop grands ou trop petits comme le montre la retranscription de session suivante : gnuplot>



2**(30) Réponse du logiciel

1073741824

gnuplot>



2**(31) Réponse du logiciel

-2147483648

gnuplot>



2**(32) Réponse du logiciel

0

gnuplot>



2**(-30) Réponse du logiciel

9.31322574615479e-10

gnuplot>



2**(-31) Réponse du logiciel

-4.65661287307739e-10

47

       gnuplot>



2**(-32) Réponse du logiciel

gnuplot> print 2**(-32) ^ undefined value

Le logiciel répète la dernière instruction accompagnée d’un commentaire pour avouer son impuissance.

 "'      1 Le logiciel Bc détecte naturellement une entrée en base 16 avec la saisie des chiffres A, B, C, D, E. Le résultat par défaut est en base 10. Voici un exemple d’addition en base 16 avec le résultat en base 7 :

 7 F+E

et Bc fournit le résultat 41. Pour rentrer des nombres dans une base différente de 10, il faut changer la variable  , ce qui demande un peu d’attention. Dans la retranscription suivante, les instructions saisies sont repérées par un point-virgule final. % bc -lq

 ;

Réponse du logiciel 10

 ; Réponse du logiciel 10

 7;   ; A; Réponse du logiciel 13

48

  ! 

66+22; Réponse du logiciel 121

 A;  A; 2*7; Réponse du logiciel 14

 ;

 " 

Les congruences de nombres entiers s’obtiennent souvent dans les logiciels de calcul par une instruction qui ressemble à mod(x,p). Les résulats ne sont pas toujours positifs, c’est-à-dire dans l’intervalle [0, p − 1] ∩ N. Cherchons à représenter l’entier relatif −5 dans Z/3Z : Avec Gp

5 (-5,3) Avec Maxima

5/)3:3;  (-5); 5/)3:6.)3; Avec Octave mod(-5,3)

Avec Scilab

 (-5,3)   (-5,3) Avec Yacas

5 (-5,3) Avec XCAS -5%3

On peut bien sûr calculer dans Z/nZ :

49

       x:7%9; y:4%9; 3*x^2-5* y^2

donne Réponse du logiciel 4 % 9

Si l’on veut connaître le chiffre des unités de 20082007

2009

, on peut faire :

(2008)^(2007^2009)%10

...mais cela ne donne rien de probant. Mieux vaut travailler tout de suite modulo 10 : (2008%10)^(2007^2009)

répond instantanément que le reste est 2. On peut préférer demander directement le reste avec la commande  (n,p) :



((2008)^(2007^2009),10)

Si l’on veut l’image de p%n par l’application canoniquement associée de Z/nZ sur N, il suffit d’utiliser %0 : k:5%11; k^(2785); k^(2785)%0

Pour d’autres utilisations du calcul modulaire, voir le thème 7.2 page 247 et la section f. page 86.

, 2  % 



! +     

Le sujet est plus que vaste ! Contentons-nous d’une petite expérimentation sur le théorème des nombres premiers. Conjecturé par G AUSS (encore lui !) et L EGENDRE, approché par T CHEBYSHEV , ce théorème a fini par être prouvé indépendamment et simultanément par Jacques H ADDAMARD et CharlesJean de L A VALLÉE P OUSSIN en 1896.

50

# + 

Théorème des nombres premiers En définissant, pour tout réel positif x, le nombre π(x) comme le nombre de nombres premiers inférieurs à x, le théorème des nombres premiers s’énonce de la façon suivante : π(x) ∼

x ln(x)

Construisons une fonction qui compte le nombre d’entiers premiers inférieurs à un nombre donné n. On utilise   qui teste si un entier est premier. On peut d’abord penser à une définition récursive : pir(n):{ (npre) { aun:un; un: (un-f(un)/fp(un)); b Dans Cfg -> Cas Configuration

56

#     k:k+1; }

 

un+" est la solution trouvée à " + (pre) + " près après "+ k +" itérations";

}

Exécutons ce programme : Newton(x->x^ 2-2,1 -100,2);

Il nous assure que 8 itérations sont nécessaires pour obtenir AU MOINSc 100 bonnes décimales... Pour des cas plus « lourds », nous pouvons utiliser la méthode de Steffenson qui accélère celle de Newton :

 (x^2-20,x0,1 -10,steffenson_solver) Bizarre... C’est qu’en fait la méthode de Steffenson comme celle de Newton est très rapide, mais elle nécessite une bonne première approximation de la racined . Mieux vaut donc rentrer :

 (x^2-20,x1,1 -10,steffenson_solver) Cet inconvénient est encore plus mis en valeur avec l’équation  x + ln(x) + 100 = 0. En effet, si  on appelle f la fonction associée, lim f (x) = −∞ et f e−100 = e−100 − 100 + 100 > 0, donc la x→0

solution appartient à l’intervalle ]0 ; e−100 [, ce qui indique que la solution est assez petite...

 (x+(x)+1000,x (-100))- (-100) nous indique que nous sommes malgré tout assez proche de e−100 . Pour un choix de la méthode de résolution numérique d’un système d’équations linéaires ou non, voir l’exemple page 196.



Format de nombre Le format de nombre approché utilisé par XCAS est par défaut le format double (53 bits de précision relative, soit environ 10−16 ). Si /010230);  (x^24,x); On peut sinon utiliser les ensembles habituels avec les notations suivantes :

58

#   '!(

N

NonNegInt

N∗

PosInt

−N∗

NegInt

Z

Integer

2Z

Even

2Z + 1

Odd

Q R

R

Real

R∗+ iR

Q

Rational

∗

∗+

PosRat

+

NonNegative

R∗−

Positive Imaginary

iZ

∗

Q

∗−

NegRat

Q

+

NonNegRat

∗

NonZero

Negative

C

IntImaginary

P

  Ensembles de nombres et MuPAD

Prime

 (x  2 --4  ):  (x^2-40,x); Une autre ruse permet de selectionner les solutions : S :  ((x*PI/7)  0, x); S    / --0 (-22, 22) //

on

demande

des

solutions

dans

[ −22 ,22]

On peut résoudre également des systèmes linéaires :

  ():  ({x+2*y+a*z-1,a*x+y+z2,2*x+a*y-z3},{x,y,z}); Il existe des outils d’algèbre linéaire plus adaptés que nous verrons plus tard. On peut résoudre des inéquations

 (x^2-2*x-4>2*x,x); des équations trigonométriques

 ((x)(x),x); À vous d’imaginer d’autres situations... Un « étudiant » taquin nous a par exemple proposé

 ((x)0*(x),x); Pour avoir une approximation de la solution, on utilise float et hold(solve)

 ( ( )(x+(x)+10)); ou numeric::solve(equation,inconnue)

 -- (x+(x)+10,x); Au-delà, MuPAD semble jetter l’éponge :

 ( ( )(x+(x)+100)); puisque la réponse proposée est l’ensemble vide. Mais MuPAD utilise la méthode de Newton et a donc besoin d’une bonne approximation de départ :

 -- (x+(x)+100,x1e-50 ( (-10)),9   3 ); indique à MuPAD de chercher une approximation de la solution dans [10−50 , e−10 ].

59

  Polynômes

Logiciel(s) abordé(s) : Yacas Gp XCAS Maxima Scilab

Problématique : Manipuler les opérations élémentaires sur les polynômes, notamment la recherche de racines.

.

# $

Le logiciel Scilab peut traiter les polynômes. On peut définir la variable : x(0,’x’)

définir le polynôme x 2 + x + 1 : Px^2+x+1

et calculer ses racines :

 (P) Le polynôme peut être construit avec ses coefficients Q([3  (Q)

2 1],’x’,’coeff’)

Il est à noter que si l’on ne précise pas le drapeau ’coeff’, le polynôme est défini par ses racines : R([3  (R)

2 1],’x’)

Le polynôme dérivé s’obtient comme suit :

 (R) La matrice compagne du polynôme P est obtenue par : A

(P)

On peut retrouver le polynôme :

  "  #$

(x*  ()-A) Les racines de P sont à comparer au spectre de la matrice compagnon (voir le chapitre 7.7) :

 (A) Voici l’exemple d’une session Scilab qui cherche les racines de x 3 + x + 1 ; les commandes sont marquées (->) : Réponse du logiciel -->x=poly(0,’x’) x = x -->P=x^3+x+1 P = 3 1 + x + x -->roots(P) ans = ! - 0.6823278 ! ! 0.3411639 + 1.1615414i ! ! 0.3411639 - 1.1615414i ! -->

. # /+  Le logiciel Maxima traite les polynômes et les fractions rationnelles en général. Trouver les racines du polynôme P se fait comme suit : P(x):=x^2+2*x+3;

 (P(x),x);

La dérivée est la dérivée formelle de toutes les fonctions :

(P(x),x); Voici l’exemple d’une session Maxima qui cherche les racines de x 3 + x + 1 ; les commandes sont marquées (Ci) et les réponses (Di) :

62

,&    Réponse du logiciel (C1) P(x):=x^3+x+1; (D1) (C2) solve(P(x)=0,x);

3 P(x) := x + x + 1

SQRT(3) %I 1 ---------- - SQRT(31) 1 1/3 SQRT(3) %I 1 2 2 (D2) [x = (--------- - -) (- ---------- - -) - --------------------, 6 SQRT(3) 2 2 2 SQRT(31) 1 1/3 3 (--------- - -) 6 SQRT(3) 2 SQRT(3) %I 1 - ---------- - SQRT(31) 1 1/3 SQRT(3) %I 1 2 2 x = (--------- - -) (---------- - -) - --------------------, 6 SQRT(3) 2 2 2 SQRT(31) 1 1/3 3 (--------- - -) 6 SQRT(3) 2 SQRT(31) 1 1/3 1 x = (--------- - -) - --------------------] 6 SQRT(3) 2 SQRT(31) 1 1/3 3 (--------- - -) 6 SQRT(3) 2 (C3)

. # !"#$ Le logiciel XCAS traite les polynômes à plusieurs variables. On rentre le polynôme de manière symbolique : P(x):x^2+2*x+3

Trouver les racines du polynôme P se fait comme suit :

 (P(x)) La dérivée est la dérivée formelle de toutes les fonctions :

(P(x),x) On peut obtenir un polynôme aléatoire de variable u, de degré inférieur ou égal à 6 et à coefficients entiers de valeur absolue strictement inférieure à 100.

 (u,6) Voici l’exemple d’une session XCAS qui cherche les racines de x 3 + x + 1 ; les commandes sont séparées des réponses par des lignes de tirets :

63

  "  #$ Réponse du logiciel P(x):=x**3+x+1 -----------------------------------------// Parsing P // Success compiling P 3 x ->x +x+1 -----------------------------------------roots(P) -----------------------------------------Evaluation time: 0.17 3 Unable to isolate x in ([x])->x +x+1

XCAS ne trouve pas de solution exacte. Il peut toutefois trouver des approximations :

 (P(x)) Réponse du logiciel

[−0.682328, 0.3411639019 + 1.1615414 ∗ i, 0.3411639019 − 1.1615414 ∗ i]

Pour un autre exemple d’activité sur les polynômes, voir aussi la section b. page 151.

. # % Le logiciel Gp traite les polynômes aussi avec des coefficients dans Z/pZ et dans les corps padiques. Trouver les racines du polynôme P se fait comme suit : P(x)x^2+2*x+3  (P(x))

La dérivée est la dérivée formelle de toutes les fonctions :

(P(x),x) Voici l’exemple d’une session Gp qui cherche les racines de x 3 + x + 1 :

64

,#   .

 Réponse du logiciel (21:15) gp > P(x)=x^3+x+1 (21:15) gp > polroots(P(x)) %2 = [-0.6823278038280193273694837397 + 0.E-28*I, 0.3411639019140096636847418698 - 1.161541399997251936087917687*I, 0.3411639019140096636847418698 + 1.161541399 997251936087917687*I]~ (21:15) gp >

., # 4

Le logiciel Yacas traite les polynômes comme les logiciels précédents. Trouver les racines du polynôme P se fait comme suit : Px^2+2*x+3 4 (P,x)

La dérivée est la dérivée formelle de toutes les fonctions :

/(x)

P

Voici l’exemple d’une session Yacas qui cherche les racines de x 3 + x + 1 : Réponse du logiciel In> Q:=x^3+x+1 Out> x^3+x+1; In> PSolve(Q,x) Out> {(Sqrt(31/108)-1/2)^(1/3)-(1/2+Sqrt(31/108))^(1/3),Complex((1/2+Sqrt(31/108)) ^(1/3)/2-(Sqrt(31/108)-1/2)^(1/3)/2,Sqrt(3/4)*(Sqrt(31/108)-1/2)^(1/3)+Sqrt(3/4)*( 1/2+Sqrt(31/108))^(1/3)),Complex((1/2+Sqrt(31/108))^(1/3)/2-(Sqrt(31/108)-1/2)^(1/ 3)/2,-(Sqrt(3/4)*(1/2+Sqrt(31/108))^(1/3)+Sqrt(3/4)*(Sqrt(31/108)-1/2)^(1/3)))}; In>

Les logiciels traités ici présentent de nombreuses fonctions arithmétiques sur les polynômes.

65

  Fonctions Logiciel(s) abordé(s) : Bc Scilab Octave Yacas XCAS Gp Maxima

Notions informatiques : Définir une fonction. Utiliser une fonction.

Problématique : Les fonctions sont centrales dans l’utilisation des logiciels de calcul. Tous les logiciels n’ont pas les mêmes conventions pour définir une fonction mathématique, ni pour l’évaluer en un point. Les fonctions sont construites à partir d’opérations élémentaires et des fonctions classiques qui sont dans la bibliothèque du logiciel. Tous les logiciels n’ont pas la même bibliothèque : la fonction sécante qui est connue de Maxima et XCAS ne l’est pas pour Gp ; seul Maxima connaît la sécante hyperbolique. . .. La bibliothèque de Bc même avec l’option : est très réduite.

5

# %

Le logiciel Gp accepte les fonctions comme des expressions données par un égalité-définition. Pour définir la fonction machin, il suffit d’entrer l’instruction : machin(x)1/(x)

Pour calculer sa valeur en 2, on tape machin(2);

5 # /+  Le logiciel Maxima considère les égalités comme des quantités à évaluer ; une égalité-définition est indiquée par l’instruction -. machin(x):=1/(x);

L’évaluation demande forcément du travail, suivant le type de résultat que l’on désire. machin(2);

donne la valeur algébrique ;

  %  &   (machin(2)); donne une valeur approchée et

 (machin(2)); donne un résultat équivalent.

5 # !"#$ 

 

Le comportement de XCAS est sans surprise au vu de ce qui précède. machin(x):1/log(x)

définit une nouvelle fonction tout comme : machin:x->1/log(x)

machin(2)

donne sa valeur algébrique au point 2 et

(machin(2)) en donne l’approximation tout comme machin(2.0)

On peut transformer une expression en fonction avec

(expression,variable)

f:(x); f(2); f:(f,x); f(2);

On peut également définir la fonction dérivée d’une fonction : fp:  fp(3)

68



(+2* );

/&   

 Fonction et expression Comme en mathématiques, il ne faut pas confondre fonction et expression. Par exemple,  



attend comme argument une fonction et non pas une expression. Ainsi le code : fp: 



((x)+2*x);

renvoie une erreur. Si l’on préfère travailler sur les expressions, alors mieux vaut utiliser

(expression,variable) : df(x): ((x)+2*x,x);

qui renvoie cos(x) + 2, puis : fp:(fp(x),x);

qui renvoie x → cos(x) + 2 ou plus directement : fp:( ((x)+2x),x)

qui renvoie x → cos(x) + 2. Voir aussi c. page 115.



(     " /  3     

  

Il existe depuis de nombreuses années des logiciels de géométrie dynamique qui sont utilisés au collège et au lycée. Cependant, n’étant voués qu’à dessiner ou éventuellement à donner quelques résultats numériques, leur utilisation est limitée et leur syntaxe, par souci d’ergonomie informatique, éloigne les élèves du problème mathématique. XCAS cependant, par sa puissance et sa souplesse, permet de « coller » au cours de mathématiques tout en permettant d’obtenir des résultats performants. Considérons par exemple le problème classique suivant donné en classe de Seconde : On considère un triangle ABC rectangle en A tel que AC = 3 et AB = 4. Soit M un point quelconque du segment [AC]. On construit le rectangle AMNP tel que N appartienne à [BC] et P à [AB]. Étudiez l’aire du rectangle AMNP en fonction de la position de M. Commençons par ouvrir une fenêtre de géométrie en tapant simultanément sur  et  puis définissons les points A et B dans un repère judicieusement choisi : A: (0,0) B: (0,-4) libre

pour

// // y

plaçons plaçons

tracer

la

A B

tel

courbe

que à

AB la

4 fin

en de

laissant la

le

1 er

quadrant

séance

69

  %  &  Définissons ensuite le point C tel que le triangle ABC soit direct, rectangle en A et que l’on ait AC = 34 AB à l’aide de la commande     :

    (A,B,3/4,C) Créons maintenant un réel quelconque de [0; 3] que l’on pourra faire varier à la souris à l’aide de la commande   : t: 

 (0 

3)

Définissons maintenant le point M. Nous qui sommes à moitié mathématiciens, nous savons que nous allons créer en fait une fonction de [0; 3] dans le plan P qui à un réel x de l’intervalle [0 ; 3] associe le point du plan de coordonnées (0 ; x). Pour les élèves, la notation : M(x): (x,0)

est naturelle et rappelle que le point M dépend de la donnée de son abscisse x. Pour définir N, commençons par définir la perpendiculaire en M à la droite (AC). La syntaxe est tout à fait naturelle grâce à   (Point,Droite). N’oublions pas qu’en fait d est une fonction de x : d(x):    (M(x),  (A,C))

Définissons ensuite N comme l’intersection de d et (BC) grâce à   N(x): 

 :

 (d(x),  (B,C))

Pour obtenir P, nous commençons par définir la parallèle à (AC) passant par N (qui est bien sûr une fonction de x) à l’aide de   (Point,Droite) : D(x):  (N(x),  (A,C));

puis l’intersection de D et (AB) : P(x): 

 (D(x),  (A,B))

Il ne reste plus qu’à définir le rectangle APNM grâce à la commande  : R(x): (A,P(x),N(x),M(x))

et à dessiner le rectangle dépendant du paramètre t :

 (R(t),, + ) En faisant varier t à la souris, le rectangle « bouge ». Définissons maintenant la fonction qui à x associe l’aire du rectangle : f(x): (R(x))

Donnons son expression simplifiée :

  (f(x)) 70

/&    Réponse du logiciel

4 3

− x2 + 4x

Définissons le point X de la courbe représentative de f d’abscisse t : X: (t,f(t))

Traçons enfin la courbe représentative de f à l’aide de la fonction  :

 (f(x),x03,  ) Voici une visualisation statique :

  Le rectangle et la courbe représentative de f Pour une autre activité géométrique de Seconde, voir section b. page 95.

71

  %  & 

assume ou element ?

Il aurait peut-être été plus simple pour des élèves de faire la construction en la voyant pas à pas tout en gardant une valeur formelle pour les expressions en utilisant  au lieu de   . Il suffit, dans le code précédent, de remplacer : t: 

 (03)

par :

 (t[1,0,3]) où 1 représente une valeur arbitraire modifiable à la souris. On ôte ensuite toute référence à la variable formelle x qui devient inutile puisque t garde un rôle formel. Par exemple, le code contient : M: (t,0) d:    (M,  (A,C))

5 # 1 Dans la calculette en mode texte appelée par l’instruction définie comme suit :

  

 :, la nouvelle fonction est

machin(x){ 1/(x)}

L’évaluation se fait naturellement. machin(2)

5, # $ 

 

Dans le logiciel de calcul matriciel Scilab, la définition d’une fonction est plus délicate.

  ymachin(x) y1/(x)

   L’évaluation se fait naturellement en un point.

72

/,   .



machin(2)



     

L’évaluation en rafale qui est possible avec Scilab requiert un peu d’attention. En utilisant ce qui précède, t2:9 machin(t)

ne donne pas le résultat voulu. Les opérations élémentaires peuvent être forcées à la place des opérations matricielles en les précédant d’un point : ; à la place de ;. L’exponentielle matricielle  et l’exponentielle coefficient par coefficient  sont distinctes. Pour poursuivre l’exemple, il faut alors définir la fonction en utilisant la division ponctuelle : attention à l’espace derrière le nombre 1 !

  ymachin(x) y1 ./(x)

   t2:9 machin(t)

On a le bon résultat, ce qui permet de tracer un graphe directement :

 (t,machin(t)) Le nombre de points d’évaluation est volontairement limité. L’évaluation marche avec des matrices quelconques : v1:5 uv’*t machin(u)

5. # 4

Le logiciel Yacas définit les fonctions de manière similaire aux autres logiciels de calcul formel. machin(x):1/)(x)

Pour calculer sa valeur en 2, on tape : machin(2)

Pour obtenir une valeur approchée, il suffit de le réclamer pour le résultat précédent.

((%) 73

  %  & 

55 #   Le logiciel Octave traite les matrices. Pour définir des fonctions, la procédure ressemble à celle de Scilab.

  ymachin(x) y1 ./(x) ;

   machin(2) t[2;3] machin(t)

Le point-virgule est nécessaire dans le corps de la définition de la fonction, car sinon la machine retournerait deux fois l’évaluation.

74

  Algèbre linéaire Logiciel(s) abordé(s) : Scilab Octave Maxima XCAS

Notions informatiques : Les logiciels Scilab et Octave sont avant tout destinés au calcul matriciel. Maxima peut faire des calculs sur les matrices, XCAS est destiné à tout calcul...

Problématique : Calculer avec des matrices.

6 

# $     

Construisons un vecteur colonne u et un vecteur ligne v : u[2;3;5] v[7 11 13]

Le produit scalaire t et la matrice A de rang un associée s’obtiennent par multiplication : tv*u Au*v

On obtient les dimensions et le rang directement

" (u) " (A) (A) Le logiciel Scilab présente une sorte de produit tensoriel ; u .*. A

La norme d’un vecteur est par défaut la norme euclidienne  (v). On peut réclamer la norme Lp :  (v,p) ou L∞ :  (v,’inf’). Pour les matrices, ces instructions donnent les normes linéaires associées aux normes Lp sur les vecteurs, au sens des applications linéaires : la norme de A est le maximum des normes de Av pour v parcourant la boule unité. L’instruction  (A) donne la norme spectrale, c’est-à-dire le maximum des modules des valeurs propres.

  '       La norme sur les matrices donnée par la formule par l’instruction  (A,’fro’).



   tr t A ∗ A , souvent utilisée, est obtenue

5  ) * + )"    

On se donne un système de trois équations à trois inconnues dont les données sont aléatoires. A (3,3) B (3,1) V(A)*B

On vérifie que le vecteur AV − B a des coordonnées proches de la précision de la machine. A*V-B

On se place maintenant dans un cas dégénéré : on cherche l’espace propre associé à la valeur propre −1. A[0 1 0;1 0 1;1 1 0] R ((A,’t’)) BA-R(2)*  (3,3)

L’espace propre est engendré par la famille V ici réduite à un vecteur. Z" (3,1) [U,V] (B,Z)

Ce cas particulier se résout aussi par l’instruction V  (B)



5 ) ! 

Pour obtenir les vecteurs propres v p et la matrice diagonalisée D correspondant à la matrice A, il suffit de taper : [vp,D] (A)

On vérifie en tapant A*vp(:,1)/D(1,1) A*vp/D

La décomposition de Schur donne les valeurs propres sur la diagonale de la matrice triangulaire T. [U,T](A)

76

0     

6 #   La syntaxe de base d’Octave est commune avec Scilab. Les instructions ci-dessous sont encore valables. u[2;3;5] v[7 11 13] tv*u Au*v " (u) " (A) (A)

Les instructions ci-dessous donnent aussi des résultats similaires. A (3,3) B (3,1) V(A)*B A*V-B

L’instruction (A) donne les coefficients du polynôme caractéristique de A. On peut calculer le pseudo-inverse de la matrice dégénérée. p(A) R (p) BA-R(2)*  (3,3) c(B) c*B B*c

La décomposition de Schur est la même que pour Scilab : [U,T](A)

6 # /+  On définit une matrice avec (%i1)

  :

  ([1,2],[3,4]);

On calcule son déterminant : (%i2)

  (%i1);

Elle est donc inversible. On demande son inverse : (%i3)

  (%i1);

Calculons le produit pour vérifier. On utilise le produit non commutatif symbolisé par ·, un point : (%i4) )%i1%o3;

77

  '       et on obtient bien l’identité. Les valeurs propres s’obtiennent avec    : (%i5)

  (%i1);

On vérifie qu’il s’agit bien des solutions du polynôme caractéristique donné par  : (%i6)

 ((%i1,x)=0,x);

On calcule la puissance quatrième. On utilise NE>SUIS>PAS>UN>NUMERO>JE>SUIS>UN>HOMME>LIBRE")

On va ensuite regrouper les nombres 3 par 3 en colonnes et travailler dans Z/27Z. On utilise  '  (Liste,nb de colonnes) qui transforme une liste en une matrice ayant un certain nombre de colonnes. On transpose ensuite cette matrice : clair:  ( '

 (L,3))%27

On choisit une clé constituée d’une matrice carrée de taille 3 à coefficients dans Z/27Z et inversible : A:[[1,22,25],[0,25,1],[25,3,1]]%27 Réponse du logiciel

⎡ 1%27

⎢ ⎢ 0%27 ⎣ −2%27

−5%27 −2%27 3%27

−2%27

⎤

⎥ 1%27 ⎥ ⎦

1%27

Calculons son déterminant :

(A) b Cf section e. page 33.

87

  '       Réponse du logiciel 13 % 27

Cette matrice est bien inversible puisque 13 est premier avec 27. On peut donc calculer son inverse :

(A) Réponse du logiciel

⎡ 10%27

−9%27

⎤

⎢ ⎢ 4%27 ⎣

2%27 6%27

⎥ 2%27 ⎥ ⎦

8%27

13%27

4%27

Codons le message clair en multipliant la matrice par A puis en transformant la transposée de la matrice en liste : cryptemod:

 ' (  (A*clair))

Le problème, c’est que XCAS utilise les restes symétriques. Nous allons donc ruser en utilisant %0 qui permet d’obtenir le nombre entier associé à la classe modulo 27 puis  qui donne le reste de la division euclidienne : crypte:(x-> (x%0,27),cryptemod)

Il ne reste plus qu’à associer ces nombres à des lettres : message:decode(crypte) Réponse du logiciel LQVPQNDUGNPENPAEZ@RYUTFEULHYJXVPLEZ@OJOOQPQKETQF

( On crée une liste avec message : Lb:code(message)

On crée la matrice à 3 lignes associée : brouille:  ( '

 (Lb,3))%27

On utilise l’inverse de la clé pour décoder : clarifie:A^(-1)*brouille

88

0   1 ! 2 )

 2  

On transforme en liste : decryptemod:

 ' (  (clarifie))

On retourne dans N : decrypte:(x-> (x%0,27),decryptemod)

On transforme les nombres en lettres : messageinit:decode(brouille) Réponse du logiciel JE@NE@SUIS@PAS@UN@NUMERO@JE@SUIS@UN@HOMME@LIBRE@

Un espace s’est ajouté au bout pour obtenir un nombre de caractères multiple de 3. Pour une activité plus sophistiquée sur le codage, voir section 7.2 page 247.

89

  Géométrie affine Logiciel(s) abordé(s) : Scilab XCAS

Problématique : Manipuler des objets élémentaires de géométrie affine.

8

# $

Utilisons le calcul matriciel dans le logiciel Scilab.



"         

On cherche la pente a et l’ordonnée à l’origine b d’une droite passant par deux points A et B. A[1;0];B[-1;2] x[A(1) B(1)] y[A(2) B(2)] [a,b] (x,y)



"       )     

On cherche une équation du plan passant par les points A, B, C sous la forme z = a1 x +a2 y +b. La matrice U contient les abscisses et ordonnées, la matrice V contient les cotes. A[1;0;2];B[-1;2;3];C[4;5;6] U[A(1:2) B(1:2) C(1:2)] V[A( ) B( ) C( )] [a,b] (U,V)

On vérifie en tapant : a*U+b

qui donne V.

8 # !"#$ Les fonctions de géométrie affines sont... innombrables, et l’aide est exhaustive.

  )  *  + Vous pouvez par exemple tracer une droite de différentes manières. On ouvre une session 2D en tapant   :

 (2*x+5*y-10) / / à p a r t i r

 ( (1,2), (-3,1)) les

d ’ une //

équation

passant

par

cartésienne deux

points

dont

on

connaît

coordonnées

 (1+,-3+) / / p a s s a n t p a r d e u x p o i n t s d o n t o n c o n n a î t

 ([5+t,-2+2*t],t) / / p a s s a n t p a r l e p o i n t ( 5 , − 2 ) e t d e directeur

les

affixes

vecteur

(1 ,2)

et dans l’espace affine de dimension 3, on ouvre une session 3D en tapant





:

 ([1,2,3],[-1,2,0]) / / o n c o n n a î t d e u x p o i n t s

 (x+y+z0,x2*y) / / i n t e r s e c t i o n d e d e u x p l a n s

 ([1+2*t,-1+t,-3+5*t],t) / / r e p r é s e n t a t i o n p a r a m é t r i q u e



    "

(   Étudions par exemple la symétrie orthogonale d’axe la droite d’équation y = x : d:  (yx) / / o n t r a c e l a M: (4,2) / / o n t r a c e u n m:  (d,M) / / o n t r a c e

droite point son

quelconque

symétrique

Déplacement d’un point à la souris Notons que l’on peut faire bouger M « à la souris » en se plaçant en mode Pointeur. On place le pointeur de la souris devant le point M : un symbole apparaît. Faites un clic droit en maintenant enfoncé et déplacez à volonté le point M.

P: (1,-3) / / u n a u t r e p o i n t p:  (d,P) / / e t s o n i m a g e

  (d,  (m,M)) / /

la

droite

? XCAS r é p o n d 1 p o u r oui et 0  non

   (  (m,M),  (p,P)) elles parallèles ?

 (m,P) / / o n t r a c e l a d r o i t e ( mP )

 (M,p) / / e t l a d r o i t e ( Mp )

( mM )

est − e l l e

orthogonale

à

l ’

axe

92

//

les

droites

( mM )

et

( pP )

sont −

3    est_faisceau_droite(  (m,P),  (M,p),d) elles

?

concourantes

//

( mP ) ,

( Mp )

et

(d)

sont −

 (M,P)- (m,p) / / l e s d i s t a n c e s s o n t − e l l e s c o n s e r v é e s ? R: (3,-6);r:  (d,R) / / u n 3 e m e p o i n t e t s o n i m a g e  (M,P,R) / / u n e m e s u r e e n r a d i a n d e l ’ a n g l e ( MP , MR )  (m,p,r) / / u n e m e s u r e d e s o n i m a g e : l e s a n g l e s s e m b l e n t d e m e s u r e opposées

A:   (   (P,R)) / / A a:  (d,A) / / s o n i m a g e

   (a,   (r,p)) / / sont

est

a

un

élément

quelconque

appartient − i l

à

[ pr ]

de

?

[ PR ]

Les

barycentres

conservés .

 (  (M,P)) / / l ’ é q u a t i o n r é d u i t e

 (  (m,p)) / / l ’ é q u a t i o n r é d u i t e  ( (  (  (M,P)),x)) / / dans

l ’ équation

inversés

par

la

de

( MP )

:

les

rôles

de

de

( MP )

de

( mp )

on x

exprime et

de

y

x

en

ont

fonction

donc

de

y

été

réflexion .

Pour explorer d’autres possibilités, voir la section 5.5 page 215 sur les tangentes à une ellipse et le thème sur le théorème de Pappus page189.

( , On ouvre une fenêtre 3D en tapant





. On peut par exemple étudier un cube :

P: ([2,2,-2]) / / u n p o i n t P cube(P,4) / / u n c u b e d ’ a r ê t e 4 d e s o m m e t P M:   (   (F,G)) / / M u n é l é m e n t q u e l c o n q u e d e [ FG ] I: (  (H,F)) J: (  (F,C)) s1:   (G,E) s2:   (G,B) s3:   (H,M) s4:   (C,M) N:( (s1,s3))[0] / / N e s t l ’ i n t e r s e c t i o n d e [ GE ] e t [ HM ] R: (s2,s4)[0]  (   (N,R), +line_width_2) / / o n t r a c e [ NR ]  (   (E,B), +line_width_2)

   (   (I,J),   (N,R)) / / l e s d r o i t e s ( I J ) −elles

parallèles

?

 (  (E,B,G),+ )

//

on

colorie

le

plan

et

( NR )

sont

( EB G )

et on obtient :

93

  )  *  +

  Parallélisme dans un cube Pour faire du calcul formel, on prend une longueur d’arête quelconque. On crée un cube ABCDEFGH d’arête a :

 (a>0) / / o n s ’ a s s u r e q u e a e s t p o s i t i f P: ((E+G)/2) / / u n e a u t r e m a n i è r e d e d é f i n i r Q: ((F+C)/2) M: ((P+Q)/2)  ( (E,P)) / / o n d e m a n d e l a l o n g u e u r Réponse du logiciel

1 2a 2

On peut demander d’autres longueurs :

 ( (A,P))  ( (A,G)) Réponse du logiciel

 1 sqrt(6)a a 3 2

Pour obtenir la figure, on fixe une valeur pour a :

94

le

EP

milieu

de

[ EG ]

3   

  Cube obtenu avec a=5 Pour étudier des sections planes de surfaces avec XCAS, voir section 5.7 page 220.



.     (  ( (0), (0,-6+x), (x,0))) / / o n d é f i n i t l a fonction

" aire "

P: (a,f(a)) / / o n p r e n d l e p o i n t d e l a c o u r b e y  f ( x ) d  

(P) / / o n d e m a n d e l e s c o o r d o n n é e s d e P  (f(x),x06,   ) / / o n t r a c e l a c o u r b e y  f ( x ) f(x) / / o n d e m a n d e l a f o r m u l e d o n n a n t l ’ a i r e e n f o n c t i o n d e

’ abscisse

a

x

Voici la sortie graphique :

95

  )  *  +

  Aire maximale d’un triangle Pour une autre activité géométrique de Seconde, voir section b. page 69.

8 #   Voici par exemple comment tracer une surface avec des lignes de niveauxa # −−−−−−−−−−−−−−−−−−−−−

définition

# −−−−−−−−−−−−−−−−−−−−−

Lignes

f(x,y)x*x+y*y

de

de

la

niveau

xval2 dx0.1 lignex(x,y) (x> xval-dx && x yval-dy && y (2*x); fd: 



(f); fd(2)

On peut aussi utiliser des fonctions pré-programmées sur XCAS :

 



( > + ) Réponse du logiciel

(‘ x‘)->cos(‘ x‘)*1/2*1/(sin(‘ x‘))*sqrt(sin(‘ x‘))+1

Le symbole @ correspond à la composée de fonction.

On obtient le calcul approché du nombre dérivé avec / (expression,variable,pas), le pas valant par défaut 0, 001, par la méthode du milieu. Par exemple :

/ (((x)),x,0.00001) Réponse du logiciel (ln(ln(x+0.001))-ln(ln(x-0.001)))*500.0

et on transforme cette expression en fonction : fp:((),x)

pour demander f  (2) : fp(2)

115

      4   

  #

Le logiciel Gp se comporte différemment.

( (2*x),x) donne un développement limité (voir section b. page 153).



  4 

Le logiciel Yacas se comporte sans surprise ; il est toutefois sensible à la hauteur de casse des commandes.

/(x)  (2*x) donne le résultat escompté. Le logiciel Yacas connaît quelque chose du calcul différentiel vectoriel. V(x):{x^3*y,x^2*z,x*y} 8(V(x,y,z),{x,y,z})

donne le rotationnel du champ de vecteur tridimensionnel V. La suite de ce chapitre utilise Scilab.

 " ; 

    

Pour une fonction différentiable f à valeurs réelles, le gradient est le vecteur associé à la différentielle par le produit scalaire euclidien.

  yf(x) y (x)^2

     yg(x) y

  (f,x)’

   x[1;1;1] g(x)

La matrice hessienne est celle de l’application linéaire tangente du gradient dans la base canonique.

  Hh(x) [J,H]

  (f,x,order2,H_form’blockmat’)

   x[1;1;1] h(x)

Le rotationnel est le double de la partie antisymétrique de l’application linéaire tangente d’un champ de vecteurs.

116

& !

  yV(x) y (x)^2*x(1)*x

     yrot( ,x) J

  ( ,x) yJ-J’

   x[1;1;1] rot(V,x)

Le rotationnel du gradient est nul : on le voit sur l’exemple  $= &.

 " 

Pour tracer une hélice (figure 11.28), il faut définir séparément les fonction coordonnées.

  xX(t) x(t)

     yY(t) y(t)

     zZ(t) zt

   t0:.1:3*%pi   (X(t),Y(t),Z(t))

10 9 8 7

Z

6 5 4 3 2 1 0 −1.0

−0.6

−0.2 Y

0.2

0.6

1.0

1.0

0.6

0.2

−0.2

−0.6

−1.0

X

   Une partie de l’hélice

117

      4   On définit le vecteur tangent unitaire :

  Mc(t) M[X(t);Y(t);Z(t)]

     vvitesse(t) v

  (c,t)

     vT(t) vvitesse(t) vv/ (v)

   On définit le vecteur normal et la courbure :

  vTprime(t) v

  (T,t)

     ykappa(t) y (Tprime(t))/

     vN(t) vTprime(t) vv/ (v)

  

(vitesse(t))

On définit le vecteur binormal grâce au produit vectoriel :

  vB(t) AT(t)*N(t)’-N(t)*T(t)’ zA(1,2) xA(2,3) yA(3,1) v[x;y;z]

   On peut vérifier que la base est orthonormée en un point : A[T(1) N(1) B(1)] A*A’

La matrice AA doit être proche de l’identité. On définit alors la torsion :

  vBprime(t) v

  (B,t)

     ytau(t) yBprime(t)’*N(t)/

  

(vitesse(t))

Courbure et torsion devraient être constantes dans le cas de l’hélice ; comme on fait des dérivées approchées jusqu’à l’ordre trois, il y a beaucoup d’erreur dans la torsion (figure 11.29) ;

118

 !5



 ' (t,kappa,style5)  ' (t,tau,style13)

   La courbure de l’hélice en rouge et sa torsion en vert

 $ 0, alors f atteint un

➥

δ = r t − s 2 > 0 et ∂x 2 (x0 , y 0 ) < 0 ou maximum relatif au point (x0 , y 0 );

➥

δ = r t − s 2 > 0 et ∂x 2 (x0 , y 0 ) > 0 ou minimum relatif au point (x0 , y 0 );

➥

δ = r t − s 2 < 0, alors f présente un point de selle au point (x0 , y 0 );

➥

δ = r t − s 2 = 0, alors le théorème ne permet pas de conclure.

135

      4   Cherchons les extrema relatifs de la fonction f : (x, y) → 6x y 2 − 2x 3 − 3y 4 qui est de classe C ∞ sur R2 . f:(x,y)->6*x*y^2-2*x^3-3*y^4

Cherchons ses points critiques :

 ([ (f(x,y),x)0, (f(x,y),y)0],[x,y]) Réponse du logiciel

⎤

⎡ 0

⎢ ⎢ ⎢ 0 ⎢ ⎢ 1 ⎢ ⎢ ⎢ 0 ⎣ 1

0

⎥ ⎥ 0 ⎥ ⎥ −1 ⎥ ⎥ ⎥ 0 ⎥ ⎦ 1

Il y a donc trois points critiques. Essayons de les classer avec le théorème précédent. On va utiliser la fonction  (()f(x,y),[x,y]) ou (f(x*y),[x,y],2) qui donnent la matrice hessienne de f qui est la matrice des dérivées d’ordre 2, c’est-à-dire :

 (F(x,y),[x,y]) Réponse du logiciel

⎡ ⎣

∂F(x,y ) ∂x 2 ∂F(x,y ) ∂x y

∂F(x,y) ∂x y ∂F(x,y) ∂y 2

⎤ ⎦

Dérivées partielles et XCAS On obtient et

Ici :

136

∂F(x,y ) ∂x y

∂F(x,y ) ∂x 2

en rentrant diff(F(x,y),x,2)

en rentrant diff(F(x,y),[x,y],[1,1])

, " )!  5   R2   R   H: (f(x,y),[x,y]) Réponse du logiciel



− (6 · 2 · x) 12 · y

6·2· y   6 · x · 2 − 12 · 3 · (y)2



Il s’agit de déterminer le déterminant de cette matrice qui, attention, est une expression. On utilisera donc astucieusement la commande  (ancien=nouveau) : delta:(a,b)-> f2:(a,b,V)->

( (

(H),xa,yb)

( ( (f(x,y),V,2),xa,yb)

Alors : delta(1,1);delta(1,-1);delta(0,0)

et : f2(1,1,x);f2(1,-1,x);f2(0,0,x)

nous permettent d’affirmer que f atteint un maximum relatif aux points (1 ; 1) et (− ; −1). La représentation graphique va nous permettre de confirmer ce résultat et de constater que (0 ; 0) est un point de selle :

   Surface d’équation z = 6x y 2 − 2x 3 − 3y 4 Pour un exposé vivant, intéressant, abordable, bref québécois de ces notions, voira . a A MYOTTE , Luc Introduction au calcul avancé et à ses applications en sciences . Québec: ERPI, 2004.

137



Intégration Logiciel(s) abordé(s) : Yacas Maxima Scilab XCAS MuPAD

Problématique : Des primitives formelles et des intégrales numériques peuvent être obtenues.

 

  

  4 

Pour trouver une primitive avec Yacas, il suffit de taper :

0  (x) 3(x) et pour obtenir son intégrale sur l’intervalle [0, π] : A:0  (x,0,4()) 3(x) ((A,20)

La dernière commande donne le résultat approché avec une précision arbitraire de vingt décimales. Des primitives plus compliquées ne lui font pas peur :

0  (x) )(x) Mais Yacas a ses limites :

0  (x)

(1+(2(x))^2)^(1/2)

ne donne rien.



   3

Pour obtenir une primitive de sin(x), avec le logiciel Maxima, il suffit de taper :

  ((x),x); et pour obtenir son intégrale sur l’intervalle [0, π] :

  ((x),x,0,%pi); Des primitives plus compliquées ne lui font pas peur :

          ((x),x);   ( (1+( (x))^2),

x);

Pour la dernière, il faut savoir que la notation .30(@ désigne l’argument sinus hyperbolique, noté Argsh en mathématiques. Maxima peut trouver la primitive d’une fraction rationnelle : R(x):=1/(x^3+x^2+x+1);

  (R(x),x);

Mais une autre fraction rationnelle peut lui faire baisser les bras : S(x):=1/(x^3+x+1);

  (R(x),x);

Dans ce cas, il y a peut-être une solution en utilisant les bonnes vieilles méthodes de l’âge du papier et du crayon.



    

La décomposition en éléments simples consiste à décomposer en facteurs irréductibles dans R le dénominateur de la fraction (mise sous forme irréductible) ; la fraction se décompose en somme de fractions construites à partir de ces facteurs. Intégrer séparément chaque terme est souvent plus facile que le problème de départ. Commençons par le cas dont on connaît déja le résultat ; R(x):=1/(x^3+x^2+x+1); RR(x):= (R(x),x); RR(x);

La fraction est décomposée en

1 x −1 − 2(x + 1) 2(x 2 + 1)

L’instruction

  (RR(x),x); donne le même résultat que la primitive de R, quoique un peu moins bien simplifié. Prenons maintenant le cas difficile. La décomposition en éléments simples ne fonctionne pas non plus. S(x):=1/(x^3+x+1);

 (S(x),x);

La différence, c’est que nous pouvons attaquer le problème sous l’angle des polynômes, où la boîte à outils est bien fournie. P(x):=x^3+x+1; A: (P(x)=0); PP(x):=(x-(A[1]))*(x-(A[2]))*(x-(A[3])); Q(x):=1/PP(x);

140

   

La fraction Q est la même que S, sauf que nous avons indiqué à la machine la factorisation du dénominateur.



Attention : à partir du degré 5, il n’y a plus de formule algébrique universelle pour extraire les racines d’un polynôme. . .

T(x):= (Q(x)); TT(x):=  (Q(x),x);

donnent des réponses complexes. Pour obtenir des réponses réelles,

  (T(x)); entraîne la question de Maxima : Réponse du logiciel

Is

SQRT(31) 1 1/3 SQRT(31) 1 2/3 3 (--------- - -) x - 3 (--------- - -) 6 SQRT(3) 2 6 SQRT(3) 2

+ 1

positive or negative?

Il faut répondre à l’alternative par exemple :

  ; De même, l’instruction

  (TT(x)); avec la même réponse que précédemment donne une expression formelle pour une primitive de la fonction S. Mais Maxima n’arrive pas à calculer une valeur pour l’intégrale sur un intervalle donné. On peut utiliser alors une fonction de calcul approché pour les intégrales :

  (S(x),x,2,3); qui donne une valeur numérique.



Attention : L’instruction romberg(Q(x),x,2,3); ne fonctionnerait pas. . .

141

        

   

Le logiciel Scilab calcule des intégrales approchées avec l’instruction   mais elle n’accepte pas les fonctions internes du logiciel. La commande intg(0,%pi,sin) est invalide. La bonne procédure est la suivante : function y=f(x) y=(x) endfunction intg(0,%pi,f)

Pour tracer le graphe de la primitive du logarithme népérien qui s’annule en 1, on commence par définir les fonctions nécessaires. function y=f(x) y=(x) endfunction function y=F(x) y=intg(1,x,f) endfunction t=1:1:3;

Mais là, aucune des instructions fplot2d(t,F), /plot(t,F(t)), plot(t,t*log(t)-t) n’est valide. Il faut accumuler les valeurs scalaires dans un vecteur : Y=[] for x=t Y=[Y F(x)]; end plot(t,Y)

ce qui donne la figure 12.49.

1.4

1.2

1.0

0.8

0.6

0.4

0.2

0.0 0.0

0.5

1.0

1.5

2.0

2.5

    Graphe de x log(x) − x + 1

142

3.0

   



   

Les instructions de base de XCAS ressemblent à celles de Maxima et les résultats sont similaires.

  ((x),x)   ((x),x,0,) Le passage par les décompositions en éléments simples est plus rapide. Les instructions suivantes donnent les mêmes résultats que sous Maxima. R(x):1/(x^3+x^2+x+1)  (R(x),x)   (R(x),x) S(x):1/(x^3+x+1)  (S(x),x)   (S(x),x)

Mais le logiciel XCAS ne sait pas trouver les racines du dénominateur de S. L’instruction

  (S(x),x,2,3) donne le calcul approché sans problème. Passons à un calcul de primitive plus intéressant. . . XCAS peut passer le Grand Oral de l’X :

 ( (( (x))^2+1),

x)

donne : Réponse du logiciel

 − ln



!! (tan (x))2 + 1 − (tan (x))

  

MuPAD serait lui recaléa : int(sqrt((tan(x))^2+1), x)

ne répond rien. Mais MuPAD a d’autres arguments : int(x^n* (x),x)

donne : Réponse du logiciel

Γ(n + 1, −x) (−1)n

a C’est ça de ne pas être libre...

143

       

 "'         % % 



   

  5  On utilise  (expression, ancien=nouveau), que vous pouvez comparer à la commande subsop vue au paragraphe e. page 33 pour les listes. Par exemple :

 (g(a*x),x,p)- ((1/a)* (g(t),t,p/a),tx*a) qui répond : Réponse du logiciel

"+∞ 0

⎛

⎞ pxa ! − " 1 ∞ g(ax)e−(px) dx − ⎝ 0 g(xa)e a a dx⎠ a

! # $ 1 a pour les transformées de Laplaceb nous permet de voir que L f (ax) = F a p

       La fonction  (F(x)*g(x),G(x)) renvoie la liste [F(x)*G(x),-f(x)*G(x)] si G(x)= 0 et  ([F(x),g(x)]) renvoie F(x)+G(x) avec les notation habituellesc . " Cela nous permet de construire une procédure ipp(F(x),g(x)) qui renverra F(x)g (x) dx calculée par une intégration par parties : ipp(F(x),g(x)):{  ( (F(x)*g(x), (g(x),x)),0) }:;

Par exemple : ipp((x),1)

donne : Réponse du logiciel -x+x*ln(x)

qui est en effet une primitive de 1 × ln(x). Si l’on veut l’évaluer sur un intervalle, on peut utiliser à renvoie F(b)-F(a) : b Voir section 15.2 page 170. c F une primitive de f.

144

 (F(x),a,b,variable) qui

         2     

 (ipp((x),1),2,3) renvoie bien : Réponse du logiciel 3*ln(3)-3-2*ln(2)+2

Mais XCAS n’a pas besoin de nous pour avoir cette idée :

 ((x));  ((x),x,2,3) renvoie directement le résultat. Cette nouvelle procédure peut nous être utile dans un calcul formel. Par exemple : ipp(f(x), (g(x),x))

renvoie bien sûr : Réponse du logiciel



f (x)g(x) dx + g(x)f(x)

qui nous rappelle la formule d’intégration par parties. Mais cette méthode a ses limites, comme nous allons le voir.

    6  Ce sont les intégrales du type Wn =

π/2

sinn (x) dx

0

En particulier π/2 0

sinn+2 (x) dx =

π/2 0

sinn (x) dx −

π/2

sinn (x) cos2 (x) dx

0

sachant que sin2 (x) = 1 − cos2 (x). Il faudrait donc calculer On pense à une intégration par parties. Mais si on tape :

"π/2 0

sinn (x) cos2 (x) dx.

ipp(((x))^n*((x))^2,(1/(n+1))*((x))^(n+1))

cela ne donne rien. Nous allons donc revenir à ibpdv. r: (((x))^n*((x))^2,(1/(n+1))*((x))^(n+1))

145

        Le logiciel répond cette fois quelque chose, mais cela reste compliqué. La ruse est de changer sinn+1 (x) en n+1 1 sinn (x)sin(x). Alors r: (((x))^n*((x))^2,(1/(n+1))*((x))^(n)*(x))

répond : Réponse du logiciel

1 (sin (x))2 (sin (x))n (sin (x))n sin (x) cos (x) , n +1 n +1

Nous avons besoin de faire une petite pause pour expliquer ce phénomène...

Comment XCAS traite-t-il x n ? Si vous interrogez XCAS sur (f(x),x), il vous répondra Réponse du logiciel

n

xn x

sans jamais vouloir simplifier ce résultat en nx n−1 . C’est que XCAS fait du calcul formel et considère x n non pas comme un polynôme mais comme une variable indépendante. C’est plus simple et plus efficace pour l’ordinateur, même si ça apparaît plus compliqué pour les faibles humains que nous sommes. Dans le cas qui nous occupe, en n’introduisant pas sinn+1 (x) qui serait une nouvelle variable, on laisse XCAS traiter le problème avec deux variables : sinn (x) et sin(x). Alors XCAS arrive à intégrer par parties et à simplifier le résultat alors que par exemple MuPAD n’y arrive pas alors qu’il traite (ou plutôt parce qu’il traite) le problème plus mathématiquement qu’informatiquement.

On peut encore simplifier le résultat avec la commande  qui justement simplifie autant que possible une expression trigonométrique en utilisant en priorité des sinus car XCAS considère les sinus comme des variables. Dans le cas qui nous occupe, après avoir rentré :

146

         2     

(r[1]) on obtient : Réponse du logiciel

(sin (x))2+n n+1

Pour revenir aux intégrales de Wallis, il nous reste à évaluer r[0] entre 0 et

π 2

:

 (r[0],0,Pi/2) nous renvoie bien 0. Finalement, nous obtenons la relation de récurrence : Wn+2 = Wn −

1 Wn+2 n +1

qui nous permet de calculer les termes pairs et impairs, ou plus directement : W(n): (((x))^n,x,0,Pi/2)  (W(k),k014)

donne : Réponse du logiciel π

π 2 3π 8 5π 16 35π 128 63π 256 231π 1024 429π 2048 6435π 32768 12155π 2 , 1, 4 , 3 , 16 , 15 , 32 , 35 , 256 , 315 , 512 , 693 , 2048 , 3003 , 4096 , 6435 , 65536 , 109395 , 131072



  

Pour l’intégration par parties, on utilise  -- (hold(int)(f(x),x= ),v(x)). "1 Ainsi, on peut intégrer par parties 0 x n ex dx :

 (n, 2 --NonNegInt):  (n>0,and_); simplify(intlib--byparts( (int)(x^n* (x),x01), (x))) qui répond : Réponse du logiciel

e−n

1

xn−1 ex dx

0

147

       

 " %% '  



!      

Pour avoir une approximation de l’aire sous la courbe, on peut l’approcher par des rectangles élémentaires. Voici une petite procédure de construction : Rect(f,N,a,b):{  RV,RR,R,k,av,ap,C; RV:()); RR:()); (k:0;k(x),n,0,2*Pi)

   Méthode des rectangles « personnelle » Pour être honnête, il existe déjà   (expr,x=a..b,n,méthode) sur XCAS qui permet d’obtenir ce résultat, où méthode peut-être     ,     ,  " ,   .

 (  ((x),x02*Pi,20,rectangle_droit), ), (   ((x),x02*Pi,20,rectangle_gauche),  ) 148

&   !  2 ) 2 

   Méthode des rectangles « à la XCAS » Ce qui nous intéresse est bien sûr d’avoir une approximation numérique : aireRect(f,N,a,b):{ ((b-a)/N*f(a+k*(b-a)/N),k1N)); }:;

(

//

subdivision

régulière

aireRect(x->(x),100,1,10) Réponse du logiciel 14.02524361

alors qu’avec par la fonction de calcul approché 0 : nInt((x),x110)) Réponse du logiciel 14.02585093

Nous avons donc 3 bonnes décimales avec 100 rectanglesd .



     )  3   π   

Il n’est pas trop difficile de trouver un rapport entre la fonction f : x →



1 − x 2 et π :

4*aireRect(x-> (1-x^2),1000000,0,1)

Avec 1000000 de rectangles et 76 secondes, on obtient difficilement 5 décimales de π. . . d Pour avoir des précisions sur le calcul approché d’intégrales avec XCAS, voir la section b. page 52.

149

         Match Scilab/XCAS sur l’approximation d’intégrales Interrogeons XCAS pour obtenir une approximation de

1 % 0

1 − x 2 dx :

4*nInt( (1-x^2),x,0,1) Réponse du logiciel [3.141580789,3.14158081,3.141580816,3.141580817, 3.141580817,3.141580818,3.141580818]

soit au mieux 4 bonnes décimales. En effet, la singularité de la dérivée en 1 brouille les algorithmes basés sur la formule d’Euler-Mac Laurin. Quant à Scilab :

  yf(x) y (1-x**2)

     (20) 4* (0,1,f) Réponse du logiciel ans

=

3.1415926535897926719088

alors qu’une valeur approchée de π est : %pi Réponse du logiciel %pi

=

3.1415926535897931159980

c’est-à-dire que Scilab donne 16 bonnes décimales : Scilab a gagné ? Eh non... Parfois le calcul formel a du bon ! Si vous demandez à XCAS : 4*

(  ( (1-x^2),x,0,1))

il vous donne 1000 bonnes décimales de π, la limite de / .

150

&   !  2 ) 2 

Approximation de π avec la formule de Machin & & & 2n+3 n (−1)k x 2k+1 & ' & x & . Vous savez bien que &Arctan(x) − &< & 2k + 1 & 2n + 3 k=0 On peut donc construire une procédure dépendant d’un nombre ! compris entre 0 u 2n+3  10−p : et 1 et donnant la plus petite valeur de l’entier n telle que 2n + 3 mini(u,p):{  k; k:0;  ( ((u^(2*k+3))/(2*k+3))>10^(-p)){ k:k+1} }:;

Vous connaissez également la formule du mathématicien anglais M ACHIN : 4 arctan

1 1 π − arctan = 5 239 4

obtenue en montrant que, a et b étant deux réels tels que ab = 1, on a arctan a +   a+b arctanb = arctan 1−ab + επ avec ε = 0 si ab < 1, ε = 1 si ab > 1 et a > 0 et ε = −1 si ab > 1 et a < 0. n (−1)k X 2k+1 ' On appelle polynôme de G REGORY le polynôme Gn (X) = . 2k + 1 k=0 On construit donc une procédure qui donne une valeur approchée de Gn (a) à 10−p près : greg(n,a,p):{  S,k; S:0; (k:0;k0):; F:x->b* (x^2/a^2-1) a:2:; b:1:; H: (F(x),x25):; H1:  ( (0),H):; H2:  (  (x0),H):; H3:  (  (y0),H):;  (H, +   B), (H1,  +   B),  (H2,+   ), (H3,   ) ce qui donne :

  Étude analytique de l’hyperbole

213

   

, )    %  /  %   Ouvrons une fenêtre de géométrie de coordonnées (x ; y).



+



MF = eMH

. On crée un point fixe F et un point quelconque

F: (0,0); M: (x,y):;

On crée deux éléments variables d, qui caractérise la directrice, et E, l’excentricité. d:  E: 

 ((-5) 

 (0  2)

5)

On crée le projeté de M sur la directrice : H:,  (  (xd),M)

On trace le lieu du point M vérifiant MF = eMH avec    (f(x,y),x,y) qui trace la courbe d’équation implicite f (x, y) = 0 et  '(A,B) qui calcule le carré de la distance AB.

 (   ( '(M,F)-E*( '(M,H)),x,y), ) et la directrice :

 (  (xd), ) On visualise alors parfaitement les 3 cas : e < 1, e = 1 et e > 1.

, - &       

 ) 

 − →  −ı un vecteur unitaire Soit Ω le centre de l’ellipse. Dans le repère orthonormé Ω; → ı , −j , avec → 2

y2

de la droite vectorielle associée au grand axe, l’ellipse admet pour équation ax 2 + b 2 = 1. Les résultats suivants s’obtiennent classiquement avec les notations usuelles dans le cas a > b:

    @

➥ c = a2 − b2

c a

F (−c ; 0)

➥ F(c ; 0) ➥ D: x =

e=

a2 c

2

D : x = − ac

On peut demander à XCAS de faire le travail : foyer_ellipse(a,b):{  c,E; (a1   pluriel’s’ ;  pluriel’’ ;  ; chaine’Il y a ’+ (s)+’ gamme’+pluriel+’ solution’+pluriel  (%io(2),chaine)

  

5 -   



Le logiciel Scilab permet de fabriquer des sons sous forme de fichiers d’extension « .wav ». Le son de l’orgue éléctronique modélisé grossièrement ici est produit par des oscillateurs à circuits bobine-condensateur. Dans le circuit magnétique de chaque bobine tourne une roue d’une certaine forme, ce qui change l’auto-inductance de la bobine et donc la fréquence de la note. Les électroniciens appellent cela une modulation de fréquence et les musiciens un vibrato. (Quand la variation de fréquence est plus ample, ils parlent respectivement de wobulation et de glissando.) //

attention

//

pour

t

ne

doit

pas

être

un

tableau

  uorgue(t,frequence,rotationRoues,profondeur,nuance) omega(1+profondeur *(t*rotationRoues *2*%pi))*2*%pi*frequence une

énergie

indépendante

de

amplitudenuance/(1+frequence/441) uamplitude *(t*omega) ;

la

fréquence

  

La fabrication de la matrice de réels qui représente l’échantillonnage sonore à 44100Hz utilise la fonction précédente. La fonction v ci-dessous sera construite à partir de la fonction orgue ci-dessus.

  Zconcret(v,duree,frequence,rotationRoues,profondeur,nuance) intervallesoundsec(duree,44100) ; Z[]  kintervalle, Z[Z v(k,duree,frequence,rotationRoues,profondeur,nuance)];



   L’écriture des échantillons numériques dans un fichier sonore se fait automatiquement. L’instruction y=[u’,v’] ; wavwrite(y,44100,16,nom) donnerait des résultats bizarres.

  ysortie(u,v,nom) 238

/ $      y[u;v] ; ynom

  (nom,y,44100)

   Il reste à écraser les extrémités pour diminuer les dégâts du jeu en boucle.

  yenveloppe(t,duree,frequence,rotationRoues,profondeur,nuance)  or([t0 tduree])   y 0 ;  yyorgue(t-duree/2,frequence,rotationRoues,profondeur,nuance) ; yyy* (100*t)* (100*(duree-t));



   Puis à utiliser les fonctions précédentes en initialisant les variables. rotationRoues7 / / l e s r o u e s t o u r n e n t à  . h e r t z profondeur.003 frequence441 / / l a d u d i a p a s o n nuance.999 / / f f f f o n n e p e u t p a s a l l e r p l u s l o i n  . zconcret(enveloppe,2,frequence,rotationRoues,profondeur,nuance); nom’orgueA3.wav’ nom’orgueBIS.wav’ sortie(z,z,nom)

La fabrication automatique du sons peut produire des échantillons pour un séquenceur informatique. La grandeur d’une octave pour l’oreille humaine, c’est-à-dire le coefficient multiplicateur que l’on applique aux notes quand on les élève d’une octave, est légèrement supérieure à deux, et varie en fonction des personnes et des circonstances. Dans le tempérament égal, les douze notes sont équiréparties en moyenne géométrique le long de l’octave. Profitons-en pour construire des fonctions logarithme et exponentielle musicales.

  ylm(x,octave) y(x)*12/(octave)

     yem(x,octave) y (x*(octave)/12)

   Les fichiers-sons se répartissent au long de la tessiture du séquenceur, qui contient typiquement 128 notes (dix octaves et demie). On peut aller jusqu’à un échantillon par note ; on se contente ici d’un échantillon par octave : évidemment l’effet vibrato sera hétérogène. . . Pour créer un nouveau répertoire où placer les encombrants fichiers-sons, il suffit d’exécuter dans Scilab une commande shell :

 (’mkdir

Sons’)

L’automate est prêt à être écrit ; le lecteur pourra aisément modifier la liste et le nombre des échantillons (le séquenceur risque de rouspéter s’il en charge plus de 128), puisque tout passe par la gestion des chaînes de caractères. Il faut juste repérer la position dans la liste de la note de référence pour le diapason (441Hz).

239

 %  =    ysequence(duree,rotationRoues,profondeur,nuance,octave) n-2:8;N (n) gamme[’A’] suite[]  kN, suite[suite gamme+k];



 ksuite, nom’orgue’+ (k)+’.wav’ ; ivectorfind(suite,k,’c’)-5 / / 5 e s t l a p l a c e d u l a 3  . frequence441*em(i*12,octave) / / 4 4 1 Hz p o u r l e l a d u d i a p a s o n zconcret(enveloppe,duree,frequence,rotationRoues,profondeur,nuance)

;

sortie(z,z,’Sons/’+nom) ;



ysuite

  

Les données nécessaires sont rentrées ; il faut plusieurs secondes sur une machine ordinaire pour produire une note d’une seconde. Augmenter le nombre d’échantillons et la durée sera gourmand en temps de calcul. octave2.01 rotationRoues7 / / profondeur.003 nuance.999 / / f f f f duree1

les

le

roues

maximum

tournent

à

 .

hertz

 .

Il ne reste plus qu’à se jeter à l’eau. sequence(duree,rotationRoues,profondeur,nuance,octave)

240

  Carrés magiques Logiciel(s) abordé(s) : Scilab

Problématique : Résoudre des problèmes amusants en apprenant la manipulation des matrices sans s’en apercevoir.

Les carrés magiques portent aussi un nom japonais imprononçable en français (sudoku). Les problèmes sont des tableaux de 9 lignes et 9 colonnes ; certaines cases sont déja remplies. Le joueur doit remplir les cases restantes en respectant des contraintes géométriques : la suite des nombres de 1 à 9 doit apparaître exactement dans chaque ligne, dans chaque colonne, et dans chacun des neuf sous-carrés de trois cases par trois découpés dans le tableau. Prenons un problème donné en remplaçant les cases vides par des zéros. m" (9,9); m(1,[1 4 5 8])[5 4 m(2,[4 6 7 9])[5 2 m(3,[1 3 5 9])[7 4 m(4,[1 5 7 8])[1 9 m(5,[3 4 5 6 7])[9 m(6,[2 3 5 9])[4 7 m(7,[1 5 7 9])[9 2 m(8,[1 3 4 6])[2 1 m(9,[2 5 6 9])[8 7 m

8 4 1 2 1 3 3 6 3

6]; 1]; 2]; 3]; 4 8 6]; 9]; 6]; 4]; 5];

La dernière instruction affiche la matrice du problème. la matrice m est une matrice 9 par 9 dans la quelle on stocke les données et où l’on stockera les réponses progressivement. Les premiers outils pour manipuler les neuf nombres sont initialisés. I (9,9) ; uI; d2*I; t3*I; q4*I; c5*I; s6*I; e7*I; h8*I; n9*I;

Un transfert pour faciliter les itérations est nécessaire.

  [M,U,D,T,Q,C,S,E,H,N]egale(m,u,d,t,q,c,s,e,h,n) Mm;Uu;Dd;Tt;Qq;Cc;Ss;Ee;Hh;Nn;

   Un infâme bricolage pour numéroter les matrices extraites ne devrait faire peur à personne.

 '        znumero(k) kk  (k,3) ; K(k-kk)/3

  

; zz

(kk,K)+2*K/3

; z

((zz),2)

Quand une case de la matrice M est remplie, on procède aux éliminations dans la matrice Y, qui sera l’une de celles où sont stockés les nombres encore inutilisés.

  Zannulation(Y,M) ZY  k1:9  l1:9  M(k,l)~0    Z(k,l)M(k,l)   Z(k,:)0;Z(:,l)0;Z(k,l)M(k,l); Knumero(k);Lnumero(l);Z(3*K+[1:3],3* L+[1:3])0;Z(k,l)M(k,l);

 Z(k,l)0 ;









   La première action pour remplir la matrice est de vérifier les nombres qui ne sont utilisés qu’une fois dans chaque ligne ou colonne.

  Mattribution(m,u,d,t,q,c,s,e,h,n) //

s ’ il

//

on

n’y

a

remplit

qu ’ u n e la

réponse

case

par

ligne

ou

de M c o r r e s p o n d a n t e

par

Mm liste[’u’,’d’,’t’,’q’,’c’,’s’,’e’,’h’,’n’] compteur1

// boucle1

 yliste Y  (y) colonne

(Y,’r’) ; ligne (Y,’c’)

// boucle2

 j1:9

//

si

une

seule

réponse

// boucle3



colonne(j)compteur

// boucle4

 k1:9

// boucle5



M(k,j)0   M(k,j)Y(k,j)



// f i n

de



242

sur

boucle5

la

 

colonne

colonne

/ $     

// fin

de

boucle4

// fin

de

boucle3

// fin

de

boucle2





// boucle2bis

 j1:9

//

si

une

seule

réponse

sur

// boucle3bis



ligne(j)compteur

la

ligne

 

// boucle4bis

 k1:9

// boucle5bis



M(j,k)0   M(j,k)Y(j,k)



// fin

de

boucle5bis

// fin

de

boucle4bis

// fin

de

boucle3bis

// fin

de

boucle2bis

de

boucle1







compteurcompteur+1



// fin

  

Si tous les nombres sauf un ont été éliminés pour un emplacement donné, l’emplacement peut être attribué.

  MATTRIBUTION(m,u,d,t,q,c,s,e,h,n) //

si

//

compte

un

//

on

seul tenu

remplit

chiffre de la

est

toutes case

apparaît les

possibilités

de M c o r r e s p o n d a n t e

Mm liste[’u’,’d’,’t’,’q’,’c’,’s’,’e’,’h’,’n’]

// boucleA

 k1:9

// boucleB

 l1:9

verticale" (9,1) compteur1

// boucleC

 yliste Y  (y)

verticale(compteur)Y(k,l)

243

 '      compteurcompteur+1



// f i n

de

boucleC

//

seul

test (verticale) un

chiffre

est

?

possible

// boucleCbis



test  (verticale) M(k,l)test

 



// f i n

de



// f in

boucleCbis

de



// f i n

boucleB

de

boucleA

  

Le travail fait par la fonction attribution suivant les lignes et colonnes est fait dans les tableaux extraits par la fonction attripb.

  Mattrib(m,u,d,t,q,c,s,e,h,n) //

s ’ il

//

on

n’y

a

remplit

qu ’ u n e la

case

réponse

par

matrice

3

par

3

extraite

de M c o r r e s p o n d a n t e

Mm liste[’u’,’d’,’t’,’q’,’c’,’s’,’e’,’h’,’n’] compteur1

// boucle1

 yliste Y  (y)

// boucle2

 K0:2

// boucle3

 L0:2 ZY(3*K+[1:3],3* L+[1:3]) test (Z)

//

si

une

seule

// boucle4



réponse

testcompteur

// boucle5



sur

 

kk1:3

// boucle6

 ll1;3 k3*K+kk ; l3*L+ll

// boucle7



M(k,l)0   M(k,l)Y(k,l)



// f i n

244

de

boucle7

la

matrice

3

par

3

extraite

/ $     



// fin

de

boucle6

// fin

de

boucle5

// fin

de

boucle4

// fin

de

boucle3

// fin

de

boucle2

de

boucle1









compteurcompteur+1



// fin

  

Maintenant vient le travail recherché : toutes les éliminations et les attributions sont rassemblées.

  //

la

[M,U,D,T,Q,C,S,E,H,N]op(m,u,d,t,q,c,s,e,h,n)

fonction

principale

[M,U,D,T,Q,C,S,E,H,N]egale(m,u,d,t,q,c,s,e,h,n) liste[’U’,’D’,’T’,’Q’,’C’,’S’,’E’,’H’,’N’]  yliste Y  (y) Zannulation(Y,M)

 (y+’Z’)



MMattribution(M,U,D,T,Q,C,S,E,H,N)  yliste Y  (y) Zannulation(Y,MM)

 (y+’Z’)



MMMATTRIBUTION(MM,U,D,T,Q,C,S,E,H,N)  yliste Y  (y) Zannulation(Y,MMM)

 (y+’Z’)



Mattrib(MMM,U,D,T,Q,C,S,E,H,N)

  

Le nombre d’itérations et le drapeau d’arrêt sont initialisés. stop0 longueur0

La boucle d’itération utilise les fonctions précédentes.

245

 '      

stop0

//

une

étape

de

//

mesure

de

//

est −ce

fini

travail

[M,U,D,T,Q,C,S,E,H,N]op(m,u,d,t,q,c,s,e,h,n) ; l ’ effort

longueurlongueur+1 ;



?

[M,U,D,T,Q,C,S,E,H,N][m,u,d,t,q,c,s,e,h,n] stop1 ;

 



[m,u,d,t,q,c,s,e,h,n]egale(M,U,D,T,Q,C,S,E,H,N) ;



Quand la machine s’arrête, le point d’arrivée est affiché avec l’effort fourni.

(m);

(longueur); Si ça bloque avant de trouver une solution, c’est qu’on ne peut pas continuer par élimination : il faut fixer une valeur arbitraire dans M (de préférence où la collision est faible). Les instructions suivantes donnent des indications. collisionu+d/2+t/3+q/4+c/5+s/6+e/7+h/8+n/9-1 ;

(u); (d); (t); (q); (c); (s); (e); (h); (n)

La valeur candidate est rentrée dans m avec une instruction du type m([i,j])valeur

Ensuite il faut réitérer l’ensemble d’instructions : [m,u,d,t,q,c,s,e,h,n]op(m,u,d,t,q,c,s,e,h,n) ; collisionu+d/2+t/3+q/4+c/5+s/6+e/7+h/8+n/9-1 ; m

Si un nombre de collision devient strictement négatif, il n’y a pas de solution : la valeur arbitraire était mauvaise, il faut tout recommencer avec une autre valeur arbitraire. Ou alors il fallait archiver sous d’autres noms les dix matrices m, u. . . n avant de rentrer le candidat. . .

246

  Codes correcteurs d’erreurs

Logiciel(s) abordé(s) : XCAS

Notions informatiques : Les codes correcteurs nous ferons travailler dans des corps finis (F2 en l’occurence) ce qui nous permettra d’approfondir le calcul modulaire. Le travail principal se fera cependant sur la manipulation des matrices. Nous évoquerons également le travail dans les corps de Galois. Nous ne ferons que survoler la partie mathématique (pour un développement très pédagogique, voir a et pour une étude plus complète, voir b ) pour nous concentrer sur l’exploitation informatique. Nous utiliserons XCAS. Problématique : Une information est codée sous la forme de bits (binary digits), donc d’éléments d’un F2 -espace vectoriel. Elle est ensuite transmise puis décodée. Un message sera donc représenté par un vecteur de Fn2 . La transmission altère parfois l’information : ainsi on récupère un vecteur transmis qui n’est pas forcément celui d’origine. Le but de l’activité est d’utiliser un code qui permetttra de détecter les erreurs et même de les corriger : on créera d’abord une procédure « naïve » qui dépendra de la matrice de codage et du vecteurmessage à tester et qui dira si ce vecteur a été mal tansmis et par quel « bon » vecteur le remplacer. Nous évoquerons ensuite une procédure plus efficace mais qui ne concernera que les codes de Hamming. Enfin, nous travaillerons dans des corps de Galois pour créer des polynômes générateurs.

a B RUGÈRE , Thierry/M OLL ARD , Alain Mathématiques à l’usage des informaticiens. Paris: Ellipses, 2003 b B ADRIKIAN , Josèphe Mathématiques pour téléinformatique : codes correcteurs. Paris: Ellipses, 2002

 )       ,  

8 

/ '  A      Fk2

Nous voudrions écrire les 2k vecteurs de Fk2 sous forme de listes de longueur k. Plusieurs options s’offrent à nous. Une des plus simples sur F2 est de compter jusqu’à 2k − 1 en base 2. Par exemple, pour écrire n en base 2, on pourrait utiliser la fonction   (n,base,b) qui convertit un nombre n, L:[]; L: (  (n, ,2),L);

mais ça nous le donne en sens inverse... On peut aussi faire des divisions euclidiennes successives. Le problème, c’est que ces vecteurs ont un nombre de composantes variable. Une petite astuce fixe le nombre de composantes à k : Fdeux(n,k):{  L; L:[];  (n>2){ L: ([ n:(n,2);

(n,2)],L);

} L: ([n],L);  (" (L)0)  (v+" doit être corrigé

 {q:q+2^k;  (v+" doit être

en "+Ima[q]%0); corrigé en "+Ima[q]%0);} };

}

Maintenant, si l’on demande decod1(A,[1,1,1,0,0,0,0])

on obtient Réponse du logiciel "Le code est 1-correcteur" "Le code est parfait" "[1,1,1,0,0,0,0] doit être corrigé en [1,1,1,0,0,1,0]" Evaluation time: 0.27

Le problème, c’est que cette procédure induit un nombre assez important de calculs qui la rendent inefficace pour des codes de longueur assez grande : par exemple, si on choisit n = 32 et p = 6, il faut 16 GB pour mémoriser les 232 vecteurs de 32 bits chacun... Il va donc falloir appeler les mathématiques au secours !

8 "  &  % &@    Un code est dit cyclique si, et seulement si, pour tout mot de code m, tout mot obtenu par permutation circulaire des coordonnées est encore un mot de code. Il s’avérera très pratique de ne plus représenter un mot par un vecteur de Fn2 mais plutôt par un polynôme de F2 [X] : après tout, pour l’ordinateur, c’est dans chaque cas une liste de n opérandes. Des considérations d’algèbre générale c permettent de dire qu’une permutation circulaire du message revient à effectuer une multiplication par X modulo X n +1 du « polynôme message ». On montre alors que I m(uM )[X] est un idéal de l’anneau principal F2 [X]/(X n + 1) de la forme g (X) · F2 [X]/(X n + 1). On montre que g (X) divise X n + 1. On appelle g (X) le polynôme générateur du code. Notons h(X) le quotient de la division euclidienne de X n + 1 par g (X). On montre également que tout mot m du code est une combinaison linéaire des X j g (X), et  -n -n j j n (X + 1) qui est nul dans F2 [X]/ donc que m(X) · h(X) = j =0 m j X g (X)h(x) = j =0 m j X n (X + 1). On appelle alors h(X) le polynôme de contrôle du code : il porte bien son nom car son produit avec un « polynôme-message » ne s’annule que si le message est un mot du code. Nous allons étudier un code cyclique particulier : le code de Hamming qui est 1-correcteur et parfait. Pour ces codes, n est de la forme 2r − 1, les mots de code ont pour longueur n − r . Nous allons construire une procédure Hamming(n,g,m) où g est un polynôme générateur du code, m un message qui sera éventuellement corrigé si ce n’est pas un mot de code. On construit le polynôme h(X), quotient de Xn + 1 par g . h(x):((x^n+1,g(x))%2); c Voir B RUGÈRE , Thierry/M OLL ARD , Alain, ibid. page 321

253

 )       ,   On transforme ensuite h(X) en la liste des coefficients grâce à la fonction  ajoute autant de zéros que nécessaires pour former une liste de longueur n : L:

' et on

'(h(x)*x^(n-1-



(h(x))));

On crée ensuite la matrice de contrôle formée du vecteur L et de ses « permutations ciculaires » successives. On utilise la fonction   (L,k) qui permet d’effectuer une permutation des k derniers éléments avec le début de la liste si k est négatif. On aurait pu tout aussi bien former les produits de h(X) par les X j et utiliser  ', c’est l’occasion de voir une commande utile... H:()); (j:0;jreed_sol.xws.

257

 

Surfaces de projection imposée Logiciel(s) abordé(s) : XCAS

Notions informatiques : Nous traiterons un problème qui semblerait plutôt adapté à un langage fonctionnel comme Caml mais qui peut cependant être également traité par XCAS. Nous verrons aussi comment tracer des surfaces définies implicitement. Problématique : On va chercher à donner une « équation » d’un polygone régulier de R2 défini normalement à l’aide d’un système d’inégalités. Pour cela on définira une variété de R3 dont la projection sur R2 est le polygone. Ce problème est inspiré d’un sujet de l’épreuve de modélisation de l’agrégation externe, session 2006.

9

    

Commençons par descendre d’une dimension pour poser le problème. La demi-droite de R définie par l’inégalité x  0 peut être également caractérisée comme étant la projection sur R de la parabole de R2 d’équation x = t 2 . Le problème que nous traiterons ici concernera les polygones réguliers de R2 que nous pouvons facilement définir ainsi, avec les b i des polynômes :   S = (x, y, z) ∈ R3 , b1 (x, y, z)  0, . . . , b n (x, y, z)  0 Il s’agit donc d’ensembles semi-algébriques à comparer aux ensembles algébriques qui sont des ensembles des zéros d’un système d’équations polynomiales. Il est souvent peu pratique de travailler avec des ensembles semi-algébriques, au moins informatiquement parlant, puisqu’il faut tenir compte de n conditions. Nous admettrons alors le résultat suivant :

    2@

; " !  8 !    %! (x, y, z) ∈ S ⇐:∃t ∈ R, P(x, y, z, t ) = 0

 2  0 :    8    Notre problème sera donc de trouver de tels polynômes, de tracer la surface d’équation implicite P(x, y, z, t ) = 0 et de la projeter correctement pour « voir » le polygone.

9 "      % &@  %  

(  ! "

Soit n un entier naturel non nula et k ∈ 0 ; n. On fabrique une suite de polynômes de la manière suivante :

(A  2@

  P1 (x1 , u) = u − x1 1 X = (x1 , . . . , xn )    2  Pk+1(x1 , . . . , xk+1 , u) = Pk a1 (X), . . . , ak (X), u − (x1 + · · · + xk+1 )

 ak (X) = xk+1 (x1 + · · · + xk )

Pour se familiariser avec ces polynômes, on peut construire les premiers à la main.   2  P2 (x, y, u) = P1 a1 (x, y), u − (x + y) . Or a1 (x, y) = y(x), donc   2   2 P2 (x, y, u) = P1 x y, u − (x + y) = u − (x + y) − x y



     "

La définition des polynômes ak ne pose pas trop de problème : a(k,x):x[k+1]* (x[j],j,1,k)

Le problème vient surtout de cette définition de polynômes qui dépendent d’un nombre variable d’indéterminées et dont la définition est triplement récurrente puisqu’elle dépend du polynôme d’ordre inférieur, mais aussi d’autres polynômes, les ak et de la somme des indéterminées qui dépend aussi de k. Un mathématicien un peu informaticien voit ici des « fonctions de fonctions » et pencherait vers un langage fonctionnel tel que Caml. C’est une manière naturelle de voir les choses, mais peu efficace avec un langage impératif comme celui utilisé par XCAS. Il faut donc apprendre à réfléchir autrement et voir un programme impératif comme un casier à tiroirs dont on peut à volonté modifier le contenu en gardant une même structure. Et pour changer le contenu des tiroirs, on utilise  (Expression,ancien,nouveau)b . Par exemple, créons une expression : L:a+b-c*d

et remplaçons b par 2 : a Dans le cas qui nous intéresse, n = 3. b

  a d’autres propriétés comme par exemple les changements de variables dans les intégrales.

260

4  !  !  8  2 L: (L,b,2)

qui pourrait se lire :« dans L, on remplace b par 2 ». On peut également faire des substitutions plus conséquentes : L: (L,[a,c,d],[1,3,4])

C’est exactement ce que nous allons faire pour nos polynômes. Le secret est de ne pas travailler sur des fonctions mais sur des expressions pour palier au problème du nombre variable... de variables. Voici le cœur du programme : nouveauzarguments:[ (a(j,x),j1k),(u- (x[j],j,1,k+1))^2] indeterminees:[ (x[j],j1k),u]; polytemp: (polytemp,indeterminees,nouveauzarguments);

Au départ, polytemp vaut Pk (x1 , . . . , xk , u).  2 On remplace alors x1 , . . . , xk , u (noté indeterminees) par a1 (X), . . . , ak (X), u−(x1 +· · ·+xk+1 ) (noté nouveauzarguments) dans polytemp, et on recommence... Voici le programme complet : ListePoly(n):{ k,polytemp,nouveauzarguments,indeterminees,liste; polytemp:u-x[1]; liste:polytemp;  (k:1;k(u-x1-x2)^2-x2*x1

et donc : P2(x,y,t^2)

renvoie : Réponse du logiciel



(t )2 − x − y

2

  − y·x

9 0B    3  % &   +  Notre problème est de définir avec un minimum d’inégalités un polygone convexe régulier, ou plus précisément « l’intérieur » du polygone. Une chose est d’abord sûre : les sommets du polygone sont inscriptibles dans un cerclec , donc le polygone est compris dans un disque. Ici, cela nous donne déjà une inégalité : 1 − x2 − y 2  0 En fait, nous allons tenter de n’utiliser qu’une deuxième inégalité.



 *

      ?

Observons un cas particulier. On peut considérer les côtés deux à deux. Par exemple appelons f 1 et f 2 les fonctions affines dont les représentations graphiques sont respectivement d1 et d1 . On obtient facilement qu’il existe deux réels a et b tels que f 1 (x) = ax + b et f 1 (x) = −ax − b. Avec un peu d’astuce, on obtient que le polygone peut être caractérisé par le système : ⎧ ⎪ ⎪ (ax + b)2 − y 2  0 ⎪ ⎪ ⎨ (ax − b)2 − y 2  0 ⎪ ⎪ ⎪ ⎪ ⎩ 2 c − y2  0 c Nous considèrerons ici qu’il s’agit du cercle de centre O et de rayon 1.

262

4& (2<  - 2%! )!    " 2! b

e

2iπ × 2/n

d2 c

e

d3 e

2iπ × 1/n

d1

2iπ × 3/n

e d 3

e

2iπ × 4/n

−c d 2

2iπ × 0/n

d 1 e

2iπ × 5/n

−b

  Hexagone

Et avec énormément d’astuce, tout ceci peut se réduire au système :

⎧ ⎪ ⎨(ax + b)2 − y 2 (ax − b)2 − y 2 c 2 − y 2   0 ⎪ ⎩1 − x 2 − y 2  0



 *

      ?

Observons un autre cas particulier. Avec toujours autant d’astuce, on peut caractériser le polygone par le système :

⎧ ⎪ ⎨(a x + b )2 − y 2 (a x + b )2 − y 2 x − b   0 1 1 2 2 3 ⎪ ⎩ 2 2 1−x − y  0

263

 2  0 :    8   

b1

e

e

d2 b2

2iπ × 2/n

2iπ × 1/n

d1

d3

e

b3 e

2iπ × 3/n

d 2

−b 2

2iπ × 0/n

d 1

2iπ × 4/n

e −b 1

  Pentagone



    "

Nous utiliserons la commande  (point1,point2)d qui détermine la droite passant par les points 1 et 2. Nous utiliserons également  (courbe,[x,y]) qui donne une équation de la courbe courbe. Enfin, la commande  (egalite)[0] renvoie la partie droite d’une égalité. La lecture du programme suivant devient alors limpide : b( g ) : {  B ; B :  ;  ( k : 1 ; k< g / 2 ; k++) { B[ k−1] : (   (  (   (  (  * ( k−1) * 2 * /g ) ,  (  * k * 2 *  /g ) ) , [ x , y ] ) [ 0 ] ) ) ^2−y^2 }  ( g  2 0) {   (   (B[ j ] , j 0g/2−1) ,1−x^2−y ^2) }  {

  (   (B[ j ] , j 0  ( g / 2) −1) * ( x− ( 2 *  *  ( g / 2) /g ) ) ,1−x^2−y^2) } }:;

Par exemple : b(4)

donne : d Il y a bien d’autres syntaxes possibles.

264

4  !   )  2%! 7     2<  - 2%! Réponse du logiciel

        ((−x + 1)2 − (y)2 ) · ((x + 1)2 − (y)2 ), 1 − (x)2 − (y)2

9 "          ? %    B    3 Vous pourrez prouver pendant vos temps libres qu’il existe un polynôme P tel que   v ∈ S = X ∈ R2 , b(X)  0, c(X)  0 ⇐:∃z ∈ R, P(b(v), c(v), z 2 ) = 0 et que P2 décrit plus haut convient. Pour visualiser, nous utiliserons la commande



   (P(x,y),x,y).

    ( (p2(b(4),z^2)),x-11,y-11,z05,  0.1, 0.1," 0.1)

  Variété dont la projection est un carré Pour obtenir la vue de dessus, on clique sur Menu−→3-d−→vue de dessus z=cst :

265

 2  0 :    8   

  Carré : projection sur (xOy)



;3     ( (p2(b(6),z^2)),x-11,y-11,z05,  0.1, 0.1," 0.1)

  Variété dont la projection est un hexagone

266

4#    Pour obtenir la vue de dessus, on clique sur Menu−→3-d−→vue de dessus z=cst :

  Hexagone : projection sur (xOy)

9,    

Le texte complet du sujet d’agrégation se trouve à l’adresse http://agreg.dnsalias.org/Textes/590.pdf

Vous comprendrez alors pourquoi nous avons construit une procédure pour trouver P2 alors qu’il aurait été plus simple de le déterminer « à la main » : nous n’avons en effet exploré que le cas particulier des polygones convexes réguliers.

267

 Taches des animaux Logiciel(s) abordé(s) : Scilab

Notions informatiques : Modélisation rudimentaire d’équations aux dérivées partielles par des différences finies

Problématique : Le logiciel Scilab est adapté au calcul approché de systèmes dynamiques faisant intervenir des dérivées partielles.



    

Le problème étudié ici est dû à une conjecture développée par Alan Turing concernant la formation des taches sur le pelage des animaux. Le véritable processus biologique n’est pas connu : voir le livre de Murraya . Le modèle mathématique est celui de deux hypothétiques substances chimiques A et B qui interagissent et se diffusent dans la peau de l’embryon d’un animal. À un certain stade de développement de l’embryon, le processus est figé et la concentration de l’un des deux produits en un endroit donné détermine la couleur de la peau ou des poils quand elle dépasse un certain seuil. Les concentrations notées A et B des deux produits dépendent du temps et de l’espace (bidimensionnel). L’évolution est conditionnée par le système ⎧ ∂A ⎪ ⎪ ⎪ ⎪ ⎨ ∂t

=

F(A, B)

+

DA Δ A

⎪ ⎪ ⎪ ⎪ ⎩ ∂B ∂t

=

G(A, B)

+

DB Δ B

Les fonctions F et G décrivent la cinétique chimique. Les laplaciens représentent le phénomène de diffusion. a M URRAY , J. D. Mathematical biology . Berlin: Springer, 1993.

      1

Le laplacien est la divergence du gradient : c’est un opérateur différentiel du second ordre. La divergence d’un champ de vecteurs est la trace de l’application linéaire tangente à ce champ.

Il est important que les deux coefficients de diffusion DA et DB soient différents et non nuls. Le calcul approché sera fait sous Scilab en représentant l’espace par un maillage rectangulaire. Les concentrations A et B sont représentées par des matrices. Le laplacien est réalisé sous forme discrète par un calcul matriciel. Trois formes de domaines sont présentées :

➥

un rectangle ;

➥

un cylindre, c’est-à-dire un rectangle dont deux côtés opposés sont recollés ;

➥

un tore, c’est-à-dire un rectangle ; dont les côtés opposés sont recollés deux-à-deux : un cylindre fermé.

 #C'   

Les données sont stockées dans des fichiers. Il faut d’abord récupérer les matrices qui correspondent aux dix étapes. A0  (’./A0’,maille,maille)/1e2 A1  (’./A1’,maille,maille)/1e2 A2  (’./A2’,maille,maille)/1e2 A3  (’./A3’,maille,maille)/1e2 A4  (’./A4’,maille,maille)/1e2 A5  (’./A5’,maille,maille)/1e2 A6  (’./A6’,maille,maille)/1e2 A7  (’./A7’,maille,maille)/1e2 A8  (’./A8’,maille,maille)/1e2 A9  (’./A9’,maille,maille)/1e2

; ; ; ; ; ; ; ; ; ;

B0  (’./B0’,maille,maille)/1e2 B1  (’./B1’,maille,maille)/1e2 B2  (’./B2’,maille,maille)/1e2 B3  (’./B3’,maille,maille)/1e2 B4  (’./B4’,maille,maille)/1e2 B5  (’./B5’,maille,maille)/1e2 B6  (’./B6’,maille,maille)/1e2 B7  (’./B7’,maille,maille)/1e2 B8  (’./B8’,maille,maille)/1e2 B9  (’./B9’,maille,maille)/1e2

; ; ; ; ; ; ; ; ; ;

270

 =     2

Les matrices Ai représentent les concentrations en produit A à la date i . On définit les coordonnées des noeuds de la grille. xx1:S yyxx

La palette des couleurs est réduite pour des vidéoprojections en toutes conditions, et pour mettre en valeur l’effet de seuil.

 ("colormap", (32)) r[0;1]; g[0;1]; b[1;0]; h[r g b]; On affiche la première donnée, concentration en produit A au début.

 ("colormap",h)   %(xx,yy,A0) On affiche la deuxième donnée après une demi-seconde.

 (’sleep 0.5’)   %(xx,yy,A1)

 Attention ! Certains interpréteurs de commandes (Shell) des systèmes Linux sont malheureusement francisés pour les données numériques, ce qui oblige soit à changer les durées 0.5 en 0,5, soit à changer une variable d’environnement linguistique. . .

On aurait pu construire une boucle itérative pour toutes ces opérations répétitives, mais pour un film de dix images cela n’en vaut pas la peine.

 (’sleep 0.5’)   %(xx,yy,A2)  (’sleep 0.5’)   %(xx,yy,A3)  (’sleep 0.5’)   %(xx,yy,A4)  (’sleep 0.5’)   %(xx,yy,A5) 271

      1  (’sleep 0.5’)   %(xx,yy,A6)  (’sleep 0.5’)   %(xx,yy,A7)  (’sleep 0.5’)   %(xx,yy,A8)  (’sleep 0.5’)   %(xx,yy,A9) On ouvre une nouvelle fenêtre pour y placer la représentation colorée de la concentration en produit B. La matrice h des couleurs est déja fixée.

 () //

couleurs

 ("colormap", (32)) Il ne reste plus qu’à y placer le film pour B.

 ("colormap",h)   %(xx,yy,B0)  (’sleep 0.5’)   %(xx,yy,B1)  (’sleep 0.5’)   %(xx,yy,B2)  (’sleep 0.5’)   %(xx,yy,B3)  (’sleep 0.5’)   %(xx,yy,B4)  (’sleep 0.5’)   %(xx,yy,B5)  (’sleep 0.5’)   %(xx,yy,B6)  (’sleep 0.5’)   %(xx,yy,B7)  (’sleep 272

0.5’)

&  !  ! !   

  %(xx,yy,B8)  (’sleep 0.5’)   %(xx,yy,B9)

 "         Le laplacien discret appliqué à une matrice carrée A est construit de manière traditionnelle.

  Dlap(A) s" (A) tts(1) ttt-1 TTs(2) TTT-1 j  (t,t) z" (t,1) kk[z’,0;j,z] m2*  (tt,tt)-kk-kk’ J  (T,T) Z" (T,1) KK[Z’,0;J,Z] M2*  (TT,TT)-KK-KK’ Dm*A+A*M

   Il faut définir les données qui interviennent dans l’équation d’évolution. DA1 DB2 k1.1 k2.02 k3.03 k4.04

La fonction qui contient le système dynamique s’appelle champ. L’équation d’évolution est considérée comme une équation différentielle ordinaire en le temps t . La partie spatiale de l’évolution est contenue dans la fonction champ et la dimension des matrices.

  ypoint (t,y) T" (y,1) S" (y,2) id  (S,S) ; un (S,S) ; Z" (S,S) D[ DA*id , Z ; Z , DB*id ] F[ -k2*id , Z ; Z , -k4*id ] ypoint( [ k1*un ; k3*un ]+F*y ) + D*lap(y)

   273

      1 Les conditions initiales sont d’abord initialisées par une répartition spatiale aléatoire. t0:.01:.13 ; t00 ; maille10 y00.00001* (2*maille,maille) ;

La première photographie de la situation est calculée. Les dimensions S et T sont définies par commodité. y

(y0,t0,t, T" (y,2) S" (y,1)/2

)

;

Les données initiales sont enregistrées dans des fichiers. A0y0(1:S,:) B0y0(S+1:2*S,:)  (’./A0’,A0)  (’./B0’,B0)

Les données de la première étape sont enregistrées à leur tour. Y1y(:,T-S+1:T) A1Y1(1:S,:) B1Y1(S+1:2*S,:)  (’./A1’,A1)  (’./B1’,B1)

Les autres étapes sont enregistrées. La facilité d’utilisation de l’éditeur de texte Emacs nous a dissuadé de construire une boucle. . . y2

(Y1,t0,t, Y2y2(:,T-S+1:T) A2Y2(1:S,:) B2Y2(S+1:2*S,:)  (’./A2’,A2)  (’./B2’,B2)

)

;

y3

(Y2,t0,t, Y3y3(:,T-S+1:T) A3Y3(1:S,:) B3Y3(S+1:2*S,:)  (’./A3’,A3)  (’./B3’,B3)

)

;

y4

(Y3,t0,t, Y4y4(:,T-S+1:T) A4Y4(1:S,:) B4Y4(S+1:2*S,:)  (’./A4’,A4)

)

;

274

&  !  ! !   

 (’./B4’,B4) y5

(Y4,t0,t, Y5y5(:,T-S+1:T) A5Y5(1:S,:) B5Y5(S+1:2*S,:)  (’./A5’,A5)  (’./B5’,B5)

)

;

y6

(Y5,t0,t, Y6y6(:,T-S+1:T) A6Y6(1:S,:) B6Y6(S+1:2*S,:)  (’./A6’,A6)  (’./B6’,B6)

)

;

y7

(Y6,t0,t, Y7y7(:,T-S+1:T) A7Y7(1:S,:) B7Y7(S+1:2*S,:)  (’./A7’,A7)  (’./B7’,B7)

)

;

y8

(Y7,t0,t, Y8y8(:,T-S+1:T) A8Y8(1:S,:) B8Y8(S+1:2*S,:)  (’./A8’,A8)  (’./B8’,B8)

)

;

y9

(Y8,t0,t, Y9y9(:,T-S+1:T) A9Y9(1:S,:) B9Y9(S+1:2*S,:)  (’./A9’,A9)  (’./B9’,B9)

)

;

Les fichiers sont prêts pour l’affichage (voir section 11.2). Si des fichiers Ai,Bi sont déja enregistrés, il est bon de les effacer par la commande :

 (’rm

A[0-9] B[0-9]’)

Le programme de construction peut alors être exécuté.

275

      1

  La concentration en produit B à la fin de l’animation sur le rectangle

 "        Le recollement des arêtes du rectangle affecte seulement la définition du laplacien.

  Dlap(A) s" (A) tts(1) ttt-1 TTs(2) TTT-1 j  (t,t) z" (t,1) k[z’,1;j,z] l2*  (tt,tt)-k-k’ J  (T,T) Z" (T,1) K[Z’,1;J,Z] L2*  (TT,TT)-K-K’ Dl*A+A*L

   Le reste du programme est le même. L’affichage de la concentration finale B donne des valeurs moins élevées.

276

#  !  ! !  

  La concentration en produit B à la fin de l’animation sur le tore

, "       & La définition du laplacien sur un cylindre est intermédiaire entre le cas du rectangle et celui du tore.

  Dlap(A) s" (A) tts(1) ttt-1 TTs(2) TTT-1 j  (t,t) z" (t,1) k[z’,1;j,z] l2*  (tt,tt)-k-k’ J  (T,T) Z" (T,1) KK[Z’,0;J,Z] M2*  (TT,TT)-KK-KK’ Dl*A+A*M

   Les données sont modifiées pour rapprocher les deux coefficients de diffusion. DA1 DB1.00001 k1.0002

277

      1 k2.0002 k30.0002 k4.0002

Les intervalles de temps sont agrandis, le maillage est plus fin. t0:.01:.27 ; t00 ; maille20 ;

Le reste du programme est similaire aux autres cas. L’affichage de la concentration finale B montre une figure nettement différente.

  La concentration en produit B à la fin de l’animation sur le cylindre

278

Quatrième partie

ANNEXES

 Tableaux comparatifs

D     Logiciel

Licence

Site internet

Bc

GPL

http://www.gnu.org/software/bc/manual/bc.html

Maxima

GPL

http://maxima.sourceforge.net

MuPAD

commerciale

http://www.mupad.de

Octave

GPL

http://www.octave.org

PARI/Gp

GPL

http://pari.math.u-bordeaux.fr/

Scilab

Scilab

http://www.scilab.fr

Yacas

GPL

http://yacas.sourceforge.net

XCAS

GPL

http://www-fourier.ujf-grenoble.fr/~parisse/giac_fr.html

GnuPlot

GPL

http://www.gnuplot.info/

   Sites de téléchargement

 

  

Logiciel

Fichier de configuration

Maxima

/.wxMaxima

PARI/Gp

/.gprc

Yacas

/yacas/yacasinit.ys

XCAS

/.xcasrc

  Où se trouve le fichier de configuration ?

1 1   : Logiciel

Ensemble

Liste

Matrice

Maxima

[1, 2]

[1, 2]

matrix([1,2], [3,4])

MuPAD

{1, 2}

[1, 2]

matrix([[1, 2], [3, 4]])

Octave

[1 2]

[1 2;3 4]

PARI/Gp

[1,2]

[1,2 ; 3,4]

Scilab

[1 2]

A=[1 2;3 4]

Yacas

{1,2}

{1,2},{3,4}}

[1,2]

[[1,2],[3,4]]

XCAS

set[1,2] %{1,2%}

matrix(2,2,(j,k)->j+k)

  Entrer une liste ou une matrice

Logiciel

Équation

Élément d’une liste

Élément d’une matrice

Longueur d’une liste

Maxima

x=0

l[2]

m[2, 3]

length(l)

MuPAD

x=0

l[2]

m[2, 3]

nops(l)

Octave

x=0

l(2)

l(2,1)

PARI/Gp

x=0

l[2]

l[1,2]

Scilab

x=0

l(2)

l(2,1)

Yacas

x==0

XCAS

x=0

length(l)

l[2][1] l[2]

l[2][1]

size(l)

  Manipulation des listes et matrices

Logiciel

True

False

And

Or

Not

Equal

Bc

0

1

&&

||

!

==

Maxima

true

false

and

or

not

=

#

MuPAD

true

false

and

or

not

=



PARI/Gp

0

1

&&

||

!

==

Scilab

%t

%f

&

or

not

= ==

Yacas

True

False

MathAnd

MathOr

MathNot

Equals

XCAS

0

1

and &&

or ||

!

==

   Opérateurs booléens

282

Not equal



!=

 "   !"   5

Logiciel

Assignement

Définition de fonctions

Bc

y=3

define f(x,y) {return(x*y);}

Maxima

y:3;

f(x, y):= x*y;

MuPAD

y:= 3;

f:= proc(x, y)

Octave

y=3;

function f(x,y)

begin x*y end_ proc;

x*y endfunction PARI/Gp

y=3

f(x,y)=x*y

Scilab

y=3;

function f(x,y) x*y endfunction

Yacas

y:=3;

Function(“f”,x,y)[x*y;];

XCAS

y:=3

f(x,y):={x*y }

   Comment rentrer une fonction ?

Logiciel

If+then+else

Bc

if(test) ...;...;

Maxima

if test then ... else if test then ... else ...

MuPAD

if test then ... elif test then ... else ... end_if

Octave

if (test) ... else ... endif

PARI/Gp

if(test,...,...)

Scilab

if test then, ..., else, ..., end

Yacas

if(test)..else...

XCAS

if(test)...; else ...; si(test)...; sinon ...; si test alors ...; sinon ...; fsi

   Test if...then...else

283

1 1   : Logiciel

Boucle for

Bc

for(i=1;i