Vous êtes sur la page 1sur 46

1 - Les nombres

et généralités sur le fonctionnement de MAPLE

Avertissement
Certains aspects de ce chapitre sont élémentaires et peuvent donner l'impression qu'une lecture rapide
est suffisante. En réalité, on a profité de la simplicité des exemples pour présenter des points très
importants (et pas toujours évidents) du fonctionnement de MAPLE. On pourra effectuer une lecture
en plusieurs temps avec la convention suivante : les paragraphes dont le titre est
- sans mention : doivent être lus en première lecture.
- marqué d'un [*] : peuvent faire l'objet d'une seconde lecture.
- marqué d'un [**] : correspondent à une lecture d'approfondissement.
Il est vivement conseillé de lire très attentivement le § 8.
Les références renvoyant à des exercices correspondent au fascicule et aux corrections que l'on
trouvera sur le site Internet de ce manuel : http://www.obs.u-bordeaux1.fr/Enseignement/MAPLE

1 Entiers relatifs et rationnels


1.1 Entrées des commandes
Il existe de nombreuses possibilités pour créer et gérer les documents MAPLE (écriture de
texte avec formules, découpage en sections, etc). Pour éviter d'encombrer la lecture dans
l'immédiat, les informations relatives à ce sujet sont reportées au § 8.4. Pour résumer, MAPLE
dispose de deux formats de documents, le "Document Mode" et le "Worksheet Mode". Le
choix par défaut s'effectue au tout premier lancement de MAPLE (après validation de la
licence). Il peut être modifié ultérieurement, parmi d'autres réglages, à l'aide des paramètres
d'initialisation de MAPLE (voir § 8.4.1). Mais il peut aussi se faire à l'aide du menu File(ou
Fichier)/New/Document Mode ou Worksheet Mode. Il existe de plus, deux modes d'entrée
des commandes décrits ci dessous. Mais il existe aussi d'autres variantes de présentations et
un choix simplifié sera proposé au § 8.4.1 pour guider l'utilisateur avec un minimum de
confusion.

1.1.1 Commandes en mode "Math"


On suppose ici que le document vierge est ouvert en "Document Mode" et le coin
supérieur gauche de la fenêtre du document MAPLE aura l'un de ces deux aspects suivants
en fonction de l'état coché ou non de l'option du menu View/Markers

avec un / clignotant dans le rectangle en pointillés ainsi que le bouton-icône "Math" sous la
forme (pour que la fenêtre du menu "Quick Help" n'apparaisse plus à l'ouverture,
voir le menu d'initialisation au § 8.3.7, cliquer sur l'onglet Interface et décocher Quick Help
popup on new documents). MAPLE attend une commande de calcul dans un mode dit
"Math" ou "2-D Math Input" ou encore "2-D Math Notation". Ce mode d'entrée des
commandes permet une écriture des expressions avec une présentation très proche de
l'écriture habituelle. La muliplication est introduite au clavier par un astérisque qui
s'affichera sous la forme d'un "$" (on lira cependant les remarques au § 1.1.1.2 à propos de la
multiplication). La commande est ensuite exécutée en appuyant sur Return.
1 C 4$2
9 (1.1.1.1)

1
K3 C 1 $ 4 K 1 C 8
2 (1.1.1.2)
La division est introduite par le caractère "/" et MAPLE formatera automatiquement et en
"direct" les expressions au cours de leurs constructions. Une puissance est obtenue avec la
touche "^" et la factorielle avec sa notation standard. Pour quitter l'écriture de la puissance
puis du dénominateur et écrire le "+" dans l'expression suivante on utilisera 2 fois la touche
"→". De même avec les autres touches de flèches pour faire circuler le curseur dans la
formule. Il est également possible de composer cette formule en utilisant les modèles de la
palette Expression (colonne de gauche de la fenêtre MAPLE).
Les nombres rationnels sont considérés par MAPLE comme tels s'ils ne sont pas
simplifiables, c'est-à-dire comme des rapports de deux entiers et non comme leurs
approximations décimales. L'évaluation d'un résultat reste sous sa forme rationnelle réduite
au plus petit dénominateur.
1 1 1
3K1
C C
4K2 7 3!
47
(1.1.1.3)
84
et par conséquent peut être renvoyé sous la forme d'un entier
15 3 1
4 C2 K C
32 192 32
2 (1.1.1.4)
Exercice : effectuer les opérations suivantes en les écrivant telles-quelles et comparer ces
résultats qui sont tous les deux... justes. On rappelle que n!! signifie
n n K 2 ...# 6 # 4 # 2 ou n n K 2 ...# 5 # 3 # 1 suivant la parité de n. Donner une
écriture non ambiguë pour le deuxième cas.
2 C 3!!
5 (1.1.1.5)
2 C 3!!
722 (1.1.1.6)

Pour une expression longue MAPLE passe automatiquement à la ligne suivante (césure).
On peut cependant souhaiter, pour une meilleure présentation, effectuer soi-même ces
césures. Ainsi dans l'exemple suivant la première ligne se termine par un Majuscule(Shift)-
Return, permettant le passage à la ligne suivante sans lancer l'exécution. MAPLE attend la
suite de l'expression qui se termine par Return. Des espaces peuvent permettre d'améliorer la
lisibilité, mais on devra être attentif à certaines erreurs et ambiguïtés (voir les remarques ci-
dessous à propos de la multiplication)
32$2 6K4
K K3 C7 $ 5K3 C2K
64K4$8 2
121K81 5 3 720
K C3 C C
2 2 2 5$6
K5 (1.1.1.7)
Si la ligne de commande se termine par " : " puis par Return, elle est exécutée mais aucun
résultat n'est affiché. Nous aurons l'occasion de revenir sur l'utilité de cette écriture (voir par
exemple § 5.2.2 dans ce chapitre).

1 K 4$2 :

1.1.1.1 Remarques importantes sur la modification et la ré-exécution des commandes


On peut toujours, à l'aide de la souris, positionner le pointeur sur une commande déjà
2
exécutée, la modifier (ou non) et l'exécuter à nouveau. Il faut alors noter les deux points
suivants:
- L'état de MAPLE n'est pas nécessairement celui qui est affiché par la feuille de
calcul...! Deux exemples d'illustration très simples sont donnés aux § 8.3.1 et § 8.3.2.
- Pour exécuter une commande, le pointeur peut se trouver n'importe où sur la
commande quand on tape Return (sauf sur un label, voir § 1.2). Après la correction d'une
commande il est inutile de perdre son temps à déplacer ce pointeur en fin de ligne avant de
taper Return comme on voit le faire souvent chez les débutants.
1.1.1.2 Remarques à propos de la multiplication
Il est possible d'utiliser la palette Operators pour remplacer l'astérisque par × ou
forcer son écriture avec ∗, etc. On peut aussi utiliser un ou des espaces entre les deux
groupes de parenthèses
1 C 4)2 C K3 C 1 # 20K1 C 8 C 3 K 1 1 C 7
K5 (1.1.1.2.1)
Néanmoins, un espace (après le 2) n'est pas toujours nécessaire... (voir § 8.2)
2 3C1
8 (1.1.1.2.2)
Si des espaces peuvent être aussi introduits dans les formules pour améliorer la
présentation, ils ne peuvent pas servir pour indiquer une multipication entre deux
nombres
42
Error, missing operation
4 2
et en conséquence, pour améliorer la présentation d'un nombre en utilisant un espace pour
séparer les triades de 0
250 C 3$1 000
Error, missing operation
250 C 3$1 000
La multiplication peut aussi être introduite par un "." entré au clavier. Si cette écriture
alternative n'a pas de conséquence pour le calcul d'une expression avec des nombres
entiers, il peut en être tout autrement avec d'autres types d'objets (voir § 5.9).
K3 C 1 . 4K1 C 8
2 (1.1.1.2.3)
Evidemment, cette écriture ne convient pas pour la multiplication de nombres car elle est
utilisée pour l'écriture des décimaux (voir § 5)
1 K 4.2
K3.2 (1.1.1.2.4)

Pour résumer ces remarques, mieux vaut s'en tenir à un usage systématique de
l'astérisque pour désigner la multiplication.

Digression : en typographie on ne dit pas "un espace", mais "une espace". Nous
n'utiliserons pas cette métonymie.

3
1.1.2 Commandes en mode "Text"
(dit aussi "Input Maple notation" ou "1-D Math Input"). On introduit ce mode avec le
menu Insert/Maple Input ou le racourci clavier Ctrl-M sous Windows/Linux ou Cmd-M
sous Mac. La différence principale avec le mode "Math", hormis l'affichage, est que la ligne
de commande doit se terminer par un ";" puis par Return qui lance l'exécution (comme
pour le mode "Math", si la ligne se termine par " : " puis par Return, elle est exécutée mais
aucun résultat n'est affiché).
3*(3+1)^3/5;
192
(1.1.2.1)
5
En cliquant sur le bouton-icône de la barre d'outils on crée ce que l'on nomme un groupe
d'exécution qui se remarque par un "prompt" > (en français "une invite") qui attend la
commande. Un "[" extensible à gauche regroupe la commande et son résultat. Normalement
le mode d'entrée par défaut est 2D Math Notation...
3
O 7C
2
17
(1.1.2.2)
2
mais on peut basculer du mode "Math" au mode "Text" et réciproquement de façon très
simple avec la touche F5 (fn-F5 sur certains claviers). Pour obtenir une entrée des
commandes en mode "Text" par défaut quand on ouvre un groupe d'exécution, remplacer
2-D Math notation par Maple Notation dans le menu Maple 12/Préférences... (Mac) ou
Tools/Options... (Windows et Linux), onglet Display, option Input display (voir § 8.3.7).
Un groupe d'exécution fait clairement ressortir du document le couple commande-résultat.
L'écriture des commandes en mode "Text" est sans doute moins esthétique, mais présente
l'avantage de montrer précisément les détails des caractères entrés au clavier pour composer
les commandes. C'est la raison pour laquelle il sera préférentiellement utilisé pour la
rédaction de ce manuel.
O (-3+1)*(4-1)+8;
2 (1.1.2.3)
Il est fréquent, surtout au début, d'oublier le ; (semicolon) ou le : devant terminer une
commande. MAPLE renvoie un message d'avertissement, mais exécute néanmoins la
commande. Pour effacer ce message, rajouter le ; ou le : à la fin de la commande avant de la
relancer. On répète aussi ce qui a déjà été dit : inutile de déplacer le pointeur en fin de ligne
pour exécuter une commande que l'on vient de corriger.
O (-3+1)*(4-1)+8
Warning, inserted missing semicolon at end of statement
2 (1.1.2.4)
Remarque : le prompt > peut être changé (voir par exemple § 8.3.8)

1.2 Numérotation des résultats, dito et commentaires [*]


1.2.1 Numérotation des résultats
Par défaut MAPLE affiche à droite du résultat un numéro, dit label, sous la forme (n)
ou (n.m.k...). On peut faire référence dans une commande à un résultat déjà calculé en
utilisant ces numéros. Des informations complémentaires sur la gestion de cet affichage sont
données au § 8.4.8.3. L'insertion de ces numéros dans une commande ne se fait pas
directement, mais à l'aide du menu Insert/Label... qui ouvre une fenêtre dans laquelle on
donne le numéro. Il est très utile de connaître le raccourci clavier permettant l'insertion d'un
numéro sans utiliser le menu : Ctrl-L (Windows ou Linux) ou Cmd-L (Mac). Pour changer
un numéro, double-cliquer dessus (l'effacer en mode "Text") puis en définir un nouveau

4
avec un Ctrl/Cmd-L.
A chaque exécution d'une commande, MAPLE re-numérote entièrement la feuille de
calcul, y compris dans les commandes. Donc, si on insère ou si on supprime une ou
plusieurs instructions (exécutées) n'importe où dans la feuille, les numéros seront
automatiquement changés partout et feront toujours référence aux bons résultats, mais
attention, si la valeur d'un résultat associé à l'un des labels a été modifié, le nouveau
résultat ne sera recalculé que si la commande est re-exécutée.
Généralement on utilise moins de niveaux de sections et les numéros sont plus simples
que ceux de ce document. Par ailleurs on peut imposer un mode d'affichage qui ne tient pas
compte des numéros de section (voir § 8.4.8.3).
O -4*(2*(1.1.2.3)-(1.1.1.7))/9;
K4 (1.2.1.1)
Bien entendu ceci, comme tout ce qui suit, est aussi valable pour le mode "Input Math"
4$ 2$(1.1.2.3)K(1.1.1.7)
O K
9
K4 (1.2.1.2)

1.2.2 Dito
Le symbole % ou dito (avec deux t dans MAPLE comme souvent en anglais) désigne le
résultat de la dernière instruction exécutée dans l'ordre chronologique et peut être utilisé
dans une expression. Les exemples et les remarques sont rassemblés au paragraphe suivant.
Le double symbole %% et le triple symbole %%% désignent les résultats précédents.
Digression : le caractère typographique % s'appelle "Pourcent". Le mot "dito" est d'origine
commerciale et désigne "ce qui vient d'être cité", évitant ainsi la répétition.

1.2.3 Commentaires sur une ligne de commande


On peut écrire un commentaire à la fin de la ligne de commande (après le : ou le ; ou
directement après la commande en mode "Math") en le faisant précéder du caractère #.
O 2*%; # ici %=-4
K8 (1.2.3.1)
O 3*%%; # %%=-4, %=-8
K12 (1.2.3.2)
O -3*(%%%/2-1)-1; # %=-12, %%=-8 et %%%=-4
8 (1.2.3.3)
Attention : les symboles dito sont d'un usage commode, mais doivent être manipulés avec
précautions en raison de leur caractère chronologique. Pour un usage systématique on
préférera la méthode utilisant les numéros des résultats sauf pour des commandes groupées
(voir l'exemple à propos des affichages multiples, § 1.3).
Le résultat de la commande suivante peut sembler curieux et on s'attent plutôt à 8/2 = 4.
Mais ce que ne peut pas montrer ce texte, c'est que la commande associée au résultat
(1.2.1.1) a été ré-exécutée immédiatement avant
O %/2;
K2 (1.2.3.4)

5
1.3 Affichages multiples [*]
On peut construire une série de commandes groupées qui renverront plusieurs résultats : la
première ligne se termine par un Majuscule-Return, permettant le passage à la ligne sans lancer
l'exécution, la deuxième par Return. Chaque expression se termine par un ; ce qui entraînera
l'évaluation de chacune et l'affichage sur des lignes séparées. Les symboles % et %% sont ici
non ambigus puisqu'ils font référence à des résultats qui ne peuvent être que calculés
immédiatement avant (%=32, %%=16). On remarquera aussi que la notation "**" (syntaxe
Fortran) à la place de "^" est admise
O (1.2.3.1)*(-4) ; (-%+28)**2 ;
-10/(-2); (1/%%)^(-2); # Les parenthèses sont nécessaires
32
16
5
256 (1.3.1)
En mode "Math" les ";" redeviennent nécessaires pour séparer les commandes
K2
2 10 1
O (1.2.3.1)$ K4 ; K% C 28 ; K ;
K2 %%
32
16
5
256 (1.3.2)
Si on termine chaque expression par une virgule et la dernière par point-virgule on obtiendra
aussi des résultats qui s'afficheront sur la même ligne. Cette façon de faire permet d'économiser
de l'espace d'affichage mais ce résultat est une objet MAPLE unique appelé suite que nous
examinerons au chapitre 3, Intervalles, Listes, Suites, Ensembles. On remarquera que le label
(1.3.2) ne fait référence qu'au dernier résultat de la série précédente.
Attention : il ne s'agit pas ici de commandes groupées, mais d'une commande unique
construisant une suite (un seul ;). On ne peut pas considérer comme précédemment que les
calculs des expressions sont fait séquentiellement. En conséquence une expression de la suite ne
peut pas se servir d'un de ses éléments précédents dans son calcul. Par exemple % ne fait pas
référence à 32 mais au dernier résultat calculé dans le groupe précédent, c'est-à-dire 256. De
même %%=5.
O -(1.3.2)/(-8) , -%/(-2) ,
(-3+1)^2 , (1/%%)^(-2);
32, 128, 4, 25 (1.3.3)
Pour MAPLE cette suite est un "objet" unique et le label fait référence à ce résultat pris comme
un tout.
O 2*((1.3.3)+1);
64, 256, 8, 50 C 2 (1.3.4)
Sa manipulation relève donc de celle des suites (voir chapitre 3) et il est possible de faire
référence à un des résultats en indiquant son numéro d'ordre avec la notation [n]
(1.3.3) 3 C 1
O %%[3]/2 , (1.3.3)[3] ,
2
5
2, 4, (1.3.5)
2
Il existe encore d'autres façons d'obtenir des affichages multiples que l'on aura l'occasion de
rencontrer (fonction print, Listes, Tableaux...).

6
1.4 Assignation
On peut affecter, on dit aussi assigner, un nombre à un nom en utilisant la notation : =. Cette
commande sera étudiée en détail au chapitre 2. Les règles de syntaxe définissant les noms sont
décrites au § 8.1.
Attention: le signe = seul a une autre signification sur laquelle nous reviendrons (définition
d'une équation, voir par exemple § 8.2 et plus généralement le chapitre 14)
O n:=2^79-1;
n := 604462909807314587353087 (1.4.1)

1.5 Fonctions relatives aux entiers


On peut se poser la question " n est-il premier ? " en utilisant la fonction isprime (comprendre
is prime ?). La réponse false signifiant "faux", la réponse est "non"
O isprime(n);
false (1.5.1)
On obtient sa décomposition en facteurs premiers avec la fonction ifactor (integer factorization)
O ifactor(n);
202029703 1113491139767 2687 (1.5.2)
Autre exemple de fonction sur les nombres entiers: les coefficients du binôme
n!
Cnp =
p! n K p !
sont donnés par la fonction binomial(n, p). On peut par exemple vérifier la relation entre les
coefficients du binôme
Cnp C
C1
1
= Cnp C Cnp C 1
en prenant des valeurs particulières pour n et p (MAPLE peut le faire pour n et p quelconques,
mais on sortirait du cadre de ce chapitre)
O n:=4;
p:=2;
binomial(n+1,p+1)=binomial(n,p)+binomial(n,p+1);
n := 4
p := 2
10 = 10 (1.5.3)
MAPLE sait aussi calculer avec une arithmétique modulaire
O 7 C 6 mod 5;
3 (1.5.4)
5C6
O mod 3;
8
1 (1.5.5)
O 12^(5+2 mod 3)+1 mod 7;
6 (1.5.6)
On ne détaillera pas dans ce manuel toutes les fonctions de MAPLE relatives aux calculs sur
les nombres entiers pas plus que bien d'autres fonctions. Celles-ci peuvent être découvertes dans
l'aide en ligne (help), c'est-à-dire directement à l'aide du logiciel (voir § 2). Il faut aussi savoir
que toutes les fonctions ne sont pas utilisables au moment du lancement de MAPLE. Elles ne le
seront qu'après les avoir rendues accessibles dans des bibliothèques (voir § 8.3.5).

7
1.6 Elision [**]
Le nombre maximal de chiffres autorisés pour un entier, bien que très grand, est limité et sa
valeur dépend de l'ordinateur utilisé. On peut l'obtenir avec la commande
O kernelopts(maxdigits);
268435448 (1.6.1)
Ce résultat indique que les entiers peuvent contenir plus de 268 millions de chiffres ! Cependant,
ces entiers sont construits par une succession de "mots mémoire" et la valeur maximale d'un
entier que peut contenir une tel mot est seulement de (ici 2 32 K 2 K 1)
O kernelopts(maximmediate);
1073741823 (1.6.2)
Si le nombre est très grand MAPLE n'affichera pas tous les chiffres, mais seulement les valeurs
fixées par défaut dans le menu d'initialisation (voir § 8.3.7) Maple 12/Préférences... (Mac) ou
Tools/Options... (Windows ou Linux), onglet Precision sous la forme nm[...d digits...]ijk (voir
ci-dessous). Le mécanisme, dit d'élision (en syntaxe française, "l(a)'élision est une élision"), va
s'appliquer dès que le nombre contient un nombre de chiffres plus grand que ("threshold"
signifiant "seuil"). Il s'agit ici de la valeur par défaut.
O interface(elisionthreshold);
10000 (1.6.3)
Même si les nombres entiers sur lesquels on travaille sont moins grands, l'affichage peut devenir
vite encombrant et on peut diminuer cette valeur. La première des commandes suivantes fixe le
nombre de chiffres à partir duquel le mécanisme s'applique (=10). Les deux autres fixent le
nombre de chiffres ("digits") qui doivent précéder (=3) et suivre (=6). La fonction interface
affiche la valeur existant avant la modification, ce qui est pratique pour mémoriser par
assignation (eth:=...) cette ancienne valeur.

Remarque : ce mécanisme d'affichage est dynamique dans le sens suivant : quand on ouvre une
feuille de calcul enregistrée, les résultats déjà calculés s'affichent avec les valeurs par défaut tant
que les commandes qui fixent les paramètres d'élision ainsi que les commandes de calcul n'ont
pas été exécutées. Si on veut obtenir un affichage immédiat tenant compte de valeurs d'élision
définies par l'utilisateur, il faut, soit fixer avant l'ouverture du document les paramètres de
MAPLE dans le menu d'initialisation comme indiqué ci-dessus, soit introduire les commandes
dans le fichier d'initialisation de MAPLE (voir § 8.3.8) ou plus simplement par initialisation de
la feuille de calcul, (voir le Startup code, § 8.4.3-1).

O m:=40!-6^36;
eth:=interface(elisionthreshold=10):
interface(elisiondigitsbefore=3):
interface(elisiondigitsafter=6):
m := 815915283247897734335296844797625358725828050944 (1.6.4)
O m/2;
407957641623948867167648422398812679362914025472 (1.6.5)
On "annulera" l'élision en posant un seuil élevé ou comme ici en restituant la valeur par défaut
qui a été mémorisée (on peut aussi poser infinity qui supprime totalement le mécanisme, mais
une telle nécessité est hautement improbable !).
O interface(elisionthreshold=eth):

Remarque : l'élision peut aussi s'appliquer sur des expressions mathématiques (voir chapitre
13).

8
2 Aide MAPLE
L'aide en ligne de MAPLE est très développée et peut être obtenue de nombreuses façons
(souvent redondantes) dont :
1) Le menu Help/Maple help ou l'icône-bouton ouvre une fenêtre dont l'utilisation est
évidente. On n'oubliera pas d'explorer les différentes Resources : All, Help Pages, Tasks,...,
Manuals (voir ci dessous). On notera que les titres de rubriques sont précédées d'icônes :
indiquant une page d'aide, une page de définition, un document MAPLE (WorkSheet) de
démonstration, des pages du manuel interne (voir ci dessous) ou pour des "Tasks
template", c'est à dire des pages prédéfinies pour réaliser des calculs classiques et simples. Ces
dernières pages sont accessibles par le menu Tools/Tasks/Browse ou File(Fichier)
/New/Templates...
2) Quand on tape les premiers caractères d'un nom, qu'il soit prédéfini par MAPLE ou créé par
l'utilisateur par une assignation, et dès que le nombre de caractères entrés est suffisant pour lever
toute ambiguïté, un mécanisme de complémentation automatique (automatic completion) affiche le
nom complet que l'on valide en tapant Return. Pour que ce mécanisme fonctionne il faut que la case
Automatic command completion, onglet Interface dans le menu d'initialisation (voir § 8.3.7)
Tools/options (Windows ou Linux) ou Maple 12/Préférences (Mac) soit cochée.
3) Le menu très important Help/Help on Context. Lorsque le pointeur est positionné sur un mot,
par exemple binomial, l'item du menu se transforme en Help on binomial et ouvre la fenêtre
correspondante donnant la définition, des explications et des exemples.
4) Par commande en faisant précéder le mot clé recherché d'un ? (le ; final n'est pas nécessaire).
Par exemple
O ?binomial
Un double ?? ouvre la fenêtre avec les sections fermées, transformant la page en une table des
matières. On peut ensuite ouvrir les sections de sont choix. Un triple ??? affiche la page avec seule
la section des exemples ouverte (équivalent à la commande > example(binomial);)
Certaines commandes doivent être combinées pour préciser la demande (on peut utiliser
indifféremment une "," ou un "/")
O ?index,functions
O ?index/packages
ou faire une recherche dans une bibliothèque particulière (on utilisera le terme de "bibliothèque" ou
indifféremment "librairie" pour traduire le mot "package").
O ?LinearAlgebra/Determinant
5) Les pages d'aide contiennent des hyperliens
- en vert souligné qui renvoient sur des pages d'aide associées par leurs sujets.
- en rouge souligné qui renvoient sur des pages d'un dictionnaire contenant de l'ordre de
5000 références ( ): définitions mathématiques, mathématiciens, etc.
6) MAPLE contient un manuel utilisateur interne accessible avec la commande
O ?UserManual
mais également par le menu Help/Manuals, Dictionary, and more.../Manuals ou avec la rubrique
Ressource : Manuals dans la page d'aide (voir ci-dessus, 1).
7) On trouvera une feuille de calcul d'initiation en mode "Document" avec
O ?MaplePortal
8) Le menu Tools propose un certains nombre d'outils pré-développés sous forme de guides
interactifs, de "Maplets" (applets MAPLE) ou de "Tasks template" déjà cités.
9) Il existe aussi d'autres possibilités par commande qui explore des bibliothèques de propriétés
mathématiques telles MathematicalFunctions ou FunctionAdvisor. Dans l'exemple suivant DE
est mis pour Differential Equation, autrement dit on demande quelle est l'équation différentielle qui a
pour solution un sinus hyperbolique, sous-entendu bien sûr que les deux conditions initiales soient
9
appropriées.
O MathematicalFunctions:-Get(definition,sinh);
1 z 1
sinh z = e K , with no restrictions on z (2.1)
2 2 ez
O FunctionAdvisor(DE,sinh);
d2
f z = sinh z , f z =f z (2.2)
dz2
Ce type d'informations peut aussi être donné par le menu Tools/Assistants/Special Functions.
10) On trouvera également des informations sur le site Internet de MAPLE par le menu Help/On
the Web (en particulier son forum d'aide "Mapleprimes" par le menu Help/On the Web/Stay
Informed/User forums).

Envisager une lecture exhaustive de l'aide en ligne serait une idée déraisonnable, mais on
recommande de compléter ces informations de base par une exploration des possibilités de l'aide
en ligne que l'on trouvera dans Help/Manuals, Dictionary, and more.../Using the Help System.

3 Nombres irrationnels
Comme pour les nombres rationnels, les nombres irrationnels sont conservés en tant que tels,
c'est-à-dire sous une forme symbolique, s'ils ne sont pas simplifiables. Par exemple, pour une racine
carrée on dispose de deux notations équivalentes : ^(1/2) ou sqrt (square root) :
O a:=3^(1/2);
a:=sqrt(3);
sqrt(16);
a := 3
a := 3
4 (3.1)
Que se soit en mode "Text" ou en mode "Math" on peut aussi utiliser le modèle a de la palette
Expression
O a d sqrt 3 ; ad 3
a := 3
a := 3 (3.2)
Le nom a est ici associé, non à une approximation numérique, mais à un nombre symbolique positif
dont le carré vaut 3 exactement, etc.
O a^2;
3 (3.3)
Le chapitre 2 montrera que pour MAPLE, a n'a pas un caractère (type) "numeric". MAPLE effectue
parfois automatiquement des transformations pour présenter un nombre
O b:=2^(-1/3);
b^(-3);
1 2/3
b := 2
2
2 (3.4)
Il n'effectue pas nécessairement des calculs qui peuvent paraître évidents à l'utilisateur. Ici on doit le
forcer à effectuer le travail à l'aide de la fonction simplify sur laquelle nous reviendrons souvent et
notamment au chapitre 13, Simplifications, Manipulations
O sqrt(6)/sqrt(2);
simplify(%);
1
6 2
2
10
(3.5)
3 (3.5)
Pour rendre rationnelle une expression on utilisera rationalize. Pour composer une commande en
mode "2-D Math Input", (sortir du radical, quitter le dénominateur ou parcourir la formule), utiliser
les touches "flèches".
3 5 K2
O rationalize
3 K2 2 C 5
1
3 5 K2 2 2 K 5 C 3 5C2 2 5 (3.6)
30

4 Nombres remarquables (π), nombres indéfinis


4.1 Nombres remarquables
MAPLE connaît, au sens de leurs propriétés et pas seulement par leurs approximations
numériques, quelques nombres remarquables comme par exemple Pi = p. Attention: notez la
lettre majuscule P obligatoire. Sinon la lettre p s'affichera aussi, mais désignera un nom, pas le
nombre. De même PI désigne seulement la lettre grecque majucule P. Avec cette définition
symbolique du nombre, MAPLE peut exprimer certains résultats classiques de fonctions qui
sont, si possible, évaluées automatiquement (GAMMA est la fonction eulérienne G, voir
exercices 2.1 à 2.4).
O Pi;
cos(Pi/4);
GAMMA(1/2);
p
1
2
2

p (4.1.1)
Pour illustrer la remarque sur la syntaxe de p
O cos(Pi);
cos(pi), cos(PI);
K1
cos p , cos P (4.1.2)
Certaines valeurs que MAPLE sait calculer (ce n'est pas toujours le cas) ne le sont cependant pas
et il faut forcer l'évaluation (voir convert, Chapitre 13, Simplifications, Manipulations...)
O cos(Pi/5);
convert(cos(Pi/5),radical);
1
cos p
5
1 1
C 5 (4.1.3)
4 4
La base e des logarithmes népériens n'est pas une constante prédéfinie (elle l'était sous la forme
E avec de très anciennes versions de MAPLE). Elle est seulement exprimée de façon particulière
lors de l'affichage de la valeur exp 1
O exp(1);
e (4.1.4)

11
---------------------------------------------------------------------------------------------------------
Attention: Le symbole e (non italique) affiché ci-dessus n'a aucun rapport avec le nom e d'une
variable, sauf bien sûr si on lui assigne cette valeur. Ici, e n'est encore qu'un nom indéfini. On
notera que, contrairement au nombre, la variable s'affiche en italique.
O e;
ln(e);
e
ln e
Après assignation de e à e, la commande e; affiche le "contenu" de la variable e, c'est à dire le
nombre e (c'est clair ? :-))
O e:=exp(1);
e;
e :=e
e
et l'expression suivante calcule maintenant ln exp 1
O ln(e);
1 (4.1.5)
---------------------------------------------------------------------------------------------------------
MAPLE est capable de reconnaître (quelquefois après simplification) l'équivalence de deux
expressions comme par exemple exp(1/2) et e .
O exp(1/2)-sqrt(e);
0 (4.1.6)
MAPLE ne connaît que deux autres nombres réels remarquables prédéfinis et que nous
rencontrerons : la constante d'Euler-Mascheroni g (voir exercices 2.5, 2.7, 2.8, 2.9 et 2.10) et la
constante de Catalan.
O constants;
false, g, N, true, Catalan, FAIL, p
On ne peut rien assigner à ces noms qui sont protégés.
O Pi:=22/7;
Error, attempting to assign to `Pi` which is protected

On reconnaît aussi des constantes logiques. La logique de MAPLE est à trois états, true =
"vrai", false = "faux" et FAIL = "échec".

Exercice : Avec l'aide en ligne, trouver une définition de la constante de Catalan.

4.2 Nombres indéfinis


MAPLE connaît également la notion de nombre indéfini avec le mot clé undefined. La
"constante" ∞ peut s'écrire infinity et
O 0*infinity , N K N
undefined, undefined (4.2.1)
Ce mot clé peut apparaître en de nombreuses circonstances (calcul de limite par exemple) et se
manipule de façon conforme à sa définition.
O exp(undefined) , 1-undefined/undefined;

undefined, undefined (4.2.2)


La division par 0 provoque une erreur même pour la forme indéterminée 0/0.
O 0/0;
Error, numeric exception: division by zero
Il faut noter également que
O 0^0;
1 (4.2.3)

12
5 Nombres décimaux
Ils sont notés de façon standard (avec un point) et ne doivent pas, comme pour les entiers,
contenir d'espaces (les espaces entourant le + sont par contre autorisés).
O -1.2 + 0.035;
K1.165 (5.1)
Il existe trois façons de définir des nombres avec des puissances de 10, la plus simple utilisant la
notation scientifique (indifféremment e ou E).
O -13.345E-27, 1.542*10^(-30), Float(15.42,-3);
K1.3345 10-26 , 1.542000000 10-30 , 0.01542 (5.2)
Attention : on ne devra pas laisser le point décimal seul devant e ou E (voir § 5.9)
O 45.e6;
Error, missing operator or `;`
Il faudra écrire (sans caractère d'espacement)
O 45.0e6;
4.50 107 (5.3)
ou plus simplement encore
O 45e6;
4.5 107 (5.4)

5.1 Evaluation décimale implicite


Le mélange dans une expression de nombres exprimés en notation décimale avec des nombres
entiers ou rationnels entraîne l'évaluation en valeur décimale. Pour la précision des calculs on se
reportera au § 5.2.2
O 0.5 + 1/3 + 1;
1.833333333 (5.1.1)
alors que
O 1/2 + 1/3 + 1;
11
(5.1.2)
6
Noter la différence entre ces deux résultats:
O 1./7*10^(-10) , 1 /7*10^(-10);
1
1.428571429 10-11 , (5.1.3)
70000000000
Lorqu'une fonction est invoquée avec un argument décimal ou un mélange conduisant à un
calcul décimal, MAPLE calcule le résultat sous une forme décimale
O exp(0.4 - 3/4) , exp(2/5 - 3/4);
7
K
20
0.7046880897, e (5.1.4)
Par contre, priorité est toujours donnée aux calculs symboliques et MAPLE ne prendra pas
l'initiative de remplacer p ou 2 par leurs valeurs décimales approchées (voir § 5.2.1 et la
fonction evalf).
O 1. + sqrt(2), Pi + 5.3;
1. C 2 , p C 5.3 (5.1.5)
De même
O cos(1. + Pi/4), exp(1. - sqrt(2));
1
cos 1. C p , e1. K 2 (5.1.6)
4
Exercice : Comparer ces trois exemples et expliquer les différences sachant que l'argument est
13
évalué avant d'appeler la fonction. Le dernier exemple est moins évident... (remplacer 5.3 par α
en gardant Pi, puis Pi par Pi/4 en gardant 5.3).
O exp(1. + sqrt(2)), exp(1 + sqrt(2.)), cos(Pi+5.3);
e1. C 2
, 11.18097376, K0.5543743362 (5.1.7)

5.2 Evaluation décimale explicite


5.2.1 Fonction evalf (arithmétique émulée)
MAPLE est avant tout un calculateur symbolique mais on peut toujours obtenir une
approximation décimale d'une expression numérique avec la fonction evalf (contraction de
"Floating-Point Evaluation")
O evalf(5/6);
evalf(100!);
0.8333333333
9.332621544 10157 (5.2.1.1)
MAPLE ne dit rien sur l'évaluation de exp(1/2). Une évaluation décimale passe par la
fonction evalf
O a:=exp(1/2);
evalf(a);
evalf(sqrt(exp(1)));
1
2
a := e
1.648721271
1.648721271 (5.2.1.2)
5.2.2 Précision des calculs et variable Digits
Le nombre de chiffres significatifs utilisés pour les calculs est fixé par défaut à 10 (voir la
fin de ce paragraphe ainsi que § 8.3.8 et § 8.4.3) par la variable d'environnement prédéfinie
Digits (pour le sens de l'expression "variable d'environnement", voir chapitre 19,
Procédures).
O Digits;
10 (5.2.2.1)
Le nombre n de chiffres significatifs de x peut être ponctuellement fixé en utilisant la
syntaxe evalf[n](x). Ceci n'affecte que le calcul demandé et ne modifie pas la valeur de la
variable Digits. L'affichage s'adapte à cette valeur, mais on peut modifier ce comportement
(voir § 5.8). Notez le "\" à la fin de la première ligne qui indique que l'affichage du nombre se
poursuit.
O evalf[100](Pi/2-1);
0.570796326794896619231321691639751442098584699687552910487472296\ (5.2.2.2)
153908203143104499314017412671058534
Il existe aussi une autre forme, evalf(x,n), utilisée dans les précédentes versions et encore
valable. La forme evalf[n](x) est maintenant recommandée.
On peut changer par assignation la valeur de Digits pour une série de calculs puis revenir
à la valeur standard. La valeur maximale de Digits est donnée par
O kernelopts(maxdigits);
268435448 (5.2.2.3)
On notera que certaines des commandes suivantes se terminent par ":". En effet l'affichage de
leurs résultats n'est pas d'un grand intérêt (ou peut, pour des affichages longs, encombrer
inutilement la lecture)
O Nb_digits:=Digits: # On mémorise la valeur par défaut
Digits:=50:
a, evalf(a); Pi/5, evalf(Pi)/5;

14

(5.2.2.4)
1
2
e , 1.6487212707001281468486507878141635716537761007101
1
p, 0.62831853071795864769252867665590057683943387987502 (5.2.2.4)
5
O Digits:=Nb_digits: # On restitue la valeur par défaut
evalf(a); evalf(Pi)/5;
1.648721271
0.6283185308 (5.2.2.5)
La valeur de Digits n'intervient que dans le calcul des nombres, mais n'effectue pas de
troncature sur leurs définitions qui restent préservées. Cette valeur n'est pas non plus
nécessairement liée au nombre de chiffres affichés (voir § 5.8).
O X:=1.2345678901234567890;
X/3; # Nombre de chiffres = Digits
X; # Nombre de chiffres = définition
X := 1.2345678901234567890
0.4115226300
1.2345678901234567890 (5.2.2.6)
De même, le nombre Y est calculé avec 20 chiffres significatifs et, malgré la valeur de Digits,
conserve toute sa précision.
O Y:=evalf[20](5/7);
Digits;
Y;
Y := 0.71428571428571428571
10
0.71428571428571428571 (5.2.2.7)
Suivant l'option choisie (voir § 5.8), l'affichage peut ne pas refléter la précision des calculs,
mais ce n'est pas le cas ici.
Attention : que ce soit avec MAPLE ou dans un autre contexte (C, C++, Fortran, Java...),
les calculs numériques doivent être menés avec la plus grande prudence (on trouvera des
illustrations au chapitre 4 Vecteurs, Matrices et Algèbre linéaire § V §§ Erreurs numériques,
ou avec les exercices 3.8 et 3.9). L'algèbre informatique des décimaux peut même se révéler
non commutative et/ou non distributive ! (voir l'exercice 3.9).
O 5*evalf(1/7)-evalf(5/7);
2. 10-10 (5.2.2.8)
La valeur par défaut de Digits peut être changée à l'aide du menu d'initialisation (voir §
8.3.7) Tools/Options (Windows-Linux) ou Maple 12/Préférences (Mac) qui ouvre une
fenêtre d'initialisation. Cliquer ensuite sur l'onglet Precision et affecter la valeur souhaitée à la
rubrique "Round calculation to" (Attention: ne pas confondre avec la rubrique "Round
screen display to"). On peut aussi, pour effectuer cette opération, utiliser un fichier
d'initialisation de MAPLE, (voir § 8.3.8) ou plus simplement une modification attachée
seulement à la feuille de calcul avec le Startup code (§ 8.4.3-1).
5.2.3 Fonction evalhf (arithmétique cablée) [*]
Les langages de programmation comme Fortran, C, C++, etc. travaillent avec une
précision fixe (6 à 7 chiffres en simple précision et 15 à 16 chiffres en double précision pour
un ordinateur 32 bits) et la comparaison avec les possibilités offertes par MAPLE semble
difficile à soutenir à première vue. En fait MAPLE génère ses calculs numériques à l'aide
d'algorithmes dont la précision peut être étendue (arithmétique émulée) alors que les autres
langages utilisent (sauf emploi de bibliothèques spécialisées) l'arithmétique câblée du
processeur dont la précision ne peut évidemment pas être changée mais dont la vitesse
d'exécution est beaucoup plus grande. La possibilité de fixer la précision va donc être au prix
d'une baisse de la rapidité des calculs. On peut néanmoins indiquer à MAPLE d'utiliser
15
l'arithmétique binaire câblée du processeur avec la fonction evalhf (Hardware Floating-Point
Evaluation). Bien sûr on ne pourra plus fixer la précision qui sera celle de la "double
précision", soit de 15 à 16 chiffres significatifs (stockage des nombres avec la norme IEEE
sur 64 bits).
Malgré l'utilisation possible de la fonction evalhf, il n'en demeure pas moins que l'on
travaille avec MAPLE dans un environement de calcul symbolique qui reste très
gourmand en mémoire et en temps de calcul. MAPLE ne saurait donc remplacer les
langages de calcul numériques.
O a;
evalhf(a);
1
2
e
1.64872127070012819 (5.2.3.1)
Avec evalhf l'on ne pourra pas se fier au dernier ou deux derniers chiffres affichés (en raison
des conversions "représentation binaire" ⇔ "représentation décimale").
O evalhf(7/3);
evalf[18](7/3);
2.33333333333333348
2.33333333333333333 (5.2.3.2)
ou encore
O evalhf(7/5);
evalf[18](7/5);
1.39999999999999990
1.40000000000000000 (5.2.3.3)
Pour la création de constantes ou le stockage des nombres, voir § 5.2.3.1 et § 5.2.3.2.

Certaines fonctions de MAPLE ne sont pas (encore) calculables avec evalhf (voir aussi le §
6 relatif aux nombres complexes)
O evalf(GAMMA(2.3));
evalf(GAMMA(1.2,2.3)); # Fonction eulérienne incomplète
evalf(BesselJ(1,2.7));
1.166711905
0.1265378441
0.4416013791 (5.2.3.4)
O evalhf(GAMMA(2.3));
evalhf(GAMMA(1.2,2.3));
evalhf(BesselJ(1,2.7));
1.16671190519816025
Error, unsupported type `complex(float)` in evalhf
Error, unsupported type `('complex')('float')` in evalhf
On trouvera la liste des fonctions calculables avec
O ?evalhf/fcnlist
Attention : on notera que Digits est une variable très particulière relativement à la fonction
evalhf et que le résultat, bien que cohérent, peut surprendre ! Même si le nombre de chiffres
affichés est de 18, MAPLE considère que le nombre effectif de chiffres significatifs est de
15, et évidemment quelque soit la valeur de Digits.
O Digits;
evalhf(Digits); # 10 devient 15. !!!
trunc(evalhf(Digits)); # voir § 5.3
10
15.
15 (5.2.3.5)
Exercice : Expliquer la raison de la différence entre les résultats suivants :

16
O evalhf(2*Pi/3);
evalhf(2*Pi)/3;

2.09439510239319526
2.094395102 (5.2.3.6)
5.2.3.1 Constantes [*]
Pour créer des constantes dans ce mode on utilisera la fonction HFloat, équivalent de
Float pour les nombres décimaux standard.
O A:=HFloat(1234.56,-2);
A := 12.3455999999999992 (5.2.3.1.1)
Exercice : le premier argument doit être un entier ou un décimal. Corriger
O HFloat(sqrt(2));
HFloat 2 (5.2.3.1.2)
O HFloat(5/3);
Error, invalid argument for HFloat constructor
Exercice : modifier pour avoir toute la précision
O HFloat(evalf(5/3));
1.66666666700000009 (5.2.3.1.3)

5.2.3.2 Stockage et conversion [**]


Le plus grand nombre représentable est obtenu avec
O evalhf(DBL_MAX);
9.9999999000000002 10307 (5.2.3.2.1)
Comme expliqué dans l'introduction, ces nombres sont stockés sur 64 bits (valeur
invariable) et la mantisse en occupe
O evalhf(DBL_MANT_DIG);
53. (5.2.3.2.2)
Les autres sont utilisés pour le signe du nombre et l'exposant de 10 et sont signe. La
précision limitée des calculs entraîne nécessairement des erreurs numériques (et pas
seulement avec evalhf !) et le plus petit nombre ε > 0 tel que 1+ε ≠ 1 est donné par
O evalhf(DBL_EPSILON);
2.22044604925031308 10-16 (5.2.3.2.3)
On trouvera des compléments d'information sur ce sujet dans l'aide en ligne
O ?evalhf/constant
O ?MTM/double
O ?MTM/single
5.2.3.3 Modes de calculs [**]
Cet exemple montre deux nombres A et B en apparence identiques. Pour MAPLE ils
sont pourtant, du point de vue informatique, de natures différentes. On dit qu'ils sont de
types différents, A étant de type hfloat et B ne l'étant pas, malgré son calcul par evalhf.
Les deux possèdent malgré tout de type float (voir le chapitre 2 à propos de la notion de
type). Ceci engendre des modes implicites de calcul différents comme le montrent les
résultats des calculs de 1/A et 1/B
O A:=HFloat(1.234567890123456789012345);
1/A, evalf(1/A);
B:=evalhf(1.234567890123456789012345);
1/B, evalhf(1/B);

A := 1.23456789012345669
0.810000007290000101, 0.810000007290000101
B := 1.23456789012345669
(5.2.3.3.1)
17
0.8100000074, 0.810000007290000101 (5.2.3.3.1)
Concernant C, on rappelle que même si Digits vaut 10, la précision imposé par la
définition du nombre est totalement préservée, ce qui n'est pas le cas de A et de B qui sont
tronqués.
O C:=1.234567890123456789012345;
1/C, evalhf(1/C);
C := 1.234567890123456789012345
0.8100000074, 0.810000007290000101 (5.2.3.3.2)
Sans entrer dans les détails on voit que A est stocké sur 8 octets (8×8 bits = hfloat) et B
ou C sont du type sfloat, c'est-à-dire software float.
O NumericClass(A);
NumericClass(B);
NumericClass(C);
And float8 , positive, numeric
And sfloat, positive, numeric
And sfloat, positive, numeric (5.2.3.3.3)
La façon dont MAPLE déduit sa façon de calculer dépend de la nature des nombres et de
la valeur de la variable d'environnement suivante qui vaut par défaut
O UseHardwareFloats;
deduced (5.2.3.3.4)
Il est possible de modifier le comportement des modes de calculs en donnant une valeur
différente à cette variable : true, false ou deduced, mais mieux vaut savoir ce que l'on
fait... !
O ?UseHardwareFloats

5.3 Décimaux, entiers et rationnels [*]


On obtient respectivement la partie entière et la partie fractionnaire d'un nombre avec les
fonctions trunc et frac
O a:=1.648;
trunc(-a);
frac(-a);
a := 1.648
K1
K0.648 (5.3.1)
Il n'est pas nécessaire de forcer au préalable l'évaluation décimale de l'argument qui peut être un
nombre symbolique. On notera que la priorité est toujours donnée aux expressions exactes
O trunc(-Pi), frac(3*sqrt(2)) , evalf(frac(3*sqrt(2)));
K3, 3 2 K 4, 0.242640686 (5.3.2)
L'entier le plus proche est donné par
O round(-a),round(exp(1));
K2, 3 (5.3.3)
Les entiers immédiatement inférieurs et supérieurs sont respectivement donnés par (ceil pour
"ceiling" = "plafond" et "floor" = "sol")
O floor(Pi), ceil(Pi);
3, 4 (5.3.4)
O floor(-Pi),ceil(-Pi);
K4, K3 (5.3.5)
Il est possible de convertir un nombre décimal en nombre rationnel. MAPLE renvoie alors une
fraction réduite au plus petit dénominateur
18
O r_Pi:=convert(evalf(Pi),rational);
ifactor(%);
104348
r_Pi :=
33215
2
2 19 1373
(5.3.6)
5 7 13 73
Pour des conversion plus spécialisées vers des entiers on se reportera à la bibliothèque
O ?MTM/integer

5.4 Tronctature et gestion des petites valeurs assimilables à 0 [**]


Cette gestion concerne aussi, et de façon particulière, les nombres complexes. Le sujet est
donc reporté au § 7.3 sur la fonction fnormal après la présentation des nombres complexes.

5.5 Gestion des erreurs [**]


On peut traiter suivant son choix les "accidents" de calcul comme des divisions par 0, les
dépassement de capacité mémoire, etc. Le sujet dépasse le cadre de ce chapitre et on trouvera
quelques éléments d'information au chapitre 19. On pourra aussi visiter l'aide en ligne, par
exemple
O ?NumericEventHandler
O ?NumericStatus

5.6 Représentations extrêmes des décimaux en arithmétique émulée


[**]
La représentation des nombres décimaux est limitée en magnitude (voir la notion de
type/extended_numeric au chapitre 2)
O exp(-2.0e10), exp(1.0e30), exp(-1.0e29)*exp(1.0e30);

K0., Float N , Float undefined (5.6.1)


Le plus grand et le plus petit nombre décimal strictement positif que peut représenter MAPLE en
arithmétique émulée sur l'ordinateur utilisé sont donnés par
O Maple_floats(MAX_FLOAT), Maple_floats(MIN_FLOAT);
1. 102147483646 , 1. 10-2147483646 (5.6.2)
On trouvera des compléments d'information sur ce sujet dans l'aide en ligne
O ?Maple_floats
Pour les nombres en arithmétiques cablée (hfloat), voir le § 5.2.3.2

5.7 Calculs des arrondis [**]


Les calculs d'arrondis sont contrôlés par la variable d'environnement Rounding. Suivant sa
valeur, l'arrondi est calculé ainsi
- nearest (par défaut) : au plus près (la plus petite distance).
- 0 : vers 0.
- ±∞ : dans la direction correspondante.
Le schéma illustre les significations de ces possibilités :
- en bleu sur l'axe réel, un nombre positif ou négatif
- en rouge, les arrondis possibles.
- en vert les arrondis calculés en fonction de la valeur de Rounding.

19
0
nearest
0
+∞

-∞

Attention : nearest n'est pas un nom réservé (il devrait l'être) et est assignable (il ne devrait pas
l'être).

Le rationnel 1/7 est représenté par une suite périodique de décimaux 0.142857 142[857...] ⇒
0.142857 142[9 ou 8]
O Rounding:=nearest; # Valeur par défaut
evalf(-1/7),evalf(+1/7);
Rounding := nearest
K0.1428571429, 0.1428571429 (5.7.1)
O Rounding:=0;
evalf(-1/7),evalf(+1/7);
Rounding := 0
K0.1428571428, 0.1428571428 (5.7.2)
O Rounding:=+infinity;
evalf(-1/7),evalf(1/7);
Rounding := N
K0.1428571428, 0.1428571429 (5.7.3)
O Rounding:=-infinity;
evalf(-1/7),evalf(1/7);
Rounding:=nearest:
Rounding := KN
K0.1428571429, 0.1428571428 (5.7.4)

5.8 Affichage des nombres décimaux [**]


5.8.1 Nombre de chiffres significatifs affichés [**]
L'affichage des nombres décimaux est piloté par une variable d'interface displayprecision.
Elle vaut -1 par défaut et permet l'adaptation automatique de l'affichage en fonction de la
valeur des nombres (et pas seulement de Digits qui n'intervient que dans les calculs ; voir §
5.2.2).
O interface(displayprecision);
K1 (5.8.1.1)
Mais on peut forcer un nombre fixe n 2 0, 100 de chiffres affichés. La fonction interface
(displayprecision=n) renvoie la valeur avant la modification, ce qui permet de la mémoriser
simplement (voir ci-dessous dp:=...)
Pour obtenir l'affichage souhaité on peut aussi modifier avant l'ouverture du document les
paramètres de MAPLE par le menu d'initialisation (onglet Precision, Round screen display
to ; voir § 8.3.7). On peut également introduire les commandes interface dans le fichier
d'initialisation de MAPLE (voir § 8.3.8) ou plus simplement encore dans le Startup code de
la feuille de calcul (voir § 8.4.3).
O dp:=interface(displayprecision=5);
X:=1.2345678901234567890;
Y:=X;
Z:=X/7e10;
20
dp := K1
X := 1.23457
Y := 1.23457
Z := 1.76367 10-11 (5.8.1.2)
Cette modification ne concerne que l'affichage et le retour au mode automatique montre bien
que les nombres ne sont pas modifiés. Le nombre Z résulte d'un calcul et ne possède donc
que Digits=10 chiffres significatifs (voir § 5.2.2).
O interface(displayprecision=dp);
X;
Y;
Z;
5
1.2345678901234567890
1.2345678901234567890
1.763668415 10-11 (5.8.1.3)
Il est fortement déconseillé de faire l'opération dans le sens d'une réduction comme
précédemment et on préférera toujours choisir displayprecision>Digits...
O Digits;
interface(displayprecision=25):
X;
Z;
10
1.2345678901234567890
1.763668415 10-11 (5.8.1.4)
mais finalement la meilleure solution, sauf besoins particuliers, est encore de conserver le
mode automatique -1
O interface(displayprecision=dp):

5.8.2 Affichages spéciaux [**]


Dans le menu général de MAPLE on trouvera aussi, pour des situations particulières,
l'item Format/Numeric Formatting... qui ouvre une fenêtre permettant de choisir certains
modes d'affichage des résultats numériques. On notera que
- ces modes d'affichage peuvent s'appliquer aussi aux entiers si la case Apply to
Integer est cochée.
- le séparateur décimal n'est plus "." mais ","
- le mode peut s'appliquer sur un résultat déjà affiché sans avoir à relancer le calcul.
On clique quelque part dans le groupe d'exécution, on fixe avec le menu le mode et
l'affichage des résultats est modifié.
- quand un mode est fixé il se conserve pour les affichages suivants.
- quand un tel mode est actif, une icône s'affiche à gauche de chaque groupe
d'exécution. Elle n'apparaît que sur la feuille de calcul (si l'option Markers dans le menu
View de MAPLE est cochée), mais pas sur le document imprimé, d'où son absence ici. On en
donne seulement trois exemples:
- Fixed, Decimal places = 3, la case Apply to Integer est cochée
O X;
Z;
1234567890;
1,235
,000
1234567890,000 (5.8.2.1)
- Scientific, Decimal places = 5, Minimum Exponent Digits = 2, Show + pour les
exposants positifs ou nuls, la case Apply to Integer est décochée.

21
O X;
Z;
1234567890;
1,23457 # 10 C 00
1,76367 # 10 - 11
1234567890 (5.8.2.2)
- Custom avec une chaîne fixant le format. Pour plus d'information sur ce mode, voir
l'aide en ligne
O ?formatting
Conseil : il est recommandé d'essayer la chaîne sur une feuille MAPLE séparée si on n'est
pas sûr de soi...

Exercice : quelle chaîne peut produire un tel format d'affichage !?


O exp(-1e2),ln(12.56),1.0e12,-evalf(exp(Pi/4));
Petit, Moyen, Grand, KPetit (5.8.2.3)

- None revient à l'affichage standard.


O X,Z;
1.2345678901234567890, 1.763668415 10-11 (5.8.2.4)

5.9 A propos du point décimal et de l'opérateur "." [**]


On a vu que laisser le point décimal seul devant e ou E engendrait une erreur (voir § 5).
O 2.e6;
Error, missing operator or `;`
La raison vient de ce que "." peut être compris par MAPLE, contrairement à "∗", comme un
opérateur de multiplication non commutatif
O y*x-x*y;
y.x-x.y;
0
y.x K x.y (5.9.1)
Lorsqu'il peut exister une ambiguïté le "." doit être obligatoirement précédé d'un espace pour
être compris comme opérateur de multiplication
O 4.5 , 4 .5 , 4 . 5;
4.5, 20, 20 (5.9.2)
Ici MAPLE comprend "45 × 0.". On se doute qu'une telle faute de frappe peut avoir des
conséquences redoutables dans une expression plus compliquée !
O 45 .0e6;
0. (5.9.3)
Maintenant MAPLE détecte une erreur
O 45. 0e6;
Error, unexpected real number

L'effet peut aussi se produire avec une césure lors d'un retour à la ligne . On a fait suivre le
chiffre 1 de Shift-Return, provoquant ainsi une césure volontaire. MAPLE calcule alors
cos(1×0.0).
O cos(1.0e0); cos(1
.0e0);
0.5403023059
1. (5.9.4)

On ne saurait trop recommander de réserver l'usage de cet opérateur aux seules opérations
non commutatives comme par exemple les produits de matrices (voir chapitre 4, Vecteurs,
Matrices et Algèbre linéaire).
22
6 Nombres complexes
Les nombres complexes, mis sous une forme algébrique, s'écrivent a + b*I. Le symbole
prédéfini I désigne K1 . Noter la majuscule obligatoire pour I.
O sqrt(-1);
z:=3+2*I;
I
z := 3 C 2 I (6.1)
Ce symbole est protégé contre toute assignation
O I:=3;
Error, illegal use of an object as a name

Remarque [**] : la notation I n'est pas figée. On peut la changer en utilisant la commande suivante
et en choisissant une autre lettre (ici i) ou un symbole quelconque valide comme par exemple Img
(éviter Im qui est le nom de la fonction d'extraction de la partie imaginaire).
> interface(imaginaryunit=i);
Mais i deviendrait alors un nom protégé et on ne pourrait plus lui assigner une valeur (i.e. i:=2;
deviendrait interdit). De plus on ne pourrait pas, par exemple, l'utiliser pour indexer une boucle.
Réciproquement I deviendrait un nom ordinaire. Ce changement ne vaudrait que pour la session en
cours ou serait annulé après un ordre restart (voir § 8.3.4, § 8.3.8 et § 8.4.3).

Si la partie réelle ou complexe est sous la forme décimale, les deux parties sont automatiquement
converties dans ce mode. Ici l'expression ei p/2 est évaluée symboliquement et vaut donc exactement
K1/2, mais est convertie en K0.50... en raison de la présence du décimal 3.0. Inversement pour Y.
O X:=3.0 + exp(I*Pi)/2*I;
Y:=3/2 + 1.*I;

X := 3.0 K 0.5000000000 I
Y := 1.500000000 C 1. I (6.2)
Un nombre qui possède une partie imaginaire décimale nulle reste sous sa forme complexe, mais
on pourra utiliser simplify avec l'option zero pour éliminer ce terme. Ce comportement est délibéré
et n'est pas une anomalie de fonctionnement (homogénéité des types pour les calculs numériques).
Mieux, il n'est en général pas souhaitable de faire cette simplification tant que des calculs
numériques sont en cours (voir la fonction fnormal au § 7.3 et l'exercice 3.3.1 à propos de la
matrice des vecteurs propres ; voir aussi au chapitre 2 le type embedded_real).
O X:=3 + 0.*I;
Y:=3.+ 0 *I;
X-Y;
simplify(X,zero);
X := 3. C 0. I
Y := 3.
0. C 0. I
3. (6.3)
Les fonctions numériques de MAPLE ne sont pas restreintes aux arguments réels (se reporter
sinon à la bibliothèque RealDomain). On peut demander d'évaluer une expression complexe sous
sa forme algébrique a + b*I avec la fonction evalc (evaluate as complex)
O z;
c:=-exp(z);
evalc(c) , evalc(ln(z));
3C2 I
c := Ke3 C 2 I
1 2
Ke3 cos 2 K I e3 sin 2 , ln 13 C I arctan (6.4)
2 3
23
1
O Q d evalc
K2 C I
1 1
Q := K4 C 2 5 5 K I 4C2 5 5 (6.5)
10 10
On peut également demander une approximation décimale
O evalf(Q);
0.1536450380 K 0.6508508258 I (6.6)
Bien sûr, une représentation algébrique symbolique n'est pas toujours possible
O ?evalc/functions
mais une représentation décimale peut être calculée avec le nombre de chiffres significatifs
souhaités.
O evalc(Zeta(z+1)); # Zeta : fonction de Riemann
evalf[20](Zeta(z+1));
z 4C2 I
0.99793259523003576331 K 0.071461016424093086313 I (6.7)
On peut extraire les parties réelles et imaginaires avec
O Re(c), Im(exp(-z^2));
Ke3 cos 2 , KeK5 sin 12 (6.8)
Si l'argument de ces fonctions est symbolique on obtient un résultat formel.
O Re(s), Im(t^2);
R s , I t2 (6.9)
Exercice : interpréter ces deux résultats
O Im(1+I*exp(-t^2));
2
R eKt (6.10)
O Re(1+I*exp(-t^2));
2
1 K I eKt (6.11)
On peut aussi donner la représentation polaire d'un nombre
O polar(c);
polar(s);
polar(Q);
polar e3 , 2 K p
polar s , argument s
1 3/4 4C2 5
polar 5 , Karctan (6.12)
5
K4 C 2 5
dans laquelle on reconnaît le module (valeur absolue) et l'argument
O abs(c) , argument(c);
abs(s) , argument(s);
abs(Q) , argument(Q);
e3 , 2 K p
s , argument s
1 3/4 4C2 5
5 , Karctan
5
K4 C 2 5
On peut construire un complexe sous forme algébrique à partir de cette représentation polaire
O W:=evalc(polar(x+y,Pi/4));
1 1
W := xCy 2 C I xCy 2 (6.13)
2 2
Attention : dire que x C y est le module de W n'est pas exact. Il faut pour cela faire l'hypothèse que
x R 0 et y R 0 et MAPLE ne s'y trompe pas !

24
O abs(W);
1 1
xCy 2 C I xCy 2 (6.14)
2 2
Il est possible de faire ce genre d'hypothèses (voir Ch. 13, Simplifications, Manipulations)
O abs(W) assuming x>=0,y>=0;
xCy (6.15)
Pour obtenir une expression conjuguée on écrira
O conjugate(c);
Ke3 K 2 I (6.16)
Pour les nombres symboliques, les expressions conjuguées sont notées avec une barre de
surlignement.
O conjugate((x-y+1)*c);
Ke3 K 2 I 1 C x K y (6.17)

Exercice : expliquer pourquoi MAPLE n'écrit pas le résultat suivant sous la forme
1 1
xCy 2 K I xCy 2
2 2
Modifier la commande pour obtenir ce résultat
O conjugate(W);
1 1
xCy 2 C I xCy 2 (6.18)
2 2

On retrouve, comme pour les réels, les mêmes règles générales d'évaluation des expressions quand
les décimaux sont mélangés aux entiers et aux rationnels.
O 1 + 2*I - sin(3/2 + 2.0*I);
K2.752771340 C 1.743446044 I (6.19)
Pour le traitement des petites valeurs résiduelles dans un calcul voir la fonction fnormal au § 7.3
O exp(-I*Pi);
E:=exp(-1.0*I*Pi);
K1
E := eK1.0 I p (6.20)
O evalf(E) , evalc(E);
K1. C 4.102067615 10-10 I, K1 (6.21)

7 Divers
7.1 Autres fonctionalités de MAPLE à propos des nombres
MAPLE révèle encore de nombreuses ressources que l'on ne pourra pas toutes présenter...!
O convert(MDXV,arabic);
1515 (7.1.1)
O convert(3.265,binary), convert(207,octal);
11.01000011, 317 (7.1.2)
Corps p-adiques ℚp (décomposition canonique de Hensel de K2 en diadique ; attention :
Digitsp)
O Digitsp:=7: padic[evalp](-2,2);
2 C 22 C 23 C 24 C 25 C 26 C O 27 (7.1.3)
Nombres de Bernoulli, d'Euler, de Mersenne, de Bell, pseudo-aléatoires...
O bernoulli(2^5), euler(10), numtheory[mersenne]([7]),
combinat[bell](5), rand();
(7.1.4)
25
7709321041217
K , K50521, 524287, 52, 395718860534 (7.1.4)
510
Pour plus d'informations sur les calculs avec unités physiques, voir chapitre 13 (me désigne ici
la masse de l'électron).
O with(Units[Natural]):
3.0 'mile'2 C 4.5 'ft'2 K 2 'm'2

2787.465291 m (7.1.5)
MAPLE possède une vaste base de donnée de constantes physico-chimiques
O m[e]:=evalf(ScientificConstants:-Constant('m[e]',
system=CGS,units));
me := 9.109381882 10-28 g (7.1.6)
O cat(`En l'an de grâce `, convert(2008,roman),
", le logiciel MAPLE 12...");
En l'an de grâce MMVIII, le logiciel MAPLE 12... (7.1.7)
O restart: # voir § 8.3.4

7.2 Identification des nombres décimaux [*]


Supposons qu'après de laborieux calculs numériques d'intégrales, de résolutions d'équations
ou autres, nous ayons obtenu la valeur suivante
O x := 3.878241035;
x := 3.878241035 (7.2.1)
On suspecte néanmoins que tous nos calculs pourraient avoir pour résultat une valeur
symbolique exacte qu'on a pas sû calculer. La fonction identify peut nous donner une indication
sur la validité de notre intuition. Evidemment cette identification n'a de sens que dans la limite de
la précision du nombre décimal proposé (voir exercice 6.6 ou la fin de 6.7.4).
O identify(x);
1
C2 p (7.2.2)
3
Ce résultat conforte notre intuition et tend à montrer que nos calculs pourraient peut-être avoir un
résultat symbolique exact, ce qui reste à vérifier.
Attention à un mythe très répandu chez certains étudiants: tout problème
mathématique formulé exactement n'a pas nécessairement, si elle existe, sa (ou ses) solution
exprimable exactement en termes de combinaisons de symboles connus (entiers, rationnels,
radicaux, constantes spéciales connues, valeurs de fonctions élémentaires ou spéciales, etc.
comme ci-dessus). Par exemple les deux solutions d'une équation aussi simple que cos x = x
sont réputées pour ne pas être exprimables exactement à l'aide de formules symboliques... Seule
une forme numérique (aussi précise que l'on souhaite) peut être obtenue : x = ±0.7390851332...
(voir chapitre 14).
Si le résultat renvoyé est le nombre lui-même, aucune identification n'a été obtenue. Mais une
réponse négative n'est pas absolue
O identify(2.599079725);
2.599079725 (7.2.3)
Il y a en effet une infinité de combinaisons possibles et il peut être nécessaire d'aider identify en
lui communiquant notre intuition.
O identify(2.599079725,BasisSumConst=[1,Pi,sqrt(Pi),ln(2),
exp(1),ln(Pi)] );
3 p Ke (7.2.4)
On complètera ces informations très succintes avec l'aide en ligne.
O ?identify

26
7.3 Fonction fnormal : troncature des nombres décimaux et
complexes et valeurs assimilables à 0 [**]
Cette fonction trouve ses applications notamment avec les calculs numériques (voir par
exemple l'exercice 3.3). Appliquée sur un nombre x, fnormal(x,n,e) effectue une troncature de
x pour conserver n chiffres significatifs avec calcul de l'arrondi sur le dernier chiffre (calculé
suivant la valeur de Rounding, voir § 5.7).
O x:=1.234567890123456789e-10;
y:=fnormal(x,6,1e-11);
x := 1.234567890123456789 10-10
y := 1.23457 10-10 (7.3.1)
Ceci est indépendant de la valeur de Digits (voir § 5.2.2)
O Digits;
x , y;
x/2, y/2;
10
1.234567890123456789 10-10 , 1.23457 10-10
6.172839450 10-11 , 6.172850000 10-11 (7.3.2)
Si |x| < e (e doit toujours être > 0) , fnormal renvoie la valeur 0.
O fnormal(x ,6,1e-10),
fnormal(x/2 ,6,1e-10),
fnormal(-x/2,6,1e-10);
1.23457 10-10 , 0., K0. (7.3.3)
Kn C 2
Si l'argument e est absent le mécanisme s'applique néanmoins pour e = 10 .
O fnormal(x,12), # => e = 10^(-12+2) = 10^(-10)
fnormal(x,11); # => e = 10^(-11+2) = 10^(- 9)
1.23456789012 10-10 , 0. (7.3.4)
KDigits C 2
Si seul x est présent, alors n = Digits et e = 10 .
O fnormal(x), # => e = 10^(-Digits+2) = 10^(-8)
fnormal(10*x),
fnormal(100*x);
0., 0., 1.234567890 10-8 (7.3.5)

Appliquée à une expression, la fonction agit sur tous les nombres (non symboliques).
O a:=Pi*(1.23456789012356e-2+1.2345e-4*I)*t+
exp(-0.1234567890123e-4*sqrt(Pi^5)*t^2);
fnormal(a,3,1e-5);
5 / 2 t2
a := 0.0123456789012356 C 0.00012345 I p t C eK0.00001234567890123 p
5/2 2
0.0123 C 0.000123 I p t C eK0.0000123 p t (7.3.6)
Il faut rester prudent car cette opération peut changer une expression, soit en supprimant des
termes, soit en changeant leur nature.
O fnormal(a,6);
0.0123457 C 0.00012345 I p t C 1. (7.3.7)
Exercice : comparer avec le résultat précédent et expliquer...
O fnormal(evalf(a),6);
2
0.0387851 C 0.000387830 I t C eK0.000215968 t (7.3.8)

Un nombre complexe pour lequel la partie imaginaire est considérée comme nulle par
fnormal conserve sa forme complexe A+0.*I (voir § 6).
O fnormal(a,5);
0.012346 C 0. I p t C 1. (7.3.9)

27
8 A propos du fonctionnement de MAPLE
8.1 Syntaxe des noms
- Les noms dans MAPLE créés par l'utilisateur (noms de variables, d'expressions, de
fonctions, etc.) doivent commencer par une lettre, mais peuvent contenir des chiffres ainsi que
le caractère de soulignement "_".
- Les caractères d'espacement sont autorisés pour séparer les éléments d'une commande
afin d'améliorer la présentation, mais ils ne sont pas admis dans l'écriture d'un nombre ou d'un
nom (voir cependant au chapitre 18, le § Symboles et chaînes de caractères).
- MAPLE fait la distinction entre majuscules et minuscules. Ainsi le nom a_1b est
différent de A_1b ou de a_1B.
- On peut aussi créer des noms commençant par un "_", mais ceci est très vivement
déconseillé car MAPLE génère lui-même de tels noms de façon automatique (constantes
d'intégration d'une équation différentielle par exemple). Même si généralement MAPLE l'en
protège, l'utilisateur risque de subir les conséquences d'interférences difficiles, voire très
difficiles à détecter dans certains cas.
- [*] S'ils sont correctement orthographiés, les noms de variables grecs tels alpha, beta,
theta, phi, rho, etc. seront affichés avec l'alphabet grec. Si seule la première lettre est une
majuscule la lettre grecque sera majuscule (à l'exception de Pi qui s'écrira π et désignera le
nombre lui même ; pour écrire Π écrire PI). On pourra aussi utiliser la palette de l'alphabet grec
(Greek) dans la colonne latérale gauche de la fenêtre MAPLE. Certaines lettres grecques
majuscules peuvent produire un affichage ambigu (la lettre grecque n'est pas en italique).
O A-Alpha;
O-Omicron;
AKA
OKO (8.1.1)
- [**] Bien que représentant une opération particulière, on peut définir des variables indicées
à l'aide de crochets (voir les chapitres 2 et 5). Cette écriture réclame cependant quelques
précautions.
O Lambda[0]:=rho*exp(theta)*cos(phi[i+nu]);
L0 := r eq cos fi C n (8.1.2)
- Un grand nombre de noms sont prédéfinis et protégés contre les assignations (certains,
comme Digits, sont prédéfinis, mais par pour autant protégés). Ici γ est la constante d'Euler-
Mascheroni (voir exercices 2.5, 2.7, 2.8, 2.9 et 2.10) et O est réservé pour la syntaxe des
développements en séries (chapitre 11).
O gamma:=3;
O:=1;
Error, attempting to assign to `gamma` which is protected
Error, attempting to assign to `O` which is protected
Néanmoins...
O Omicron:=1;
O := 1 (8.1.3)
Certains sont des mots clé, comme ceux utilisés en programmation. Par exemple une boucle de
calcul utilise les mots clé for... from... to... by... do... end do. Comme le dit le message d'erreur,
l'analyseur syntaxique n'attend pas d'assignation après ce mot (la lettre grecque τ s'écrit tau)
O to:=0;
Error, `:=` unexpected
O ?keyword
Beaucoup de noms sont aussi réservés par les fonctions (Si = Sinus intégral, Int = Intégrale, D
opérateur de dérivation des fonctions).
28
O cos:=3;
Si:=4;
Int:=0;
D:=0;
Error, attempting to assign to `cos` which is protected
Error, attempting to assign to `Si` which is protected
Error, attempting to assign to `Int` which is protected
Error, attempting to assign to `D` which is protected
O ?functions/index
Attention : on peut par contre écrire cos(0):=0, ce qui conduirait à des calculs aberrants. Cette
possibilité est délibérée mais évidemment pour des raisons utiles en choisissant un autre
exemple ! (voir chapitre 7, § Table remember).

8.2 Les "fausses" erreurs de syntaxe


L'analyseur syntaxique de MAPLE détecte certaines erreurs dans la frappe d'une commande
comme par exemple l'oubli ou le surnombre de parenthèses ouvrantes ou fermantes. Mais il
existe des erreurs assez fréquentes qui ne peuvent pas être détectées car ce sont des erreurs pour
l'utilisateur, mais pas pour MAPLE qui est un calculateur symbolique. En voici quatre
exemples.
1) On a déjà rencontré l'opérateur d'assignation := (§ 1.4). Si l'utilisateur écrit par exemple
O x_min = 2;
x_min = 2 (8.2.1)
il aura peut-être voulu assigner le nombre 2 au nom x_min. Il a écrit en réalité une équation
dont la syntaxe est parfaitement correcte. Aucune erreur ne peut donc être signalée et aucune
assignation n'est effectuée.
O x_min;
x_min (8.2.2)
2) On peut faire une erreur dans l'orthographe d'un nom. Par exemple on attend a:=2, mais
O x1 := 1:
a := X1 + 1;
a := X1 C 1 (8.2.3)
Il n'y a pas d'erreur détectée car X1 est compris comme un nouveau nom symbolique de valeur
indéfinie.
3) De même, lorsque le nom d'une fonction est mal orthographié, MAPLE se contente de le
renvoyer à l'identique. Il considère cette fonction comme symbolique et non définie et par
conséquent ne signale aucune erreur, ce qui est un comportement normal et même indispensable
pour un calculateur symbolique. Par exemple on obtiendra :
O 3!*cosinus(Pi)/3+2;
2 cosinus p C 2 (8.2.4)
Alors que l'on attend
O 3!*cos(Pi)/3+2;
0 (8.2.5)
Cette erreur est assez fréquente pour des fonctions moins habituelles. Elle est source de
confusions, l'utilisateur non averti cherchant l'erreur ailleurs ou pensant qu'il ne sait pas se servir
de la fonction. Un exemple fréquent est celui des calculs de limites avec la fonction de MAPLE
qui s'écrit limit et non lim comme habituellement : lim exp t = 1
t/0
O lim (exp(t),t=0);
limit(exp(t),t=0);
lim et , t = 0
1 (8.2.6)
Encore une variante avec un L majuscule dont on trouvera l'explication et l'utilité au chapitre 9: la
fonction est bien comprise, mais aucun calcul n'est effectué
O Limit(exp(t),t=0);
29 (8.2.7)
lim et (8.2.7)
t/0
Ceci est également vrai pour une fonction dont la syntaxe est correcte mais qui n'est pas
automatiquement accessible par MAPLE au moment de son lancement (voir § 8.3.5).
4) Certaines "erreurs" relèvent d'une interprétation, disons... plus subtile. On a ici oublié
l'astérisque de multiplication comme on le fait avec une écriture standard et le résultat est
manifestement faux.
O 1+5(3+2);
6 (8.2.8)
En fait, l'expression 5(3+2) est interprétée comme une fonction constante de valeur 5 et
d'argument 3+2. D'ailleurs...
O 1+5(x);
6 (8.2.9)
O 1+(1+4)(x);
6 (8.2.10)
Ceci est délibéré et n'est pas considéré par MAPLE comme une erreur.
Par contre l'interprétation est un peu différente en mode "2-D Math Input"
O 1C5 3C2
26 (8.2.11)
O 1C5 t
1C5 t (8.2.12)
Encore que...
O 1C 4C1 3C2
6 (8.2.13)
O 1C 4C1 t
6 (8.2.14)
Comme indiqué au § 1.1.1, un espace entre les parenthèses (ou un point ou un astérisque)
transforme cette interprétation de type "fonction" en un produit.
O 1C 4C1 t
1C5 t (8.2.15)
Il devrait être possible d'améliorer les choses...!

Pensez toujours à vérifier la syntaxe de vos commandes et assurez-vous que les fonctions
utilisées sont bien connues de MAPLE (voir § 2-3) avant de vous poser des questions
inutiles !

Exercice : interpréter et corriger


O 4!*cos(pi)/3+2;
8 cos p C 2 (8.2.16)

8.3 Etats de MAPLE


Au lancement, le programme MAPLE se charge dans la mémoire de la machine : c'est ce qui
va réaliser les opérations de calcul. En même temps une zone mémoire, extensible au fur et à
mesure des besoins, va être créée pour stocker l'environnement propre à l'utilisateur (noms des
variables, expressions, valeurs numériques etc.) pendant la période d'utilisation
(appelée session): c'est ce qu'on appelle le noyau (kernel).

Attention : L'aspect de la feuille de calcul et l'état interne du noyau de MAPLE sont deux
choses distinctes comme on va le voir sur deux exemples simples. C'est un point capital à
comprendre !

30
8.3.1 Modification et ré-exécution d'une commande
On peut « cliquer » sur une commande déjà calculée, la modifier et presser sur Return
pour l'exécuter à nouveau. Il faut alors faire très attention au fait que les résultats affichés ne
sont plus nécessairement corrects car ceux des autres commandes ne sont pas modifiés en
conséquence. Supposons une feuille de calculs dont les résultats devraient paraître normaux à
l'utilisateur (dans le cas contraire on lui suggère de faire autre chose que d'apprendre à utiliser
MAPLE...;-)
O ...
O a:=1;
a := 1 (8.3.1.1)
O ...
O a+1;
2 (8.3.1.2)
O ...
Maintenant on clique sur la commande > a:=1; , on la modifie en écrivant > a:=2;
puis on l'exécute. La feuille de calcul aura alors l'aspect suivant
O ...
O a:=2;
a := 2 (8.3.1.3)
O ...
O a+1;
2 (8.3.1.4)
Tant que la commande > a+1; n'aura pas été ré-exécutée le résultat affiché ne sera pas
modifié. Si vous sauvez la feuille de calcul telle quelle ou si vous l'imprimez, un doute risque
de germer dans votre esprit : "MAPLE sait-il réellement faire des calculs ?". Cet exemple de
principe est trivial, mais il est loin d'en être toujours ainsi.
L'utilisation du dito (%, %% ou %%%) peut conduire aux mêmes types d'ambiguïtés car
ce symbole désigne le résultat de la dernière opération effectuée chronologiquement et non
nécessairement le résultat de la commande située sur la ligne précédente, ce que l'on a
généralement tendance à penser en lisant les feuilles de calculs (voir § 1.2.3, résultat
(1.2.3.4)).
8.3.2 Ouverture d'une feuille de calcul enregistrée
Lorsque l'on ouvre une feuille de calculs enregistrée, celle-ci s'affiche à l'écran, mais le
noyau de MAPLE est vide. Pour retrouver l'intégralité du noyau il faut ré-exécuter la
totalité des commandes. Ainsi, supposons que la feuille de calcul que l'on vient de charger se
résume à la seule ligne
> a:=2;
a:=2
>
En entrant directement la commande a+1; sur le prompt final libre on obtiendra
> a:=2;
a:=2
> a+1;
a+1
car 2 n'aura pas été automatiquement assigné à la variable a au chargement de la feuille de
calcul. Pour obtenir 3 il faudra d'abord ré-exécuter : a:=2;
Pour exécuter la totalité d'une feuille de calcul on pourra utiliser Edit/Execute/Worksheet ou
le bouton icône de la barre d'outils (attention : lire § 8.3.4).
8.3.3 Arrêt d'un calcul
Pour arrêter un calcul en cours que l'on croit erroné ou qui paraît anormalement long,
utiliser le bouton icône de la barre d'outils. L'effet n'est pas nécessairement immédiat.
31
8.3.4 L'ordre restart.
On peut recommander d'entrer systématiquement (bien que ce ne soit pas une nécessité
absolue), l'ordre restart; comme première commande de la feuille de calcul. Cette
commande ré-initialise le noyau. Compte tenu de ce qui a été dit précédemment on peut
comprendre qu'elle puisse être placée et exécutée n'importe où dans la feuille et les
commandes ré-exécutées à partir du début. Mais vous risquez alors de repasser sur l'ordre
restart par inadvertance et ainsi vider malencontreusement le noyau (ceci est particulièrement
vrai si on exécute la totalité de la feuille par le menu Edit/Execute/Worksheet ou avec le
bouton icône de la barre d'outils).

On peut par contre introduire autant d'ordres restart que l'on souhaite dans une feuille
de calcul pour séparer des calculs indépendants (voir la fin du § 7.1).
Il est également possible d'effectuer cette action avec le bouton-icône de la barre
d'outils.
Si plusieurs feuilles de calculs sont ouvertes simultanément, l'ordre restart s'applique à la
feuille (au serveur) le contenant ainsi qu'aux serveurs qui lui sont reliés et seulement à
eux (voir § 8.3.6).
8.3.5 Accès aux fonctions des bibliothèques (packages)
Certaines fonctions appartiennent à des bibliothèques auxquelles on n'a pas
automatiquement accès au lancement ou après un ordre restart (sauf utilisation d'un fichier
d'initialisation, voir § 8.3.8 ou § 8.4.3-1). Pour pouvoir accéder à ces fonctions, on utilisera
soit
a) la syntaxe dite « longue » qui permet d'utiliser ponctuellement une fonction dans une
instruction sans avoir un accès permanent aux fonctions de la bibliothèque. Elle peut prendre
deux formes
• Bibliothèque:-Fonction(arguments). Cette écriture correspond aux
bibliothèques récentes de MAPLE (bibliothèques de modules, voir chapitre 19).
• Bibliothèque:[Fonction](arguments). Identique à la précédente et
pour toutes les bibliothèques, les anciennes et les nouvelles.
b) avec l'opérateur with
• qui donne un accès permanent à toute la bibliothèque.
> with(Bibliothèque):
• qui donne un accès permanent seulement à une ou plusieurs fonctions
> with(Bibliothèque,Fonction_1,Fonction_2,...):
On trouvera de nombreux exemples d'utilisation aussi bien dans ce manuel que dans les
exercices (par exemple, chapitre 4 Vecteurs, Matrices,... , § IV Algèbre Linéaire :
bibliothèque, LinearAlgebra §§ Accès aux fonctions de LinearAlgebra). La forme "longue"
est celle qui doit être utilisée dans les procédures (chapitre 19).
c) avec le menu Tools/Load Package on pourra aussi accéder à certaines bibliothèques,
mais pas à toutes...
La liste de toutes les bibliothèques pourra être obtenue avec
O ?index/package
ou avec le menu Tools/Load Package/List All Packages... On notera également que certaines
bibliothèques comme linalg sont, bien que toujours présentes pour des raisons de
compatibilité, déclarées obsolètes et remplacées par de nouvelles.
8.3.6 Gestion des serveurs (noyaux) [*]
On peut ouvrir plusieurs feuilles de calcul simultanément avec le menu File/New (voir §
8.4.7) et on pourra gérer la dépendance entre les serveurs (les noyaux) qui leur sont associés.
On utilisera pour cela le menu Tools/Options... (Windows-Linux) ou MAPLE
12/Preference... (Mac OS). L'onglet General propose deux options dans la rubrique Always

32
use these settings et pour pouvoir choisir on doit connaître les significations suivantes:
• New engine for each document : les serveurs sont indépendants. Si on entre
> a:=2; dans une feuille de calcul, on obtiendra a+1 en exécutant > a+1; dans une autre.
• Shared one engine among all documents : tous les serveurs partagent les données.
Si on entre > a:=2; dans une feuille de calcul, on obtiendra 3 en exécutant > a+1; dans une
autre.
• On notera également l'option donnant la possibilité de poser la question (Ask each
time) à chaque ouverture d'un nouveau document. On devra préciser dans une fenêtre à
chaque ouverture le numéro du serveur (noyau) avec lequel il partage les données. Les
numéros des serveurs sont indiqués en bas à droite de la fenêtre MAPLE. Pour le cas ou l'on
ne veut pas de partage, sélectionner (create new engine).
Sauvegarder avec le bouton Apply Globally ou Apply to Session (voir § 8.3.7).
8.3.7 Initialisation de MAPLE par menu
On a souvent mentionné dans ce chapitre la possibilité de paramétrer MAPLE au moment
de son lancement ou après un ordre restart à l'aide du menu Tools/Options (Windows-
Linux) ou Maple 12/Préférences (Mac) qui ouvre une fenêtre d'initialisation. On ne
résumera pas ici toutes les possibilités et le lecteur se reportera aux divers paragraphes de ce
chapitre qui y font mention. On rappelle seulement que les paramètres ainsi définis ne seront
sauvegardés que pour la session en cours avec le bouton Apply to Session (i.e. : jusqu'à la
fermeture de MAPLE) ou de façon permanente avec Apply Globally.
8.3.8 Initialisation de MAPLE par fichier [**]
Remarque : il faut savoir que l'on peut aussi initialiser individuellement les feuilles de calcul
de façon similaire sans avoir à initialiser globalement MAPLE de la façon décrite ici (voir §
8.4.3-1).
On peut prédéfinir l'état initial de MAPLE (au lancement et valable pour chaque ouverture
d'un nouveau document et/ou chaque ordre restart) et réaliser des options que ne permet pas
le menu précédent en plaçant dans le répertoire d'entrée de l'utilisateur un fichier contenant
des ordres d'initialisation.
Attention : le fichier doit être en ASCII simple sans formatage (format "texte", pas de
formats du genre .doc ou .rtf). On utilisera donc pour le créer un éditeur capable d'enregister
un mode texte seul (avec Word sous Windows utiliser le format Texte brut puis MS-Dos,
sous Mac le format Texte seulement).
Le nom du fichier dépend du système d'exploitation : maple.ini sous Windows et
.mapleinit sous Mac ou Linux. Le répertoire dans lequel doit être sauvegardé ce fichier sera
obtenu avec la commande
O kernelopts(homedir);
Pour plus de détails, on se reportera à l'aide en ligne
O ?worksheet,reference,initialization
Un tel fichier contiendra simplement des ordres MAPLE valides qui seront exécutés de façon
automatique. Suivant la ponctuation finale des ordres ( ; ou : ) les résultats d'exécution
apparaîtront ou non. On montre un exemple de contenu de ce type de fichier dont l'exécution
sera transparente (terminaison par : de tous les ordres).

Digits:=6: e:=exp(1): protect('e'):


with(LinearAlgebra,LinearSolve): # voir § 8.3.5
interface(imaginaryunit=j):
interface(prompt="$:"):

On demande donc avec ce fichier


• de travailler avec 6 chiffres significatifs par défaut (valeur qui peut aussi être aussi
définie avec le menu d'initialisation)
• d'assigner la base des logarithmes népériens au nom e et de protéger ce nom contre

33
toute autre assignation (voir chapitre 2)
• de pouvoir accéder automatiquement au solveur de systèmes linéaires (ce qui n'est
pas le cas par défaut ; voir § 8.3.5)
• de fixer la syntaxe des nombres complexes comme a+j*b et non a+I*b (voir § 6)
• que le "prompt" des groupes d'exécution (l'invite) ne soit plus > , mais $:
8.3.9 Interopérabilité [**]
Les langages de programmation C, Java et Visual Basic peuvent appeler des applications
MAPLE grâce à des API.
O ?OpenMaple
Inversement MAPLE peut accéder à des routines écrites en C, Fortran ou Java
O ?ExternalCalling
MAPLE peut aussi interagir avec MATLAB
O ?Matlab
ou communiquer avec des bases de données (SQL via JDBC).
O ?Database

8.4 Gestion des feuilles de calcul


8.4.1 "Document mode" et "Worksheet mode"
Comme indiqué dans l'introduction, MAPLE propose deux formes de présentation des
feuilles de calcul : le "Document mode" et le "Worksheet mode" (voir § 8.4.8.1 pour
quelques détails caractéristiques). On pourrait dire de façon simplifiée que le mode
"Worksheet" est plutôt orienté vers un "document de travail" et le mode "Document" vers un
"document scientifique" avec une présentation plus habituelle des commandes de calculs. Ce
mode "Document" semble être celui que tente de promouvoir Maplesoft, mais le mode
"Worksheet" présente aussi des avantages de simplicité et de clarté d'utilisation pour un
travail courant ainsi que des ressources mémoire moins importantes.
Le mode par défaut du document ouvert (lancement de MAPLE ou utilisation du bouton-
icône de la barre d'outils pour ouvrir un nouveau document) est défini par le choix
effectué dans le menu d'initialisation (voir ci dessous). Mais il est toujours possible, à l'aide
du menu File(Fichier)/New/Worksheet ou Document Mode, de faire un choix différent.
Pour le travail courant on conseillera plutôt le "Worksheet mode" avec entrée des
commandes en mode 1D (dit "Maple Notation" ou "1-D Math Input" ; caractères rouges,
voir ci-dessous). C'est le mode traditionnel de MAPLE. Il présente aussi l'avantage
d'enchaîner naturellement les commandes de calcul : quand une commande est exécutée le
curseur saute automatiquement sur la commande suivante. On choisira le "Document
mode" pour l'édition de documents scientifiques et dynamiques (c'est celui des feuilles de
ce manuel).
Pour obtenir par défaut l'ouverture d'un nouveau document dans l'un de ces deux modes,
on ouvrira la fenêtre des réglages d'initialisation avec Tools/Options... (Windows-Linux)
ou MAPLE 12/Préférences... (Mac OS). Cliquer ensuite sur l'onglet Interface puis
sélectionner Document ou Worksheet dans la rubrique Default format for new worksheet.
Valider la commande en cliquant sur Apply Globally (définition permanente) ou Apply to
Session.
Pour que l'entrée des commandes dans une feuille au format Worksheet (ou dans
d'éventuels groupes d'exécution introduits dans une feuille en mode Document) se fasse par
défaut en mode caractères (dit "1D Math Input" ou "Maple Notation", en caractères rouges)
ouvrir la fenêtre des réglages d'initialisation, cliquer sur l'onglet Display et sélectionner
Maple Notation dans la rubrique Input Display. On rappelle qu'il sera toujours possible
d'entrer ou de convertir une commande en mode 2D-Math (écriture standard) par
basculement (voir § 8.4.8.1).
34
[**] Il existe aussi plusieurs types de formats d'écriture pour l'affichage des résultats. On
pourra les expérimenter avec l'onglet Display, option Output display de la fenêtre
d'initialisation ou mieux, avec la commande interface(prettyprint=n). Voici trois exemples
sachant que le mode par défaut est n=3. Noter que restart ne réinitialise pas la valeur par
défaut et que la commande interface(prettyprint=n) affiche la valeur précédente (voir un
exemple similaire au § 5.8.1).
1) 2D-Math Notation.
O Int(sin(x^2)*x,x=0..Pi):%=value(%);
p
1 1 2
sin x2 x dx = K cos p (8.4.1.1)
0
2 2
2) Character Notation (la valeur rendue/affichée par interface est la valeur précédente,
ce qui facilite une mise en mémoire simultanée au changement)
O pty:=interface(prettyprint=1);
Int(sin(x^2)*x,x=0..Pi):%=value(%);
pty := 3
/Pi
| / 2\ 1 1 / 2\
| sin\x / x dx = - - - cos\Pi /
| 2 2
/0

3) Maple Notation
O interface(prettyprint=0):
Int(sin(x^2)*x,x=0..Pi):%=value(%);
Int(sin(x^2)*x, x = 0 .. Pi) = 1/2-(1/2)*cos(Pi^2)
On revient à la valeur par défaut (n=3) avec la valeur mise en mémoire dans pty
O interface(prettyprint=pty);
Int(sin(x^2)*x,x=0..Pi):%=value(%);
0
p
1 1 2
sin x2 x dx = K cos p (8.4.1.2)
0
2 2
Certes les modes CharacterNotation ou Maple Notation sont moins esthétiques, mais
sont aussi beaucoup moins gourmands en mémoire. Ils permettent également d'autres options
comme l'étiquetage (voir interface-labelling) très utile pour afficher des expressions longues
et encombrantes. Par ailleurs ils sont quelquefois indispensables (écriture dans un fichier)
et/ou sont basculés automatiquement par MAPLE (voir § 8.4.5).
8.4.2 Enregistrement et sauvegarde des documents
L'enregistrement des documents se fait de façon habituelle par Fichier(File)/Save ou Save
As... Noter sur Mac une notation qui peut prêter à confusion : l'option Save As... sert à
enregistrer une feuille sous un autre nom, mais le menu mentionne Save As Worksheet... Le
mot Worksheet signifie en fait "Standard Worksheet" et ne signifie pas que l'on sauvera une
feuille MAPLE écrite en mode "Document" dans le mode "Worksheet" (voir § 8.4.1), mais
simplement dans le mode en cours.
MAPLE dispose d'un mécanisme de sauvegarde automatique des documents qui se
lance de façon périodique et discrète pendant le travail (l'accès à MAPLE est néanmoins
interrompu durant l'opération et la mention "Autosaving Worksheet..." s'affiche dans le coin
en bas à gauche de la fenêtre). Un document portant le nom XYZ.mw est alors
automatiquement enregistré sous le nom XYZ_MAS.bak (Maple Auto Saving bakup) dans
le même répertoire et est périodiquement remis à jour. En cas d'anomalie de fonctionnement
de l'ordinateur interrompant inopinément le fonctionnement de MAPLE sans enregistrement
effectué, relancer MAPLE en cliquant sur le document XYZ.mw. MAPLE détectera la
présence du fichier XYZ_MAS.bak et restituera l'information contenue lors de la dernière
sauvegarde automatique. Ce fichier disparaît dès que l'on provoque une sauvegarde
35
volontaire comme indiqué plus haut.
Pour que ce mécanisme fonctionne il faut que dans la fenêtre d'initialisation (voir §
8.3.7), onglet General, la case Auto save every soit cochée et la période de sauvegarde
automatique fixée.
Recommandation : dès que l'on ouvre un nouveau document, le sauver, même vide ou
avec son ordre restart en tête (voir § 8.3.4), en lui donnant un nom. On pourra ensuite
sauver régulièrement le document en cours de construction par une simple pression sur le
bouton-icône de la barre d'outils et éviter ainsi la perte partielle du travail en cas
d'anomalie de fonctionnement de l'ordinateur. En matière de sauvegarde, aucune précaution
n'est superflue...

8.4.3 Initialisation des feuilles de calcul, groupes autoexécutables [**]


1) Initialisation des feuilles de calcul. Une feuille de calcul peut contenir un groupe
"caché" de commandes, dit Startup code, qui seront exécutées lors de son ouverture ou après
un ordre restart. Pour éditer ou modifier ces commandes et/ou procédures, il suffit de
cliquer sur le bouton-icône de la barre d'outils ou d'utiliser le menu Edit/Startup Code et
d'écrire dans la fenêtre qui s'ouvre. Cette édition est passive puisqu'un Return ne déclenche
ni une exécution de l'ordre donné, ni une analyse syntaxique des erreurs. Pour obtenir cette
dernière on utilisera le bouton "Syntax" ou le menu Syntax/Check syntax now. Cette
opération sera systématiquement effectuée avant la sauvegarde si l'option Syntax/Check
syntax before saving est cochée (le défaut). Les ordres de l'exemple du § 8.3.8 pourraient
être introduits comme Startup code. Après avoir sauvegardé avec le bouton "Save" ou le
menu File/Save, lancer un ordre restart ou réouvrir la feuille, autoriser si nécessaire (voir ci-
dessous) l'exécution du Startup code et vérifier que tout est conforme (en exécutant par
exemple ln(e) ou un evalf pour vérifier la valeur de Digits d'après l'exemple donné au §
8.3.8). A la différence de l'exécution du fichier du § 8.3.8, l'exécution est ici toujours
transparente quelque soient les terminaisons des ordres (";" ou ":"). Pour ne pas enregistrer
les modifications faites, fermer directement la fenêtre ou utiliser le menu File/Exit. Pour
supprimer le Startup code, vider son contenu et sauvegarder.
Si un Startup code est présent, les roues de l'icône se remplissent et deviennent .
O ?worksheet,documenting,startupcode
Si on souhaite une exécution automatique du Startup code sans demande d'autorisation
préalable, on fixera dans la fenêtre d'initialisation de MAPLE (voir § 8.3.7), onglet Security,
l'option Autoexecute security level à Don't warm before autoexecution ("Ne pas avertir
avant l'auto-exécution").

ATTENTION : certaines commandes de MAPLE, telles system ou ssystem,


potentiellement dangereuses si elles sont utilisées de façon maladroites ou malveillantes, ne
sont pas, par défaut, directement exécutables par le Startup code, mais d'autres comme
mkdir (création d'un répertoire), rmdir (effacement d'un répertoire vide) ou fremove
(effacement d'un fichier), ainsi que les outils de la bibliothèque FileTools, le sont. Egalement,
ces commandes ainsi que system ou ssystem pourraient être introduites dans des procédures
du Startup code et exécutées ultérieurement dans la feuille de calcul à l'insu de l'utilisateur.
Aussi, avant d'ouvrir un document d'origine douteuse, il est préférable de configurer
MAPLE en mode sécurisé (i.e. l'état de configuration par défaut : Autoexecute security level
mis à Warm once for each Worksheet ; voir § 8.3.7), de répondre "non" à l'autorisation
d'exécution du Startup code s'il existe et de vérifier son contenu. Le menu d'initialisation
permet également d'activer un mécanisme de contrôle (cocher la case Enable engine
security) qui permet à l'utilisateur de contrôler les actions de MAPLE, en particulier celles de
lecture/écriture des fichiers de l'ordinateur.

36
2) Groupes autoexécutables. Les feuilles de calcul peuvent également contenir des
commandes ou groupes de commandes (voir § 1.3) qui seront visibles et exécutables
automatiquement à l'ouverture du document ou après un ordre restart. Pour rendre
autoexécutable une commande ou un groupe de commandes, il suffit de cliquer dessus puis
d'activer le menu Format/Autoexecute/Set. Si l'option View/Markers est cochée, une icône
apparaît à gauche indiquant que le groupe est autoexécutable. Pour annuler cet état on
utilisera de même Format/Autoexecute/Clear. Le contrôle d'autorisation d'exécution se
définit comme pour les ordres du Startup Code.
8.4.4 Sauvetage d'un document corrompu [**]
Il est possible, lors de manipulations peu orthodoxes, que la feuille de calcul enregistrée
soit corrompue (c'est heureusement rarissime). On est catastrophé de voir qu'à l'ouverture du
document une partie semble manquer de façon incompréhensible. Elle est en réalité
probablement présente, mais ne peut être lue car un "groupe" corrompu bloque la lecture. Il
est néanmoins possible de tenter une manoeuvre de récupération.
ATTENTION : L'opération n'est pas forcément évidente et on travaillera toujours avec
une copie du document corrompu.
Les documents MAPLE sont au format XML et par conséquent peuvent être lus avec
n'importe quel éditeur. XML est un langage à balises (dites aussi étiquettes, tags,...)
reconnaissables par leurs formes classiques <xyz>...</xyz>. Les curieux pourront visiter
l'aide en ligne, mais sans que ce soit indispensable...!
O ?Worksheet
ou
O ?XMLTools
Si on ouvre un document MAPLE avec un éditeur on voit, après un long préambule
définissant les caractéristiques générales du document, apparaître les groupes générés par
l'utilisateur entre les tags <Group...>...</Group>. Par exemple :

<?xml version="1.0" encoding="UTF-8"?>


<Worksheet>
... (long préambule)
<Group labelreference="L1" drawlabel="true">
<Input>
...
</Input>
<Output>
...
display="LUklbXJvd0c2Iy9JK...
</Output>
</Group>
<Group labelreference="L2" drawlabel="true">
...
</Group>
...
</Worksheet>

Dans les zones "Input" des documents au format "2-D Math Input" et dans les zones
"Output" en général, les suites de caractères du genre display="LUklbXJ..." sont des
codages qui ne sont interprétables que par MAPLE et qui sont utilisés pour dessiner les
expressions en mode 2D. Il est néanmoins possible de repérer le groupe corrompu par le (ou
les) texte de la commande qui apparaît en clair d'une façon ou d'une autre dans la zone Input.
En mode "2-D Math Input", c'est un peu plus difficile car une commande telle a d 1 s'écrit
input-equation="`:=`(a, 1)". Le groupe corrompu est certainement celui qui suit le dernier
qui s'affiche quand on ouvre la feuille. Il suffit de l'effacer en supprimant les lignes
correspondantes
<Group...>
37
...
</Group>
d'enregistrer la feuille en mode texte (pas de formats du type .rtf ou .doc) puis de l'ouvrir à
nouveau avec MAPLE. On devrait retrouver l'intégralité du document à l'exception bien sûr
du groupe supprimé.
8.4.5 Exportation des documents [**]
Les feuilles de calculs peuvent être exportées dans divers formats comme HTML ou
LaTeX avec le menu Fichier(File)/Export As. Nous ne détaillerons pas ces procédures et
nous renvoyons le lecteur sur l'aide en ligne de MAPLE
O ?worksheet/managing/export
Les feuilles de calcul peuvent être présentées comme des diapositives plein écran (à la
façon PowerPoint, Keynote ou Impress) avec le menu View/Slideshow.
Noter aussi la commande suivante qui compose une expression LaTeX en basculant
automatiquement le format d'écriture du résulat (voir la fin de § 8.4.1). Un simple copier
coller du résultat sera alors possible pour une insertion dans un document LaTeX.
O latex(Int(sin(x^2)*x,x=0..Pi));
\int _{0}^{\pi }\!\sin \left( {x}^{2} \right) x{dx}
Il existe également la possibilité de coder automatiquement des expressions dans un
langage comme C, Fortran, Java, Matlab ou VisualBasic (le transcodage Fortran de MAPLE,
bien que correct, est désuet par rapport à la norme actuelle de ce langage). Voir aussi le §
8.3.9.
O CodeGeneration[Java]([s_x=sin(x^2+1)*x,z=s_x-3]);
s_x = Math.sin((double) (x * x + 1)) * (double) x;
z = s_x - 0.3e1;
8.4.6 Impression des documents. Numérotation des pages
L'impression des feuilles de calcul se fait simplement à l'aide du menu Fichier(File)/Print

Néanmoins, le passage à l'impression peut être source de difficultés en raison de l'absence


de relation entre la largeur de la mise en page à l'écran de la feuille de calcul et celle de la
feuille papier. Lors d'une impression, MAPLE opère des modifications de mise en page et
des compressions automatiques des graphiques qui ne sont pas effectuées sur les légendes,
textes et expressions mathématiques (par exemple § 8.4.8.4-7-c). Ceci provoque des
modifications d'aspect, voire des troncatures, peu esthétiques. On ne peut que recommander,
avant tout travail nécessitant une mise en page précise, de déterminer empiriquement une
largeur virtuelle à l'écran de la feuille de calcul qui soit proche de la largeur réelle imprimée
sur le papier afin d'éviter au maximum les mauvaises surprises au moment de l'impression.
Pour obtenir ce résultat on peut proposer la recette suivante :
1) Ecrire un texte d'au moins dix à quinze lignes sur la feuille de calcul (en mode "Text")
et dans lequel on n'introduira pas de retour à la ligne (utiliser un copier-coller d'un texte
quelconque et supprimer éventuellement les retours à la ligne non automatiques).
2) S'assurer de la justification à gauche ( dans la barre d'outils).
3) Effectuer une prévisualisation ou imprimer le texte ou créer un pdf.
4) Vérifier que l'option Markers du menu View est décochée.
5) Ajuster à l'écran la largeur de la fenêtre MAPLE de façon à ce que les mêmes mots du
texte terminent toutes les lignes dans la page à l'écran et la page imprimée. Plus le nombre de
lignes est important, plus la relation de la largeur de mise en page sera précise par effet
statistique. Normalement MAPLE conserve la taille de la fenêtre ainsi définie d'un lancement
à l'autre.
Il est possible d'insérer des sauts de page avec le menu Insert/Page Break.
Pour numéroter les pages imprimées, on utilisera le menu View/Header Footer... qui
permet aussi de choisir différents format de tête ou de pied de page avec la possiblité
d'inclure des dates, des logos, etc. La numérotation n'est effective que lors d'une
38
prévisualisation, de la création d'un fichier pdf ou d'une impression (la prévisualisation sur
Mac étant une fonction disponible et indépendante pour tous les logiciels, elle se fait en
passant par la fenêtre d'impression).
8.4.7 Ouvertures simultannées de plusieurs feuilles de calculs [*]
On peut ouvrir plusieurs feuilles de calcul simultanément et chacune dans le mode
souhaité (Document ou Worksheet ; voir § 8.4.1). On notera les deux points suivants:
- L'affichage peut apparaître soit dans des fenêtres MAPLE séparées (New Window), soit
dans la même fenêtre avec un sélection des feuilles par onglet (New Tab). Pour obtenir un de
ces choix par défaut on ouvrira la fenêtre des réglages d'initialisation (voir § 8.3.7), on
cliquera sur l'onglet Interface puis on choisira à la rubrique Open worksheets in :, soit New
Window soit New Tab.
- La gestion de la dépendance entre les données des feuilles de calcul (des serveurs) ainsi
ouvertes sera gérée suivant la méthode décrite au § 8.3.6.
8.4.8 Structures et éléments des feuilles de calculs
8.4.8.1 Document blocks et Execution groups, Math et Texte
Une feuille de calcul en mode Document est essentiellement structurée en "documents
blocks" marqués à gauche (si l'option du menu View/Markers est cochée) par les
symboles et et une feuille de calcul en mode Worksheet, en "groupes
d'exécution" marqués par un prompt > et un crochet extensible à gauche [. Les deux
modes ont en commun le langage XML (voir § 8.4.4) et en réalité ne s'excluent pas l'un
l'autre car les éléments standard de l'un peuvent être introduits dans l'autre. On a vu avec
la structure de ce chapitre que l'on pouvait introduire des "groupes d'exécutions" dans un
mode Document, mais on peut aussi introduire des "documents blocks" dans un mode
Worksheet avec le menu Format/Create Document Block. On peut aussi, pour écrire du
texte utiliser le menu Insert/Paragraph/Before-After Cursor (voir aussi le bouton-icône
de la barre d'outils), etc. On notera toutefois que trop de mélange peut rendre la
gestion d'un document confuse et difficile.
Un Return crée un nouveau block ou un nouveau groupe d'exécution alors qu'un
Shift-Return fait seulement passer à la ligne. On rappelle que l'on peut passer du mode
"Math" au mode "Text"
- à l'aide du bouton et bien sûr réciproquement avec .
- à l'aide de la touche F5 (fn-F5 pour certains claviers).
- à l'aide du menu Edit/Switch to Text Mode (et réciproquement, l'item changeant
automatiquement de nom, avec Edit/Switch to Math Mode).
- on peut convertir une commande écrite en "1-D Math Input" (caractères rouges)
en mode "Math" avec Format/Convert To/2-D Math Input (attention : ne pas choisir
l'option "2-D Math"-"tout court" pour convertir une commande). On peut bien sûr faire
l'opération réciproque avec Format/Convert To/1-D Math Input.
- on peut convertir une formule incluse dans un texte et écrite en mode "Text" vers
sin p x
le mode "Math" (par exemple sin(Pi*x)/(Pi*x) / ) en sélectionnant le texte de
px
la formule puis en utilisant le menu Format/Convert To/2-D Math ("tout court" et non "2
-D Math Input").
Pour effacer un élément (paragraphe de texte, commande, résultat...) on clique sur cet
élément puis on utilisera le menu Edit/Delete Element ou son raccourci clavier associé
que l'on pourra lire sur le menu (à droite). Si le block ou le groupe est vide il sera effacé.
On a renoncé à présenter toutes les fonctionnalités de ces deux modes en raison de
leur trop grand nombre. Signalons simplement les actions par menus contextuels en mode
Document : un clic droit sur une expression entrée en mode "Math" permet d'accéder à de
nombreuses opérations de base que MAPLE peut effectuer. Par exemple, après avoir
39
entré l'expression à gauche (en mode Math), un clic droit dessus (Ctrl-clic sur un Mac
non équipé d'une souris trois boutons) ouvre un menu ou on a choisi "Differentiate/x"
(MAPLE reconnaît les variables libres x et y ; "w.r.t." = "with respect to" = "par rapport
à").

differentiate w.r.t. x
2$cos x2 C sin x$y K2 sin x2 C sin x y 2 x C cos x y y

Il pourra de même, avec un clic droit sur le résultat, faire une autre opération, comme par
exemple un tracé. Si on modifie l'expression initiale, on pourra ré-exécuter la commande
en cliquant sur le bouton-icône de la barre d'outils. On notera aussi la fonction
Explore de ce menu contextuel. On pourra reproduire l'exemple suivant : après avoir
entré l'expression sur laquelle on effectuera un clic droit, on choisit Explore dans le menu
et on coche "skip" pour x (expliquer pourquoi après avoir essayé).

factor 1 C xa

Un peu d'expérimentation empirique pour dégrossir le terrain peut être une bonne
méthode pour débuter, mais elle devra être suivie d'une lecture attentive de l'aide en ligne
pour éviter de manquer les nombreuses fonctionnalités disponibles. Pour une première
présentation générale on recommande la lecture de
O ?MaplePortal
(ce document contient un lien Internet vers une vidéo en anglais très explicite), ainsi que
les paragraphes 1 et 2 de l'aide en ligne
O ?UserManual
8.4.8.2 Division en sections et sous-sections
Quelque soit le format de la feuille de calcul (Document ou Worksheet), il est possible,
comme il a été fait pour ce manuel, de la découper en Sections et Sous-sections avec le
menu Insert Section/ Insert Subsection ( ). Ceci est très utile pour s'obliger à
structurer un document correctement. De plus, chacune des sections peut-être ouverte ou
fermée ( ) masquant ainsi son contenu et ne laissant apparaître que son titre. Il suffit de
cliquer sur le triangle ou sur la barre latérale. On pourra aussi utiliser les boutons-icônes
de la barre d'outils pour gérer ces divisions.
Les numérotations qui apparaissent sur les sections de ce manuel ne sont pas
automatiques et ont été introduites au clavier.
8.4.8.3 Numérotation des résultats des commandes
La numérotation des résultats introduite au § 1.2.1 est une option dont on choisit le
défaut dans la fenêtre d'initialisation (voir § 8.3.7), onglet Display, option Show equation
labels. En fait, quelque soit le choix par défaut, il est toujours possible de le modifier avec
le menu Format/Labels. L'option Label Display... de cet item permet d'introduire un
préfixe à la numérotation (par exemple "Ch I-" pour désigner le chapitre I) et d'activer ou
non une numérotation qui prend en compte le découpage des sous-sections.
Pour les autres chapitres du manuel on va supprimer la numérotation automatique que
l'on introduira à la demande sur quelques résultats avec le menu Format/Labels et avec
l'option Execution Group (l'option Worksheet numérotant tous les résultats).
8.4.8.4 Autres éléments des feuilles de calculs
Les feuilles de calcul peuvent contenir divers autres types d'objets. Ne perdant pas de
vue que MAPLE est avant tout destiné à faire des calcul, on se contentera de très brèves
descriptions...

40
1. Des listes numérotées automatiques comme celle-ci ou à puces (,) introduite par les
boutons-icônes de la barre d'outils.

2. Des représentations graphiques des fonctions mathématiques en 2D ou 3D. Ce sujet,


en raison de son importance, fait l'objet des deux chapitres 16 et 17.

3. Des interfaces graphiques. On en trouve de trois sortes


a) Les composantes graphiques (Components) qui permettent la construction
d'applications (voir chapitre 19) par insertion dans la feuille de calcul (modes Worsheet
ou Document) d'objets graphiques (voir l'exemple ci-dessous et la palette
dans la colonne gauche de la fenêtre MAPLE) associés à des actions
programmées. Pour la disposition en deux colonnes des éléments de cet exemple, voir le
§ 8.4.8.4-7.c.
--------------------------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------------------------
b) Des fenêtres réservées à l'édition de procédures, dites Code Edit Region (voir
chapitre 19). Elles sont insérées avec le menu Insert/Code Edit Region. Ces zones
peuvent être fermées pour masquer le texte (voir l'icône ci-dessous) avec le menu
View/Collapse Code Edit Region ou ouvertes pour la lecture et l'édition avec
View/Expand Code Edit Region. Ces deux actions sont aussi accessibles par un menu
contextuel ouvert avec un "clic droit". Les dimensions en pixels de la fenêtre peuvent être
fixées avec ce menu contextuel/Component Properties...

Ma_procedure

c) Les Maplets : se sont des applications présentées dans des fenêtres indépendantes et
écrites dans un langage spécifique à MAPLE (voir chapitre 19).

41
4. Des schémas introduits par le menu Insert/Canvas (voir par exemple le § 5.7). Les
possibilités de dessin sont assez restreintes mais on peut y introduire aisément des
formules mathématiques. Pour plus de détails sur l'utilisation de ces outils on se reportera
à l'annexe 1 du chapitre 16. Il est aussi possible de créer des graphiques ayant pour base
une représentation graphique mentionné ci-dessus en 2. (voir un exemple à la fin de ce
paragraphe) ou un graphique importé puis complété (voir 5.).
La taille des mailles de la grille de dessin peuvent être fixée avec le bouton-icône
qui apparaît quand on clique dans le cadre du dessin. Pour faire disparaître la
grille (comme ci-dessous) il suffit, toujours avec ce bouton, de lui donner la même
couleur (Line) que celle du fond (Canvas).

E f est injective F

c x, y 2 E2 , x s y 0 f x s f y

5. Des images ou des graphiques créés avec d'autres logiciels et importés avec le menu
Insert/Image...
Bonjour de

Les images sont sommairement éditables (voir Annexe 1, Chapitre 16) dans le sens où
l'on peut, après importation, leur superposer des éléments de dessin MAPLE comme, par
exemple, l'ajout du texte "Bonjour de" sur l'image ci-dessus.
Les formats acceptés sont (pas de format eps)
- jpe, jpeg, jpg (Joint Photographic Experts Group)
- gif (Graphics Interchange Format)
- png (Portable Network Graphics)
- tiff, tif, jfx (Tagged Image File Format)
- pnm (Portable aNyMap)
- bmp (Bitmap Graphics)
- fpx (Kodak FlashPiX bitmap image).
42
ATTENTION : MAPLE effectue un codage des images ("lisible" en ASCII ; voir
éventuellement § 8.4.4) et toutes les informations qui les définissent seront incluses dans
la feuille de calcul. Il en résulte qu'il faut être très attentif à ne pas insérer des images de
grandes tailles ou à haute définition, sous peine de voir le fichier de la feuille de calcul
prendre une taille ingérable et des temps de sauvegarde et d'auto-sauvegarde (voir § 8.4.2)
très longs... !

Pour pallier les carences des outils de dessin de MAPLE, il est aussi possible
d'importer des graphiques construits avec un autre logiciel (ci-dessous xfig) et utiliser, par
superposition, les possibilités graphiques de MAPLE et surtout l'écriture mathématique
qui est souvent absente des logiciels de dessin.

f z dz = 0
C
W
C

6. Des feuilles de tableur avec le menu Insert/Spreadsheet... La gestion se fait par le


menu Spreadsheet et/ou par un clic droit sur la feuille de tableur et qui fait apparaître un
menu contextuel. L'exemple montre des calculs symboliques, mais les tableurs gèrent,
bien entendu, aussi les calculs numériques. On peut voir en D1 un exemple de
construction avec une référence à la cellule A1 et notée ~A1 (l'expression est une
intégration double, voir chapitre 10). La colonne D peut ensuite être remplie
automatiquement (menu Spreadsheet/Fill) pour établir les mêmes calculs pour tous les
Ai .

On se reportera pour tous les détails à l'aide en ligne


O ?SpreadSheet

7. Des tables que l'on introduit avec le menu Insert/Table... et que l'on gère simplement
avec le menu Table. Pour tous les détails on se reportera à l'aide en ligne
O ?worksheet/documenting/table

43
Attention : > ?table renvoie à un autre concept (voir chapitre 5).

Fonctions Primitives

n xn C 1
x , n sK1 C Cte
nC1

1
ln x C Cte
x

... ...
Remarques à propos des tables :
a) On peut agir à l'intérieur de chaque cellule comme dans une feuille de calcul (les
cellules sont ouvertes dans le mode Document ou Worksheet, le même que celui de la
feuille de calcul) On peut introduire tout type d'élément dans les cellules : des blocks, des
groupes, des graphiques, des tracés de courbes, images, etc. et y compris d'autres tables.
b) Les encadrés que l'on trouve dans le texte de ce manuel ne sont que des tables à
une colonne et une ligne...
c) Une table peut aussi permettre d'effectuer des mises en forme de textes,
d'illustrations ou d'applications à interface graphique (§ 8.4.8.4-3a). La première partie du
texte sur l'intégration ci-dessous qui accole du texte (colonne de gauche) avec un
graphique est obtenue avec une table à une ligne et deux colonnes pour laquelle, à l'aide
du menu Table/Properties..., on a supprimé les bordures intérieures et extérieures
(Exterior Borders et Interior Borders mis à None). Le dessin a pour base une
commande plot pour tracer la courbe (options color=black, axes=none ; voir chapitre
16) introduite dans la case de droite. Cette commande a été masquée en décochant l'option
Show input toujours dans la fenêtre du menu Table/Properties... Le graphique a ensuite
été illustré avec les outils de dessin comme indiqué au chapitre 16, Annexe 1. Les
intégrales et les formules ont été écrites en utilisant les gabarits de la palette Expression et
la lettre A avec la palette Script.
Si la feuille doit être imprimée, il est recommandé de suivre la recette de mise en
page indiquée au § 8.4.6.
_____________________________________________________________________
Ce texte est une illustration de la dernière des remarques à propos des tables
(§ 8.4.8.4-7.c)

Intégrale : aire algébrique et aire géométrique


L'intégrale d'une fonction f est une mesure b
algébrique de l'aire située entre la courbe f f x dx = A C K AK
représentative de la fonction et l'axe des a
abscisses. Avec les notations du dessin ci-
contre on écrit, en utilisant la relation de A+ x
Chasles b
O a c A-
b c b
f x dx = f x dx C f x dx
a a c

Chacune des intégrales est une mesure


algébrique de l'aire correspondante

44
c b
f x dx = A C O 0 et f x dx = AK! 0
a c
Si l'on souhaite calculer l'aire géométrique entre a et b on écrira donc, toujours avec le schéma de
principe du dessin ci dessus
c b
A= f x dxK f x dx
a c
_____________________________________________________________________

45
46