Utiliser Maple 8

Utiliser
Maple 8
Inspiré du travail de B.W. Char

Traduit de l’anglais par Sylvain Hallé

c 2002 Waterloo Maple Inc.
ii •
Waterloo Maple Inc.

57 Erb Street West
Waterloo, ON N2L 6C2
Canada
Maple et Maple 8 sont des marques déposées de Waterloo Maple Inc.

c 2002, 2001, 2000, 1998, 1996 Waterloo Maple Inc.
Tous droits réservés. La reproduction ou la traduction, même partielle,

par quelque procédé que ce soit, est interdite sans l’autorisation écrite du
détenteur des droits d’auteur, à l’exception de courts extraits en rapport
avec un compte rendu ou une analyse savante. L’utilisation en relation
avec quelque forme de stockage et de recherche d’information, d’adapta-
tion électronique, de logiciel d’ordinateur, ou avec toute autre méthode
semblable ou différente, connue ou conue ultérieurement, est interdite.
L’utilisation de noms descriptifs généraux, de noms déposés, de

marques de commerce, etc., dans la présente publication, même s’ils ne
sont pas expressément désignés, n’est pas une indication que de tels noms,
en vertu de la Loi sur les marques de commerce, peuvent conséquemment
être librement employés par quiconque.
Imprimé au Canada
ISBN 1-894511-33-6
Table des matières
1 Introduction à Maple 1
1.1 Les autres manuels . . . . . . . . . . . . . . . . . . . . . . 3
2 Mathématiques de base avec Maple 5

2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Calculs numériques . . . . . . . . . . . . . . . . . . . . . . 7
Calculs sur des entiers . . . . . . . . . . . . . . . . . . . . 7
Arithmétique exacte – Rationnels, irrationnels et constantes 9
Approximations à virgule flottante . . . . . . . . . . . . . 12
Arithmétique avec des nombres spéciaux . . . . . . . . . . 14
Fonctions mathématiques . . . . . . . . . . . . . . . . . . 15
2.3 Calculs symboliques de base . . . . . . . . . . . . . . . . . 16
2.4 Affecter des noms à des expressions . . . . . . . . . . . . . 18
2.5 Les principaux types d’objets Maple . . . . . . . . . . . . 20
Les suites d’expressions . . . . . . . . . . . . . . . . . . . 20
Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . 23
Les opérations sur les ensembles et les listes . . . . . . . . 25
Les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . 26
Les tables . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
Les chaı̂nes . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.6 La manipulation d’expressions . . . . . . . . . . . . . . . . 32
La commande simplify . . . . . . . . . . . . . . . . . . . 33
La commande factor . . . . . . . . . . . . . . . . . . . . 34
La commande expand . . . . . . . . . . . . . . . . . . . . 34
La commande convert . . . . . . . . . . . . . . . . . . . . 35
La commande normal . . . . . . . . . . . . . . . . . . . . 37
La commande combine . . . . . . . . . . . . . . . . . . . . 37
La commande map . . . . . . . . . . . . . . . . . . . . . . 38
Les commandes lhs et rhs . . . . . . . . . . . . . . . . . 39
iii
iv • Table des matières
Les commandes numer et denom . . . . . . . . . . . . . . . 39

Les commandes nops et op . . . . . . . . . . . . . . . . . 40
Questions courantes sur la manipulation d’expressions . . 41
2.7 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3 Trouver des solutions 45

3.1 Résolution au moyen de solve . . . . . . . . . . . . . . . 45
Vérifier les solutions . . . . . . . . . . . . . . . . . . . . . 47
Restreindre les solutions . . . . . . . . . . . . . . . . . . . 49
Explorer les solutions . . . . . . . . . . . . . . . . . . . . . 50
La commande unapply . . . . . . . . . . . . . . . . . . . . 51
La commande assign . . . . . . . . . . . . . . . . . . . . 53
La commande RootOf . . . . . . . . . . . . . . . . . . . . 55
3.2 Résoudre numériquement : fsolve . . . . . . . . . . . . . 56
Les limites de solve . . . . . . . . . . . . . . . . . . . . . 57
3.3 D’autres solveurs . . . . . . . . . . . . . . . . . . . . . . . 60
Trouver des solutions entières . . . . . . . . . . . . . . . . 60
Trouver des solutions modulo m . . . . . . . . . . . . . . 60
Résoudre des relations de récurrence . . . . . . . . . . . . 61
3.4 Les polynômes . . . . . . . . . . . . . . . . . . . . . . . . 61
Tri et regroupement . . . . . . . . . . . . . . . . . . . . . 62
Opérations mathématiques . . . . . . . . . . . . . . . . . 64
Coefficients et degrés . . . . . . . . . . . . . . . . . . . . . 65
Recherche de racines et factorisation . . . . . . . . . . . . 65
3.5 Le calcul différentiel . . . . . . . . . . . . . . . . . . . . . 67
3.6 Les équations différentielles : dsolve . . . . . . . . . . . . 73
3.7 L’organisation de Maple . . . . . . . . . . . . . . . . . . . 79
3.8 Les packages Maple . . . . . . . . . . . . . . . . . . . . . . 81
Liste des packages . . . . . . . . . . . . . . . . . . . . . . 81
Le package Student Calculus1 (une variable) . . . . . . . . 86
Le package LinearAlgebra . . . . . . . . . . . . . . . . . . 91
Le package Matlab . . . . . . . . . . . . . . . . . . . . . . 93
Le package Statistics . . . . . . . . . . . . . . . . . . . . . 94
Le package d’optimisation linéaire . . . . . . . . . . . . . 97
3.9 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 99
4 Tracer des graphiques 101

4.1 Graphiques en deux dimensions . . . . . . . . . . . . . . . 101
Les graphiques paramétriques . . . . . . . . . . . . . . . . 103
Les coordonnées polaires . . . . . . . . . . . . . . . . . . . 105
Les fonctions discontinues . . . . . . . . . . . . . . . . . . 108
Table des matières • v
Graphiques multiples . . . . . . . . . . . . . . . . . . . . . 111

Tracer des points . . . . . . . . . . . . . . . . . . . . . . . 113
Raffiner des graphiques . . . . . . . . . . . . . . . . . . . 115
4.2 Graphiques en trois dimensions . . . . . . . . . . . . . . . 116
Les graphiques paramétriques . . . . . . . . . . . . . . . . 118
Les coordonnées sphériques . . . . . . . . . . . . . . . . . 119
Les coordonnées cylindriques . . . . . . . . . . . . . . . . 121
Raffiner des graphiques . . . . . . . . . . . . . . . . . . . 123
Modèles de coloriage et d’éclairage . . . . . . . . . . . . . 124
4.3 L’animation . . . . . . . . . . . . . . . . . . . . . . . . . . 125
L’animation en deux dimensions . . . . . . . . . . . . . . 125
L’animation en trois dimensions . . . . . . . . . . . . . . . 128
4.4 Annoter des graphiques . . . . . . . . . . . . . . . . . . . 129
4.5 Les graphiques composites . . . . . . . . . . . . . . . . . . 132
Placer du texte dans les graphiques . . . . . . . . . . . . . 134
4.6 Quelques graphiques particuliers . . . . . . . . . . . . . . 135
4.7 Manipuler des objets graphiques . . . . . . . . . . . . . . 140
4.8 Code des graphiques des planches en couleurs . . . . . . . 145
4.9 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 147
5 L’évaluation et la simplification 149

5.1 Manipulations mathématiques . . . . . . . . . . . . . . . . 149
Développer des polynômes en sommes . . . . . . . . . . . 150
Regrouper les coefficients de même degré . . . . . . . . . . 152
Factoriser des polynômes et des fonctions rationnelles . . 154
Supprimer des exposants rationnels . . . . . . . . . . . . . 157
Combiner des termes . . . . . . . . . . . . . . . . . . . . . 158
Forme normale factorisée . . . . . . . . . . . . . . . . . . 159
Simplifier des expressions . . . . . . . . . . . . . . . . . . 161
Simplification avec des hypothèses . . . . . . . . . . . . . 163
Simplification au moyen des relations accessoires . . . . . 163
Trier des expressions algébriques . . . . . . . . . . . . . . 164
Conversion entre différentes formes . . . . . . . . . . . . . 166
5.2 Les hypothèses . . . . . . . . . . . . . . . . . . . . . . . . 168
La commande assume . . . . . . . . . . . . . . . . . . . . 168
La commande assuming . . . . . . . . . . . . . . . . . . . 172
5.3 Manipulations structurelles . . . . . . . . . . . . . . . . . 173
Appliquer une fonction à une liste ou un ensemble . . . . 174
Choisir des éléments dans une liste ou un ensemble . . . . 176
Combiner deux listes . . . . . . . . . . . . . . . . . . . . . 178
Trier des listes . . . . . . . . . . . . . . . . . . . . . . . . 179
vi • Table des matières
Les parties d’une expression . . . . . . . . . . . . . . . . . 182

La substitution . . . . . . . . . . . . . . . . . . . . . . . . 190
Changer le type d’une expression . . . . . . . . . . . . . . 193
5.4 Les règles d’évaluation . . . . . . . . . . . . . . . . . . . . 196
Niveaux d’évaluation . . . . . . . . . . . . . . . . . . . . . 196
Évaluation du dernier nom . . . . . . . . . . . . . . . . . 197
Évaluation à un niveau . . . . . . . . . . . . . . . . . . . . 200
Commandes avec des règles spéciales d’évaluation . . . . . 200
Empêcher l’évaluation d’une expression . . . . . . . . . . 201
Utiliser les variables entourées de guillemets comme argu-
ments de fonctions . . . . . . . . . . . . . . . . . . 204
Concaténation de noms . . . . . . . . . . . . . . . . . . . 205
5.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 207
6 Exemples tirés du calcul différentiel 209

6.1 Calcul différentiel élémentaire . . . . . . . . . . . . . . . . 209
La dérivée . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Une approximation de Taylor . . . . . . . . . . . . . . . . 215
L’intégrale . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Dérivées partielles mixtes . . . . . . . . . . . . . . . . . . 231
6.2 Équations différentielles ordinaires . . . . . . . . . . . . . 235
La commande dsolve . . . . . . . . . . . . . . . . . . . . 236
Un exemple : les séries de Taylor . . . . . . . . . . . . . . 251
Lorsqu’une solution explicite est impossible à trouver . . . 255
Tracer le graphique d’équations différentielles ordinaires . 256
Coefficients discontinus d’une équation . . . . . . . . . . . 261
6.3 Équations aux dérivées partielles . . . . . . . . . . . . . . 266
La commande pdsolve . . . . . . . . . . . . . . . . . . . . 266
Changer la variable dépendante dans une EDP . . . . . . 268
Tracer le graphique d’équations aux dérivées partielles . . 269
6.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 271
7 Entrées et sorties 273

7.1 Lire des fichiers . . . . . . . . . . . . . . . . . . . . . . . . 273
Lire des colonnes de nombres depuis un fichier . . . . . . 274
Lire des commandes depuis un fichier . . . . . . . . . . . . 276
7.2 Écrire des données dans un fichier . . . . . . . . . . . . . 278
Écrire des colonnes de données numériques dans un fichier 278
Sauvegarder des expressions au format interne de Maple . 279
Convertir au format LATEX . . . . . . . . . . . . . . . . . . 280
7.3 Exporter des feuilles complètes . . . . . . . . . . . . . . . 282
Table des matières • vii
Texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
Texte Maple . . . . . . . . . . . . . . . . . . . . . . . . . . 283
LATEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
HTML et HTML avec MathML . . . . . . . . . . . . . . . 285
RTF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
7.4 Imprimer des graphiques . . . . . . . . . . . . . . . . . . . 288
7.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 290
8 Les maplets 291

8.1 Exemple de maplet . . . . . . . . . . . . . . . . . . . . . . 291
8.2 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . 292
8.3 Comment démarrer le package Maplets . . . . . . . . . . 293
8.4 Comment appeler une maplet à partir d’une feuille Maple 293
8.5 Comment fermer une maplet . . . . . . . . . . . . . . . . 294
8.6 Comment utiliser les Maplets et la fenêtre Maple (modalité)294
8.7 Comment activer la fenêtre d’une maplet . . . . . . . . . 294
8.8 Comment arrêter puis redémarrer une maplet . . . . . . . 295
8.9 Comment utiliser les raccourcis de l’interface graphique . 295
Listes déroulantes . . . . . . . . . . . . . . . . . . . . . . . 295
La barre d’espacement et la touche Tab . . . . . . . . . . 295
8.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 296
1 Introduction à Maple
On appelle le logiciel Maple un système de calcul symbolique, évoquant

ainsi sa capacité à manipuler l’information de manière symbolique ou
algébrique. En effet, contrairement aux logiciels mathématiques stan-
dard, qui requièrent des valeurs numériques pour toutes leurs variables,
Maple, tout en demeurant capable d’évaluer des expressions numériques,
sait également manipuler les expressions et les symboles sous-jacents.
Cette capacité symbolique permet à Maple de calculer des solutions
analytiques exactes à de nombreux problèmes mathématiques incluant
systèmes d’équations, intégrales, équations différentielles et problèmes
d’algèbre linéaire. En complément à ces opérations symboliques, une vaste
gamme de routines graphiques facilite la visualisation de données mathé-
matiques complexes ; des algorithmes numériques fournissent des réponses
approximées aux problèmes ne possédant pas de solution exacte, et un lan-
gage de programmation complet et accessible permet le développement sur
mesure de nouvelles fonctions et applications.
On accède facilement à l’étendue des fonctions mathématiques de
Maple par son interface graphique prenant la forme de feuilles (work-
sheets ). Une feuille est un document flexible permettant d’explorer des
idées mathématiques et de créer des rapports complexes.
Les utilisateurs de Maple ont trouvé plusieurs manières d’utiliser son
langage et ses feuilles.
Les ingénieurs et les professionnels dans des industries aussi variées
que l’agriculture et l’aérospatiale utilisent Maple comme un outil puissant
remplaçant à la fois leurs manuels de référence, leurs calculatrices, leurs
chiffriers et même leurs langages de programmation tel FORTRAN. Ces
utilisateurs gagnent en rapidité dans la résolution de problèmes mathé-
matiques courants et consignent les résultats de leurs calculs dans des
rapports techniques professionnels.
Les chercheurs de plusieurs domaines considèrent également Maple
comme un outil essentiel à leur travail. Maple est en effet tout indiqué pour
1
2 • Chapitre 1: Introduction à Maple
la formulation, la résolution et l’exploration de modèles mathématiques.

Son caractère symbolique élargit grandement l’éventail des problèmes
qu’ils peuvent ainsi traiter.
Les professeurs emploient Maple en classe, ravivant l’enseignement
traditionnel au collège et à l’université en introduisant des problèmes
et des exercices qui exploitent l’interactivité du logiciel. Plutôt que de
s’astreindre à des manipulations algébriques fastidieuses, leurs étudiants
peuvent ainsi se concentrer sur les concepts fondamentaux.
Chacun utilise Maple d’une manière toute personnelle selon ses be-
soins ; cependant, deux grandes catégories d’utilisation dominent.
La première catégorie consiste en l’utilisation de Maple comme d’un
environnement interactif de résolution de problèmes. Traditionnellement,
lorsqu’on travaille sur un problème, l’essai d’une méthode de résolution
nécessite parfois plusieurs heures et plusieurs pages. Maple permet à son
utilisateur de se concentrer sur de beaucoup plus grands problèmes en
le libérant d’erreurs mécaniques ; son interface documente les étapes de
sa recherche d’une solution. Elle permet aussi de modifier aisément l’une
de ces étapes, ou même d’en insérer une nouvelle. Que ce soit pour le
développement d’un nouveau modèle mathématique ou pour l’analyse
d’une stratégie financière, il est possible d’en apprendre beaucoup sur
un problème, facilement et efficacement.
La seconde catégorie utilise Maple en tant que système de création
de documents techniques. Il est en effet possible de créer des documents
interactifs, structurés et dynamiques ou de modifier une équation et d’ac-
tualiser sa solution automatiquement. Le langage mathématique naturel
de Maple facilite l’entrée des équations, et permet le calcul et le tracé
de graphiques sur demande. De plus, les documents Maple peuvent être
structurés en utilisant des outils modernes tels les styles, la division en
sous-sections et les hyperliens, créant ainsi des feuilles qui sont non seule-
ment claires et faciles à créer, mais également faciles à mettre à jour.
Puisque les composantes des feuilles sont directement associées à la struc-
ture du document, il est facile de les traduire en d’autres formats comme
LATEX, RTF ou HTML.
Plusieurs types de documents peuvent profiter des caractéristiques
des feuilles Maple. Ces caractéristiques facilitent la rédaction de rapports
ou même d’ouvrages mathématiques et sont aussi appropriées pour la
création et la présentation d’exposés. Par exemple, la division en sous-
sections cache des sections arides et riches en détails qui peuvent être
distrayantes aux yeux de l’observateur ; les styles font clairement ressortir
les mots clés et les titres ; les hyperliens autorisent la création de références
dynamiques qui amènent le lecteur aux pages renfermant de l’information
1.1 Les autres manuels • 3
complémentaire. Enfin, la nature interactive de Maple permet de calcu-

ler et de répondre à des questions durant une présentation. On peut ainsi
clairement et efficacement démontrer pourquoi une méthode de résolution
a priori acceptable s’avère en fait inappropriée, ou pourquoi une modifi-
cation à un processus de manufacturation entraı̂ne des pertes ou engendre
des profits.
Ce livre constitue votre introduction à Maple. Il discute systémati-
quement des concepts clés et construit un cadre d’apprentissage qui vous
guidera dans votre utilisation de l’interface et du langage Maple. Ce ma-
nuel vous donnera un aperçu des fonctionnalités de Maple, décrivant à
la fois ses capacités symboliques et numériques, et introduisant les ob-
jets Maple, les commandes et les méthodes mises à votre disposition. Une
attention particulière est placée non seulement sur la recherche de solu-
tions, mais également sur le tracé de graphiques, la création d’animations
et l’exportation de feuilles en d’autres formats. Plus important encore,
il présente la philosophie et les méthodes d’utilisation suggérées par les
concepteurs du système. Ces quelques concepts simples vous permettront
d’utiliser Maple à son meilleur.
Considérez ce livre d’abord comme un guide ; l’aide en ligne consti-
tuera votre manuel de référence. En effet, puisque l’on peut y rechercher
de l’information de plusieurs manières et qu’il se trouve toujours acces-
sible, le système d’aide de Maple se révèle plus pratique que tout autre
texte traditionnel. Vous trouverez également des exemples que vous pou-
vez copier, coller et exécuter immédiatement.
1.1 Les autres manuels

Trois autres manuels (en anglais) décrivent le fonctionnement de Maple :
le Guide de prise en main (Maple 8 Getting Started Guide), le Guide
d’introduction à la programmation (Maple 8 Introductory Program-
ming Guide) et le Guide de programmation avancée (Maple 8 Advanced
Programming Guide)1 .
Le Guide de prise en main (Getting Started Guide) contient une
introduction à l’interface graphique et un tutoriel résumant l’utilisation
1
La version étudiante n’inclut pas les deux guides de programmation. Ces guides
peuvent toutefois etre achetés chez des libraires spécialisés ou directement auprès de
Waterloo Maple Inc.
4 • Chapitre 1: Introduction à Maple
de Maple pour résoudre des problèmes mathématiques et créer des do-

cuments techniques. À l’intérieur, vous y trouverez de l’information sup-
plémentaire à l’intention des nouveaux utilisateurs au sujet du système
d’aide en ligne, sur le tour guidé du logiciel (New User’s Tour ), sur
les exemples de feuilles de travail ainsi que sur le site Web de Waterloo
Maple.
Le Guide d’introduction à la programmation (Introductory Program-
ming Guide) présente les concepts fondamentaux de la programmation
sous Maple : les expressions, les structures de données, les boucles et les
mécanismes de décision, les procédures, les entrées-sorties, le débogage et
les Maplets.
Enfin, le Guide de programmation avancée (Advanced Programming
Guide) couvre des concepts de programmation comme les modules, les
entrées-sorties, la programmation numérique, les graphiques et le code
compilé.
2 Mathématiques de base
avec Maple
Ce chapitre commence par une discussion à propos des calculs numériques

exacts avec Maple, qui diffèrent légèrement de ceux effectués par d’autres
applications. Des renseignements sur les calculs symboliques de base et les
commandes d’affectation suivent. Les deux dernières sections énoncent les
principaux types d’objets de base et donnent des instructions concernant
la manipulation d’objets et les commandes les plus utiles à cet égard.
Vous tirerez le meilleur parti de ce livre en utilisant votre ordinateur
pour esssayer les différents exemples que vous rencontrerez au fil de votre
lecture. Ce chapitre explique les commandes nécessaires pour commencer
à travailler. Les chapitres subséquents donneront à ces commandes ainsi
qu’à d’autres un traitement plus approfondi.
Si vous souhaitez comprendre davantage les rouages du système
Maple, vous pouvez utiliser le système d’aide en ligne. Pour obtenir de
l’aide à propos d’une commande, tapez simplement à l’invite Maple un
point d’interrogation (?) suivi du nom de la commande ou, dans d’autres
cas, du sujet sur lequel vous souhaitez obtenir plus d’information.
?commande
2.1 Introduction
Les calculs les plus simples dans Maple sont numériques. Maple peut
fonctionner comme une calculatrice traditionnelle avec les entiers et les
5
6 • Chapitre 2: Mathématiques de base avec Maple
nombres à virgule flottante. Entrez l’expression en utilisant la syntaxe

naturelle1 . Un point-virgule indique la fin de chaque calcul.
> 1 + 2;
> 1 + 3/2;
5
2
> 2*(3+1/3)/(5/3-4/5);
100
13
> 2.8754/2;
1.437700000
Bien entendu, Maple peut faire beaucoup plus, comme vous pourrez
le voir bientôt.
Pour le moment, considérez cet exemple simple.
> 1 + 1/2;
3
2
Remarquez que Maple effectue des calculs exacts avec des nombres
rationnels. Le résultat de 1 + 1/2 est 3/2, et non 1.5. Pour Maple, le
nombre rationnel 3/2 et son approximation décimale 1.5 sont deux objets
complètement différents.
La possibilité de représenter des expressions de manière exacte permet
à Maple de préserver beaucoup plus d’information à propos de leur origine
et de leur structure. Par exemple, l’origine et la structure d’un nombre
comme
1
N.d.t. : Le logiciel Maple utilise la syntaxe anglo-saxonne pour la représentation
des nombres décimaux. C’est donc le point, et non la virgule, qu’il faut utiliser pour
saisir de tels nombres.
2.2 Calculs numériques • 7
0.5235987758
est beaucoup moins évidente que pour une quantité exacte comme
1
π
6
Lorsque vous commencerez à travailler avec des expressions plus com-

plexes, l’avantage en sera d’autant plus grand.
Maple peut travailler non seulement avec des nombres rationnels,
mais également avec des expressions arbitraires. Il peut manipuler les
entiers, les nombres à virgule flottante, les variables, les ensembles, les
suites, les polynômes sur un anneau ainsi que plusieurs autres construc-
tions mathématiques. De plus, Maple est un langage de programmation
complet contenant des procédures, des tableaux et d’autres structures de
données.
2.2 Calculs numériques

Calculs sur des entiers
Les calculs sur des entiers sont directs. N’oubliez pas de terminer chaque
commande par un point-virgule.
> 1 + 2;
> 75 - 3;
72
> 5*3;
15
> 120/2;
60
Maple peut également travailler avec des nombres entiers arbitraire-

ment grands. La limite pratique sur les entiers est d’environ 228 chiffres,
en fonction principalement de la vitesse et des ressources de votre or-
dinateur. Maple n’éprouve aucun problème à calculer de grands entiers,
compter le nombre de chiffres d’un nombre ou factoriser des entiers. Pour
des nombres et d’autres types de données qui s’étendent sur plus d’une
ligne à l’écran, Maple utilise le caractère (\) pour indiquer que le résultat
est continu. La barre oblique et la coupure de ligne doivent être ignorées.
> 100!;
933262154439441526816992388562667004907\
15968264381621468592963895217599993229\
91560894146397615651828625369792082722\
37582511852109168640000000000000000000\
00000
> length(%);
158
La réponse indique le nombre de chiffres contenus dans le dernier

exemple. L’opérateur idem (%) est tout simplement une notation abrégée
affichant le résultat précédent. Pour rappeler le deuxième ou le troisième
résultat précédent, utilisez respectivement %% et %%%.
> ifactor(60);
(2)2 (3) (5)
En plus de ifactor, Maple possède plusieurs commandes pour tra-

vailler avec des entiers permettant le calcul du plus grand commun di-
viseur (PGCD) de deux entiers, la division euclidienne et les tests de
primalité. Consultez les exemples ci-dessous ainsi que la table 2.1.
> igcd(123, 45);
> iquo(25,3);
Tab. 2.1 – Commandes opérant sur des entiers

Fonction Description
abs valeur absolue d’une expression
factorial factorielle d’un entier
iquo quotient d’une division entière
irem reste d’une division entière
iroot racine entière approximée d’un entier
isqrt racine carrée entière approximée d’un entier
max, min maximum et minimum d’un ensemble d’entrées
mod arithmétique modulo
surd racine réelle d’un entier
> isprime(18002676583);
true
Arithmétique exacte – Rationnels, irrationnels et constantes

Une propriété importante de Maple est sa capacité à effectuer l’arithmé-
tique rationnelle exacte, et ainsi de travailler avec des nombres rationnels
(fractions) sans avoir à les réduire à leurs approximations décimales.
> 1/2 + 1/3;
5
6
Maple gère les nombres rationnels et produit un résultat exact. La

distinction entre des résultats exacts et approximatifs est importante. La
faculté d’effectuer des calculs exacts au moyen d’ordinateurs vous permet
de résoudre une toute nouvelle gamme de problèmes.
Maple peut effecter des approximations en virgule flottante si néces-
saire. En fait, le logiciel peut travailler avec des nombres à virgule flottante
de plusieurs milliers de chiffres pour des estimations précises d’expressions
exactes.
> Pi;
> evalf(Pi, 100);
3.1415926535897932384626433832795028841\
97169399375105820974944592307816406286\
208998628034825342117068
Il est important d’apprendre comment Maple distingue les représen-
tations exactes des valeurs de leurs approximations décimales.
Voici un exemple de nombre rationnel (exact).
> 1/3;
1
3
Le nombre suivant est son approximation décimale (avec une précision

par défaut de dix chiffres).
> evalf(%);
0.3333333333
Ces résultats ne sont pas les mêmes mathématiquement, et ne sont

pas non plus les mêmes pour Maple.
Chaque fois que vous entrez un nombre sous forme décimale,
Maple le considère comme une approximation à virgule flottante. En
fait, la présence d’un nombre décimal dans une expression force Maple à
produire un résultat en virgule flottante, puisqu’il ne peut être certain
de produire une solution exacte, même à partir de données partiellement
exactes.
> 3/2*5;
15
2
> 1.5*5;
7.5
Ainsi, il est recommandé de n’utiliser des nombres décimaux que

lorsque vous souhaitez forcer Maple à travailler avec des expressions
non exactes.
Vous pouvez saisir des quantités exactes en utilisant la représentation
symbolique, comme π, comparativement à 3.14. Maple traite les nombres
irrationnels comme des quantités exactes. Voici comment représenter la
racine carrée de 2 dans Maple.
> sqrt(2);
√
2
Voici un autre exemple de racine carrée.

> sqrt(3)^2;
Maple connaı̂t les constantes arithmétiques standard comme π et la

base des logarithmes naturels, e. Il travaille avec ces nombres comme avec
des quantités exactes.
> Pi;
> sin(Pi);
La fonction exponentielle est représentée par la fonction Maple exp.

> exp(1);
> ln(exp(5));
Le deuxième exemple peut paraı̂tre étrange. Souvenez-vous que

lorsque Maple produit une notation mathématique typographique ,
il essaie de représenter les expressions mathématiques de la manière dont
vous les écririez vous-même. Ainsi, vous entrez π comme Pi et Maple

l’affiche comme π.
Maple tient compte des majuscules et des minuscules ; soyez donc
certain de les respecter en faisant référence à ces constantes. Les noms
Pi, pi et PI ne sont pas équivalents ! Les noms Pi et PI sont employés
pour afficher respectivement les lettres grecques minuscule et majuscule π
et Π. Pour obtenir davantage d’information sur les constantes de Maple,
tapez ?constants à l’invite.
Approximations à virgule flottante

Même si Maple préfère travailler avec des valeurs exactes, il peut retour-
ner une approximation décimale d’une longueur maximale de 238 chiffres
lorsque cela lui est demandé.
Dix ou vingt chiffres exacts semblent adéquats pour la plupart des
situations ; cependant, deux problèmes particuliers limitent sérieusement
l’utilité d’un tel système.
Tout d’abord, en soustrayant deux nombres décimaux d’ordres de
grandeur presque identiques, l’erreur relative de la différence peut être
très grande : si chacun des deux nombres originaux sont identiques pour
leurs dix-sept premiers chiffres (sur vingt), leur différence est un nombre
de vingt chiffres dont on ne connaı̂t que trois chiffres significatifs ! Dans
ce cas, une précision de quarante chiffres serait nécessaire pour obtenir en
fin de calcul un résultat précis à environ vingt chiffres significatifs.
Ensuite, la forme mathématique d’un résultat est plus concise, com-
pacte et utile que sa valeur numérique. Par exemple, une fonction expo-
nentielle fournit plus d’information sur la nature d’un phénomène qu’un
grand ensemble de nombres de vingt chiffres significatifs. Une descrip-
tion analytique exacte peut également déterminer le comportement d’une
fonction en extrapolant à des régions pour lesquelles aucune donnée n’est
disponible.
La commande evalf convertit une expression numérique exacte en un
nombre décimal.
> evalf(Pi);
3.141592654
Par défaut, Maple calcule le résultat à l’aide de dix chiffres de préci-

sion ; vous pouvez cependant spécifier un nombre arbitraire de chiffres. Il
suffit de le spécifier après l’expression numérique en utilisant la notation
suivante.
> evalf(Pi, 200);
3.1415926535897932384626433832795028841\
97169399375105820974944592307816406286\
20899862803482534211706798214808651328\
23066470938446095505822317253594081284\
81117450284102701938521105559644622948\
9549303820
Vous pouvez également forcer Maple à effectuer tous ses calculs avec
des approximations décimales en incluant au moins un nombre décimal
dans chaque expression. Les nombres à virgule flottante sont conta-
gieux : si une expression contient ne serait-ce qu’un seul nombre décimal,
Maple évalue l’expression entière en arithmétique à virgule flottante.
> 1/3 + 1/4 + 1/5.3;
0.7720125786
> sin(0.2);
.1986693308
Alors que le second argument optionnel de la commande evalf

détermine le nombre de chiffres à afficher pour ce calcul en particulier, la
variable spéciale Digits fixe le nombre de chiffres décimaux pour tous les
calculs subséquents.
> Digits := 20;
Digits := 20
> sin(0.2);
0.19866933079506121546
Digits est maintenant fixé à vingt, le nombre de chiffres que Maple

utilisera maintenant pour chaque étape d’un calcul. Sur ce plan, Maple
fonctionne comme une calculatrice ou un ordinateur classique. Souvenez-
vous que, lorsque vous évaluez une expression numérique compliquée, des
erreurs peuvent s’accumuler et rendre le résultat final moins précis que
les vingt chiffres qu’il contient. En général, déterminer la valeur que doit
prendre Digits pour obtenir une précision donnée n’est pas chose facile,
le résultat final dépendant du problème. Cependant, il est en général de
mise d’en augmenter la valeur pour obtenir plus de précision. Maple est
très flexible si une grande précision décimale est importante dans votre
travail.
Arithmétique avec des nombres spéciaux

Maple peut également travailler avec des nombres complexes. Par ex-
emple, I est le symbole par√ défaut de Maple pour la racine carrée de
moins un, c’est-à-dire I = −1.
> (2 + 5*I) + (1 - I);
3 + 4I
> (1 + I)/(3 - 2*I);
1 5
+ I
13 13
Vous pouvez aussi travailler sous d’autres bases avec d’autres systèmes
de nombres.
> convert(247, binary);
11110111
> convert(1023, hex);
3FF
> convert(17, base, 3);
[2, 2, 1]
Maple retourne une conversion en base entière comme une liste de

nombres ; autrement, une ligne de nombres comme 221 peut devenir am-
biguë, spécialement pour de grandes bases. Remarquez que Maple liste
les chiffres dans l’ordre, du plus significatif au moins significatif.
Maple effectue également l’arithmétique dans des anneaux finis et des
corps.
> 27 mod 4;
Les représentations symétriques et positives sont également dispo-

nibles.
> mods(27,4);
−1
> modp(27,4);
La valeur par défaut de la commande mod est la représentation posi-

tive, mais vous pouvez changer cette option (consultez l’écran d’aide ?mod
pour plus de détails).
Maple peut également travailler avec les entiers gaussiens. Le package
GaussInt contient une trentaine de commandes permettant de travailler
avec ces nombres spéciaux. Tapez ?GaussInt pour plus d’information sur
ces commandes.
Fonctions mathématiques
Maple connaı̂t toutes les fonctions mathématiques standard (consultez la
table 2.2 pour une liste partielle).
> sin(Pi/4);
1√
2
2
> ln(1);
Lorsque Maple ne peut trouver une forme plus simple, il laisse l’ex-
pression telle quelle plutôt que de la convertir en une forme inexacte.
> ln(Pi);
ln(π)
Tab. 2.2 – Quelques fonctions mathématiques connues de Maple

sin, cos, tan, etc. fonctions trigonométriques
sinh, cosh, tanh, etc. fonctions trigonométriques
hyperboliques
arcsin, arccos, arctan, etc. fonctions trigonométriques
inverses
exp fonction exponentielle
ln logarithme naturel
log[10] logarithme en base 10
sqrt racine carrée algébrique
round arrondir à l’entier le plus près
trunc tronquer à la partie entière
frac partie fractionnaire
BesselI, BesselJ, fonctions de Bessel
BesselK, BesselY
binomial fonction binomiale
erf, erfc fonctions d’erreur et
d’erreur complémentaire
Heaviside fonction de Heaviside
Dirac fonction delta de Dirac
MeijerG fonction G de Meijer
Zeta fonction zeta de Riemann
LegendreKc, LegendreKc1,
LegendreEc, LegendreEc1,
LegendrePic, LegendrePic1 intégrales elliptiques de Legendre
hypergeom fonction hypergéométrique
2.3 Calculs symboliques de base

Maple sait comment travailler avec des inconnues et des expressions les
contenant.
> (1 + x)^2;
2.3 Calculs symboliques de base • 17
(1 + x)2
> (1 + x) + (3 - 2*x);
4−x
Remarquez que Maple simplifie automatiquement la seconde expres-

sion.
Maple possède des centaines de commandes pour travailler avec des
expressions symboliques.
> expand((1 + x)^2);
1 + 2 x + x2
> factor(%);
(1 + x)2
Comme il est mentionné à la section Calculs numériques de la page 7,

l’opérateur idem, %, est une notation abrégée de la commande précédente.
> Diff(sin(x), x);
d
sin(x)
dx
> value(%);
cos(x)
> Sum(n^2, n);

n2
n
> value(%);
1 3 1 2 1
n − n + n
3 2 6
Divisez un polynôme en x par un autre.

> rem(x^3+x+1, x^2+x+1, x);
2+x
Créez une série.

> series(sin(x), x=0, 10);
1 3 1 5 1 1
x− x + x − x7 + x9 + O(x10 )
6 120 5040 362880
Toutes les fonctions mathématiques mentionnées dans la section

précédente acceptent également les inconnues comme arguments.
2.4 Affecter des noms à des expressions

Utiliser l’opérateur idem ou taper une expression chaque fois que vous
souhaitez l’employer peut s’avérer fastidieux. C’est pourquoi Maple vous
permet de nommer des objets. Appliquez la syntaxe suivante.
nom := expression ;
Vous pouvez affecter un nom à n’importe quelle expression Maple.

> var := x;
var := x
> terme := x*y;
terme := x y
Vous pouvez même donner des noms à des équations.

> eqs := x = y + 2;
eqs := x = y + 2
2.4 Affecter des noms à des expressions • 19
Sous Maple, les noms peuvent contenir n’importe quel caractère al-
phanumérique en plus du caractère souligné (underscore en anglais),
mais ils ne peuvent pas commencer par un nombre. De plus, évitez
de commencer un nom par le caractère souligné ; Maple utilise ces noms
à des fins de classification interne. Les noms polynomial, test_data,
RoOt_lOcUs_pLoT et value2 sont des noms Maple valides, tandis que
2ndphase (parce qu’il commence par un nombre) et x&y (parce que &
n’est pas un caractère alphanumérique) sont des noms invalides.
Vous pouvez définir vos propres fonctions à l’aide de la notation
flèche (->) de Maple. Cela indique à Maple comment évaluer la fonc-
tion lorsqu’elle apparaı̂t dans les expressions Maple. À ce point de votre
lecture, vous pouvez dessiner des graphiques simples au moyen de la com-
mande plot.
> f := x -> 2*x^2 -3*x +4;
f := x → 2 x2 − 3 x + 4
> plot (f(x), x= -5...5);
70
60
50
40
30
20
10
–4 –2 0 2 4
x
Vous en apprendrez davantage sur la commande plot au chapitre 4.

L’opération d’affectation (:=) peut ensuite associer le nom d’une fonc-
tion à la définition de cette fonction. Le nom de la fonction se place à
gauche du signe :=, tandis que sa définition de la fonction (utilisant la
notation flèche) est à droite. L’expression suivante définit f comme étant
la fonction mettre au carré .
> f := x -> x^2;
f := x → x2
Puis, en évaluant f en un argument, on obtient le carré de l’argument

de f.
> f(5);
25
> f(y+1);
(y + 1)2
Tous les noms ne sont pas disponibles comme variables : Maple en a

prédéfini et réservé quelques-uns. Si vous tentez d’assigner un objet à un
nom qui est prédéfini ou réservé, Maple affiche un message vous informant
que le nom choisi est protégé.
> Pi := 3.14;
Error, attempting to assign to ‘Pi‘ which is protected
> set := {1, 2, 3};
Error, attempting to assign to ‘set‘ which is protected
2.5 Les principaux types d’objets Maple

La présente section examine les principaux types d’objets Maple, incluant
les suites d’expressions, les listes, les ensembles (sets ), les tableaux (ar-
rays ), les tables (tables ) et les chaı̂nes (strings ).
Les suites d’expressions

La structure de données de base de Maple est la suite d’expressions .
C’est un groupe d’expressions Maple séparées par des virgules.
> 1, 2, 3, 4;
1, 2, 3, 4
2.5 Les principaux types d’objets Maple • 21
> x, y, z, w;
x, y, z, w
Une suite d’expressions n’est ni une liste, ni un ensemble. C’est une

structure de données particulière qui possède ses caractéristiques propres.
Par exemple, elle préserve l’ordre et la répétition des éléments. Les objets
respectent l’ordre dans lequel ils ont été entrés et si un objet est entré deux
fois, les deux copies demeurent dans la suite. Vous remarquerez d’autres
propriétés des suites à mesure que vous parcourrez ce manuel. Les suites
sont souvent utilisées pour construire d’autres objets complexes par des
opérations comme la concaténation.
Les suites permettent d’étendre les capacités de plusieurs opérations
de base de Maple. Par exemple, la concaténation est une opération de
base permettant de former des noms. L’opérateur de concaténation sous
Maple est le || , et vous pouvez l’utiliser de la manière suivante.
> a||b;
ab
Lorsque vous appliquez la concaténation à une séquence, l’opération

touche à chacun de ses éléments. Ainsi, pour une suite S, vous pouvez
ajouter à un nom a des suffixes formés de chaque élément de S en
concaténant a et S :
> S := 1, 2, 3, 4;
S := 1, 2, 3, 4
> a||S;
a1 , a2 , a3 , a4
Vous pouvez aussi effectuer plusieurs assignations en utilisant des

suites d’expressions. Par exemple :
> f,g,h := 3, 6, 1;
f, g, h := 3, 6, 1
> f;
> h;
Les listes
Une liste est formée en encadrant un nombre quelconque d’objets Maple
(séparés par des virgules) par des crochets.
> data_list := [1, 2, 3, 4, 5];
data_list := [1, 2, 3, 4, 5]
> polynomes := [x^2+3, x^2+3*x-1, 2*x];
polynomes := [x2 + 3, x2 + 3 x − 1, 2 x]
> participants := [Simon, Martin, Kim, Francois, Sylvain];
participants := [Simon, Martin, Kim, Francois , Sylvain]
Ainsi, une liste est une suite d’expressions encadrée par des crochets.
Maple conserve l’ordre et la répétition des éléments dans une liste.
Ainsi, [a,b,c], [b,c,a] et [a,a,b,c,a] sont trois listes différentes.
> [a,b,c], [b,c,a], [a,a,b,c,a];
[a, b, c], [b, c, a], [a, a, b, c, a]
La conservation de l’ordre vous permet de retrouver un élément par-

ticulier d’une liste sans avoir à vous soucier d’un possible déplacement de
celui-ci.
> lettres := [a,b,c];
lettres := [a, b, c]
> lettres[2];
Utilisez la commande nops pour déterminer le nombre total d’élé-

ments d’une liste.
> nops(lettres);
La section Les commandes nops et op de la page 40 traite en pro-

fondeur de cette commande et de ses usages.
Les ensembles
Maple permet la gestion d’ensembles au sens mathématique du terme.
Tout comme dans une suite ou dans une liste, des virgules séparent les
objets ; cependant, les accolades désignent l’objet en tant qu’ensemble.
> data_set := {1, -1, 0, 10, 2};
data_set := {−1, 0, 1, 2, 10}
> inconnues := {x, y, z};
inconnues := {x, y, z}
Ainsi, un ensemble est une suite d’expressions encadrée par des acco-
lades.
Maple ne conserve ni l’ordre, ni la répétition des éléments dans les
ensembles : ces derniers possèdent ainsi les mêmes propriétés que leurs
équivalents mathématiques. Ainsi, les trois ensembles suivants sont iden-
tiques :
> {a,b,c}, {c,b,a}, {a,a,b,c,a};
{a, b, c}, {a, b, c}, {a, b, c}
Rappelez-vous que, pour Maple, l’entier 2 est distinct de son approxi-

mation numérique 2.0. L’ensemble suivant contient donc trois éléments,
et non deux.
> {1, 2, 2.0};
{1, 2, 2.0}
Les propriétés que revêtent les ensembles font de ceux-ci des outils par-
ticulièrement utiles dans Maple, tout comme ils le sont en mathématiques.
Maple fournit plusieurs opérateurs ensemblistes, incluant les opérateurs
de base de l’intersection et de l’union en utilisant la notation intersect
et union.
> {a,b,c} union {c,d,e};
{a, b, c, d, e}
> {1,2,3,a,b,c} intersect {0,1,y,a};
{1, a}
La commande nops compte le nombre d’éléments d’un ensemble, tout

comme pour une liste.
> nops(%);
Pour plus d’information, consultez la section Les commandes nops

et op de la page 40.
Souvent utilisée, la commande map s’avère très utile pour les en-
sembles. L’opération de correspondance (mapping ) vous permet d’appli-
quer une fonction simultanément à tous les éléments de n’importe quelle
structure.
> nombres := {0, Pi/3, Pi/2, Pi};
1 1
nombres := {0, π, π, π}
3 2
> map(g, nombres);
1 1
{g(0), g(π), g( π), g( π)}
3 2
> map(sin, nombres);
1√
{0, 1, 3}
2
D’autres exemples démontrant l’utilisation de map figurent dans la

section La commande map de la page 38 et Appliquer une fonction à
une liste ou un ensemble à la page 174.
Les opérations sur les ensembles et les listes

La commande member permet de vérifier l’appartenance d’un objet à un
ensemble ou à une liste.
> participants := [JeanSebastien, Sophie, Josee];
participants := [JeanSebastien, Sophie, Josee]
> member(Sophie, participants);
true
> data_set := {5, 6, 3, 7};
data_set := {3, 5, 6, 7}
> member(2, data_set);
false
Pour choisir des éléments depuis une liste, utilisez la notation indicée
[n ] , où n désigne la position de l’élément désiré dans la liste.
> participants[2];
Sophie
Maple reconnaı̂t les ensembles et les listes vides (qui ne contiennent

aucun élément).
> empty_set := {};
empty _set := {}
> empty_list := [];
empty _list := []
Vous pouvez créer un nouvel ensemble à partir d’autres ensembles à

l’aide, par exemple, de la commande union. Supprimez des éléments d’un
ensemble par la commande minus.
> old_set := {2, 3, 4} union {};
old _set := {2, 3, 4}
> new_set := old_set union {2, 5};
new _set := {2, 3, 4, 5}
> third_set := old_set minus {2, 5};
third _set := {3, 4}
Les tableaux
Les tableaux (arrays en anglais) sont une extension d’une autre structure
de données : la liste. Imaginez une liste comme un groupe d’éléments où
chacun est associé à un nombre entier positif, son indice, qui représente
sa position dans la liste. La structure de tableau (array) est une
généralisation de cette idée. Chaque élément est toujours associé à un
indice, mais cet indice n’est pas forcément unidimensionnel. De plus, les
indices peuvent être nuls ou négatifs. Vous pouvez également définir ou
modifier individuellement chacun des éléments d’un tableau sans pour
autant redéfinir ce dernier entièrement.
On doit déclarer le tableau de manière que Maple connaisse le nombre
de dimensions souhaité.
> carres := array(1..3);
carres := array(1..3, [])

Assignez des éléments au tableau. Plusieurs commandes peuvent être

entrées à la même invite en autant que chacune d’entre elles se termine
par le deux-points ou le point-virgule.
> carres[1] := 1; carres[2] := 2^2; carres[3] := 3^2;
carres 1 := 1
carres 2 := 4
carres 3 := 9
Ou, si vous préférez, effectuez toutes ces opérations en même temps.

> cubes := array( 1..3, [1,8,27] );
cubes := [1, 8, 27]
Vous pouvez choisir un seul élément en utilisant la notation appliquée

aux listes.
> carres[2];
Vous devez déclarer les tableaux à l’avance. Pour afficher le contenu

du tableau, vous devez utiliser une commande comme print.
> carres;
carres
> print(carres);
[1, 4, 9]
Le tableau précédent ne possède qu’une dimension. Cependant, en

général, les tableaux peuvent en avoir plus d’une. Définissez un tableau
de dimensions 3 × 3.
> pwrs := array(1..3,1..3);
pwrs := array(1..3, 1..3, [])

Ce tableau est de dimension deux (deux ensembles d’indices). Assignez

d’abord les éléments de la première rangée.
> pwrs[1,1] := 1; pwrs[1,2] := 1; pwrs[1,3] := 1;
pwrs 1, 1 := 1
pwrs 1, 2 := 1
pwrs 1, 3 := 1
Poursuivez maintenant avec le reste du tableau. Si vous préférez, vous

pouvez terminer chaque commande par le deux-points (:) plutôt que par
le point-virgule habituel (;), pour supprimer l’affichage du résultat. Le
deux-points, tout comme le point-virgule, est un séparateur de com-
mandes.
> pwrs[2,1] := 2: pwrs[2,2] := 4: pwrs[2,3] := 8:
> pwrs[3,1] := 3: pwrs[3,2] := 9: pwrs[3,3] := 27:
> print(pwrs);
 
1 1 1
2 4 8
3 9 27
Vous pouvez sélectionner un élément en spécifiant à la fois sa rangée

et sa colonne.
> pwrs[2,3];
Vous pouvez définir un tableau bidimensionnel et ses éléments tout à

la fois en appliquant une méthode similaire à celle qui a été employée pour
l’exemple unidimensionnel montré précédemment. Pour ce faire, utilisez
des listes imbriquées dans d’autres listes : créez une liste dans laquelle
chaque élément est une autre liste qui contient les éléments d’une rangée
du tableau. Ainsi, vous pouvez définir le tableau pwrs de la manière sui-
vante :
> pwrs2 := array( 1..3, 1..3, [[1,1,1], [2,4,8], [3,9,27]] );
 
1 1 1

pwrs2 := 2 4 8 
3 9 27
Les tableaux ne sont pas limités à deux dimensions ; cependant, ceux

qui contiennent plus de deux dimensions sont difficiles à afficher. Si vous
le souhaitez, vous pouvez également déclarer les éléments du tableau en
même temps que vous déclarez le tableau lui-même.
> tableau3 := array( 1..2, 1..2, 1..2,
> [[[1,2],[3,4]], [[5,6],[7,8]]] );
tableau3 := array(1..2, 1..2, 1..2, [

(1, 1, 1) = 1
(1, 1, 2) = 2
(1, 2, 1) = 3
(1, 2, 2) = 4
(2, 1, 1) = 5
(2, 1, 2) = 6
(2, 2, 1) = 7
(2, 2, 2) = 8
])
Maple n’étend pas automatiquement le nom d’un tableau à la
représentation de tous ses éléments. Ainsi, pour certaines commandes,
vous devez spécifier que vous souhaitez effectuer une opération sur les
éléments.
Supposons que vous souhaitez remplacer chaque apparition du
nombre 2 dans pwrs par le nombre 9. Pour effectuer des substitutions
de ce genre, utilisez la commande subs. Sa syntaxe de base est la sui-
vante :
subs( x =expr1, y =expr2, ... , expr_principale )
Par exemple, supposons que vous souhaitez remplacer z par x + y dans

une équation.
> expr := z^2 + 3;
expr := z 2 + 3
> subs( {z=x+y}, expr);
(x + y)2 + 3
Cependant, vous pourriez être déçu de découvrir que la commande

suivante ne fonctionne pas.
> subs( {2=9}, pwrs );
pwrs
En effet, vous devez forcer Maple à évaluer complètement le nom du

tableau tant pour ce qui est de ses composantes que pour ce qui regarde
son nom, en utilisant la commande d’évaluation de matrices evalm.
> subs( {2=9}, evalm(pwrs) );
 
1 1 1
9 4 8
3 9 27
Non seulement cette commande permet la substitution des éléments

comme il est souhaité, mais encore l’évaluation complète affiche également
les éléments du tableau, de la même manière que grâce à la commande
print.
> evalm(pwrs);
 
1 1 1
2 4 8
3 9 27
Les tables
Une table est une extension de tableau. À la différence d’un tableau, les
indices d’une table peuvent être quelconques, et non seulement limités à
des nombres entiers.
> traduit := table([one=un,two=deux,three=trois]);
traduit := table([two = deux , three = trois , one = un])

> traduit[two];
deux
Même si les tables semblent à première vue revêtir peu d’intérêt,

elles sont en fait des structures puissantes. Les tables vous permettent
de travailler avec des notations naturelles dans vos structures de données.
Par exemple, vous pouvez afficher les propriétés physiques de certains
matériaux en utilisant une table Maple.
> earth_data := table( [ mass=[5.976*10^24,kg],
> radius=[6.378164*10^6,m],
> circumference=[4.00752*10^7,m] ] );
earth_data := table([radius = [.6378164000 107 , m],

circumference = [.4007520000 108 , m],
mass = [.5976000000 1025 , kg ]
])
> earth_data[mass];
[.5976000000 1025 , kg ]
Dans cet exemple, chacun des indices est un nom et chaque entrée est
une liste. Ce n’est en fait qu’un exemple très simple ; la plupart du temps,
des indices beaucoup plus généraux sont préférables. Ainsi, vous pourriez
construire une table dont les indices sont des formules algébriques et dont
les valeurs sont les dérivées de ces formules.
Les chaınes
Une chaıne est un autre objet Maple créé en encadrant un nombre quel-
conque de caractères par des guillemets anglais.
> "Ceci est une chaine.";
“Ceci est une chaine.”
Les chaı̂nes sont des unités indivisibles que l’on peut considérer comme
des constantes : on ne peut leur assigner une valeur.
> "mon age" := 22;
Error, invalid left hand side of assignment

Comme les éléments des listes ou des tableaux, on peut accéder indivi-
duellement aux différents caractères d’une chaı̂ne en utilisant la notation
des crochets.
> mystr := "I ate the whole thing.";
mystr := “I ate the whole thing.”
> mystr[11..-2];
“whole thing”
L’opérateur de concaténation (“||”) ou la commande cat sont utilisés

pour joindre deux chaı̂nes ensemble. La commande length, de son côté,
est employée pour déterminer le nombre de caractères dans une chaı̂ne.
> newstr := cat("I can’t believe ", mystr);
newstr := “I can’t believe I ate the whole thing.”
> length(newstr);
38
Il existe plusieurs autres commandes qui agissent sur des chaı̂nes et

d’autres encore qui prennent des chaı̂nes comme arguments. Pour d’autres
exemples, reportez-vous à l’écran d’aide ?StringTools.
2.6 La manipulation d’expressions

De nombreuses commandes Maple permettent la manipulation d’expres-
sions. Il vous est ainsi possible de transformer les résultats de commandes
Maple en des formes familières, ou encore de manipuler vos propres ex-
pressions en des formes que Maple peut reconnaı̂tre. Dans cette section,
vous apprendrez les commandes les plus couramment utilisées à cet effet.
2.6 La manipulation d’expressions • 33
La commande simplify
Vous pouvez choisir cette commande pour appliquer des règles de simpli-
fication à une expression. Maple connaı̂t certaines règles de simplification
pour divers types d’expressions et de formes comme les fonctions trigo-
nométriques, les radicaux, les fonctions logarithmiques, les fonctions ex-
ponentielles, les puissances ainsi que plusieurs autres fonctions spéciales.
> expr := cos(x)^5 + sin(x)^4 + 2*cos(x)^2
> - 2*sin(x)^2 - cos(2*x);
expr :=
cos(x)5 + sin(x)4 + 2 cos(x)2 − 2 sin(x)2 − cos(2 x)
> simplify(expr);
cos(x)5 + cos(x)4
Pour effectuer seulement un certain type de simplification, spécifiez le

type souhaité.
> simplify(sin(x)^2 + ln(2*y) + cos(x)^2);
1 + ln(2) + ln(y)
> simplify(sin(x)^2 + ln(2*y) + cos(x)^2, ’trig’);
1 + ln(2 y)
> simplify(sin(x)^2 + ln(2*y) + cos(x)^2, ’ln’);
sin(x)2 + ln(2) + ln(y) + cos(x)2
Avec les relations accessoires (side relations ), vous pouvez

également appliquer vos propres règles de simplification.
> siderel := {sin(x)^2 + cos(x)^2 = 1};
siderel := {sin(x)2 + cos(x)2 = 1}
> trig_expr := sin(x)^3 - sin(x)*cos(x)^2 + 3*cos(x)^3;

trig _expr := sin(x)3 − sin(x) cos(x)2 + 3 cos(x)3
> simplify(trig_expr, siderel);
2 sin(x)3 − 3 cos(x) sin(x)2 + 3 cos(x) − sin(x)
La commande factor
La commande factor factorise les expressions polynomiales.
> big_poly := x^5 - x^4 - 7*x^3 + x^2 + 6*x;
big _poly := x5 − x4 − 7 x3 + x2 + 6 x
> factor(big_poly);
x (x − 1) (x − 3) (x + 2) (x + 1)
> rat_expr := (x^3 - y^3)/(x^4 - y^4);
x3 − y 3
rat _expr :=
x4 − y 4
Le numérateur et le dénominateur contiennent tous les deux le facteur

commun x − y ; ainsi, la factorisation annule ces termes.
> factor(rat_expr);
x2 + x y + y 2
(y + x) (x2 + y 2 )
Maple peut factoriser les polynômes univariés et multivariés sur le

domaine de coefficients spécifié. Vous pouvez également factoriser les
polynômes sur des extensions algébriques. Voyez ?factor pour plus de
détails à ce sujet.
La commande expand
Essentiellement, la commande expand est l’inverse de la commande
factor. Elle permet l’expansion de termes multipliés de même que plu-
sieurs autres expansions. Pour cette raison, expand figure parmi les com-
mandes de manipulation les plus utiles. Bien que l’on puisse imaginer par
son nom que le résultat qu’elle produit soit plus long et plus complexe que
l’expression originale, il n’en est pas toujours ainsi. En fait, l’expansion
de certaines expressions permet de grandes simplifications.
> expand((x+1)*(x+2));
x2 + 3 x + 2
> expand(sin(x+y));
sin(y) cos(x) + cos(y) sin(x)
> expand(exp(a+ln(b)));
ea b
La commande expand est très flexible ; non seulement il est pos-

sible de préciser que certaines sous-expressions doivent être laissées telles
quelles au cours de l’expansion, mais des règles d’expansion personnalisées
peuvent également être programmées.
Lorsqu’on utilise Maple pour la première fois, on est porté à croire que
la commande simplify est la commande la plus utile. Malheureusement,
le mot simplify est plutôt vague. Lorsqu’on lui demande de simplifier une
expression, Maple examine cette dernière, essaie plusieurs techniques, puis
tente d’appliquer la règle de simplification la plus appropriée. Cela peut
prendre du temps. De plus, Maple peut ne pas être en mesure de devi-
ner ce que vous souhaitez accomplir, puisque aucune règle mathématique
universelle ne définit ce qui est plus simple .
Lorsque vous connaissez quelles manipulations rendront votre expres-
sion plus simple à vos yeux, spécifiez-les directement. En particulier, la
commande expand figure parmi les plus utiles. Elle permet souvent une
simplification substantielle des expressions et reformule ces dernières sous
une forme pratique pour plusieurs autres commandes.
La commande convert
Cette commande convertit les expressions entre différentes formes.
> convert(cos(x),exp);
1 (I x) 1 1
e +
2 2 e(I x)
Tab. 2.3 – Conversions courantes

Argument Description
polynom d’une série à un polynôme
exp, expln, expsincos d’une expression trigonométrique à une
forme exponentielle
parfrac d’une expression rationnelle à une
fraction partielle
rational d’un nombre à virgule flottante à une
forme rationnelle
radians, degrees des degrés aux radians
set, list, listlist entre différentes structures de données
> convert(1/2*exp(x) + 1/2*exp(-x),trig);
cosh(x)
> A := Matrix([[a,b],[c,d]]);

a b
A :=
c d
> convert(A, ’listlist’);
[[a, b], [c, d]]
> convert(A, ’set’);
{a, b, c, d}
> convert(%, ’list’);
[a, b, c, d]
La commande normal
Cette commande transforme les expressions rationnelles en forme nor-
male factorisée (factored normal form),
numérateur
dénominateur
où numérateur et dénominateur sont deux polynômes relativement pre-
miers à coefficients entiers. Ainsi, la commande normal met les fractions
au même dénominateur.
> rat_expr_2 := (x^2 - y^2)/(x - y)^3 ;
x2 − y 2
rat _expr _2 :=
(−y + x)3
> normal(rat_expr_2);
y+x
(−y + x)2
> normal(rat_expr_2, ’expanded’);
y+x
y 2 − 2 x y + x2
L’option expanded transforme les expressions rationnelles en forme

normale factorisée.
La commande combine
Cette commande combine les termes de sommes, de produits et de puis-
sances en un seul terme. Ces transformations sont, dans plusieurs cas,
l’inverse des transformations appliquées par la commande expand.
> combine(exp(x)^2*exp(y),exp);
e(2 x+y)
> combine((xâ)^2, power);
x(2 a)
La commande map
Cette commande est très utile lorsque vous travaillez sur des listes, des en-
sembles et des tableaux. Elle fournit un moyen commode de gérer plusieurs
solutions ou d’appliquer une opération à chaque élément d’un tableau. La
commande map applique une commande à chaque élément de la structure
de données ou de l’expression fournie. Même s’il est possible d’écrire des
boucles dans un programme pour accomplir ces tâches, l’utilité et la puis-
sance de la commande map ne devraient pas être sous-estimées. Prenez le
temps nécessaire pour vous assurer que vous connaissez bien l’utilisation
de map, l’une des plus puissantes fonctions de Maple.
> map( f, [a,b,c] );
[f(a), f(b), f(c)]
> data_list := [0, Pi/2, 3*Pi/2, 2*Pi];
1 3
data_list := [0, π, π, 2 π]
2 2
> map(sin, data_list);
[0, 1, −1, 0]
Si vous donnez à la commande map plus de deux arguments, Maple

passe les derniers à la commande initiale.
> map( f, [a,b,c], x, y );
[f(a, x, y), f(b, x, y), f(c, x, y)]
Par exemple, pour dériver chaque élément d’une liste par rapport à
x, vous pouvez utiliser les commandes suivantes :
> fcn_list := [sin(x),ln(x),x^2];
fcn_list := [sin(x), ln(x), x2 ]
> map(Diff, fcn_list, x);
d d d 2
[ sin(x), ln(x), x ]
dx dx dx
> map(value, %);
1
[cos(x), , 2 x]
x
Non seulement la procédure peut être une commande existante, mais

vous pouvez également créer une opération à appliquer sur une liste. Par
exemple, supposons que vous voulez mettre au carré chaque élément d’une
liste.
> map(x->x^2, [-1,0,1,2,3]);
[1, 0, 1, 4, 9]
Les commandes lhs et rhs

Ces deux commandes vous permettent de prendre respectivement le côté
gauche (left-hand side) et le côté droit (right-hand side) d’une expres-
sion.
> eqn1 := x+y=z+3;
eqn1 := y + x = z + 3
> lhs(eqn1);
y+x
> rhs(eqn1);
z+3
Les commandes numer et denom

Ces deux commandes servent à extraire respectivement le numérateur et
le dénominateur d’une expression rationnelle.
> numer(3/4);
> denom(1/(1 + x));

x+1
Les commandes nops et op

Ces deux commandes s’avèrent utiles pour diviser des expressions en plu-
sieurs parties et en extraire les sous-expressions.
La commande nops vous indique combien de parties contient une ex-
pression.
> nops(x^2);
> nops(x + y + z);
La commande op vous permet d’accéder aux différentes parties d’une

expression, qu’elle retourne sous forme de suite d’expressions.
> op(x^2);
x, 2
Vous pouvez également accéder à des éléments en particulier en

spécifiant leur indice, ou une plage d’indices.
> op(1, x^2);
> op(2, x^2);
> op(2..-2, x+y+z+w);
y, z
Questions courantes sur la manipulation d’expressions

Comment substituer un produit de deux inconnues ? Utilisez les rela-
tions accessoires pour spécifier une identité . La substituion directe ne
fonctionne généralement pas, puisque Maple cherche une correspondance
exacte avant de remplacer.
> expr := a^3*b^2;
expr := a3 b2
> subs(a*b=5, expr);
a3 b2
Ici, la commande subs a échoué dans sa tentative de substitution.

Utilisez la commande simplify pour obtenir la réponse souhaitée.
> simplify(expr, {a*b=5});
25 a
Vous pouvez également essayer la commande algsubs, qui effectue

une substitution algébrique.
> algsubs(a*b=5, expr);
25 a
Pourquoi le résultat de simplify n’est-il pas sous sa forme la plus

simple ? Par exemple :
> expr2 := cos(x)*(sec(x)-cos(x));
expr2 := cos(x) (sec(x) − cos(x))
> simplify(expr2);
1 − cos(x)2
La forme attendue était sin(x)2 .

Encore une fois, utilisez les relations accessoires pour spécifier l’iden-
tité.
> simplify(%, {1-cos(x)^2=sin(x)^2});
sin(x)2
La question de la simplification est compliquée en raison de la dif-

ficulté à définir ce qu’est une forme simple pour une expression. La
conception d’une forme simple pour un utilisateur peut être très différente
de celle d’un autre utilisateur ; de plus, l’idée d’une forme la plus simple
peut varier d’une situation à l’autre.
Comment mettre en évidence la constante dans 2x + 2y ? Actuel-

lement, cette opération n’est pas possible dans Maple puisque son sim-
plificateur distribue automatiquement le nombre sur le produit, croyant
qu’une somme est plus simple qu’un produit. Dans la plupart des cas, cela
est vrai.
Si vous entrez l’expression
> 2*(x + y);
2x + 2y
vous remarquez que Maple multiplie automatiquement la constante dans

l’expression.
Comment peut-on alors gérer de telles expressions, lorsque l’on doit
mettre des constantes ou des signes négatifs en évidence ? Advenant le
besoin de factoriser ces expressions, utilisez la prochaine substitution.
> expr3 := 2*(x + y);
expr3 := 2 x + 2 y
> subs( 2=deux, expr3 );
x deux + y deux
> factor(%);
deux (x + y)
2.7 Conclusion • 43
2.7 Conclusion
Dans ce chapitre, vous avez vu plusieurs des types d’objets que Maple
peut manipuler : les suites, les ensembles et les listes. Vous avez également
vu plusieurs commandes, dont expand, factor et simplify, qui figurent
parmi les plus utiles pour manipuler et simplifier des expressions algé-
briques. D’autres, comme map, sont utiles pour les ensembles, les listes et
les tableaux. De son côté, la commande subs sert dans presque toutes les
situations.
Dans le prochain chapitre, vous apprendrez à manipuler ces concepts
pour aborder un des problèmes fondamentaux des mathématiques : la
résolution des systèmes d’équations. À mesure que vous apprendrez de
nouvelles commandes, observez comment les concepts de ce chapitre sont
utilisés pour poser les problèmes et manipuler leurs solutions.
3 Trouver des solutions
Ce chapitre introduit les concepts clés nécessaires à une résolution de

problèmes rapide et efficace dans Maple. En apprenant comment utiliser
des outils comme solve, map, subs et unapply, vous gagnerez du temps
et économiserez de nombreux efforts. De plus, le présent chapitre examine
l’interaction entre ces différentes commandes.
3.1 Résolution au moyen de solve

La commande solve de Maple est un solveur d’équations tout usage.
Dans un ensemble d’une ou de plusieurs équations, solve tente de
résoudre le système de manière exacte pour l’ensemble d’inconnues
spécifié. (Souvenez-vous que, dans la section Les ensembles de la page 23,
on utilisait les accolades pour encadrer les éléments d’un ensemble.) Dans
les exemples suivants, vous résolvez une équation pour une inconnue, et
chaque ensemble contient conséquemment un seul élément.
> solve({x^2=4}, {x});
{x = 2}, {x = −2}
> solve({a*x^2+b*x+c=0}, {x});

√ √
1 −b + b2 − 4 a c 1 −b − b2 − 4 a c
{x = }, {x = }
2 a 2 a
Maple retourne chaque solution possible sous forme d’un ensemble.

Puisque les deux équations précédentes possèdent deux solutions, Maple
45
46 • Chapitre 3: Trouver des solutions
retourne une suite d’ensembles solutions. Si aucune inconnue n’est

spécifiée dans l’équation, Maple résout pour toutes celles-ci.
> solve({x+y=0});
{x = −y, y = y}
Ici, une seule solution est obtenue, contenant deux équations. Ce

résultat signifie que y peut prendre n’importe quelle valeur, tandis que x
est l’opposé de y. Cette solution est paramétrisée par rapport à y.
Si vous donnez une expression plutôt qu’une équation, Maple assume
automatiquement que l’équation est égale à zéro.
> solve({x^3-13*x+12}, {x});
{x = 1}, {x = 3}, {x = −4}
La commande solve peut également gérer les systèmes d’équations.

> solve({x+2*y=3, y+1/x=1}, {x,y});
1
{x = −1, y = 2}, {x = 2, y = }
2
Même si les accolades (dénotant un ensemble) ne sont obligatoires ni

autour de l’équation, ni autour de la variable, leur utilisation force Maple
à retourner la solution sous la forme d’un ensemble, ce qui représente
généralement la manière la plus commode. En effet, la première chose à
faire avec une solution est généralement de la vérifier en la substituant
à nouveau dans les équations originales. L’exemple suivant montre cette
procédure.
Étant un ensemble d’équations, la solution est une forme idéale pour
la commande subs. Vous pouvez d’abord donner un nom à l’ensemble
d’équations, par exemple eqns.
> eqns := {x+2*y=3, y+1/x=1};
1
eqns := {x + 2 y = 3, y + = 1}
x
Puis, résolvez.
> soln := solve( eqns, {x,y} );
3.1 Résolution au moyen de solve • 47
1
soln := {x = −1, y = 2}, {x = 2, y = }
2
Cela produit deux solutions : d’abord,

> soln[1];
{x = −1, y = 2}
et ensuite,
> soln[2];
1
{x = 2, y = }
2
Vérifier les solutions

Pour vérifier les solutions ainsi produites, il suffit de les substituer à nou-
veau dans l’ensemble d’équations original en utilisant la commande eval.
> eval( eqns, soln[1] );
{3 = 3, 1 = 1}
> eval( eqns, soln[2] );
{3 = 3, 1 = 1}
Vous découvrirez que cette méthode de vérification est généralement

la plus commode.
Remarquez que cette application de la commande eval se prête à
d’autres usages. Supposons que vous voulez extraire la valeur de x de la
première solution. Encore une fois, la commande eval s’avère le meilleur
outil.
> x1 := eval( x, soln[1] );
x1 := −1
Vous pouvez également extraire la première solution pour y.

> y1 := eval(y, soln[1]);
y1 := 2
Vous pouvez même appliquer ce truc d’évaluation pour convertir

des ensembles solutions sous d’autres formes. Par exemple, vous pou-
vez construire une liste (list) à partir de la première solution, où x sera
le premier élément et y le second. D’abord, construisez une liste dont
les variables sont dans le même ordre que souhaité dans les solutions
correspondantes.
> [x,y];
[x, y]
Puis, évaluez simplement cette liste à la première solution.

> eval([x,y], soln[1]);
[−1, 2]
La première solution est maintenant une liste.

Si vous préférez obtenir d’abord la solution pour y dans la liste, évaluez
[y,x] à la solution.
> eval([y,x], soln[1]);
[2, −1]
Puisque, typiquement, Maple retourne ses solutions sous la forme

d’ensembles (dans lesquels l’ordre des objets est incertain), il est utile
de se souvenir de cette méthode d’extraction des solutions.
Une autre commande utile, map, vous permet d’appliquer une opéra-
tion à toutes les solutions. Par exemple, essayez de substituer les deux
solutions.
La commande map applique l’opération spécifiée comme premier ar-
gument à son deuxième argument.
> map(f, [a,b,c], y, z);
[f(a, y, z), f(b, y, z), f(c, y, z)]

En raison de la syntaxe de map, cette dernière ne peut appliquer en

même temps plusieurs fonctions à des suites. Par exemple, considérez la
suite de solutions précédente.
> soln;
1
{y = 2, x = −1}, {y = , x = 2}
2
Encadrez soln par des crochets pour la convertir en liste (list).

> [soln];
1
[{y = 2, x = −1}, {y = , x = 2}]
2
Maintenant, utilisez la commande suivante pour substituer chacune

des solutions simultanément dans les équations originales, eqns.
> map(subs, [soln], eqns);
[{3 = 3, 1 = 1}, {3 = 3, 1 = 1}]
Cette méthode peut s’avérer précieuse si votre équation possède plu-

sieurs solutions, ou si vous n’êtes pas certain du nombre de solutions
qu’une certaine commande produira.
Restreindre les solutions

Vous pouvez limiter les solutions en spécifiant les inégalités au moyen de
la commande solve.
> solve({x^2=y^2},{x,y});
{x = −y, y = y}, {x = y, y = y}
> solve({x^2=y^2, x<>y},{x,y});
{x = −y, y = y}
Considérez ce système de cinq équations à cinq inconnues.

> eqn1 := x+2*y+3*z+4*t+5*u=41:

> eqn2 := 5*x+5*y+4*z+3*t+2*u=20:
> eqn3 := 3*y+4*z-8*t+2*u=125:
> eqn4 := x+y+z+t+u=9:
> eqn5 := 8*x+4*z+3*t+2*u=11:
Résolvez maintenant le système pour toutes ses variables.
> s1 := solve({eqn1,eqn2,eqn3,eqn4,eqn5}, {x,y,z,t,u});
s1 := {x = 2, t = −11, z = −1, y = 3, u = 16}
Vous pouvez également choisir de résoudre pour un sous-ensemble des

inconnues ; Maple retourne ensuite les solutions en fonction des autres
inconnues.
> s2 := solve({eqn1,eqn2,eqn3}, { x, y, z});
527 28 70 59
s2 := {x = − − 7t − u, z = − − 7 t − u,
13 13 13 13
635 70
y= + 12 t + u}
13 13
Explorer les solutions

Vous pouvez explorer les solutions paramétriques calculées à la fin de la
section précédente. Par exemple, évaluez la solution en u = 1 et t = 1.
> eval( s2, {u=1,t=1} );
−646 −220 861

{x = ,z= ,y= }
13 13 13
Tout comme à la page 47, supposons que vous nécessitiez que les cinq
solutions trouvées par solve soient placées dans un ordre particulier.
Puisqu’il est impossible de fixer l’ordre des éléments dans un ensemble,
solve ne retournera pas nécessairement les solutions dans l’ordre x, y, z.
Cependant, les listes préservent l’ordre de leurs éléments ; ainsi, essayez
la commande suivante.
> eval( [x,y,z], s2 );
527 28 635 70 70 59
[− − 7t − u, + 12 t + u, − − 7 t − u]
13 13 13 13 13 13
Non seulement cette commande a fixé l’ordre des solutions, mais elle
en a également extrait le côté droit de l’égalité (puisque vous connais-
sez toujours quelle solution s’applique à quelle variable en raison de leur
ordre). Cette possibilité est particulièrement utile lorsque vous souhaitez
tracer la surface qui représente la solution.
> plot3d(%, u=0..2, t=0..2, axes=BOXED);
–5
–10
–15
–20
–25
50 –58
–56
55 –54
60 –52
65 –50
–48
70 –46
75 –44
80 –42
La commande unapply
Supposez que vous souhaitez explorer encore davantage. Par souci de com-
modité, définissez x = x(u, t), y = y(u, t) et z = z(u, t) (c.-à-d. convertis-
sez les solutions en fonctions). Souvenez-vous que vous pouvez facilement
choisir l’expression d’une solution pour une variable particulière en uti-
lisant eval.
> eval( x, s2 );
527 28
− − 7t − u
13 13
Cependant, cela est une expression pour x, et non une fonction.

> x(1,1);
x(1, 1)
Pour transformer l’expression en une fonction, il faut utiliser une autre

commande très importante, unapply. Pour ce faire, il suffit de fournir à
unapply l’expression et les variables à partir desquelles Maple doit faire
une fonction. Ainsi, par exemple,
> f := unapply(x^2 + y^2 + 4, x, y);
f := (x, y) → x2 + y 2 + 4
produit la fonction f de x et y, qui fait correspondre à un couple (x, y) le

polynôme x2 + y 2 + 4. Cette nouvelle fonction est facile à utiliser.
> f(a,b);
a2 + b2 + 4
Ainsi, pour transformer la solution pour x en une fonction à la fois de

u et de t, la première étape consiste à obtenir l’expression pour x, comme
il a été mentionné précédement.
> eval(x, s2);
527 28
− − 7t − u
13 13
Puis, on doit utiliser unapply pour transformer cette expression en

une fonction de u et de t.
> x := unapply(%, u, t);
527 28
x := (u, t) → − − 7t − u
13 13
> x(1,1);
−646
13
On crée les fonctions y et z de la même manière.

> eval(y,s2);
635 70
+ 12 t + u
13 13
> y := unapply(%,u,t);
635 70
y := (u, t) → + 12 t + u
13 13
> eval(z,s2);
70 59
− − 7t − u
13 13
> z := unapply(%, u, t);
70 59
z := (u, t) → − − 7t − u
13 13
> y(1,1), z(1,1);
861 −220
,
13 13
La commande assign
La commande assign permet également d’affecter des valeurs à des in-
connues. Par exemple, plutôt que de définir x, y et z en tant que fonc-
tions, assignez chacune d’elles à l’expression du côté droit de l’égalité de
l’équation correspondante.
> assign( s2 );
> x, y, z;
527 28 635 70 70 59
− − 7t − u, + 12 t + u, − − 7 t − u
13 13 13 13 13 13
Souvenez-vous de assign comme étant la commande permettant de

transformer le signe = de la solution en un signe := .
La commande assign est utile pour assigner des noms aux expres-
sions. Cependant, rappelez-vous que m eme si cette commande est
utile pour rapidement assigner des noms aux solutions, elle ne peut
créer de fonctions.
Le prochain exemple comprend la résolution d’équations différen-
tielles, dont la section 3.6 discute plus en détail. Pour commencer, assignez
un nom à la solution.
> s3 := dsolve( {diff(f(x),x)=6*x^2+1, f(0)=0}, {f(x)} );

s3 := f(x) = 2 x3 + x
> assign( s3 );
Il vous reste cependant à créer une fonction.

> f(x);
2 x3 + x
produit la réponse attendue ; cependant, malgré les apparences, f (x) est

simplement le nom de l’expression 2x3 + x, et non une fonction. Appelez
la fonction f en utilisant un argument autre que x.
> f(1);
f(1)
La raison de ce comportement en apparence étrange vient du fait que

assign demande à Maple l’affectation
> f(x) := 2*x^3 + x;
f(x) := 2 x3 + x
qui n’est pas du tout semblable à l’affectation

> f := x -> 2*x^3 + x;
f := x → 2 x3 + x
La première définit seulement la valeur de la fonction f pour l’argu-

ment spécial x ; la seconde définit la fonction f : x → 2x3 + x de manière
à fonctionner, que l’on écrive f (x), f (y) ou f (1).
Pour définir la solution f comme une fonction de x, utilisez unapply.
> eval(f(x),s3);
2 x3 + x
> f := unapply(%, x);
f := x → 2 x3 + x
> f(1);
La commande RootOf
À l’occasion, Maple retourne ses solutions à l’aide de la commande
RootOf. Considérons l’exemple suivant.
> solve({x^5 - 2*x + 3 = 0},{x});
{x = RootOf(_Z 5 − 2 _Z + 3, index = 1)},

{x = RootOf(_Z 5 − 2 _Z + 3, index = 2)},
{x = RootOf(_Z 5 − 2 _Z + 3, index = 3)},
{x = RootOf(_Z 5 − 2 _Z + 3, index = 4)},
{x = RootOf(_Z 5 − 2 _Z + 3, index = 5)}
RootOf(expr ) est un nom générique pour toutes les racines de expr,
et _Z est un nom générique pour x. Cela signifie que x est une racine
du polynôme z 5 − 2z + 3, où le paramètre index numérote et ordonne les
solutions. Cela peut s’avérer fort utile lorsqu’on fait de l’algèbre sur un
corps différent des nombres complexes. En utilisant la commande evalf,
vous obtenez une forme explicite des racines complexes.
> evalf(%);
{x = .9585321812 + .4984277790 I},

{x = −.2467292569 + 1.320816347 I},
{x = −1.423605849},
{x = −.2467292569 − 1.320816347 I},
{x = .9585321812 − .4984277790 I}
Une expression générale pour désigner les racines des polynômes de
degré cinq sous forme de radicaux n’existe pas.
3.2 Résoudre numériquement : fsolve

La commande fsolve est l’équivalent numérique de solve. Elle trouve
les racines d’une ou de plusieurs équations en utilisant une variante de la
méthode de Newton, et produit des solutions numériques approximées.
> fsolve({cos(x)-x = 0}, {x});
{x = .7390851332}
Pour une équation générale, fsolve cherche une racine réelle simple.
Pour un polynôme, cependant, la commande cherche toutes les racines
réelles.
> poly :=3*x^4 - 16*x^3 - 3*x^2 + 13*x + 16;
poly := 3 x4 − 16 x3 − 3 x2 + 13 x + 16
> fsolve({poly},{x});
{x = 1.324717957}, {x = 5.333333333}
Pour chercher plus d’une racine d’une équation générale, utilisez l’op-
tion avoid.
> fsolve({sin(x)=0}, {x});
{x = 0.}
> fsolve({sin(x)=0}, {x}, avoid={x=0});
{x = −3.141592654}
Pour chercher un nombre déterminé de racines d’un polynôme, utilisez

l’option maxsols.
> fsolve({poly}, {x}, maxsols=1);
{x = 1.324717957}
L’option complex force Maple à chercher des racines complexes en

plus des racines réelles.
3.2 Résoudre numériquement : fsolve • 57
> fsolve({poly}, {x}, complex);
{x = −.6623589786 − .5622795121 I},

{x = −.6623589786 + .5622795121 I},
{x = 1.324717957}, {x = 5.333333333}
Vous pouvez également spécifier l’intervalle dans lequel chercher une
racine en particulier.
> fsolve({cos(x)=0}, {x}, Pi..2*Pi);
{x = 4.712388980}
Dans plusieurs cas, fsolve peut échouer dans sa recherche d’une ra-
cine, même si une telle racine existe. Dans ces situations, spécifier un
intervalle peut aider Maple. Pour améliorer la précision de solutions,
vous pouvez augmenter la valeur de la variable spéciale, Digits. Remar-
quez que dans l’exemple suivant, la solution trouvée ne garantit pas une
précision de trente décimales ; cependant, Maple effectue toutes les étapes
de ses calculs à une précision d’au moins trente chiffres significatifs au lieu
des dix chiffres par défaut.
> Digits := 30;
Digits := 30
> fsolve({cos(x)=0}, {x});
{x = 1.57079632679489661923132169164}
Les limites de solve

La commande solve ne s’applique pas à toutes les situations. Souvenez-
vous que l’approche employée par Maple est algorithmique et que ce der-
nier ne possède pas nécessairement la capacité de faire appel aux trucs
que vous pouvez utiliser lorsque vous résolvez un problème à la main.
Mathématiquement parlant, les polynômes de degré supérieur ou égal
à cinq ne possèdent pas de solution générale sous forme de radicaux. Maple
tente de les résoudre symboliquement le mieux possible, mais il est fort
possible que vous deviez avoir recours à une solution numérique en cas
d’échec.
La résolution d’équations trigonométriques peut également être dif-

ficile. En fait, le travail avec toutes les équations transcendantes s’avère
plutôt difficile.
> solve({sin(x)=0}, {x});
{x = 0}
Remarquez que Maple retourne seulement une solution parmi une in-
finité. Cependant, si vous fixez la valeur de la variable _EnvAllSolutions
à true (vrai), Maple retourne alors l’ensemble complet des solutions.
> _EnvAllSolutions := true;
_EnvAllSolutions := true
> solve({sin(x)=0}, {x});
{x = π _Z1 ~}
Le préfixe _Z de la variable indique que cette dernière possède des

valeurs entières. Le tilde (~) indique qu’une hypothèse a été placée sur
cette variable ; dans le cas présent, on suppose qu’il s’agit d’une variable
entière. De plus, la commande fsolve vous permet de spécifier l’intervalle
dans lequel Maple cherchera une solution. Ainsi, vous pouvez obtenir plus
de contrôle sur les solutions calculées.
> fsolve({sin(x)=0}, {x}, 3..4);
{x = 3.14159265358979323846264338328}
Ces types de problèmes sont communs à tous les sytèmes de calcul

symbolique et témoignent des limites naturelles d’une approche algorith-
mique à la résolution d’équations.
Lorsque vous utilisez solve, rappelez-vous de bien vérifier vos résul-
tats. Le prochain exemple met en évidence une incompréhension qui peut
survenir en raison de la gestion des singularités par Maple.
> expr := (x-1)^2/(x^2-1);
3.2 Résoudre numériquement : fsolve • 59
(x − 1)2
expr :=
x2 − 1
Maple trouve bien une solution

> soln := solve({expr=0},{x});
soln := {x = 1}
mais lorsqu’elle est évaluée en x = 1, on obtient 0/0.

> eval(expr, soln);
Error, division by zero
La limite montre pourtant que x = 1 est presque une solution.

> Limit(expr, x=1);
(x − 1)2
lim
x→1 x2 − 1
> value (%);
Maple affiche une ligne verticale à l’endroit de l’asymptote, à moins de

spécifier discont=true.
> plot(expr, x=-5..5, y=-10..10);
10
8
6
y
4
2
–4 –2 0 2 4
–2 x
–4
–6
–8
–10
Maple enlève la singularité x = 1 de l’expression avant de la résoudre.

Peu importe la méthode ou les outils utilisés pour résoudre les équations,
il est crucial de vérifier les résultats obtenus. Fort heureusement, ces
vérifications sont faciles au moyen de Maple.
3.3 D’autres solveurs

Maple contient plusieurs commandes solve spécialisées. Puisque vous ris-
quez de ne pas les trouver aussi utiles que les fonctions plus générales
solve et fsolve, cette section n’en signale que quelques-unes. Si vous
désirez obtenir plus de détail à propos de ces commandes, utilisez le
système d’aide en ligne en entrant ? suivi du nom de commande sou-
haité à l’invite de Maple.
Trouver des solutions entières

La commande isolve trouve des solutions entières aux équations en ré-
solvant pour toutes les inconnues dans l’expression ou les expressions.
> isolve({3*x-4*y=7});
{x = 5 + 4 _Z1 , y = 2 + 3 _Z1 }
Trouver des solutions modulo m

La commande msolve résout des équations entières modulo m (la repré-
sentation positive pour les entiers) en résolvant pour toutes les inconnues
dans l’expression ou les expressions.
> msolve({3*x-4*y=1,7*x+y=2},17);
{y = 6, x = 14}
Maple utilise les variables globales _Z1, . . ._Zn pour dénoter les pa-
ramètres entiers de la solution.
> msolve({2^n=3},19);
{n = 13 + 18 _Z1 ~}
Le tilde (~) sur _Z1 indique que msolve a placé une hypothèse à propos
de _Z1 ; dans ce cas-ci, que _Z1 soit entier.
> about( _Z1 );
3.4 Les polyn
omes • 61
Originally _Z1, renamed _Z1~:

is assumed to be: integer
La section 5.2 décrit comment vous pouvez placer vous-même des

hypothèses à propos d’inconnues.
Résoudre des relations de récurrence

La commande rsolve résout des relations de récurrence, retournant une
expression correspondant au terme général de la fonction.
> rsolve({f(n)=f(n-1)+f(n-2),f(0)=1,f(1)=1},{f(n)});
 
√ 2 √ 2


 5 (− √ )n 5 (− √ ) 
n

2 1−
√ 5 2
√ 5 + 1
f(n) = − +

 5 1− 5 5 5+1 

 
Consultez également la rubrique d’aide ?LREtools.
3.4 Les polyn

omes
Pour Maple, un polyn ome est une expression contenant des incon-
nues ; chaque terme du polynôme contient un produit des inconnues. Par
exemple, si le polynôme contient seulement une inconnue, x, les termes
peuvent contenir x3 , x1 = x et x0 = 1, comme dans le cas du polynôme
x3 − 2x + 1. Si plus d’une inconnue existe, un terme peut également conte-
nir un produit des inconnues, comme dans le polynôme x3 +3x2 y +y 2 . Les
coefficients peuvent être entiers (comme dans les exemples précédents), ra-
tionnels, irrationnels, décimaux, complexes ou même faire appel à d’autres
variables.
> x^2 - 1;
x2 − 1
> x + y + z;
x+y+z
> 1/2*x^2 - sqrt(3)*x - 1/3;
1 2 √ 1
x − 3x −
2 3
> (1 - I)*x + 3 + 4*I;
(1 − I) x + 3 + 4 I
> a*x^4 + b*x^3 + c*x^2 + d*x + f;
a x4 + b x3 + c x2 + d x + f
Maple possède des commandes permettant plusieurs types de mani-

pulations et de calculs mathématiques sur les polynômes ; les prochaines
sections en examinent quelques-uns.
Tri et regroupement
La commande sort arrange les termes d’un polynôme dans l’ordre
décroissant des degrés de leurs inconnues. Plutôt que de conserver une
deuxième copie du polynôme original dont les termes ont été triés, sort
modifie directement la manière dont les termes sont emmagasinés dans
le polynôme de départ. Ainsi, si vous affichez le polynôme après l’avoir
passé à sort, vous remarquerez qu’il demeure trié :
> sort_poly := x + x^2 - x^3 + 1 - x^4;
sort _poly := x + x2 − x3 + 1 − x4
> sort(sort_poly);
−x4 − x3 + x2 + x + 1
> sort_poly;
−x4 − x3 + x2 + x + 1
3.4 Les polyn
omes • 63
Maple classe les polynômes multivariés de deux manières. La méthode

par défaut classe les termes selon leur degré total. Ainsi, x2 y 2 sera placé
avant x3 et y 3 . Selon l’autre option, les termes sont classés selon l’ordre
lexicographique pur (plex). Lorsque vous choisissez cette option, le tri
examine d’abord les puissances de la première variable de la liste des
variables (cette liste est le second argument de la commande sort), puis
les puissances de la seconde variable. La différence entre ces deux types
de tri se conçoit clairement au moyen d’un exemple.
> mul_var_poly := y^3 + x^2*y^2 + x^3;
mul _var _poly := y 3 + x2 y 2 + x3
> sort(mul_var_poly, [x,y]);
x2 y 2 + x3 + y 3
> sort(mul_var_poly, [x,y], ’plex’);
x3 + x2 y 2 + y 3
La commande collect regroupe les coefficients de même degré dans

un polynôme. Par exemple, lorsque les termes ax et bx se trouvent dans
le même polynôme, Maple les regroupe en (a + b)x.
> big_poly:=x*y + z*x*y + y*x^2 - z*y*x^2 + x + z*x;
big _poly := x y + z x y + y x2 − z y x2 + x + z x
> collect(big_poly, x);
(y − z y) x2 + (y + z y + 1 + z) x
> collect(big_poly, z);
(x y − y x2 + x) z + x y + y x2 + x
Opérations mathématiques
Vous pouvez effectuer plusieurs opérations mathématiques sur les po-
lynômes. Parmi les opérations les plus fondamentales, on trouve la division
(c’est-à-dire diviser un polynôme par un autre et en déterminer le quotient
et le reste). Maple fournit les commandes rem et quo pour déterminer le
reste (remainder en anglais) et le quotient d’une division polynomiale.
> r := rem(x^3+x+1, x^2+x+1, x);
r := 2 + x
> q := quo(x^3+x+1, x^2+x+1, x);
q := x − 1
> collect( (x^2+x+1) * q + r, x );
x3 + x + 1
Dans certaines situations, il peut suffire de déterminer si un polynôme

divise exactement un autre polynôme. La commande divide vérifie la
division polynomiale exacte.
> divide(x^3 - y^3, x - y);
true
> rem(x^3 - y^3, x - y, x);
Vous évaluez les polynômes en des valeurs comme avec n’importe

quelle expression en utilisant la commande eval.
> poly := x^2 + 3*x - 4;
poly := x2 + 3 x − 4
> eval(poly, x=2);
6
3.4 Les polyn
omes • 65
Tab. 3.1 – Commandes servant à déterminer les coefficients polynomiaux

Commande Description
coeff extraire un coefficient
lcoeff trouver le coefficient du terme de plus haut degré
tcoeff trouver le coefficient du terme de plus faible degré
coeffs retourner une suite de tous les coefficients
degree déterminer le degré (supérieur) du polynôme
ldegree déterminer le degré inférieur du polynôme
> mul_var_poly := y^2*x - 2*y + x^2*y + 1;
mul _var _poly := y 2 x − 2 y + y x2 + 1
> eval(mul_var_poly, {y=1,x=-1});
−1
Coefficients et degrés
Les commandes degree et coeff déterminent le degré d’un polynôme et
fournissent un mécanisme d’extraction des coefficients.
> poly := 3*z^3 - z^2 + 2*z - 3*z + 1;
poly := 3 z 3 − z 2 − z + 1
> coeff(poly, z^2);
−1
> degree(poly,z);
Recherche de racines et factorisation

La commande solve détermine les racines d’un polynôme tandis que
factor exprime le polynôme sous une forme complètement factorisée.
> poly1 := x^6 - x^5 - 9*x^4 + x^3 + 20*x^2 + 12*x;
poly1 := x6 − x5 − 9 x4 + x3 + 20 x2 + 12 x
> factor(poly1);
x (x − 2) (x − 3) (x + 2) (x + 1)2
> poly2 := (x + 3);
poly2 := x + 3
> poly3 := expand(poly2^6);
poly3 :=
x6 + 18 x5 + 135 x4 + 540 x3 + 1215 x2 + 1458 x + 729
> factor(poly3);
(x + 3)6
> solve({poly3=0}, {x});
{x = −3}, {x = −3}, {x = −3}, {x = −3}, {x = −3}, {x = −3}
> factor(x^3 + y^3);
(x + y) (x2 − x y + y 2 )
Maple factorise le polynôme sur l’anneau contenant les coefficients

(entiers, rationnels, etc.). La commande factor vous permet également de
spécifier un corps algébrique de nombres sur lequel factoriser le polynôme.
Consultez la rubrique d’aide ?factor pour obtenir plus de renseigne-
ments.
3.5 Le calcul différentiel • 67
Tab. 3.2 – D’autres fonctions agissant sur des polynômes

content contenu d’un polynôme multivarié
compoly décomposition polynomiale
discrim discriminant d’un polynôme
gcd plus grand commun diviseur
gcdex algorithme étendu de division euclidienne
interp interpolation polynomiale
lcm plus petit commun multiple
norm norme d’un polynôme
prem pseudo-reste
primpart partie primitive d’un polynôme multivarié
randpoly polynôme aléatoire
recipoly polynôme réciproque
resultant résultante de deux polynômes
roots racines sur un corps algébrique de nombres
sqrfree factorisation libre de carrés
3.5 Le calcul différentiel

Maple offre plusieurs outils puissants permettant la résolution de
problèmes de calcul différentiel. Par exemple, il est utile pour calculer les
limites des fonctions. Calculez la limite d’une fonction rationnelle lorsque
x tend vers 1.
> f := x -> (x^2-2*x+1)/(x^4 + 3*x^3 - 7*x^2 + x+2);
x2 − 2 x + 1
f := x →
x4 + 3 x3 − 7 x2 + x + 2
> Limit(f(x), x=1);
x2 − 2 x + 1
lim
x→1 x4 + 3 x3 − 7 x2 + x + 2
> value(%);
1
8
Il est également possible de calculer les limites à gauche et à droite

d’une fonction. Par exemple, considérez la limite de tan(x) lorsque x tend
vers π/2.
Calculez la limite à gauche en utilisant l’option left.
> Limit(tan(x), x=Pi/2, left);
lim tan(x)
x→(1/2 π)−
> value(%);
Faites de même pour la limite à droite.

> Limit(tan(x), x=Pi/2, right);
lim tan(x)
x→(1/2 π)+
> value(%);
−∞
Une autre opération facile à effectuer est la création d’une série ap-
proximant une fonction donnée. Par exemple, utilisez la fonction
> f := x -> sin(4*x)*cos(x);
f := x → sin(4 x) cos(x)
> fs1 := series(f(x), x=0);
38 3 421 5
fs1 := 4 x − x + x + O(x6 )
3 30
Remarquez que, par défaut, la commande series produit un po-

lynôme d’ordre 6. En modifiant la valeur de la variable spéciale Order, il
est possible d’augmenter ou de diminuer l’ordre d’une série polynomiale.
L’utilisation de convert(fs1, polynom) supprime le terme d’ordre
de la série de manière que Maple puisse en tracer le graphique.
> p := convert(fs1,polynom);
38 3 421 5
p := 4 x − x + x
3 30
> plot({f(x), p},x=-1..1, -2..2);
–1 –0.8–0.6–0.4–0.20 0.2 0.4 0.6 0.8 1

x
–1
–2
En augmentant l’ordre de troncation de la série à 12 et en recommen-

ant les opérations précédentes, on remarque l’amélioration escomptée de
la précision de l’approximation.
> Order := 12;
Order := 12
> fs1 := series(f(x), x=0);
38 3 421 5 10039 7 246601 9

fs1 := 4 x − x + x − x + x −
3 30 1260 90720
6125659 11
x + O(x12 )
9979200
> p := convert(fs1,polynom);
38 3 421 5 10039 7 246601 9

p := 4 x − x + x − x + x
3 30 1260 90720
6125659 11
− x
9979200
> plot({f(x), p}, x=-1..1, -2..2);
–1 –0.8–0.6–0.4–0.20 0.2 0.4 0.6 0.8 1

x
–1
–2
Maple peut calculer symboliquement les dérivées et les intégrales. Par

exemple, dérivez une expression, intégrez son résultat et comparez celui-ci
à l’expression originale.
> f := x -> x*sin(a*x) + b*x^2;
f := x → x sin(a x) + b x2
> Diff(f(x),x);
∂
(x sin(a x) + b x2 )
∂x
> df := value(%);
df := sin(a x) + x cos(a x) a + 2 b x
> Int(df, x);

sin(a x) + x cos(a x) a + 2 b x dx
> value(%);
cos(a x) cos(a x) + a x sin(a x)

− + + b x2
a a
> simplify(%);
x (sin(a x) + b x)
Il n’est pas nécessaire d’utiliser les formes inertes Diff et Int en con-
jonction avec la commande value pour calculer symboliquement la dérivée
et l’intégrale. Les résultats peuvent être calculés en une seule commande
en utilisant respectivement diff et int.
Vous pouvez également effectuer des intégrales définies. Par exemple,
recalculez l’intégrale précédente sur l’intervalle de x = 1 à x = 2.
> Int(df,x=1..2);
2
sin(a x) + x cos(a x) a + 2 b x dx
1
> value(%);
2 sin(2 a) + 3 b − sin(a)
Considérez une intégrale plus compliquée.

> Int(exp(-x^2), x);

2
e(−x ) dx
> value(%);
1√
π erf(x)
2
À quelques occasions, Maple ne peut déterminer si une variable est

réelle ou complexe, et retourne donc un résultat inattendu.
> g := t -> exp(-a*t)*ln(t);
g := t → e(−a t) ln(t)
> Int (g(t), t=0..infinity);

∞
e(−a t) ln(t) dt
0
> value(%);
e(−a t) ln(t) + Ei(1, a t) + γ + ln(a)

lim −
t→∞ a
Ici, Maple assume que le paramètre est un nombre complexe. Il re-

tourne donc une réponse plus générale.
Dans les situations où vous savez que a est un nombre positif réel,
spécifiez-le à Maple en utilisant la commande assume.
> assume(a > 0):
> ans := Int(g(t), t=0..infinity);
∞
ans := e(−a~ t) ln(t) dt
0
> value(%);
ln(a~) γ
− −
a~ a~
Le résultat est beaucoup plus simple. Le seul terme non élémentaire est
la constante gamma. Le tilde (~) indique que a porte une hypothèse. Vous
devez maintenant supprimer cette hypothèse pour parcourir les exemples
ultérieurs. Deux étapes sont nécessaires. La réponse, ans, contient a avec
des hypothèses. Si vous souhaitez repartir de zéro et continuer à utiliser
ans, vous devez remplacer toutes les occurrences de a~ par a.
> ans := subs(a =’a’, ans );
∞
ans := e(−a t) ln(t) dt
0
Le premier argument, a = ’a’, mérite une attention particulière. Si

vous tapez a après avoir placé une hypothèse sur a, Maple assume auto-
matiquement que vous parlez de la variable a~. En Maple, les guillemets
simples retardent l’évaluation. Dans ce cas, ils assurent que Maple in-
terprète le deuxième a comme a et non a~.
Maintenant que vous avez supprimé l’hypothèse sur a dans ans, vous
pouvez supprimer l’hypothèse sur a elle-même en lui affectant son propre
nom.
> a := ’a’:
Utilisez les guillemets simples pour la même raison que précédemment.
Pour plus de renseignements, consultez la section 5.2.
3.6 Les équations différentielles : dsolve • 73
3.6 Les équations différentielles : dsolve

Maple peut résoudre symboliquement plusieurs équations différentielles
ordinaires (EDO), incluant les problèmes de conditions initiales et de
conditions aux limites.
Définissez une EDO.
> ode1 := {diff(y(t),t,t) + 5*diff(y(t),t) + 6*y(t) = 0};
d2 d
ode1 := {( 2
y(t)) + 5 ( y(t)) + 6 y(t) = 0}
dt dt
Définissez les conditions initiales.

> ic := {y(0)=0, D(y)(0)=1};
ic := {y(0) = 0, D(y)(0) = 1}
Résolvez au moyen de dsolve, en utilisant l’opérateur union pour

former l’union des deux ensembles.
> soln := dsolve(ode1 union ic, {y(t)});
soln := y(t) = −e(−3 t) + e(−2 t)
Si vous souhaitez utiliser cette solution pour l’évaluer en certains

points ou pour en tracer le graphique, rappelez-vous d’utiliser la com-
mande unapply pour définir correctement une fonction Maple. La sec-
tion 3.1 discute davantage de cette question.
Vous pouvez extraire une valeur d’un ensemble solution au moyen de
la commande eval.
> eval( y(t), soln );
−e(−3 t) + e(−2 t)
Utilisez maintenant ce fait pour définir y comme une fonction de t en

utilisant unapply :
> y1:= unapply(%, t );
y1 := t → −e(−3 t) + e(−2 t)
> y1(a);
−e(−3 a) + e(−2 a)
Vérifiez maintenant que y1 est bien une solution de l’EDO :

> eval(ode1, y=y1);
{0 = 0}
et que y1 satisfait bien aux conditions initiales.

> eval(ic, y=y1);
{1 = 1, 0 = 0}
Une autre méthode de vérification des solutions est également dispo-

nible, bien qu’elle puisse sembler déroutante au premier abord. Donnez à
la nouvelle solution le nom y plutôt que y1.
> y := unapply( eval(y(t), soln), t );
y := t → −e(−3 t) + e(−2 t)
Maintenant, lorsque vous entrez une équation contenant y, Maple uti-

lise cette fonction et en évalue le résultat, en une seule étape.
> ode1;
{0 = 0}
> ic;
{1 = 1, 0 = 0}
Si vous souhaitez modifier l’équation différentielle, vous ne voudrez

plus de cette définition pour y(x) ; vous devrez donc supprimer cette
définition au moyen de la commande suivante :
> y := ’y’;
y := y
Maple reconnaı̂t également les fonctions spéciales, comme la fonction

de Dirac utilisée en physique.
> ode2 := 10^6*diff(y(x),x,x,x,x) = Dirac(x-2) -
> Dirac(x-4);
d4
ode2 := 1000000 ( y(x)) = Dirac(x − 2) − Dirac(x − 4)
dx4
Spécifiez des conditions aux limites :

> bc := {y(0)=0, D(D(y))(0)=0, y(5)=0};
bc := {(D(2) )(y)(0) = 0, y(0) = 0, y(5) = 0}
spécifiez également une valeur initiale.

> iv := {D(D(y))(5)=0};
iv := {(D(2) )(y)(5) = 0}
> soln := dsolve({ode2} union bc union iv, {y(x)});
1
soln := y(x) = Heaviside(x − 2) x3
6000000
1 1
− Heaviside(x − 2) + Heaviside(x − 2) x
750000 500000
1
− Heaviside(x − 2) x2
1000000
1
6000000
1 1
+ Heaviside(x − 4) − Heaviside(x − 4) x
93750 125000
1 1
+ Heaviside(x − 4) x2 − x3
500000 15000000
1
+ x
1250000
> eval(y(x), soln);
1 1
Heaviside(x − 2) x3 − Heaviside(x − 2)
6000000 750000
1
+ Heaviside(x − 2) x
500000
1
1000000
1
6000000
1 1
93750 125000
1 1
500000 15000000
1
+ x
1250000
> y := unapply(%, x);
1
y := x → Heaviside(x − 2) x3
6000000
1 1
− Heaviside(x − 2) + Heaviside(x − 2) x
750000 500000
1
1000000
1
6000000
1 1
93750 125000
1 1
500000 15000000
1
+ x
1250000
Cette valeur de y satisfait à l’équation différentielle, à la condition
aux limites et à la valeur initiale.
> ode2;
24 Dirac(1, x − 4) − 12 Dirac(1, x − 2)
+ 6 Dirac(1, x − 2) x − 6 Dirac(1, x − 4) x
+ 8 Dirac(2, x − 2) − 8 Dirac(2, x − 2) x
+ 2 Dirac(2, x − 2) x2 + 16 Dirac(2, x − 4) x
1
− 2 Dirac(2, x − 4) x2 + Dirac(3, x − 2) x3
6
+ 2 Dirac(3, x − 2) x − Dirac(3, x − 2) x2
1
− Dirac(3, x − 4) x3 − 8 Dirac(3, x − 4) x
6
+ 2 Dirac(3, x − 4) x2 − 32 Dirac(2, x − 4)
4 32
− Dirac(3, x − 2) + Dirac(3, x − 4) + 4 Dirac(x − 2)
3 3
− 4 Dirac(x − 4) = Dirac(x − 2) − Dirac(x − 4)
> simplify(%);
Dirac(x − 2) − Dirac(x − 4) = Dirac(x − 2) − Dirac(x − 4)
> bc;
{0 = 0}
> iv;
{0 = 0}
> plot(y(x), x=0..5, axes=BOXED);
1e–06
8e–07
6e–07
4e–07
2e–07
0
0 1 2 3 4 5
x
Maintenant que vous n’utilisez plus y, vous devriez y enlever toute

référence.
> y := ’y’;
y := y
Maple peut également résoudre des systèmes d’équations différen-

tielles ; par exemple, le système suivant formé de deux équations simul-
tanées du second ordre.
> de_sys := { diff(y(x),x,x)=z(x), diff(z(x),x,x)=y(x) };
d2 d2
de_sys := { y(x) = z(x), z(x) = y(x)}
dx2 dx2
> soln := dsolve(de_sys, {z(x),y(x)});
soln := {
y(x) = −_C1 sin(x) + _C2 ex − _C3 cos(x) + _C4 e(−x) ,
z(x) = _C1 sin(x) + _C2 ex + _C3 cos(x) + _C4 e(−x) }
Si vous résolvez le système sans spécifier de conditions supplémen-
taires, Maple produit automatiquement les constantes appropriées _C1,
. . ., _C4.
Observez encore qu’il est possible d’extraire et de définir les solutions
à l’aide des commandes eval et unapply :
> y := unapply(eval(y(x), soln), x );
y := x → −_C1 e(−x) + _C2 ex − _C3 sin(x) + _C4 cos(x)
> y(1);
−_C1 e(−1) + _C2 e − _C3 sin(1) + _C4 cos(1)
Vous pouvez déréférencer les solutions lorsque vous en avez terminé.

> y := ’y’;
y := y
3.7 L’organisation de Maple • 79
3.7 L’organisation de Maple

Au démarrage, Maple ne charge en mémoire que le noyau (en anglais
kernel ) de son programme. Ce noyau constitue la base du système, car
il contient les commandes fondamentales et primitives : l’interpréteur du
langage Maple (qui convertit les commandes saisies en instructions ma-
chine que le microprocesseur de votre ordinateur peut comprendre), des
algorithmes de calcul numérique élémentaire ainsi que des routines d’af-
fichage des résultats et d’opérations d’entrée-sortie.
Le noyau est formé de code C hautement optimisé et totalise environ
10% de la taille du système. Les programmeurs de Maple ont délibérément
conservé sa taille petite pour en préserver la rapidité d’exécution. Le
noyau de Maple exécute les routines les plus fréquentes en arithmétique
entière et rationnelle et dans la manipulation des polynômes.
Les 90% restants du savoir mathématique de Maple sont écrits dans
le langage Maple et résident dans sa bibliothèque (library en anglais). La
bibliothèque se divise en deux groupes : la bibliothèque principale (main
library ) et les packages. Hiérarchiquement, ces groupes de fonctions se
situent au-dessus du noyau.
La bibliothèque principale contient les commandes Maple les plus
fréquemment utilisées (excluant celles déjà contenues dans le noyau).
Ces commandes sont chargées lorsqu’elles sont appelées — il n’est pas
nécessaire de les charger explicitement. Le langage Maple produit des
procédures très compactes qui n’affichent pas de délai observable : vous
ne remarquerez probablement pas la différence entre ces dernières et les
commandes du noyau écrites en C.
Les dernières commandes de la bibliothèque sont les packages. Chacun
des nombreux packages de Maple contient un groupe de commandes ef-
fectuant des calculs apparentés. Par exemple, le package LinearAlgebra
contient des commandes pour la manipulation des matrices.
Vous pouvez utiliser une commande d’un package de trois manières.
1. Utilisez le nom complet du package, suivi de la commande désirée.
package [cmd ]( ... )
Si le package possède un sous-package, utilisez le nom complet du pac-

kage, le nom complet du sous-package, suivi de la commande désirée.
package[souspackage][cmd] (...)
Puis, entrez le nom abrégé de la commande.

cmd (...)
2. Activez les noms abrégés pour toutes les commandes d’un package en
utilisant la commande with.
with(package )
Si le package possède un sous-package, utilisez la commande with de

la manière suivante.
with(package[souspackage] )
cmd (...)
3. Activez le nom abrégé d’une seule commande d’un package.
with(package, cmd )
Si le package possède un sous-package, utilisez la commande with de

la manière suivante.
with(package[souspackage], cmd )
cmd (...)
Le prochain exemple utilise la commande Tangent du package

Student pour calculer la pente de la tangente de l’expression sin(x) au
point x = 0.
> with(Student[Calculus1]);
3.8 Les packages Maple • 81
[AntiderivativePlot , ApproximateInt , ArcLength,

Asymptotes , Clear , CriticalPoints , DerivativePlot ,
ExtremePoints , FunctionAverage, FunctionChart ,
GetMessage, GetNumProblems , GetProblem, Hint ,
InflectionPoints , Integrand , InversePlot ,
MeanValueTheorem, NewtonQuotient , NewtonsMethod ,
PointInterpolation, RiemannSum, RollesTheorem,
Roots , Rule, Show , ShowIncomplete, ShowSteps,
Summand , SurfaceOfRevolution, Tangent ,
TaylorApproximation, Understand , Undo,
VolumeOfRevolution, WhatProblem]
> Tangent(sin(x), x = 0);
Lorsque vous utilisez with(package ), vous voyez apparaı̂tre une liste

de tous les noms abrégés des commandes du package. De plus, Maple vous
avertit lorsqu’il redéfinit des noms déjà existants.
3.8 Les packages Maple

Les packages inclus dans Maple permettent d’effectuer des tâches dans
de nombreuses disciplines, du calcul différentiel élémentaire à la théorie
générale de la relativité. Les exemples de cette section ne se veulent pas
détaillés et complets : ils ne sont que des illustrations de quelques com-
mandes dans des packages particuliers qui vous donneront un aperçu des
capacités de Maple.
Liste des packages

Vous trouverez la liste de packages suivante dans la page d’aide
?packages. Pour obtenir une liste complète des commandes d’un package
en particulier, consultez la page d’aide ?nomdupackage .
algcurves Outils pour l’étude des variétés (courbes) algébriques unidi-
mensionnelles définies par des polynômes multivariés.
codegen Outils de création, de manipulation et de traduction de procé-
dures Maple en d’autres langages. Ce package permet la différentiation
automatique, l’optimisation de code, la traduction en C et en FOR-

TRAN, etc.
CodeGeneration Fonctions qui traduisent un programme Maple en
d’autres langages de programmation.
combinat Fonctions combinatoires incluant des commandes pour calculer
les permutations et les combinaisons de listes, de même que les parti-
tions entières. (Utilisez plutôt le package combstruct lorsque cela est
possible.)
combstruct Commandes qui permettent de générer et de compter les
structures combinatoires ainsi que de déterminer les équations des
fonctions génératrices permettant ce comptage.
context Outils de construction et de modification des menus contextuels
de l’interface graphique de Maple (affichés, par exemple, en cliquant
sur une expression avec le bouton de droite de la souris).
CurveFitting Commandes qui permettent de tracer des courbes de ten-
dances.
DEtools Outils de manipulation, de résolution et d’affichage des systèmes
d’équations différentielles ; espaces de phases et graphiques de champs.
diffalg Commandes de manipulation de systèmes d’équations différen-
tielles polynomiales (EDO ou EDP).
difforms Commandes de gestion des formes différentielles ; dédié aux
problèmes de géométrie différentielle.
Domains Commandes qui permettent de créer des domaines de calcul
(domains of computation en anglais) ; supporte le calcul sur les
polynômes, les matrices de même que les séries sur des anneaux de
nombres, les anneaux finis, les anneaux de polynômes et les anneaux
de matrices.
ExternalCalling Commandes effectuant des liens vers des fonctions ex-
ternes.
finance Commandes de calcul financier.
GaussInt Commandes qui permettent de travailler sur les nombres de
la forme a + bI (où a et b sont entiers) que l’on appelle les entiers
gaussiens ; commandes de calcul du PGCD, de factorisation et de
tests de primalité.
genfunc Commandes de manipulation des fonctions génératrices ration-
nelles.
geom3d Commandes de géométrie euclidienne tridimensionnelle pour
définir et manipuler en trois dimensions points, lignes, plans, triangles,
sphères, polyèdres, etc.
geometry Commandes de géométrie euclidienne bidimensionnelle servant

à définir et à manipuler en deux dimensions points, lignes, triangles
et cercles.
Groebner Commandes pour les calculs en base de Gröbner ; en particu-
lier, outils de calcul pour les algèbres de Ore et les D-modules.
group Commandes permettant de travailler avec les groupes de permu-
tations et les groupes finiment présentés.
inttrans Commandes qui permettent de travailler avec les transforma-
tions d’intégrales et leurs inverses.
LibraryTools Commandes de manipulation et de traitement de biblio-
thèques.
liesymm Commandes servant à caractériser les symétries de contact des
systèmes d’équations aux dérivées partielles.
linalg Plus de 100 commandes de manipulation matricielle et vecto-
rielle ; de l’addition de matrices aux vecteurs et valeurs propres.
LinearAlgebra Commandes d’algèbre linéaire améliorées servant à créer
des types spéciaux de matrices, calculer avec de grandes matrices nu-
mériques et effectuer des opérations d’algèbre matricielle.
LinearFunctionalSystems Commandes qui permettent de résoudre des
systèmes linéaires de fonctions avec des coefficients polynomiaux,
déterminent le dénominateur universel d’une solution rationnelle et
transforment un système de récurrence matriciel en un système
équivalent avec une matrice de tête ou de queue non singulière.
ListTools Commandes de manipulation de listes.
LREtools Commandes de manipulation, d’affichage et de résolution de
relations de récurrence linéaire.
Maplets Commandes permettant de créer des fenêtres, des boı̂tes de dia-
logue et d’autres interfaces visuelles qui interagissent avec l’utilisateur.
MathML Commandes qui importent et exportent des expressions Maple en
texte MathML.
Matlab Commandes qui exploitent plusieurs des fonctions matricielles nu-
mériques de Matlab, incluant les valeurs et les vecteurs propres, les
déterminants et la décomposition LU. (Ce package est accessible seule-
ment si Matlab est installé sur votre système.)
MatrixPolynomialAlgebra Ensemble d’outils de manipulation algé-
brique des polynômes matriciels.
networks Outils de construction, de traçage et d’analyse des réseaux

combinatoires. Outils de gestion des graphes orientés et d’expressions
arbitraires pour les poids des nœuds et des arêtes.
numapprox Commandes de calcul d’approximations polynomiales de fonc-
tions sur un intervalle donné.
numtheory Commandes de théorie des nombres classique, tests de pri-
malité, calcul du n-ième nombre premier, génération de polynômes
d’unités cyclotomiques. Ce package contient également des com-
mandes de gestion des convergents.
Ore_algebra Routines de calcul de base dans les algèbres d’opérateurs
linéaires.
OrthogonalSeries Commandes de manipulation de séries de polynômes
orthogonaux classiques ou, de manière plus générale, de polynômes
hypergéométriques.
orthopoly Commandes servant à générer différents types de polynômes
orthogonaux ; ce package s’avère utile pour la résolution d’équations
différentielles.
padic Commandes de calcul des approximations p-adiques de nombres
réels.
PDEtools Outils de manipulation, de résolution et d’affichage d’équations
aux dérivées partielles.
plots Commandes pour différents types de graphiques spécialisés, in-
cluant les graphiques d’isovaleurs, les graphiques bidimensionnels et
tridimensionnels de fonctions implicites, l’affichage de texte et de gra-
phiques dans différents systèmes de coordonnées.
plottools Commandes servant à générer et à manipuler des objets gra-
phiques.
PolynomialTools Commandes de manipulation d’objets polynomiaux.
polytools Commandes de manipulation d’objets polynomiaux.
powseries Commandes servant à créer et manipuler des séries entières
formelles représentées par leur terme général.
process Commandes permettant d’écrire des programmes Maple multi-
processus sous UNIX.
RandomTools Commandes permettant de travailler avec des objets aléa-
toires.
RationalNormalForms Commandes permettant de construire la forme
normale polynomiale ou les formes rationnelles canoniques d’une fonc-
tion rationnelle, ou la représentation minimale d’un terme hypergéo-
métrique.
RealDomain Fournit un environnement dans lequel le système de nombres

assumé est le système des nombres réels, et non le système des nombres
complexes.
ScientificConstants Commandes donnant accès aux valeurs de diffé-
rentes quantités physiques utilisées couramment en physique ou en
chimie.
simplex Commandes d’optimisation linéaire utilisant la méthode du sim-
plexe.
Slode Commandes servant à trouver des solutions à des EDO linéaires
sous forme de séries entières.
Sockets Commandes permettant les communications réseau avec Maple.
Les routines de ce package vous permettent de vous connecter à des
processus situés sur des hôtes distants (par Internet ou Intranet) et
échanger des données avec ces processus.
SolveTools Commandes qui permettent de résoudre des systèmes
d’équations algébriques. Ce package donne aux utilisateurs expéri-
mentés l’accès aux routines appliquées par la commande solve pour
un meilleur contrôle du processus de résolution.
Spread Outils permettant de travailler avec les feuilles de calcul dans
Maple.
stats Manipulation statistique de données ; inclut des commandes pour
le calcul de la moyenne, l’écart type, les coefficients de corrélation, la
variance et l’analyse de régression.
StringTools Commandes optimisées de manipulation des chaı̂nes de ca-
ractères.
Student Sous-packages spécifiques à certains cours. Dans des versions
futures de Maple, ce package sera élargi pour inclure d’autres sous-
packages liés à l’enseignement. Le premier de ceux-ci est Calculus1.
Calculus1 Commandes permettant de décortiquer les étapes de la
différentiation, de l’intégration et du calcul des limites, la visua-
lisation de la méthode de Newton, les sommes de Riemann, la
longueur d’arc, les volumes de révolution, de même que des rou-
tines pour trouver les points critiques d’une expression.
sumtools Commandes de calcul de sommes définies et indéfinies. Com-
prend les algorithmes de Gosper et de Zeilberger.
Sumtools Outils permettant de calculer des formes fermées de sommes
définies et indéfinies.
tensor Commandes permettant le calcul tensoriel et ses applications à
la théorie générale de la relativité.
Le package Student Calculus1 (une variable)

Le package Student[Calculus1] vous aide à effectuer les calculs de
différentiation, d’intégration et de limites. Considérez le problème sui-
vant : trouvez la dérivée de la fonction 4 ∗ x2 .
> with(Student[Calculus1]):
> infolevel[Student] := 1:
Pour voir la liste de toutes les commandes chargées par Maple, remplacez
les deux points par le point-virgule à la fin de la commande.
> Diff(4*x^2, x);
d
(4 x2 )
dx
Utilisez la règle constantmultiple.

> Rule[constantmultiple](%);
Creating problem #1
d d
(4 x2 ) = 4 ( (x2 ))
dx dx
Utilisez la règle power.

> Rule[power](%);
d
(4 x2 ) = 8 x
dx
Considérez maintenant cet exemple d’intégration. Intégrez x∗cos(x)+

x entre x = 0 et x = π.
> Int(x*cos(x) + x, x=0..Pi);
π
x cos(x) + x dx
0
Utilisez la règle sum.

> Rule[sum](%);
Creating problem #2
π π π
x cos(x) + x dx = x cos(x) dx + x dx
0 0 0
Utilisez la règle power.

> Rule[power](%);
π π
1 2
x cos(x) + x dx = x cos(x) dx + π
0 0 2
Employez la commande Hint pour obtenir un indice sur la prochaine

étape de résolution du problème.
> Hint(%);
[parts , x, sin(x)]
Utilisez cet indice avec la commande Rule.

> Rule[%](%%);
π π
1
x cos(x) + x dx = − sin(x) dx + π 2
0 0 2
Servez-vous de la règle sin pour terminer le calcul.

> Rule[sin](%);
π
1 2
x cos(x) + x dx = −2 + π
0 2
Employez le package Student[Calculus1] pour calculer la limite de

(1 + 1/x)x .
Utilisez la commande Understand pour spécifier des règles qui servi-
ront au calcul d’une limite par la commande Limit sans les appliquer
directement. Spécifiez à Understand les règles de la constante, de la
constante multiplicative, de la puissance et de la somme pour le pro-
chain exemple.
> Understand(Limit, constant, ‘c*‘, power, sum);
Limit = [constant , constantmultiple, power , sum]
> Limit((1 + 1/x)^x, x=infinity);
1 x
lim (1 + )
x→∞ x
Demandez un indice à propos de la prochaine étape à effectuer.

> Hint(%);
Creating problem #3
Rewrite the expression as an exponential to prepare for

using l‘Hopital’s rule
1 x 1
[rewrite, (1 + ) = e(x ln(1+ x )) ]
x
Utilisez la règle donnée par Hint.

> Rule[%](%%);
1 x 1
lim (1 + ) = lim e(x ln(1+ x ))
x→∞ x x→∞
> Hint(%);
[exp]
> Rule[%](%%);
1 x x ln(1+ x1 ))
lim (1 + ) = e(limx→∞
x→∞ x
> Hint(%);
1
[lhopital , ln(1 + )]
x
> Rule[%](%%);
1 x x
lim (1 + ) = e(limx→∞ x+1
)
x→∞ x
> Hint(%);
 
 x 1 
rewrite, =
1
x+1
1+
x
> Rule[%](%%);
1 x
lim (1 + ) =e
x→∞ x
Considérez la fonction −2/3 ∗ x2 + x. Tracez-en le graphique, de même

que la pente de sa tangente en x = 0.
> Tangent(-2/3*x^2+x, x=0, -2..2, output=plot,
> showtangent=true);
TheTangenttotheGraphof
f(x)=–2/3*x^2+x
atthePoint(0,f(0))
1
x
–2 –1 1 2
–1
–2
–3
–4
–5
f(x)
Thetangentatx=0
En quel endroit cette courbe traverse-t-elle l’axe des x ?

> Roots(-2/3*x^2+x);
3
[0, ]
2
Vous pouvez calculer l’aire sous la courbe entre ces deux points au
moyen de sommes de Riemann.
> ApproximateInt(-2/3*x^2+x, x=0..3/2, method=midpoint,

> output=plot, view=[0..1.6, -0.15..0.4]);
AnApproximationoftheIntegralof
f(x)=–2/3*x^2+x
ontheInterval[0,3/2]
UsingaMidpointRiemannSum
ApproximateValue:.3750000000
0.4
0.3
0.2
0.1
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6

x
–0.1
–0.2
Area:.3768750000
f(x)
Puisque le résultat n’est pas une bonne approximation, augmentez

à 40 le nombre de boı̂tes utilisées.
> output=plot, view=[0..1.6, -0.15..0.4],
> partition=40);
f(x)=–2/3*x^2+x
ontheInterval[0,3/2]
UsingaMidpointRiemannSum
ApproximateValue:.3750000000
0.4
0.3
0.2
0.1
0 0.2 0.4 0.6 0.8 1 1.2 1.4 1.6

x
–0.1
–0.2
Area:.3751171867
f(x)
Quelle est la valeur exacte ? Utilisez d’abord n boı̂tes et calculez la

formule de la somme.
> output=sum, partition=n);
 
1 2 1

n−1
 3
(i + ) i +
− 2 +3 2
2 n 2 2 n
i=0
3
2 n
Prenez ensuite la limite lorsque n tend vers ∞.

> Limit( %, n=infinity );
 
1 2 1

n−1
 3
(i + ) i +
− 2 +3 2
2 n 2 2 n
i=0
3
lim
n→∞ 2 n
> value(%);
3
8
Remarquez maintenant que vous pouvez obtenir le même résultat au

moyen d’une intégrale.
> Int(-2/3*x^2+x, x=0..3/2 );
3/2
2 2
− x + x dx
0 3
> value(%);
3
8
Pour plus d’information sur le calcul différentiel avec Maple, reportez-

vous au chapitre 6.
Le package LinearAlgebra
En algèbre linéaire, un ensemble de vecteurs linéairement indépendants
qui engendrent l’espace vectoriel se nomme une base. Il est possible d’ex-
primer n’importe quel élément de l’espace vectoriel comme une combinai-
son linéaire des éléments de la base.
Un ensemble de vecteurs {v1 , v2 , v3 , . . . , vn } est linéairement indépen-
dant si et seulement si, lorsque
c1 v1 + c2 v2 + c3 v3 + · · · + cn vn = 0
alors
c1 = c2 = c3 = · · · = cn = 0.
Problème : Déterminer une base de l’espace vectoriel généré par les

vecteurs [1, −1, 0, 1], [5, −2, 3, −1] et [6, −3, 3, 0]. Exprimer le vecteur
[1, 2, 3, −5] par rapport à cette base.
Solution : Entrer les vecteurs.
> with(LinearAlgebra):
> v1:=<1|-1|0|1>:
> v2:=<5|-2|3|-1>:
> v3:=<6|-3|3|0>:
> vector_space:=<v1,v2,v3>;
 
1 −1 0 1
vector _space :=  5 −2 3 −1 
6 −3 3 0
Si les vecteurs sont linéairement indépendants, il forment une base.

Pour vérifier l’indépendance linéaire, écrivez l’équation c1 v1 +c2 v2 +c3 v3 =
0.
c1 [1, −1, 0, 1] + c2 [5, −2, 3, −1] + c3 [6, −3, 3, 0] = [0, 0, 0, 0]
Cette équation est équivalente à
c1 + 5c2 + 6c3 = 0
−c1 − 2c2 − 3c3 = 0
3c2 + 3c3 = 0
c1 − c2 = 0
> LinearSolve( Transpose(vector_space), <0,0,0,0> );

 
−_t3 3
 −_t3 3 
_t3 3
Les vecteurs sont linéairement dépendants puisque chacun est un pro-

duit linéaire d’une variable. Ils ne peuvent donc pas former une base. La
commande RowSpace retourne une base pour un espace vectoriel donné.
> b:=RowSpace(vector_space);
b := [[1, 0, 1, −1], [0, 1, 1, −2]]

> b1:=b[1]; b2:=b[2];
b1 := [1, 0, 1, −1]
b2 := [0, 1, 1, −2]
> basis:=<b1,b2>;

1 0 1 −1
basis :=
0 1 1 −2
Exprimer [1, 2, 3, −5] en coordonnées par rapport à cette base.

> LinearSolve( Transpose(basis), <1|2|3|-5> );

1
2
Pour obtenir davantage d’information à propos de ce package, exécu-

tez la commande ?LinearAlgebra.
Le package Matlab
Le package Matlab vous permet d’appeler certaines fonctions de Matlab à
partir d’une session Maple, en supposant que Matlab soit installé sur votre
système 1 . Matlab est une abréviation de matrix laboratory (laboratoire
de matrices) et est un package de calcul numérique fort populaire, utilisé
par des ingénieurs et d’autres professionnels.
On doit d’abord établir une connexion entre les deux produits avec
> Matlab[openlink]();
Pour déterminer les valeurs et les vecteurs propres d’une matrice d’en-
tiers, on définit d’abord la matrice souhaitée avec la syntaxe de Maple.
> A := Matrix([1,2,3],[1,2,3],[2,5,6]]):
On appelle ensuite la commande eig de Matlab.
1
Il existe également un Symbolic Computation Toolbox disponible pour Matlab qui
vous permet d’appeler des commandes Maple depuis Matlab.
> P,W := Matlab[eig](A, eigenvectors=true):
Remarquez ce qui se trouve à la gauche de l’opérateur d’affectation.

Le (P,W) spécifie que deux objets seront générés et assignés aux variables
— les valeurs propres, à W, et les vecteurs propres, à P. L’affectation
multiple est également possible avec les commandes Maple, mais, puisque
les commandes Maple existantes sont conçues pour ne retourner qu’un
seul résultat, cette fonctionnalité est peu utilisée.
Examinons les résultats.
> W;
 
9.321825 0. 0.
 
 0. −.5612673 10−15 0. 
 
0. 0. −.3218253
> P;
 
−.3940365889964673 −.9486832980505138 −.5567547110202646
 
 −.3940365889964672 −2.758331802155925 10−16 −.5567547110202655 
 
−.8303435030540421 .3162277660168383 .6164806432593667
Les commandes de ce package peuvent également prendre comme pa-

ramètres des données en format Matlab. Consultez l’aide sous la rubrique
Matlab pour obtenir plus d’information sur les données Matlab acceptées
par Maple.
Le package Statistics
Le package stats possède plusieurs commandes d’analyse et de mani-
pulation de données, de même que plusieurs types de graphiques utilisés
en statistique. Il contient également un grand éventail de distributions
statistiques.
stats est un exemple de package renfermant des sous-packages (sub-
packages en anglais). À l’intérieur de chaque sous-package se trouvent
plusieurs commandes groupées par fonctionnalité.
> with(stats);
[anova, describe, fit , importdata, random, statevalf ,

statplots , transform]
Le package stats traite les données sous la forme de listes statis-

tiques , qui peuvent être de simples listes Maple. Une liste statistique peut
également contenir des intervalles et des valeurs auxquelles des poids ont
été assignés. La différence se comprend plus facilement au moyen d’un
exemple. marks est une liste standard,
> marks :=
> [64,93,75,81,45,68,72,82,76,73];
marks := [64, 93, 75, 81, 45, 68, 72, 82, 76, 73]
tout comme readings,

> readings := [ 0.75, 0.75, .003, 1.01, .9125,
> .04, .83, 1.01, .874, .002 ];
readings :=
[.75, .75, .003, 1.01, .9125, .04, .83, 1.01, .874, .002]
qui sont équivalentes à cette liste statistique.
> readings := [ Weight(.75, 2), .003, Weight(1.01, 2),
> .9125, .04, .83, .874, .002 ];
readings := [Weight(.75, 2), .003, Weight(1.01, 2),

.9125, .04, .83, .874, .002]
L’expression Weight(x,n ) indique que la valeur x apparaı̂t n fois dans
la liste.
Si des différences de moins de 0, 01 sont suffisamment petites pour
être négligeables, il est possible de les regrouper et de ne spécifier qu’un
intervalle (en utilisant “..”).
> readings := [ Weight(.75, 2), Weight(1.01, 2), .9125,
> .04, .83, .874, Weight(0.002..0.003, 2) ];
readings := [Weight(.75, 2), Weight(1.01, 2), .9125, .04,

.83, .874, Weight(.002...003, 2)]
Le sous-package describe contient des commandes servant à l’analyse
de données.
> describe[mean](marks);
729
10
> describe[range](marks);
45..93
> describe[range](readings);
.002..1.01
> describe[standarddeviation](readings);
.4038750456
Ce package contient plusieurs distributions statistiques. Générez des

données aléatoires en utilisant la distribution normale, groupez-les en
classes et tracez un histogramme de ces classes.
> random_data:=[random[normald](50)];
random_data := [1.253885017, −.8364873682,

−.4386378394, −1.140005385, .1529160443,
.7487697029, −.4908898750, −.6385850228,
.7648245898, −.04721150696, −1.463572278,
.4470293004, 1.342701867, 2.162605068,
−.2620109124, .1093403084, −.9886372087,
−.7765483851, −.1231141571, .3876183720,
1.625165927, 1.095665255, −.2068680316,
−1.283733823, 1.583279600, .3045008349,
−.7304597374, .4996033128, .8670709448,
−.1729739933, −.6819890237, .005183053789,
.8876933468, −.3758638317, 1.452138520,
2.858250470, .6917100232, .6341448687,
.6707087107, .5872984199, .03801888006,
−.1238893314, −.01231563388, −.7709242575,
−1.599692668, .8181350112, .08547526754,
.09467224460, −1.407989130, .4128440679]
> ranges:=[-5..-2,-2..-1,-1..0,0..1,1..2,2..5];
ranges := [−5.. − 2, −2.. − 1, −1..0, 0..1, 1..2, 2..5]
> data_list:=transform[tallyinto](random_data,ranges);
data_list := [Weight(1..2, 6), Weight(−5.. − 2, 0),

Weight(2..5, 2), Weight(−2.. − 1, 5), Weight(0..1, 20),
Weight(−1..0, 17)]
> statplots[histogram](data_list);
20
15
10
–6 –4 –2 0 2 4 6
Le package d’optimisation linéaire

Le package simplex contient des commandes d’optimisation linéaire grâce
à l’utilisation de l’algorithme du simplexe. L’optimisation linéaire permet
de trouver des solutions optimales à des équations soumises à certaines
contraintes.
Un exemple classique d’optimisation est le problème de la livraison de
pizza. Imaginez-vous en livreur de pizza : vous devez livrer quatre pizzas
en quatre endroits différents dispersés dans la ville. Vous souhaitez livrer
toutes les quatre en utilisant le moins de carburant possible. Vous devez
également vous rendre aux quatre endroits en moins de vingt minutes,
de manière que les pizzas demeurent chaudes. Si vous créez des équations
mathématiques représentant les routes menant aux quatre endroits ainsi
que leurs distances respectives, vous pouvez trouver la solution optimale,
c’est-à-dire la solution qui vous fera utiliser le moins de carburant tout
en atteignant toutes les adresses dans le plus court délai possible. Les
contraintes de ce système particulier sont que vous devez avoir livré toutes
les quatre pizzas vingt minutes après avoir quitté le restaurant.
Voici un petit système en guise d’exemple.
> with(simplex);
Warning, the protected names maximize and minimize have

been redefined and unprotected
Warning, the name basis has been redefined
[basis , convexhull , cterm, define_zero, display , dual ,

feasible, maximize, minimize, pivot , pivoteqn, pivotvar ,
ratio, setup, standardize]
Supposons que vous souhaitez maximiser l’expression w
> w := -x+y+2*z;
w := −x + y + 2 z
soumise aux contraintes c1, c2 et c3.

> c1 := 3*x+4*y-3*z <= 23;
c1 := 3 x + 4 y − 3 z ≤ 23
> c2 := 5*x-4*y-3*z <= 10;
c2 := 5 x − 4 y − 3 z ≤ 10
> c3 := 7*x +4*y+11*z <= 30;
c3 := 7 x + 4 y + 11 z ≤ 30
> maximize(w, {c1,c2,c3});

Dans ce cas, l’absence de réponse signifie que Maple ne peut trouver de
solution. Vous pouvez utiliser la commande feasible pour vérifier que
l’ensemble des contraintes est valide.
> feasible({c1,c2,c3});
true
Essayez à nouveau, en ajoutant une restriction à la solution.

> maximize(w, {c1,c2,c3}, NONNEGATIVE);
1 49
{x = 0, z = , y = }
2 8
3.9 Conclusion
Ce chapitre vous a présenté des caractéristiques fondamentales de Maple
qui vous aideront grandement à mesure que vous apprendrez de nouvelles
méthodes de résolution de problèmes plus complexes. La section 3.1 vous
a introduit aux commandes solve et fsolve de même qu’à leur utilisation
adéquate. Que vous utilisiez ou non les commandes solve, ces méthodes
s’avèreront utiles à de nombreuses reprises.
Les dernières sections du présent chapitre ont introduit les mani-
pulations, la commande solve et l’organisation de Maple et de ses bi-
bliothèques de manière à vous donner un avant-goût de son potentiel. À
ce point de votre lecture, vous ne connaissez pas encore tout à fait ce
logiciel. Vous en savez cependant suffisamment pour commencer à utiliser
Maple de manière efficace.
À votre guise, vous pouvez interrompre ici votre étude pour travailler
(ou jouer !) avec Maple.
4 Tracer des graphiques
Quelquefois, la meilleure manière de mieux comprendre une structure

mathématique consiste à en tracer le graphique. Maple peut produire
plusieurs formes de graphiques : en deux ou trois dimensions, animés ou
non, affichables selon n’importe quel angle. Maple peut gérer les formes
explicites, implicites et paramétriques et exploiter plusieurs systèmes de
coordonnées. La flexibilité de Maple vous permet de manipuler aisément
des graphiques dans de nombreuses situations.
4.1 Graphiques en deux dimensions

Lorsqu’on lui demande de tracer une fonction donnée explicitement y =
f (x), Maple doit connaı̂tre la fonction et son domaine.
> plot( sin(x), x=-2*Pi..2*Pi );
0.5
–6 –4 –2 0 2 4 6
x
–0.5
–1
Cliquer sur n’importe quel point de la fenêtre du graphique fait af-

ficher les coordonnées de ce point. Les menus (que l’on retrouve sur la
barre de menu ou en cliquant avec le bouton droit de la souris sur le gra-
phique lui-même) vous permettent de modifier plusieurs caractéristiques
101
102 • Chapitre 4: Tracer des graphiques
des graphiques et d’utiliser des options d’affichage résumées sous la ru-

brique ?plot,options.
Maple peut également tracer le graphe de fonctions définies par l’uti-
lisateur.
> f := x -> 7*sin(x) + sin(7*x);
f := x → 7 sin(x) + sin(7 x)
> plot(f(x), x=0..10);
6
4
2
0 2 4 6 8 10
–2 x
–4
–6
Maple vous permet d’examiner plus en détail des intervalles, à la fois

en x et en y.
> plot(f(x), x=0..10, y=4..8);
y6
40 2 4 6 8 10
x
Maple peut même gérer des domaines infinis.

> plot( sin(x)/x, x=0..infinity);
4.1 Graphiques en deux dimensions • 103
0 infinity
x
Les graphiques paramétriques

Certains graphiques ne peuvent être spécifiés explicitement ; en d’autres
mots, il est impossible d’exprimer la variable dépendante sous forme de
fonction y = f (x). Sur un cercle, par exemple, la plupart des valeurs de x
correspondent deux valeurs de y. Une solution consiste à rendre à la fois
x et y dépendantes d’un autre paramètre, par exemple t. Le graphique
généré à partir de ces fonctions se nomme un graphique paramétrique.
Utilisez la syntaxe suivante pour utiliser les graphiques paramétriques.
plot( [ x-expr, y-expr, parametre =intervalle ] )
Vous tracez ainsi une liste contenant x-expr, y-expr, le nom et l’intervalle
du paramètre. Par exemple :
> plot( [ t^2, t^3, t=-1..1 ] );
0.5
0 0.2 0.4 0.6 0.8 1
–0.5
–1
Les points (cos t, sin t) forment un cercle.

> plot( [ cos(t), sin(t), t=0..2*Pi ] );
0.5
–1 –0.5 0.5 1
–0.5
–1
Plutôt que de produire un cercle, le graphique ci-dessus ressemble da-

vantage à une ellipse puisque Maple, par défaut, déforme le graphique
pour lui faire prendre les dimensions de la fenêtre. Voici le même gra-
phique pour lequel on a spécifié le paramètre scaling=constrained. Il
est possible de changer l’échelle des axes en utilisant les menus ou l’option
scaling.
> plot( [ cos(t), sin(t), t=0..2*Pi ], scaling=constrained );
0.5
–1 –0.5 0.5 1
–0.5
–1
Le désavantage de constrained réside dans le fait que cette option

peut cacher d’importants détails lorsque les caractéristiques d’une dimen-
sion apparaissent à une échelle beaucoup plus petite que les autres. Le
graphique suivant est tracé sans l’option constrained (unconstrained).
> plot( exp(x), x=0..3 );
20
18
16
14
12
10
8
6
4
2
0 0.5 1 1.5 2 2.5 3
x
Voici maintenant le même graphique, tracé avec l’option

constrained.
> plot( exp(x), x=0..3, scaling=constrained);
20
18
16
14
12
10
8
6
4
2
012 3
x
Les coordonnées polaires

Les coordonnées cartésiennes (ordinaires) sont les coordonnées par défaut
de Maple et ne représentent qu’une des multiples manières de spécifier un
point dans l’espace ; les coordonnées polaires, (r, θ), peuvent également
être utilisées.
En coordonnées polaires, r est la distance du point à l’origine, et θ
représente l’angle entre l’axe des x et la ligne passant par le point donné
et l’origine.
Maple peut tracer une fonction en coordonnées polaires à l’aide de
la commande polarplot. Pour accéder à la forme abrégée de cette com-
mande, vous devez d’abord appeler la commande with(plots).
> with(plots):
Figure 4.1 Le système de coordonnées polaires
r
y
0 x
Utilisez la syntaxe suivante pour tracer les graphiques en coordonnées

polaires.
polarplot( r-expr, angle =intervalle )
En coordonnées polaires, vous pouvez spécifier le cercle explicitement en

entrant r = 1.
> polarplot( 1, theta=0..2*Pi, scaling=constrained );
0.5
–1 –0.5 0.5 1
–0.5
–1
Tout comme dans cette section à la page 103, le paramètre

scaling=constrained fait apparaı̂tre le cercle rond. Voici le graphique
de r = sin(3θ).
> polarplot( sin(3*theta), theta=0..2*Pi );
0.4
0.2
–0.8–0.6–0.4–0.2 0.2 0.4 0.6 0.8
0
–0.2
–0.4
–0.6
–0.8
–1
Le graphique de r = θ est une spirale.

> polarplot(theta, theta=0..4*Pi);
8
6
4
2
–5 5 10
–2
–4
–6
–8
–10
La commande polarplot accepte également les graphiques paramétri-

sés ; vous pouvez donc exprimer le rayon et les coordonnées angulaires en
fonction d’un paramètre, par exemple t. La syntaxe est similaire aux gra-
phiques paramétriques en coordonnées cartésiennes. Consultez la présente
section, page 103.
polarplot( [ r-expr, angle-expr, paramètre =intervalle ] )
Les équations r = sin(t) et θ = cos(t) définissent le graphique suivant.

> polarplot( [ sin(t), cos(t), t=0..2*Pi ] );
0.4
0.2
–1 –0.5 0.5 1
–0.2
–0.4
Voici le graphique de θ = sin(3r).

> polarplot( [ r, sin(3*r), r=0..7 ] );
0 1 2 3 4 5 6
–2
–4
Les fonctions discontinues

Les fonctions possédant des discontinuités demandent davantage d’at-
tention. Considérez par exemple la fonction suivante, qui possède deux
discontinuités en x = 1 et x = 2.

 −1 si x < 1,
f (x) = 1 si 1 ≤ x < 2,

3 sinon.
Voici comment définir f (x) dans Maple.

> f := x -> piecewise( x<1, -1, x<2, 1, 3 );
f := x → piecewise(x < 1, −1, x < 2, 1, 3)
> plot(f(x), x=0..3);

0 0.5 1 1.5 2 2.5 3

x
–1
Maple dessine des lignes presque verticales près d’un point de discon-
tinuité. L’option discont=true indique qu’il peut y avoir des disconti-
nuités.
> plot(f(x), x=0..3, discont=true);
0 0.5 1 1.5 2 2.5 3

x
–1
Les fonctions qui possèdent des singularités (qui deviennent arbitrai-

rement grandes en un certain point) forment un autre cas particulier. La
fonction x → 1/(x − 1)2 possède une singularité en x = 1.
> plot( 1/(x-1)^2, x=-5..6 );
250000
200000
150000
100000
50000
–4 –2 0 2 4 6
x
Dans le graphique précédent, tous les détails intéressants du graphique

sont perdus en raison du pic en x = 1. La solution consiste à visualiser la
fonction sur un intervalle restreint, par exemple entre y = −1 et y = 7.
> plot( 1/(x-1)^2, x=-5..6, y=-1..7 );
7
6
5
4
y
3
2
1
–4 –2 0 2 4 6
–1 x
π
La fonction tangente possède plusieurs singularités en x = 2 + πn, où
n est un entier.
> plot( tan(x), x=-2*Pi..2*Pi );
3000
2000
1000
–6 –4 –2 2 4 6
x
Pour en voir les détails, on réduit l’intervalle entre y = −4 et y = 4,

par exemple.
> plot( tan(x), x=-2*Pi..2*Pi, y=-4..4 );
4
3
y 2
1
–6 –4 –2 0 2 4 6
–1 x
–2
–3
–4
Maple dessine des lignes presque verticales près des singularités ; vous
devez donc utiliser l’option discont=true.
> plot( tan(x), x=-2*Pi..2*Pi, y=-4..4, discont=true );
4
3
y 2
1
–6 –4 –2 0 2 4 6
–1 x
–2
–3
–4
Graphiques multiples
Pour tracer plus d’une fonction dans un même graphique, il suffit de
donner à la commande plot une liste de fonctions.
> plot( [ x, x^2, x^3, x^4 ], x=-10..10, y=-10..10 );
10
8
6
y
4
2
–10 –8 –6 –4 –2 0 2 4 6 8 10
–2 x
–4
–6
–8
–10
> f := x -> piecewise( x<0, cos(x), x>=0, 1+x^2 );
f := x → piecewise(x < 0, cos(x), 0 ≤ x, 1 + x2 )
> plot( [ f(x), diff(f(x), x), diff(f(x), x, x) ],

> x=-2..2, discont=true );
–2 –1 0 1 2
x
–1
Cette technique fonctionne également pour les graphiques paramé-

triques.
> plot( [ [ 2*cos(t), sin(t), t=0..2*Pi ],
> [ t^2, t^3, t=-1..1 ] ], scaling=constrained );
0.5
–2 –1 1 2
–0.5
–1
En utilisant différents styles de ligne (par exemple continue ou poin-

tillée), il est aisé de distinguer différentes fonctions dans un même gra-
phique en spécifiant le paramètre linestyle. Dans l’exemple suivant,
Maple utilise linestyle=SOLID pour la première fonction, sin(x)/x et
linestyle=DOT pour la seconde fonction, cos(x)/x.
> plot( [ sin(x)/x, cos(x)/x ], x=0..8*Pi, y=-0.5..1.5,
> linestyle=[1,4] );
1.4
1.2
1
y0.8
0.6
0.4
0.2
0 5 10 15 20 25
–0.2 x
–0.4
Vous pouvez également changer le style de ligne en utilisant les menus

standard et contextuels. De manière similaire, vous pouvez spécifier les
couleurs des graphiques au moyen de l’option color. (Vous pouvez en
voir l’effet sur un affichage en couleurs, contrairement au présent livre qui
n’affiche les lignes que selon différentes teintes de gris.)
> plot( [ [f(x), D(f)(x), x=-2..2],
> [D(f)(x), (D@@2)(f)(x), x=-2..2] ],
> color=[gold, plum] );
0 1 2 3 4 5
–1
Consultez la rubrique ?plot,color pour obtenir plus de détails sur

les couleurs dans Maple.
Tracer des points

Pour tracer des données numériques, appelez la fonction pointplot en
spécifiant les données dans une liste de listes de la forme
[[x1 , y1 ], [x2 , y2 ], . . . , [xn , yn ]].
Si la liste est longue, donnez-lui un nom.

> data_list:=[[-2,4],[-1,1],[0, 0],[1,1],[2,4],[3,9],[4,16]];
data_list :=
[[−2, 4], [−1, 1], [0, 0], [1, 1], [2, 4], [3, 9], [4, 16]]
> pointplot(data_list);
16
14
12
10
8
6
4
2
–2 –1 0 1 2 3 4
Par défaut, Maple ne relie pas les points par des lignes droites ; l’option
style=line oblige à tracer ces lignes. Vous pouvez également utiliser les
menus pour indiquer à Maple de tracer les lignes.
> pointplot( data_list, style=line );
16
14
12
10
8
6
4
2
–2 –1 0 1 2 3 4
Vous pouvez changer l’apparence des points eux-mêmes à l’aide des

menus ou des options symbol et symbolsize.
> data_list_2:=[[1,1], [2,2], [3,3], [4,4]];
data_list _2 := [[1, 1], [2, 2], [3, 3], [4, 4]]
> pointplot(data_list_2, style=point, symbol=cross,

> symbolsize=16);
3.5
2.5
1.5
1
1 1.5 2 2.5 3 3.5 4
Utilisez le package CurveFitting pour lisser une courbe passant par

une suite de points et appelez la commande plot pour en voir le résultat.
Pour plus d’information, reportez-vous à la rubrique ?CurveFitting.
Raffiner des graphiques

Maple comporte un algorithme de tracé adaptatif. Il calcule la valeur de
la fonction en un nombre raisonnable de points approximativement é-
quidistants dans l’intervalle spécifié. Il décide ensuite de calculer plus de
points dans les intervalles où les valeurs fluctuent davantage. Cependant,
il peut arriver que cet algorithme adaptatif ne donne pas de résultats
satisfaisants.
> plot(sum((-1)^(i)*abs(x-i/10), i=0..30), x=-1..4);
3.4
3.2
2.8
2.6
–1 0 1 2 3 4 5 6
x
Pour raffiner ce graphique, on peut indiquer à Maple de calculer da-

vantage de points.
> plot(sum((-1)^(i)*abs(x-i/10), i=0..30), x=-1..4,
> numpoints=500);
3.4
3.2
2.8
2.6
–1 0 1 2 3 4 5 6
x
Consultez ?plot et ?plot,options pour en connaı̂tre davantage.
4.2 Graphiques en trois dimensions

Vous pouvez tracer le graphique d’une fonction de deux variables comme
une surface dans l’espace tridimensionnel. Cela vous permet de visualiser
cette dernière. La syntaxe de plot3d est similaire à celle de plot. Encore
une fois, une fonction donnée explicitement, z = f (x, y), est la plus facile
à tracer.
> plot3d( sin(x*y), x=-2..2, y=-2..2 );
Vous pouvez faire tourner le graphique en cliquant sur la fenêtre avec

votre souris et en faisant bouger la boı̂te qui en définit le contour. Les
menus vous permettent de modifier plusieurs caractéristiques d’un gra-
phique.
Tout comme plot, plot3d peut tracer des fonctions définies par l’uti-
lisateur.
4.2 Graphiques en trois dimensions • 117
> f := (x,y) -> sin(x) * cos(y);
f := (x, y) → sin(x) cos(y)
> plot3d( f(x,y), x=0..2*Pi, y=0..2*Pi );
Par défaut, Maple affiche le graphique comme une surface colorée,

mais il est possible de modifier cette option en utilisant les menus ou
le paramètre style. Par exemple, style=hidden dessine le graphique
comme une structure en fil de fer.
> plot3d( f(x,y), x=0..2*Pi, y=0..2*Pi, style=hidden );
Consultez ?plot3d,options pour obtenir une liste des options de

style.
Le domaine du deuxième paramètre peut dépendre du premier pa-
ramètre.
> plot3d( sqrt(x-y), x=0..9, y=-x..x );
Les graphiques paramétriques

Certains graphiques ne peuvent être spécifiés explicitement ; en d’autres
mots, il est impossible d’exprimer la variable dépendante sous forme de
fonction z = f (x, y). La sphère en est un exemple. Comme pour les
graphiques bidimensionnels (consultez la section Les graphiques pa-
ramétriques de la page 103), une solution consiste à rendre à la fois
x, y et z dépendantes de deux autres paramètres, par exemple s et t.
Le graphique produit à partir de ces fonctions se nomme un graphique
paramétrique. Utilisez la syntaxe suivante pour spécifier les graphiques
paramétriques.
plot3d( [ x-expr, y-expr, z-expr ],

paramtre1 =intervalle, paramtre2 =intervalle )
En voici deux exemples.

> plot3d( [ sin(s), cos(s)*sin(t), sin(t) ],
> s=-Pi..Pi, t=-Pi..Pi );
> plot3d( [ s*sin(s)*cos(t), s*cos(s)*cos(t), s*sin(t) ],

> s=0..2*Pi, t=0..Pi );
Les coordonnées sphériques

Les coordonnées cartésiennes (ordinaires) sont les coordonnées par défaut
de Maple et ne représentent qu’une des multiples manières de spécifier un
point dans l’espace en trois dimensions ; les coordonnées sphériques sont
une autre option.
En coordonnées sphériques, les trois coordonnées sont r, la distance
du point à l’origine, l’angle θ dans le plan xy depuis l’axe des x et l’angle
φ depuis l’axe des z.
Figure 4.2 Le système de coordonnées sphériques
φ r
0
y
x θ
Maple peut tracer une fonction en coordonnées sphériques en utilisant

la commande sphereplot du package plots. Pour accéder à la forme
abrégée de cette commande, vous devez d’abord appeler la commande
with(plots). Pour éviter d’afficher la liste de toutes les commandes de
plots, tapez les deux-points plutôt que le point-virgule.
> with(plots):
Vous pouvez utiliser la commande sphereplot de la manière suivante.
sphereplot( r-expr, theta =intervalle, phi =intervalle )
Le graphique de r = (4/3)θ sin φ ressemble à ceci :

> sphereplot( (4/3)^theta * sin(phi),
> theta=-1..2*Pi, phi=0..Pi );
Le tracé d’une sphère en coordonnées sphériques est simple : il suffit

de spécifier le rayon, par exemple 1, et de laisser θ tourner tout le long de
l’équateur et φ tourner du pôle nord (φ = 0) au pôle sud (φ = π).
> sphereplot( 1, theta=0..2*Pi, phi=0..Pi,
> scaling=constrained );
(Consultez la section 4.1 pour une explication de l’option

constrained.)
La commande sphereplot accepte également les graphiques para-
métrisés, c’est-à-dire les graphiques qui spécifient le rayon et les deux
coordonnées d’angle en fonction de deux autres paramètres, par exemple s
et t. La syntaxe est similaire à celle d’un graphique paramétrique en deux
dimensions en coordonnées cartésiennes ; consultez la présente section à
la page 118.
sphereplot([ r-expr, theta-expr, phi-expr ],

param1 =intervalle, param2 =intervalle )
Ici, r = exp(s) + t, θ = cos(s + t) et φ = t2 .

> sphereplot( [ exp(s)+t, cos(s+t), t^2 ],
> s=0..2*Pi, t=-2..2 );
Les coordonnées cylindriques

On peut également spécifier un point dans le système cylindrique en
spécifiant les coordonnées r, θ et z. Ici, r et θ sont les cooronnées polaires
(voir la section 4.1) dans le plan xy et z est la coordonnée cartésienne
usuelle en z.
Figure 4.3 Le système de coordonnées cylindriques
0
y
x θ r
Maple trace les fonctions en coordonnées cylindriques au moyen de la

commande cylinderplot du package plots.
> with(plots):
Vous pouvez tracer les graphiques en coordonnées cylindriques en appli-
quant la syntaxe suivante :
cylinderplot( r-expr, angle =intervalle, z =intervalle )
Voici une version tridimensionnelle de la spirale montrée dans la sec-

tion 4.1.
> cylinderplot( theta, theta=0..4*Pi, z=-1..1 );
Les cônes sont facilement tracés en coordonnées cylindriques : il suffit

de spécifier r = z et de faire varier θ de 0 à 2π.
> cylinderplot( z, theta=0..2*Pi, z=0..1 );
cylinderplot accepte également les graphiques paramétriques. Leur

syntaxe est similaire à celle des graphiques paramétriques en coordonnées
cartésiennes. Consultez la section Les graphiques paramétriques de la
page 118.
cylinderplot( [ r-expr, theta-expr, z-expr ],

paramètre1 =intervalle,
paramètre2 =intervalle )
L’image suivante est un graphique de la fonction r = st, θ = s et

z = cos(t2 ).
> cylinderplot( [s*t, s, cos(t^2)], s=0..Pi, t=-2..2 );
Raffiner des graphiques

Si votre graphique n’est pas aussi lisse ou précis que vous le souhaitez,
vous pouvez indiquer à Maple d’en calculer plus de points. L’option le
permettant est
grid=[m, n ]
où m est le nombre de points à utiliser pour la première coordonnée, et n

le nombre de points à utiliser pour la seconde coordonnée.
> plot3d( sin(x)*cos(y), x=0..3*Pi, y=0..3*Pi, grid=[50,50] );
Dans le prochain exemple, un grand nombre de points (100) pour la

première coordonnée (theta) rend la spirale lisse. Cependant, la fonction
ne varie pas selon l’axe des z ; un nombre faible de points (5) est donc
suffisant.
> cylinderplot( theta, theta=0..4*Pi, z=-1..1, grid=[100,5] );
La valeur par défaut de grid est d’environ 25 points sur 25.
Modèles de coloriage et d’éclairage

Deux méthodes permettent colorier une surface en trois dimensions. Dans
la première, une ou plusieurs sources lumineuses colorées illuminent la
surface. Dans la seconde, la couleur de chaque point est fonction directe
de ses coordonnées.
Maple possède un grand nombre de configurations de sources lumi-
neuses donnant des résultats esthétiquement satisfaisants. Vous pouvez
choisir ces sources lumineuses par les menus ou au moyen de l’option
lightmodel. Pour colorier la surface directement, un certain nombre de
fonctions de coloriage prédéfinies est également disponible par les menus
ou au moyen de l’option shading.
L’usage simultané de sources lumineuses et de coloriage direct peut
compliquer le rendu des couleurs. Utilisez des sources lumineuses ou un
coloriage direct. Voici une surface coloriée avec un shading zgrayscale
sans éclairage.
> plot3d( x*y^2/(x^2+y^4), x=-5..5,y=-5..5,
> shading=zgrayscale, lightmodel=none );
4.3 L’animation • 125
Voici la même surface illuminée par le modèle d’éclairage light1 sans

coloriage (shading).
> plot3d( x*y^2/(x^2+y^4), x=-5..5,y=-5..5,
> shading=none, lightmodel=light1 );
Dans le présent manuel, les graphiques apparaissent en noir et blanc.

Essayez-les vous-même pour voir les effets de la couleur.
4.3 L’animation
Tracer des graphiques constitue une excellente manière de représenter
l’information ; cependant, des images statiques ne mettent pas toujours
en évidence certains comportements graphiques, comme la déformation
d’une balle qui rebondit.
Une animation Maple ressemble à une séquence d’images d’un film :
une suite de graphiques s’affichent rapidement l’un après l’autre. Les deux
commandes utilisées pour les animations, animate et animate3d, sont
définies dans le package plots. Souvenez-vous qu’il vous faut d’abord
entrer la commande with(plots) pour exploiter ensuite ces fonctions
sous leur forme abrégée.
L’animation en deux dimensions

Vous pouvez spécifier une animation bidimensionnelle selon la syntaxe qui
suit.
animate( y-expr, x =intervalle, temps =intervalle )
Les images suivantes sont un exemple d’animation.

> with(plots):
Warning, the name changecoords has been redefined
> animate( sin(x*t), x=-10..10, t=1..2 );
x x x x
x x x x
x x x x
x x x x
Pour faire défiler une animation, vous devez d’abord la sélectionner

en cliquant dessus. Puis, choisissez Play dans le menu Animation.
Par défaut, une animation en deux dimensions est formée de seize
graphiques (frames). Si le mouvement vous semble saccadé, vous pouvez
augmenter le nombre d’images. Notez cependant que le calcul d’un grand
nombre d’images demande beaucoup de temps et accapare beaucoup de
mémoire. La commande suivante peut être collée dans Maple pour pro-
duire une animation de 50 images.
> animate( sin(x*t), x=-10..10, t=1..2, frames=50);
Les options standard des commandes plot sont également disponibles.

Entrez l’exemple suivant dans Maple pour en voir l’animation.
> animate( sin(x*t), x=-10..10, t=1..2,
> frames=50, numpoints=100 );
Vous pouvez afficher n’importe quelle animation bidimensionnelle sous

la forme d’un graphique tridimensionnel statique. Par exemple, essayez de
tracer l’animation de sin(xt) ci-dessus comme une surface.
> plot3d( sin(x*t), x=-10..10, t=1..2, grid=[50,100],
> orientation=[135,45], axes=boxed , style=HIDDEN );
4.3 L’animation • 127
–1
10 1
x t
–10 2
Que vous préfériez une animation ou un graphique est une question de

goût et dépend des concepts que l’animation ou le graphique doit mettre
en évidence.
L’animation de graphiques paramétriques est également possible (con-
sultez la section 4.1 de la page 103).
> animate( [ a*cos(u), sin(u), u=0..2*Pi ], a=0..2 );
L’option coords indique à la commande animate d’utiliser un système

de coordonnées autre que les coordonnées cartésiennes.
> animate( theta*t, theta=0..8*Pi, t=1..4, coords=polar );
Pour voir les animations, entrez ces commandes dans Maple.
L’animation en trois dimensions

Utilisez la commande animate3d pour animer des surfaces en trois di-
mensions. Vous pouvez utiliser la commande animate3d de la manière
suivante.
animate3d( z-expr, x =intervalle, y =intervalle,

temps =intervalle )
Les images qui suivent sont un exemple d’une animation en trois di-
mensions.
> animate3d( cos(t*x)*sin(t*y),
> x=-Pi..Pi, y=-Pi..Pi, t=1..2 );
Par défaut, une animation tridimensionnelle est formée de huit gra-

phiques. De la même manière que pour les animations en deux dimensions,
vous pouvez indiquer à Maple le nombre de graphiques à tracer au moyen
du paramètre frames.
> animate3d( cos(t*x)*sin(t*y), x=-Pi..Pi, y=-Pi..Pi, t=1..2,
> frames=16 );
La section 4.2 explique le fonctionnement des graphiques tridimen-

sionnels paramétriques, que vous pouvez également animer.
4.4 Annoter des graphiques • 129
> animate3d( [s*time, t-time, s*cos(t*time)],

> s=1..3, t=1..4, time=2..4, axes=boxed);
2 2 2 2
2 2 2
–3
2 2
12
Pour animer une fonction dans un système de coordonnées différent

des coordonnées cartésiennes, utilisez l’option coords. Pour les coor-
données sphériques, par exemple, utilisez coords=spherical.
> animate3d( (1.3)^theta * sin(t*phi), theta=-1..2*Pi,
> phi=0..Pi, t=1..8, coords=spherical );
Pour les coordonnées cylindriques, utilisez coords=cylindrical.

> animate3d( sin(theta)*cos(z*t), theta=1..3, z=1..4,
> t=1/4..7/2, coords=cylindrical );
Pour obtenir une liste des systèmes de coordonnées acceptés par

Maple, consultez ?plots,changecoords.
4.4 Annoter des graphiques

Il est possible d’ajouter plusieurs types d’annotations textuelles aux gra-
phiques. L’option title imprime le titre choisi dans la fenêtre du gra-
phique, centré et près du haut.
> plot( sin(x), x=-2*Pi..2*Pi, title="Plot of Sine" );
PlotofSine
1
0.5
–6 –4 –2 0 2 4 6
x
–0.5
–1
Prenez note qu’en spécifiant le titre, vous devez placer des guillemets
doubles (") aux deux extrémités du texte. Ce détail est très important.
Maple utilise des guillemets doubles pour délimiter les chaı̂nes de ca-
ractères : il considère tout ce qui apparaı̂t entre les guillemets doubles
comme du texte qu’il doit prendre tel quel. Vous pouvez spécifier la po-
lice, le style et la taille du titre au moyen de l’option titlefont. Consultez
?plot,options ou ?plot3d,options.
> with(plots):
> sphereplot( 1, theta=0..2*Pi, phi=0..Pi,

> scaling=constrained, title="The Sphere",
> titlefont=[HELVETICA, BOLD, 24] );
TheSphere
L’option labels vous permet de créer des étiquettes aux axes, l’op-
tion labelsfont définit la police et le style des étiquettes et l’option
labeldirections permet de placer les étiquettes des axes verticale-
ment ou horizontalement. Remarquez que les étiquettes ne doivent pas
4.4 Annoter des graphiques • 131
forcément être identiques au nom des variables de l’expression dont vous

tracez le graphique.
> plot( x^2, x=0..3, labels=["time", "velocity"],
> labeldirections=[horizontal,vertical] );
3
2.5
2
time
1.5
1
0.5
2
8
0
4
velocity
Les étiquettes s’affichent seulement si les axes sont également affichés.

Dans le cas des graphiques tridimensionnels, les axes ne sont pas affichés
par défaut ; vous devez donc les spécifier.
> plot3d( sin(x*y), x=-1..1, y=-1..1,
> labels=["length", "width", "height"], axes=FRAMED );
0.8
height
–0.8
–1 –1
width length
1 1
L’option legend vous permet d’ajouter une légende de texte à votre

graphique.
> plot( [sin(x), cos(x)], x=-3*Pi/2..3*Pi/2, linestyle=[1,4],
> legend=["The Sine Function", "The Cosine Function"] );
0.5
–4 –2 2x 4
–0.5
–1
TheSineFunction
TheCosineFunction
Voyez également la section 4.5 à la page 134.
4.5 Les graphiques composites

Maple vous permet d’afficher plusieurs graphiques simultanément, après
avoir donné des noms aux graphiques individuels. Puisque la structure
interne des graphiques est généralement très longue à afficher, terminez
vos commandes d’affectation par deux points plutôt que par un point-
virgule.
> mon_graphique := plot( sin(x), x=-10..10 ):
Vous pouvez conserver le graphique pour un usage ultérieur, comme toute
autre expression. Affichez-le en utilisant la commande display définie
dans le package plots.
> with(plots):
> display( mon_graphique );
0.5
–10 –8 –6 –4 –2 0 2 4 6 8 10
x
–0.5
–1
La commande display permet de tracer plus d’un graphique à la fois.

Il suffit de lui spécifier une liste de graphiques.
4.5 Les graphiques composites • 133
> a := plot( [ sin(t), exp(t)/20, t=-Pi..Pi ] ):

> b := polarplot( [ sin(t), exp(t), t=-Pi..Pi ] ):
> display( [a,b] );
0.5
–1 –0.5 0 0.5 1
–0.5
–1
Cette technique vous permet d’afficher plusieurs graphiques de dif-

férents types sur les mêmes axes. Vous pouvez également afficher des
graphiques tridimensionnels et même des animations.
> c := sphereplot( 1, theta=0..2*Pi, phi=0..Pi ):
> d := cylinderplot( 0.5, theta=0..2*Pi, z=-2..2 ):
> display( [c,d], scaling=constrained );
Entrez la définition précédente de b et les commandes suivantes dans

Maple pour voir une animation et un graphique avec les mêmes axes.
> e := animate( m*x, x=-1..1, m=-1..1 ):
> display( [b,e] );
Si vous affichez deux animations ou plus ensemble, assurez-vous que

ces dernières possèdent toutes le même nombre d’images. Entrez l’exemple
suivant dans Maple pour voir deux animations simultanément.
> f := animate3d( sin(x+y+t), x=0..2*Pi, y=0..2*Pi, t=0..5,
> frames=20 ):
> g := animate3d( t, x=0..2*Pi, y=0..2*Pi, t=-1.5..1.5,
> frames=20):
> display( [f,g] );
Placer du texte dans les graphiques

Les options title et labels des commandes graphiques vous permettent
de placer des titres et des étiquettes dans vos graphiques. Les commandes
textplot et textplot3d vous donnent encore plus de flexibilité en vous
permettant de spécifier la position exacte des éléments de texte. Le pa-
ckage plots contient ces deux commandes.
> with(plots):
Vous pouvez utiliser textplot and textplot3d de la manière suivante.
textplot( [ x-coord, y-coord, "texte " ] ) ;

textplot3d( [ x-coord, y-coord, z-coord, "texte "] ) ;
Par exemple :
> a := plot( sin(x), x=-Pi..Pi ):
> b := textplot( [ Pi/2, 1, "Local Maximum" ] ):
> c := textplot( [ -Pi/2, -1, "Local Minimum" ] ):
> display( [a,b,c] );
1 LocalMaximum
0.5
–3 –2 –1 1 2 3
x
–0.5
LocalMinimum –1
Consultez la rubrique ?plots,textplot pour obtenir plus de détails

sur la manière de placer les éléments de texte avec précision. Utilisez l’op-
tion font pour spécifier la police de caractères employée pour l’affichage.
Dans le graphique suivant, l’origine, un point de selle, est indiquée par la
lettre P .
> d := plot3d( x^2-y^2, x=-1..1, y=-1..1 ):
> e := textplot3d( [0, 0, 0, "P"],
> font=[HELVETICA, OBLIQUE, 22], color=white ):
> display( [d,e], orientation=[68,45] );
4.6 Quelques graphiques particuliers • 135
4.6 Quelques graphiques particuliers

Le package plots contient plusieurs routines permettant de produire des
types de graphiques particuliers.
En voici quelques exemples. Pour obtenir davantage d’information sur
une commande particulière, consultez la rubrique ?plots,commande .
> with(plots):
Tracez des fonctions définies implicitement au moyen de implicitplot.

> implicitplot( x^2+y^2=1, x=-1..1, y=-1..1, scaling=
> constrained );
y 0.5
–1 –0.5 0 0.5 1
x
–0.5
–1
L’image ci-dessous est un graphique de la région satisfaisant aux

inégalités x + y < 5, 0 < x et x ≤ 4.
> inequal( {x+y<5, 0<x, x<=4}, x=-1..5, y=-10..10,
> optionsexcluded=(color=yellow) );
10
–1 1 2 3 4 5
–5
–10
Dans l’exemple suivant, l’axe vertical est tracé à une échelle logarith-
mique.
> logplot( 10^x, x=0..10 );
1e+10
1e+09
1e+08
1e+07
1e+06
1e+05
.1e5
.1e4
.1e3
.1e2
1. 2 4 6 8 10
x
Un graphique semilogplot possède un axe horizontal logarithmique.

> semilogplot( 2^(sin(x)), x=1..10 );
2
1.8
1.6
1.4
1.2
1
0.8
0.6
1. 2. 4. 7. .1e2
x
Maple peut également tracer des graphiques où les deux axes pos-
sèdent des échelles logarithmiques.
> loglogplot( x^17, x=1..7 );
1e+14
1e+13
1e+12
1e+11
1e+10
1e+09
1e+08
1e+07
1e+06
1e+05
.1e5
.1e4
.1e3
.1e2
1. 2. 4. 7.
x
Dans un densityplot, des teintes plus claires indiquent une plus

grande valeur de la fonction.
> densityplot( sin(x*y), x=-1..1, y=-1..1 );
y 0.5
–1 –0.5 0.5 1
x
–0.5
–1
Le long des courbes suivantes, la fonction sin(xy) est constante,

comme dans une carte topographique.
> contourplot(sin(x*y),x=-10..10,y=-10..10);
10
y 5
–10 –5 0 5 10
x
–5
–10
Une grille rectangulaire dans le plan complexe devient le graphique

suivant par la relation z → z 2 .
> conformal( z^2, z=0..2+2*I );
–4 –2 0 2 4
La commande fieldplot dessine un vecteur donné pour plusieurs

valeurs de x et y ; le graphique ainsi formé est un champ de vecteurs de
même type qu’un champ magnétique.
> fieldplot( [y*cos(x*y), x*cos(x*y)], x=-1..1, y=-1..1);
y 0.5
–1 –0.5 0.5 1
x
–0.5
–1
Maple peut dessiner des courbes dans l’espace à trois dimensions.

> spacecurve( [cos(t),sin(t),t], t=0..12 );
Ici, Maple gonfle la courbe précédente pour en faire un tube.

> tubeplot( [cos(t),sin(t),t], t=0..4*Pi, radius=0.5 );
La commande matrixplot affiche les valeurs d’un objet de type Ma-

trix.
> A := LinearAlgebra[HilbertMatrix](8):
> B := LinearAlgebra[ToeplitzMatrix]([1,2,3,4,-4,-3,-2,-1],
> symmetric):
> matrixplot( A+B, heights=histogram, axes=frame,
> gap=0.25, style=patch);
4
2
0
–2
–4
2 2
4 4
column 6 6 row
8 8
L’image suivante est une démonstration d’un graphique root locus .

> rootlocus( (s^5-1)/(s^2+1), s, -5..5, style=point,
> adaptive=false );
0.5
–0.5
–1
–1.5 –1 –0.5 0 0.5 1 1.5

La commande arrow affiche des flèches ou des vecteurs en deux ou

trois dimensions.
> plots[arrow]( [<2, 1>, <3, 2>], [<2, 5>, <1, 4>], difference,
> scaling=constrained );
1
1 1.5 2 2.5 3
En tapant ?plots à l’invite, vous obtiendrez une liste de tous les types
de graphiques possibles dans Maple.
4.7 Manipuler des objets graphiques

Le package plottools contient des commandes permettant de créer des
objets graphiques et de manipuler leurs graphiques correspondants. Utili-
sez with(plottools) pour accéder aux commandes par leur nom abrégé.
> with(plottools):
Les objets dans le package plottools ne s’affichent pas par eux-

mêmes ; on doit y accéder par la commande display définie dans le
package plots à l’aide de la commande with.
> with(plots):
Considérez l’exemple suivant.

> display( dodecahedron(), scaling=constrained, style=patch );
4.7 Manipuler des objets graphiques • 141
Donnez un nom à l’objet.

> s1 := sphere( [3/2,1/4,1/2], 1/4, color=red):
Remarquez que l’affectation se termine par deux points (:) ; si vous utili-
sez un point-virgule (;), Maple affiche une longue structure de graphique.
Encore une fois, vous devez utiliser display pour faire afficher le gra-
phique.
> display( s1, scaling=constrained );
Placez une seconde sphère dans l’image et faites afficher les axes.
> s2 := sphere( [3/2,-1/4,1/2], 1/4, color=red):
> display( [s1, s2], axes=normal, scaling=constrained );
–0.4 0.6
–0.20.4
0
1.3 0.2
1.4 0.4
1.5
1.6
1.7
Vous pouvez également créer des cônes au moyen de plottools.

> c := cone([0,0,0], 1/2, 2, color=khaki):
> display( c, axes=normal );
2
1.5
1
–0.4 0.5 –0.4
–0.2 –0.2
0.2 0.2
0.4 0.4
Expérimentez la capacité de Maple à faire tourner les objets.

> c2 := rotate( c, 0, Pi/2, 0 ):
> display( c2, axes=normal );
–2
0.4 –1.5
–0.4 0.2 –1
–0.2 –0.5
–0.2 0.2
–0.4 0.4
Vous pouvez aussi translater les objets.

> c3 := translate( c2, 3, 0, 1/4 ):
> display( c3, axes=normal );
4.7 Manipuler des objets graphiques • 143
0.6
–0.4 0.4
–0.20.2
0
0.2
1–0.2 0.4
1.5
2
2.5
3
La commande hemisphere crée un hémisphère. Vous pouvez spécifier

le rayon et les coordonnées de son centre ; sinon, n’écrivez rien entre les
parenthèses pour accepter les valeurs par défaut.
> cup := hemisphere():
> display( cup );
> cap := rotate( cup, Pi, 0, 0 ):

> display( cap );
Les côtés du dodécaèdre mentionné plus tôt dans cette section sont
tous des pentagones. Si vous élevez le point milieu de chaque penta-
gone au moyen de la commande stellate, l’objet résultant se nomme
un dodécaèdre étoilé.
> a := stellate( dodecahedron() ):
> display( a, scaling=constrained, style=patch );
> stelhs := stellate(cap, 2):

> display( stelhs );
Plutôt que de rendre le dodécaèdre étoilé, vous pouvez supprimer les

trois quarts de l’intérieur de chaque pentagone.
> a := cutout( dodecahedron(), 3/4 ):
> display( a, scaling=constrained, orientation=[45, 30] );
> hedgehog := [s1, s2, c3, stelhs]:

> display( hedgehog, scaling=constrained,
4.8 Code des graphiques des planches en couleurs • 145
> style=patchnogrid );
4.8 Code des graphiques des planches en

couleurs
Dans Maple, créer des graphiques impressionnants ne nécessite souvent
que quelques lignes de code, ainsi que le montrent les exemples de la
présente section. Cependant, d’autres graphiques demandent plusieurs
lignes de code. Les commandes utilisées pour les planches en couleurs1 qui
ne sont pas indiquées ici se trouvent dans le Maple Application Center.
Il existe deux manières d’accéder au Maple Application Center.
– Ouvrez le navigateur Internet de votre choix et entrez
http ://www.mapleapps.com
– Dans le menu Help de votre session Maple 8, choisissez Maple on
the Web, puis Application Center.
Pour accéder au code des planches qui n’est pas affiché dans ce manuel :
1. Accédez au Maple Application Center.
2. Rendez-vous au bas de la page. Dans la section Maple Tools, cliquez
sur Maple 8 Color Plates. Le code est disponible en format HTML
et sous forme de feuille Maple.
Des centaines de graphiques ainsi que des animations sont disponibles

dans la Maple Graphics Gallery et la Maple Animation Gallery. Pour
accéder à ces galeries, rendez-vous au Maple Application Center et cli-
quez sur Maple Graphics.
1
La plupart des planches en couleurs ont été exportées et dessinées dans POV-
RayTM . La duplication exacte des images peut de ce fait s’avérer difficile.
Note : Sur certains ordinateurs, il peut être nécessaire de diminuer la

valeur de l’option numpoints pour dessiner le graphique.
1. Problème de Dirichlet pour un cercle
> with(plots):
> setoptions3d(scaling=constrained, projection=0.5,
> style=patchnogrid):
> f1 := (x, y) -> 0.5*sin(10*x*y):
> f2 := t -> f1(cos(t), sin(t)):
> a0 := evalf(Int(f2(t), t=-Pi..Pi)/Pi):
> a := seq(evalf(Int(f2(t)*cos(n*t), t=-Pi..Pi)/Pi), n=1..50):
> b := seq(evalf(Int(f2(t)*sin(n*t), t=-Pi..Pi)/Pi), n=1..50):
> L := (r, s) -> a0/2+sum(’r^n*(a[n]*cos(n*s)+b[n]*sin(n*s))’,
> ’n’=1..50):
> q := plot3d([r*cos(s), r*sin(s), L(r, s)], r=0..1, s=0..2*Pi,
> color=[L(r, s), -L(r, s), 0.2], grid=[29, 100],
> numpoints=10000):
> p := tubeplot([cos(t), sin(t), f2(t), t=-Pi..Pi,
> radius=0.015], tubepoints=70, numpoints=1500):
> display3d({q, p}, orientation=[3, 89], lightmodel=light2);
2. Ensemble de Mandelbrot
L’ensemble de Mandelbrot est l’un des objets mathématiques les plus
complexes en raison de sa nature cahotique. Le code de ce graphique
est disponible dans le Maple Application Center.
3. Oiseau en origami
L’oiseau en origami peut être affiché comme un simple graphique ou
comme une animation Maple. Le code de ce graphique ainsi que de
l’animation sont disponibles dans le Maple Application Center.
4. Structure conchoı̈dale
Le code de cet objet ainsi que d’autres coquillages est disponible dans
le Maple Application Center.
5. Transformation de Gauss appliquée à un tore
> sp := [rho*cos(2*Pi*t), rho*sin(2*Pi*t), 0, radius=b]:
> pc := n -> [ (rho-r*cos(2*Pi*t))*cos(2*Pi/(n+t)),
> (rho-r*cos(2*Pi*t))*sin(2*Pi/(n+t)),
> -r*sin(2*Pi*t)]:
> rho, r, b := 3, 1.1, 1:
> with(plots):
> s := spacecurve( {seq(pc(k), k=1..50)}, t=0..1, thickness=2,
> color=blue, view=[-4.4..4.4, -4.4..4.4, -2.2..2.2]):
> s2 := tubeplot( sp, t=0..1, tubepoints=20, color=green,
> view=[-4.4..4.4, -4.4..4.4, -2.2..2.2], style=PATCHNOGRID,
> lightmodel=light2 ):
> display( {s,s2} );
6. Ruban de Moebius
> moebius := plot3d([4+x*cos(1/2*y), y, x*sin(1/2*y)],

> x=-Pi..Pi, y=-0..2*Pi, coords=cylindrical, style=patchnogrid,
> grid=[60,60], orientation=[-176, 45], lightmodel=light3,
> shading=zhue, scaling=constrained):
> plots[display](moebius);
7. Icosaèdre
> with(geom3d):
> icosahedron(p1, point(o, 0, 0, 0), 1):
> stellate(p2, p1, 4):
> p := draw(p2):
> q := plottools[homothety](p,3):
> plots[display]([p,q], scaling=constrained, style=patchnogrid,
> lightmodel=light4, shading=xyz, orientation=[-107,81]);
Pour voir d’autres variations, modifiez la valeur de hauteur dans la

commande stellate.
8. Surface de révolution paramétrisée
> r1 := 2 + sin(7*t):
> z1 := r1*cos(s):
> r2 := 8+r1*sin(s):
> plot3d([r2*sin(t), r2*cos(t), z1], s=0..2*Pi, t=0..2*Pi,
> grid=[80, 80], axes=none, style=patchnogrid, lightmodel=light1);
9. Bonhomme de neige
Le graphique du bonhomme de neige est une animation. Le code de
cette animation est disponible dans le Maple Application Center.
10. Fonction de deux variables en coordonnées cartésiennes
> plot3d({sin(x^2+y^2), 2*cos(x^3+y^3)}, x=-3..3, y=-3..3,
> style=patch, grid=[120, 120], axes=none, shading=zhue,
> style=patchnogrid, scaling=constrained, orientation=[50,30]);
4.9 Conclusion
Ce chapitre a présenté les capacités d’affichage graphique de Maple en
deux et trois dimensions pour des fonctions explicites, implicites et pa-
ramétriques. Les coordonnées cartésiennes, polaires, sphériques et cylin-
driques ne sont que quelques-uns des systèmes de coordonnées exploités
par Maple. De plus, vous pouvez animer un graphique et le colorier de
plusieurs manières pour vous assurer d’une bonne compréhension de sa
nature.
Utilisez les commandes contenues dans le package plots pour affi-

cher plusieurs graphiques de fonctions et d’expressions. Quelques-uns des
types particuliers de graphiques que vous pouvez créer en utilisant ces
commandes sont les graphiques logarithmiques, de contour et de densité.
Les commandes du package plottools permettent de créer et de mani-
puler des objets. Ces commandes rendent possibles la translation et la
rotation des entités graphiques, et peuvent même les rendre étoilés.
5 L’évaluation et la
simplification
Dans Maple, beaucoup de temps et d’efforts sont consacrés à la manipu-

lation d’expressions. Celle-ci sert à convertir des résultats sous une forme
familière et vérifier une réponse, ou à convertir une expression sous une
forme particulière requise par certaines routines Maple.
Le problème de la simplification s’avère étonnamment complexe en
mathématiques symboliques. Ce qui est simple dans un contexte peut ne
pas l’être dans un autre ; chaque situation peut avoir sa propre définition
d’une forme simple .
Maple fournit un jeu d’outils permettant de travailler avec les ex-
pressions pour y effectuer à la fois des manipulations mathématiques et
structurelles. Les manipulations mathématiques sont celles correspondant
à une forme de processus mathématique, par exemple la factorisation d’un
polynôme ou la rationalisation du dénominateur d’une expression ration-
nelle. Les manipulations structurelles sont quant à elles des outils fournis
par Maple pour accéder à certaines parties des structures de données du
logiciel qui représentent des expressions et d’autres types d’objets, et les
modifier.
5.1 Manipulations mathématiques

La résolution d’équations à la main demande normalement d’effectuer une
séquence de manipulations algébriques. Vous pouvez également effectuer
ces étapes au moyen de Maple.
> eq := 4*x + 17 = 23;
eq := 4 x + 17 = 23
149
150 • Chapitre 5: L’évaluation et la simplification
Ici, vous devez soustraire 17 des deux côtés de l’équation. Pour ce faire,
il suffit de soustraire l’équation 17=17 de eq. Assurez-vous de mettre des
parenthèses autour de l’équation sans nom.
> eq - ( 17 = 17 );
4x = 6
Divisez maintenant le résultat par 4. Remarquez qu’il n’est pas

nécessaire d’utiliser 4=4 dans ce cas.
> % / 4;
3
x=
2
Les sections suivantes présentent plusieurs autres manipulations com-

plexes.
Développer des polyn

omes en sommes
Les sommes sont généralement plus faciles à comprendre que les produits ;
vous pouvez donc trouver utile de développer un polynôme comme somme
de produits. La commande expand vous permet de le faire.
> poly := (x+1)*(x+2)*(x+5)*(x-3/2);
3
poly := (x + 1) (x + 2) (x + 5) (x − )
2
> expand( poly );
13 3 31
x4 + x + 5 x2 − x − 15
2 2
La commande expand développe le numérateur d’une expression ra-

tionnelle.
> expand( (x+1)*(y^2-2*y+1) / z / (y-1) );
x y2 xy x y2
−2 + +
z (y − 1) z (y − 1) z (y − 1) z (y − 1)
y 1
−2 +
z (y − 1) z (y − 1)
5.1 Manipulations mathématiques • 151
Utilisez la commande normal pour annuler les facteurs communs ;

consultez la section Forme normale factorisée de la page 159.
La commande expand applique également les règles d’expansion de
plusieurs fonctions mathématiques standard.
> expand( sin(2*x) );
2 sin(x) cos(x)
> ln( abs(x^2)/(1+abs(x)) );
|x|2
ln( )
1 + |x|
> expand(%);
2 ln(|x|) − ln(1 + |x|)
La commande combine applique les mêmes règles, mais dans le sens

opposé. Consultez la présente section à la page 158.
Vous pouvez aussi spécifier des sous-expressions que vous ne voulez
pas développer comme argument de la commande expand.
> expand( (x+1)*(y+z) );
xy + xz + y + z
> expand( (x+1)*(y+z), x+1 );
(x + 1) y + (x + 1) z
Vous pouvez développer une expression sur un domaine spécifique.

> poly := (x+2)^2*(x-2)*(x+3)*(x-1)^2*(x-1);
poly := (x + 2)2 (x − 2) (x + 3) (x − 1)3
> expand( poly );
x7 + 2 x6 − 10 x5 − 12 x4 + 37 x3 + 10 x2 − 52 x + 24
> % mod 3;
x7 + 2 x6 + 2 x5 + x3 + x2 + 2 x
Cependant, la commande Expand est plus utile.

> Expand( poly ) mod 3;
x7 + 2 x6 + 2 x5 + x3 + x2 + 2 x
Lorsque vous utilisez Expand avec mod, Maple effectue tous les calculs
intermédiaires en arithmétique modulo. Vous pouvez également écrire vos
propres routines pour expand ; consultez la rubrique ?expand pour plus
de détails.
Regrouper les coefficients de m

eme degré
Une expression comme x2 + 2x + 1 − ax + b − cx2 peut être plus facile à
lire si vous regroupez les coefficients de x2 , x et les constantes à l’aide de
la commande collect.
> collect( x^2 + 2*x + 1 - a*x + b - c*x^2, x );
(1 − c) x2 + (2 − a) x + b + 1
Le deuxième argument de la commande collect spécifie sur quelle

variable il doit regrouper les termes.
> poly := x^2 + 2*y*x - 3*y + y^2*x^2;
poly := x2 + 2 y x − 3 y + y 2 x2
> collect( poly, x );
(1 + y 2 ) x2 + 2 y x − 3 y
> collect( poly, y );
y 2 x2 + (2 x − 3) y + x2
Vous pouvez regrouper les termes sur des variables ou des appels de
fonctions non évalués.
> trig_expr := sin(x)*cos(x) + sin(x) + y*sin(x);
trig _expr := sin(x) cos(x) + sin(x) + y sin(x)
> collect( trig_expr, sin(x) );
(cos(x) + 1 + y) sin(x)
> DE := diff(f(x),x,x)*sin(x) - diff(f(x),x)*sin(f(x))

> + sin(x)*diff(f(x),x) + sin(f(x))*diff(f(x),x,x);
2
2 f(x)) sin(x) − ( dx f(x)) sin(f(x))
d d
DE := ( dx
d d 2
+ sin(x) ( dx f(x)) + sin(f(x)) ( dx 2 f(x))
> collect( DE, diff );
d
(−sin(f(x)) + sin(x)) ( dx f(x))
d 2
+ (sin(x) + sin(f(x))) ( dx 2 f(x))
Vous ne pouvez regrouper les termes sur des sommes ou des produits.
> big_expr := z*x*y + 2*x*y + z;
big _expr := z x y + 2 y x + z
> collect( big_expr, x*y );
Error, (in collect) cannot collect y*x
Pour contourner ce problème, effectuez d’abord une substitution.

Dans l’exemple précédent, créez une variable remplaçant x*y, puis re-
groupez les termes sur cette nouvelle variable.
> subs( x=xyprod/y, big_expr );
z xyprod + 2 xyprod + z
> collect( %, xyprod );
(z + 2) xyprod + z
> subs( xyprod=x*y, % );
(z + 2) y x + z
Dans la section 5.3 de la page 190, on explique l’usage de la commande

subs.
Si vous regroupez les coefficients de plus d’une variable à la fois, deux
options s’offrent à vous : employer la forme récursive ou la forme dis-
tribuée. La forme récursive regroupe d’abord les termes autour de la
première variable spécifiée, puis la deuxième, et ainsi de suite. C’est la
forme par défaut.
> poly := x*y + z*x*y + y*x^2 - z*y*x^2 + x + z*x;
poly := y x + z x y + y x2 − z y x2 + x + z x
> collect( poly, [x,y] );
(1 − z) y x2 + ((1 + z) y + 1 + z) x
La forme distribuée regroupe les coefficients de toutes les variables en

même temps.
> collect( poly, [x,y], distributed );
(1 + z) x + (1 + z) y x + (1 − z) y x2
La commande collect ne trie pas les termes ; pour ce faire, vous devez
utiliser la commande sort. Consultez la présente section à la page 164.
Factoriser des polyn

omes et des fonctions rationnelles
Vous pouvez écrire un polynôme sous forme d’un produit de termes de plus
faible degré. Utilisez la commande factor pour factoriser des polynômes.
> factor( x^2-1 );
(x − 1) (x + 1)
> factor( x^3+y^3 );

(x + y) (x2 − y x + y 2 )
Vous pouvez également factoriser des fonctions rationnelles. La com-

mande factor factorise à la fois le numérateur et le dénominateur, et
annule ensuite leurs termes communs.
> rat_expr := (x^16 - y^16) / (x^8 - y^8);
x16 − y 16
rat _expr :=
x8 − y 8
> factor( rat_expr );
x8 + y 8
> rat_expr := (x^16 - y^16) / (x^7 - y^7);
x16 − y 16
rat _expr :=
x7 − y 7
> factor(rat_expr);
(y + x) (x2 + y 2 ) (x4 + y 4 ) (x8 + y 8 )

x6 + y x5 + y 2 x4 + y 3 x3 + y 4 x2 + y 5 x + y 6
Spécifier le corps de nombres algébriques La commande factor fac-

torise un polynôme sur l’anneau indiqué par les coefficients. Le polynôme
suivant possède des coefficients entiers ; ainsi, les termes de sa forme fac-
torisée possèdent également des coefficients entiers.
> poly := x^5 - x^4 - x^3 + x^2 - 2*x + 2;
poly := x5 − x4 − x3 + x2 − 2 x + 2
> factor( poly );
(x − 1) (x2 − 2) (x2 + 1)
√
Dans le prochain exemple, les coefficients incluent 2. Remarquez la
différence dans le résultat.
> expand( sqrt(2)*poly );

√ √ √ √ √ √
2 x5 − 2 x4 − 2 x3 + 2 x2 − 2 2x + 2 2
> factor( % );
√ √ √
2 (x2 + 1) (x − 2) (x + 2) (x − 1)
Vous pouvez étendre explicitement le corps des coefficients en four-

nissant un deuxième argument à la commande factor.
> poly := x^4 - 5*x^2 + 6;
poly := x4 − 5 x2 + 6
> factor( poly );
(x2 − 2) (x2 − 3)
> factor( poly, sqrt(2) );

√ √
(x2 − 3) (x − 2) (x + 2)
> factor( poly, { sqrt(2), sqrt(3) } );

√ √ √ √
(x − 3) (x + 3) (x − 2) (x + 2)
Vous pouvez également spécifier l’extension en utilisant √ Ici,

√ RootOf.
RootOf(x^2-2) représente une solution à x2 − 2 = 0, soit 2 ou − 2.
> factor( poly, RootOf(x^2-2) );
(x2 − 3) (x + RootOf(_Z 2 − 2)) (x − RootOf(_Z 2 − 2))
Consultez la rubrique ?evala pour plus d’information sur le calcul

dans un corps algébrique de nombres.
Factoriser dans des domaines spéciaux Utilisez la commande Factor

pour factoriser une expression sur les entiers modulo p pour un p premier.
La syntaxe est similaire à celle de la commande Expand.
> Factor( x^2+3*x+3 ) mod 7;
(x + 6) (x + 4)
La commande Factor permet également les extensions algébriques de

corps.
> Factor( x^3+1 ) mod 5;
(x + 1) (x2 + 4 x + 1)
> Factor( x^3+1, RootOf(x^2+x+1) ) mod 5;
(x + 1) (x + 4 RootOf(_Z 2 + _Z + 1) + 4)
(x + RootOf(_Z 2 + _Z + 1))
Pour obtenir des détails sur l’algorithme utilisé, la factorisation des
polynômes multivariés ou la factorisation de polynômes sur des corps
algébriques de nombres, consultez la rubrique ?Factor.
Supprimer des exposants rationnels

En général, il est préférable de présenter les expressions rationnelles sans
exposant rationnel au dénominateur. La commande rationalize enlève
les racines du dénominateur d’une expression rationnelle en multipliant
par un facteur convenable.
> 1 / ( 2 + root[3](2) );
1
2 + 2(1/3)
> rationalize( % );
2 1 (1/3) 1 (2/3)
− 2 + 2
5 5 10
> (x^2+5) / (x + x^(5/7));

x2 + 5
x + x(5/7)
> rationalize( % );
(x2 + 5)

(x(6/7) − x(12/7) − x(4/7) + x(10/7) + x(2/7) − x(8/7) + x2 ) (
x3 + x)
Le résultat de rationalize est souvent plus long que l’original.
Combiner des termes

La commande combine applique certaines règles de transformation pour
de nombreuses fonctions mathématiques.
> combine( sin(x)^2 + cos(x)^2 );
> combine( sin(x)*cos(x) );
1
sin(2 x)
2
> combine( exp(x)^2 * exp(y) );
e(2 x+y)
> combine( (xâ)^2 );
x(2 a)
Pour voir comment combine permet d’obtenir le résultat, donnez au

paramètre infolevel[combine] une valeur positive.
> infolevel[combine] := 1;
infolevel combine := 1
> expr := Int(1, x) + Int(x^2, x);


expr := 1 dx + x2 dx
> combine( expr );
combine: combining with respect to Int

combine: combining with respect to linear
combine: combining with respect to int
combine: combining with respect to int
combine: combining with respect to cmbplus
combine: combining with respect to cmbpwr
combine: combining with respect to power

x2 + 1 dx
La commande expand applique la plupart de ces règles de transforma-

tion en sens inverse. Consultez la section Développer des polyn
omes en
sommes à la page 150.
Forme normale factorisée

Si une expression contient des fractions, vous pouvez trouver utile de
regrouper celles-ci en une seule et d’annuler les facteurs communs du nu-
mérateur et du dénominateur. La commande normal effectue ce processus,
qui mène généralement à des expressions plus simples.
> normal( x + 1/x );
x2 + 1
x
> expr := x/(x+1) + 1/x + 1/(1+x);
x 1 1
expr := + +
x+1 x x+1
> normal( expr );

x+1
x
> expr := (x^2 - y^2) / (x-y)^3;
x2 − y 2
expr :=
(x − y)3
> normal( expr );
x+y
(x − y)2
> expr := (x - 1/x) / (x-2);
1
x−
expr := x
x−2
> normal( expr );
x2 − 1
x (x − 2)
Utilisez le deuxième argument, expanded, si vous souhaitez que

normal développe le numérateur et le dénominateur.
> normal( expr, expanded );
x2 − 1
x2 − 2 x
La commande normal agit récursivement sur les fonctions, les en-

sembles et les listes.
> normal( [ expr, exp(x+1/x) ] );
x2 − 1 x2 +1
[ , e( x ) ]
x (x − 2)
> big_expr := sin( (x*(x+1)-x)/(x+2) )^2

> + cos( (x^2)/(-x-2) )^2;
(x + 1) x − x 2 x2
big _expr := sin( ) + cos( )2
x+2 −x − 2
> normal( big_expr );
x2 2 x2 2
sin( ) + cos( )
x+2 x+2
Remarquez dans le dernier exemple que la commande normal ne sim-

plifie que les fonctions rationnelles – et non les fonctions trigonométriques.
Un cas particulier La commande normal peut retourner une expression

sous forme étendue qui n’est pas aussi simple que la forme factorisée.
> expr := (x^25-1) / (x-1);
x25 − 1
expr :=
x−1
> normal( expr );
1 + x5 + x4 + x3 + x2 + x18 + x12 + x14 + x19 + x17 + x15 + x9

+ x8 + x11 + x10 + x + x16 + x7 + x24 + x22 + x23 + x21 + x20
+ x13 + x6
Pour annuler le facteur commun (x − 1) du numérateur et du dé-
nominateur, utilisez la commande factor. Consultez la section 5.1 à la
page 154.
> factor(expr);
(x4 + x3 + x2 + x + 1) (x20 + x15 + x10 + x5 + 1)
Simplifier des expressions

Les résultats des calculs de simplification de Maple peuvent être très com-
pliqués. La commande simplify tente de trouver une expression plus
simple en effectuant une série de manipulations.
> expr := 4^(1/2) + 3;
√
expr := 4+3
> simplify( expr );
> expr := cos(x)^5 + sin(x)^4 + 2*cos(x)^2

> - 2*sin(x)^2 - cos(2*x);
expr :=
cos(x)5 + sin(x)4 + 2 cos(x)2 − 2 sin(x)2 − cos(2 x)
> simplify( expr );
cos(x)4 (cos(x) + 1)
Maple possède des règles de simplification pour les expressions trigo-

nométriques, logarithmiques et exponentielles de même que pour les ex-
pressions contenant des radicaux, des puissances, des expressions RootOf
ainsi que d’autres fonctions spéciales.
Lorsque vous spécifiez une règle particulière de simplification comme
argument à la commande simplify, seule cette règle (ou cette classe de
règles) sera utilisée.
> expr := ln(3*x) + sin(x)^2 + cos(x)^2;
expr := ln(3 x) + sin(x)2 + cos(x)2
> simplify( expr, trig );
ln(3 x) + 1
> simplify( expr, ln );
ln(3) + ln(x) + sin(x)2 + cos(x)2
> simplify( expr );
ln(3) + ln(x) + 1
Consultez la rubrique ?simplify pour obtenir une liste des règles de

simplification intégrées.
Simplification avec des hypothèses

Il est possible que Maple n’effectue pas une simplification comme vous
l’entendez ; cela survient lorsque vous connaissez les propriétés spéciales
d’une variable mais que Maple la traite d’une manière plus générale.
> expr := sqrt( (x*y)^2 );

expr := x2 y 2
> simplify( expr );

x2 y 2
L’option assume=propriété indique à la commande simplify d’as-

sumer que toutes les inconnues de l’expression possèdent la propriété.
> simplify( expr, assume=real );
|x y|
> simplify( expr, assume=positive );
xy
Vous pouvez également vous servir de la commande assume pour pla-

cer des hypothèses individuellement sur des variables. Consultez la section
5.2.
Simplification au moyen des relations accessoires

Vous pouvez quelquefois simplifier une expression en utilisant votre propre
règle de transformation. La commande simplify vous permet de le faire
en utilisant des relations accessoires .
> expr := x*y*z + x*y + x*z + y*z;
expr := x y z + x y + x z + y z
> simplify( expr, { x*z=1 } );
xy + yz + y + 1
Vous pouvez spécifier une ou plusieurs relations accessoires dans un

ensemble ou une liste. La commande simplify considère les équations
données comme des simplifications additionnelles.
Il est également possible de spécifier l’ordre dans lequel simplify
effectue l’opération.
> expr := x^3 + y^3;
expr := x3 + y 3
> siderel := x^2 + y^2 = 1;
siderel := x2 + y 2 = 1
> simplify( expr, {siderel}, [x,y] );
y3 − x y2 + x
> simplify( expr, {siderel}, [y,x] );
x3 − y x2 + y
Dans le premier cas, Maple effectue la substitution x2 = 1−y 2 dans la

première expression, puis tente d’effectuer une substituion pour les termes
en y 2 ; n’en trouvant aucun, l’exécution est arrêtée.
Dans le second cas, Maple effectue la substitution y 2 = 1 − x2 dans
la première expression, puis tente d’effectuer des substitutions pour les
termes en x2 ; n’en trouvant aucun, l’exécution est arrêtée.
Les manipulations de polynômes en base de Gröbner sont à la base du
fonctionnement de simplify. Pour obtenir davantage d’information sur
cette commande, consultez la rubrique ?simplify,siderels.
Trier des expressions algébriques

Maple affiche les termes d’un polynôme dans l’ordre où le polynôme a
d’abord été créé. Vous pouvez en trier les termes par ordre décroissant de
degré à l’aide de la commande sort.
> poly := 1 + x^4 - x^2 + x + x^3;
poly := 1 + x4 − x2 + x + x3
> sort( poly );
x4 + x3 − x2 + x + 1
Remarquez que sort réorganise les expressions algébriques sur place

en remplaçant le polynôme original par sa copie triée.
> poly;
x4 + x3 − x2 + x + 1
Vous pouvez trier des polynômes multivariés de deux manières : par

degré total ou en ordre lexicographique. Maple utilise par défaut le tri
par degré total ; les termes sont alors réarrangés en ordre décroissant de
degré. Avec ce tri, lorsque deux termes ont le même degré, Maple les trie
en ordre lexicographique (de telle sorte que a vienne avant b, et ainsi de
suite).
> sort( x+x^3 + w^5 + y^2 + z^4, [w,x,y,z] );
w5 + z 4 + x3 + y 2 + x
> sort( x^3*y + y^2*x^2, [x,y] );
x3 y + x2 y 2
> sort( x^3*y + y^2*x^2 + x^4, [x,y] );
x4 + x3 y + x2 y 2
Remarquez que l’ordre des variables dans la liste détermine l’ordon-

nancement de l’expression.
> sort( x^3*y + y^2*x^2, [x,y] );
x3 y + x2 y 2
> sort( x^3*y + y^2*x^2, [y,x] );
y 2 x2 + y x3
Vous pouvez également trier l’expression entière en ordre lexicogra-

phique en utilisant l’option plex de la commande sort.
> sort( x + x^3 + w^5 + y^2 + z^4, [w,x,y,z], plex );
w5 + x3 + x + y 2 + z 4
Encore une fois, l’ordre dans lequel sont données les inconnues au
moment de l’appel à sort détermine l’ordonnancement.
> sort( x + x^3 + w^5 + y^2 + z^4, [x,y,z,w], plex );
x3 + x + y 2 + z 4 + w5
La commande sort peut également trier des listes. Consultez la sec-

tion 5.3.
Conversion entre différentes formes

Vous pouvez écrire plusieurs fonctions mathématiques selon diverses
formes équivalentes. Par exemple, vous pouvez exprimer sin(x) en termes
de la fonction exponentielle. La commande convert permet d’effectuer
des conversions de ce genre. Pour plus d’information, consultez la ru-
brique ?convert.
> convert( sin(x), exp );
−1 1
I (e(I x) − (I x) )
2 e
> convert( cot(x), sincos );
cos(x)
sin(x)
> convert( arccos(x), ln );

−I ln(x + I −x2 + 1)
> convert( binomial(n,k), factorial );
n!
k! (n − k)!
L’argument parfrac indique que l’on souhaite obtenir des fractions

partielles.
> convert( (x^5+1) / (x^4-x^2), parfrac, x );
1 1
x+ − 2
x−1 x
Vous pouvez également utiliser convert pour trouver une approxima-

tion fractionnelle à un nombre décimal.
> convert( .3284879342, rational );
19615
59713
Remarquez que les conversions ne sont pas nécessairement réci-

proques.
> convert( tan(x), exp );
−I ((e(I x) )2 − 1)
(e(I x) )2 + 1
> convert( %, trig );
−I ((cos(x) + I sin(x))2 − 1)
(cos(x) + I sin(x))2 + 1
La commande simplify nous révèle que cette expression est tan(x).

> simplify( % );
sin(x)
cos(x)
Vous pouvez également vous servir de la commande convert pour

effectuer des manipulations structurelles sur des objets Maple. Consultez
la section 5.3.
5.2 Les hypothèses

Il existe deux manières d’imposer des hypothèses sur des inconnues. Pour
modifier globalement les propriétés des inconnues, utilisez la commande
assume. Pour effectuer une seule opération avec des hypothèses sur des
inconnues, utilisez la commande assuming. Les commandes assume et
assuming sont expliquées dans les sous-sections suivantes.
La commande assume
Le système d’hypothèses de Maple est un ensemble de routines permettant
de gérer les propriétés des inconnues. La commande assume permet une
meilleure simplification d’expressions symboliques, particulièrement avec
les fonctions retournant plusieurs valeurs comme les racines carrées.
> sqrt(a^2);
√
a2
Maple ne peut simplifier cette expression, étant donné que le résultat

est différent pour les valeurs positives et négatives de a. Fournir une hy-
pothèse sur la valeur de a permet à Maple de simplifier l’expression.
> assume( a>0 );
> sqrt(a^2);
a~
Utilisez la commande about pour obtenir de l’information sur les hy-

pothèses à propos d’une inconnue.
> about(a);
Originally a, renamed a~:

is assumed to be: RealRange(-infinity,Open(0))
Utilisez la commande additionally pour poser des hypothèses

supplémentaires sur une inconnue.
> assume(m, nonnegative);
> additionally( m<=0 );
> about(m);
Originally m, renamed m~:

is assumed to be: 0
5.2 Les hypothèses • 169
Plusieurs fonctions font usage des hypothèses sur une inconnue. La

commande frac retourne la partie fractionnaire d’un nombre.
> frac(n);
frac(n)
> assume(n, integer);

> frac(n);
La limite suivante dépend de b.

> limit(b*x, x=infinity);
signum(b) ∞
> assume( b>0 );

> limit(b*x, x=infinity);
Vous pouvez utiliser infolevel pour obtenir de Maple un rapport

détaillé de l’activité d’une commande.
> infolevel[int] := 2;
infolevel int := 2
> int( exp(c*x), x=0..infinity );
int/cook/nogo1:
Given Integral
Int(exp(c*x),x = 0 .. infinity)
Fits into this pattern:
Int(exp(-Ucplex*x^S1-U2*x^S2)*x^N*ln(B*x^DL)^M*cos(C1*x^R)
/((A0+A1*x^D)^P),x = t1 .. t2)
Definite integration: Can’t determine if the integral is
convergent.
Need to know the sign of --> -c
Will now try indefinite integration and then take limits.
int/indef1: first-stage indefinite integration
int/indef2: second-stage indefinite integration
int/indef2: applying derivative-divides
int/indef1: first-stage indefinite integration
e(c x) − 1
lim
x→∞ c
La commande int doit connaı̂tre le signe de c (ou plutôt le signe de -c).

> assume( c>0 );
> int( exp(c*x), x=0..infinity );
int/cook/nogo1:
Given Integral
Int(exp(x),x = 0 .. infinity)
Fits into this pattern:
Int(exp(-Ucplex*x^S1-U2*x^S2)*x^N*ln(B*x^DL)^M*cos(C1*x^R)
/((A0+A1*x^D)^P),x = t1 .. t2)
int/cook/IIntd1:
--> U must be <= 0 for converging integral
--> will use limit to find if integral is +infinity
--> or - infinity or undefined
Les logarithmes retournent plusieurs valeurs ; généralement, pour des

valeurs complexes de x, ln(ex ) est différent de x.
> ln( exp( 3*Pi*I ) );
πI
Ainsi, Maple ne simplifie pas l’expression suivante, à moins de la savoir

correcte, par exemple lorsque x est réel.
> ln(exp(x));
ln(ex )
> assume(x, real);

> ln(exp(x));
x~
Vous pouvez utiliser la commande is pour vérifier directement les

propriétés des inconnues.
5.2 Les hypothèses • 171
> is( c>0 );
true
> is(x, complex);
true
> is(x, real);
true
Dans le prochain exemple, Maple croit toujours que la variable a est

négative.
> eq := xi^2 = a;
eq := ξ 2 = a~
> solve( eq, {xi} );
√ √
{ξ = −a~ I}, {ξ = −I −a~}
Pour retirer des hypothèses sur une variable, il suffit d’en désaffecter
le nom. Cependant, l’expression eq renvoie toujours à a~.
> eq;
ξ 2 = a~
Vous devez retirer l’hypothèse sur a à l’intérieur de eq avant

de retirer l’hypothèse sur a. Tout d’abord, retirez les hypothèses sur a à
l’intérieur de eq.
> eq := subs( a=’a’, eq );
eq := ξ 2 = a
Puis, désaffectez a.
> a := ’a’;
a := a
Consultez la rubrique ?assume pour obtenir davantage d’information.

S’il ne vous est nécessaire de poser une hypothèse que pour une
seule évaluation, vous pouvez utiliser la commande assuming décrite
dans la prochaine sous-section. Lorsque vous vous servez de la commande
assuming, vous n’avez pas besoin de retirer par la suite les hypothèses
sur les inconnues et les équations.
La commande assuming
Pour n’effectuer qu’une seule évaluation avec des hypothèses sur les noms
d’une expression, utilisez la commande assuming. Son utilisation est
équivalente à la procédure consistant à appeler la commande assume,
à évaluer l’expression, puis à retirer les hypothèses sur l’expression et ses
composantes. Cela facilite l’expérimentation de l’évaluation d’une expres-
sion sous différentes hypothèses.
> about(a);
a:
nothing known about this object
> sqrt(a^2) assuming a<0;
−a
> about(a);
a:
nothing known about this object
> sqrt(a^2) assuming a>0;
Vous pouvez évaluer une expression avec une hypothèse sur tous les
noms dans une expression :
5.3 Manipulations structurelles • 173
> sqrt((a*b)^2) assuming positive;
a b~
ou avec des hypothèses sur des noms en particulier.

> ln(exp(x)) + ln(exp(y)) assuming x::real, y::complex;
x ~ + ln(ey )
Dans cet exemple, les doubles deux-points (::) indiquent l’affectation

d’une propriété. En général, les doubles deux-points sont utilisés pour
vérifier le type d’un objet. Pour plus d’information, référez-vous à la ru-
brique ?type.
Pour en savoir davantage sur la commande assuming, consultez la
rubrique ?assuming.
5.3 Manipulations structurelles

Les manipulations structurelles sont des manipulations qui permettent,
entre autres choses, de choisir et de modifier des parties d’un objet, d’uti-
liser la connaissance de la structure ou la représentation interne d’un
objet plutôt que de travailler avec l’expression comme un objet purement
mathématique. Dans les cas particuliers des listes et des ensembles, choisir
un élément est direct.
> L := { Z, Q, R, C, H, O };
L := {O, R, Z, Q, H, C}
> L[3];
Choisir des éléments de listes et d’ensembles est facile, ce qui rend leur
manipulation aisée. Le concept de ce qui constitue les parties d’une ex-
pression générale est plus difficile. Cependant, plusieurs des commmandes
qui manipulent les listes et les ensembles s’appliquent également aux ex-
pressions générales.
Appliquer une fonction à une liste ou un ensemble

Vous pouvez appliquer une fonction ou une commande à chacun des
éléments plutôt qu’à un objet en tant que tout. La commande map vous
permet d’effectuer cette application multiple.
> f( [a, b, c] );
f([a, b, c])
> map( f, [a, b, c] );
[f(a), f(b), f(c)]
> map( expand, { (x+1)*(x+2), x*(x+2) } );
{x2 + 2 x, x2 + 3 x + 2}
> map( x->x^2, [a, b, c] );
[a2 , b2 , c2 ]
Lorsque map est appelée avec plus de deux arguments, les arguments
supplémentaires sont passés à la fonction.
> map( f, [a, b, c], p, q );
[f(a, p, q), f(b, p, q), f(c, p, q)]
> map( diff, [ (x+1)*(x+2), x*(x+2) ], x );
[2 x + 3, 2 x + 2]
La commande map2 est étroitement liée à map. Là où map remplace
séquentiellement le premier argument d’une fonction, map2 remplace le
deuxième argument d’une fonction.
> map2( f, p, [a,b,c], q, r );
[f(p, a, q, r), f(p, b, q, r), f(p, c, q, r)]

> map2( diff, x^y/z, [x,y,z] );
xy y xy ln(x) xy
[ , , − 2]
xz z z
Vous pouvez utiliser map2 pour obtenir la liste de toutes les dérivées
partielles d’une expression.
> map2( map, { [a,b], [c,d], [e,f] }, p, q );
{[a(p, q), b(p, q)], [c(p, q), d(p, q)], [e(p, q), f(p, q)], }
Vous pouvez même utiliser seq conjointement avec map lorsque vous
les appliquez à des sous-éléments. Ici, seq produit une suite en appliquant
la fonction f aux éléments d’un ensemble et d’une liste.
> seq( f(i), i={a,b,c} );
f(a), f(b), f(c)
> seq( f(p, i, q, r), i=[a,b,c] );
f(p, a, q, r), f(p, b, q, r), f(p, c, q, r)
Un autre exemple est le triangle de Pascal.

> L := [ seq( i, i=0..5 ) ];
L := [0, 1, 2, 3, 4, 5]
> [ seq( [ seq( binomial(n,m), m=L ) ], n=L ) ];
[[1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 0, 0], [1, 2, 1, 0, 0, 0],

[1, 3, 3, 1, 0, 0], [1, 4, 6, 4, 1, 0], [1, 5, 10, 10, 5, 1]]
> map( print, % );
[1, 0, 0, 0, 0, 0]
[1, 1, 0, 0, 0, 0]
[1, 2, 1, 0, 0, 0]
[1, 3, 3, 1, 0, 0]
[1, 4, 6, 4, 1, 0]
[1, 5, 10, 10, 5, 1]
[]
Les commandes add et mul fonctionnent comme seq, à l’exception

qu’elles engendrent respectivement des sommes et des produits au lieu de
suites.
> add( i^2, i=[5, y, sin(x), -5] );
50 + y 2 + sin(x)2
Les commandes map, map2, seq, add et mul peuvent également agir
sur des expressions générales. Consultez la section Les parties d’une
expression de la page 182.
Choisir des éléments dans une liste ou un ensemble

Vous pouvez choisir certains éléments d’une liste ou d’un ensemble en four-
nissant une fonction booléenne qui détermine les éléments à sélectionner.
La fonction booléenne suivante retourne true si son argument est supé-
rieur à 3.
> large := x -> is(x > 3);
large := x → is(3 < x)
Vous pouvez maintenant utiliser la commande select pour choisir les

éléments dans une liste ou un ensemble qui satisfont à la propriété large.
> L := [ 8, 2.95, Pi, sin(9) ];
L := [8, 2.95, π, sin(9)]

> select( large, L );
[8, π]
De façon similaire, la commande remove retire les éléments de L qui

satisfont à la propriété large et affiche comme résultat les éléments res-
tants.
> remove( large, L );
[2.95, sin(9)]
Pour effectuer les deux opérations simultanément, utilisez la com-

mande selectremove.
> selectremove( large, L);
[8, π], [2.95, sin(9)]
Servez-vous de la commande type pour déterminer le type d’une ex-

pression.
> type( 3, numeric );
true
> type( cos(1), numeric );
false
Ici, la syntaxe de select passe le troisième argument, numeric, à la

commande type.
> select( type, L, numeric );
[8, 2.95]
Consultez la section Les parties d’une expression à la page 182 pour

obtenir davantage d’information sur les types de données et sur la manière
d’utiliser select et remove sur des expressions en général.
Combiner deux listes

Il est possible de combiner des listes de plusieurs manières. Voici une liste
de valeurs en x et une liste de valeurs en y.
> X := [ seq( ithprime(i), i=1..6 ) ];
X := [2, 3, 5, 7, 11, 13]
> Y := [ seq( binomial(6, i), i=1..6 ) ];
Y := [6, 15, 20, 15, 6, 1]
Pour tracer le graphique des valeurs en y en fonction des valeurs en

x, construisez une liste de listes : [ [x1,y1 ], [x2,y2 ], ... ]. Pour
chaque paire de valeurs, construisez donc une liste de deux éléments.
> pair := (x,y) -> [x, y];
pair := (x, y) → [x, y]
La commande zip peut combiner les listes X et Y selon la fonction

binaire pair.
> P := zip( pair, X, Y );
P := [[2, 6], [3, 15], [5, 20], [7, 15], [11, 6], [13, 1]]
> plot( P );
20
18
16
14
12
10
8
6
4
2
2 4 6 8 10 12
Si les deux listes sont de longueur différente, zip retourne une liste
de la longueur de la plus courte.
> zip( (x,y) -> x.y, [a,b,c,d,e,f], [1,2,3] );
[a, 2 b, 3 c]
Vous pouvez spécifier un quatrième argument à zip qui lui fait retour-
ner une liste aussi longue que la plus longue des deux listes, en utilisant
le quatrième paramètre pour remplacer les valeurs manquantes.
> zip( (x,y) -> x.y, [a,b,c,d,e,f], [1,2,3], 99 );
[a, 2 b, 3 c, 99 d, 99 e, 99 f ]
> zip( igcd, [7657,342,876], [34,756,213,346,123], 6! );
[1, 18, 3, 2, 3]
La commande zip peut également combiner des vecteurs. Consultez

la rubrique ?zip pour obtenir plus d’information sur cette commande.
Trier des listes

Dans Maple, une liste est une structure de données fondamentale qui
préserve l’ordre des éléments. Les éléments d’une liste demeurent dans le
même ordre que lorsque la liste a été créée. Vous pouvez cependant créer
une copie d’une liste triée dans un autre ordre en utilisant la commande
sort. Entre autres fonctions, la commande sort trie les listes en ordre
croissant. Elle trie une liste de nombres en ordre numérique.
> sort( [1,3,2,4,5,3,6,3,6] );
[1, 2, 3, 3, 3, 4, 5, 6, 6]
La commande sort peut également trier une liste chaı̂nes de ca-

ractères en ordre lexicographique.
> sort( ["Mary", "has", "a", "little", "lamb"] );
[“Mary”, “a”, “has”, “lamb”, “little”]

Lorsque vous mélangez des nombres et des chaı̂nes, ou lorsqu’une liste

contient des expressions autres que des nombres ou des chaı̂nes, la com-
mande sort applique les adresses machine, qui peuvent varier à chaque
session.
> sort( [x, 1, "apple"] );
[1, “apple”, x]
> sort( [-5, 10, sin(34)] );
[10, sin(34), −5]
Notez que, pour Maple, π n’est pas un nombre.

> sort( [4.3, Pi, 2/3] );
2
[π, 4.3, ]
3
Vous pouvez spécifier une fonction booléenne pour définir un ordre

à la liste. Cette fonction booléenne doit avoir deux arguments et retour-
ner true si le premier argument doit être placé avant le second. Vous
pouvez employer cette méthode pour trier une liste de nombres en ordre
décroissant.
> sort( [3.12, 1, 1/2], (x,y) -> evalb( x>y ) );
1
[3.12, 1, ]
2
La commande is sert à comparer des constantes comme π et sin(5)

avec des nombres purs.
> bf := (x,y) -> is( x < y );
bf := (x, y) → is(x < y)
> sort( [4.3, Pi, 2/3, sin(5)], bf );
2
[sin(5), , π, 4.3]
3
Vous pouvez également trier des chaı̂nes de caractères par longueur.

> shorter := (x,y) -> evalb( length(x) < length(y) );
shorter := (x, y) → evalb(length(x) < length(y))
> sort( ["Mary", "has", "a", "little", "lamb"], shorter );
[“a”, “has”, “lamb”, “Mary”, “little”]
Maple ne possède pas de méthode intégrée pour trier des listes mixtes
de chaı̂nes de caractères et de nombres (sauf par adresse machine). Pour
trier une liste mixte de chaı̂nes et de nombres, vous pouvez effectuer les
opérations suivantes.
> big_list := [1,"d",3,5,2,"a","c","b",9];
big _list := [1, “d”, 3, 5, 2, “a”, “c”, “b”, 9]
Créez deux listes à partir de l’originale, l’une contenant des nombres,

et l’autre des chaı̂nes de caractères.
> list1 := select( type, big_list, string );
list1 := [“d”, “a”, “c”, “b”]
> list2 := select( type, big_list, numeric );
list2 := [1, 3, 5, 2, 9]
Triez maintenant les deux listes indépendamment.

> list1 := sort(list1);
list1 := [“a”, “b”, “c”, “d”]
> list2 := sort(list2);
list2 := [1, 2, 3, 5, 9]
Finalement, regroupez les deux listes.

> sorted_list := [ op(list1), op(list2) ];
sorted _list := [“a”, “b”, “c”, “d”, 1, 2, 3, 5, 9]
La commande sort peut également servir à trier des expressions

algébriques. Consultez la section 5.1.
La présente section, à la page 176, donne davantage d’information à
propos des commandes de cet exemple.
Les parties d’une expression

Pour manipuler les détails d’une expression, vous devez en choisir les
parties individuelles. Trois cas simples pour illustrer cette situation font
appel aux équations, aux intervalles et aux fractions. La commande lhs
sélectionne le côté gauche d’une équation.
> eq := a^2 + b^ 2 = c^2;
eq := a2 + b2 = c2
> lhs( eq );
a2 + b2
La commande rhs, de manière similaire, en sélectionne le côté droit.

> rhs( eq );
c2
Les commandes lhs et rhs fonctionnent également pour les inter-

valles.
> lhs( 2..5 );
> rhs( 2..5 );
> eq := x = -2..infinity;
eq := x = −2..∞
> lhs( eq );
> rhs( eq );
−2..∞
> lhs( rhs(eq) );
−2
> rhs( rhs(eq) );
Les commandes numer et denom extraient respectivement le numéra-

teur et le dénominateur d’une fraction.
> numer( 2/3 );
> denom( 2/3 );
> fract := ( 1+sin(x)^3-y/x) / ( y^2 - 1 + x );

y
1 + sin(x)3 −
fract := x
y2 − 1 + x
> numer( fract );
x + sin(x)3 x − y
> denom( fract );

x (y 2 − 1 + x)
Considérez l’expression
> expr := 3 + sin(x) + 2*cos(x)^2*sin(x);
expr := 3 + sin(x) + 2 cos(x)2 sin(x)
La commande whattype considère expr comme une somme.

> whattype( expr );
Utilisez la commande op pour lister les termes d’une somme ou, en

général, les opérandes d’une expression.
> op( expr );
3, sin(x), 2 cos(x)2 sin(x)
L’expression expr est formée de trois éléments. Utilisez la commande

nops pour compter le nombre d’opérandes d’une expression.
> nops( expr );
Par exemple, vous pouvez choisir le troisième terme de la manière

suivante.
> term3 := op(3, expr);
term3 := 2 cos(x)2 sin(x)
term3 est un produit de trois facteurs.

> whattype( term3 );
> nops( term3 );

> op( term3 );
2, cos(x)2 , sin(x)
Obtenez le second facteur de term3 de la manière suivante.

> factor2 := op(2, term3);
factor2 := cos(x)2
C’est une exponentiation.

> whattype( factor2 );
factor2 possède deux opérandes.

> op( factor2 );
cos(x), 2
Le premier opérande est une fonction et ne contient qu’un seul

opérande.
> op1 := op(1, factor2);
op1 := cos(x)
> whattype( op1 );
function
> op( op1 );
x est un symbole.
> whattype( op(op1) );
symbol
Puisque vous n’avez pas assigné une valeur à x, il ne contient qu’un

seule opérande, soit lui-même.
> nops( x );
> op( x );
Vous pouvez représenter le résultat de la recherche des opérandes

d’une expression par un graphique appelé arbre des expressions. L’arbre
des expressions de expr ressemble à ceci.
+
3 * sin
x
sin ^ 2
x
cos 2
x
Les opérandes d’une liste ou d’un ensemble sont ses éléments.
> op( [a,b,c] );
a, b, c
> op( {d,e,f} );
e, f, d
À la présente section (page 174), on décrit comment la commande map

applique une fonction à tous les éléments d’une liste ou d’un ensemble.
La fonctionnalité de map s’étend aux expressions en général.
> map( f, x^2 );
f(x)f(2)
Les commandes select et remove décrites dans la section 5.3 de la

page 176 fonctionnent également pour des expressions en général.
> large := z -> evalb( is(z>3) = true );
large := z → evalb(is(3 < z) = true)
> remove( large, 5+8*sin(x) - exp(9) );
8 sin(x) − e9
Maple possède plusieurs commandes utiles, comme la fonction boolé-

enne dans un appel à select ou remove. La commande has détermine si
une expression contient une sous-expression spécifique.
> has( x*exp(cos(t^2)), t^2 );
true
> has( x*exp(cos(t^2)), cos );
true
Quelques-unes des solutions du système d’équations suivant con-

tiennent des références à RootOf.
> sol := { solve( { x^2*y^2 = b*y, x^2-y^2 = a*x },
> {x,y} ) };
sol := {{y = 0, x = 0}, {y = 0, x = a}, {

b
y= ,
RootOf(_Z − b2 − a _Z 5 )2
6
x = RootOf(_Z 6 − b2 − a _Z 5 )}}
Utilisez select et has pour choisir ces solutions.

> select( has, sol, RootOf );
b
{{y = ,
RootOf(_Z − b2 − a _Z 5 )2
6
x = RootOf(_Z 6 − b2 − a _Z 5 )}}
Vous pouvez également choisir ou retirer des sous-expressions par
type. La commande type détermine si une expression est d’un type donné.
> type( 3+x, ‘+‘ );
true
Dans cet exemple, la commande select passe son troisième argument,

‘+‘, à type.
> expr := ( 3+x ) * x^2 * sin( 1+sqrt(Pi) );
√
expr := (3 + x) x2 sin(1 + π)
> select( type, expr, ‘+‘ );
3+x
La commande hastype détermine si une expression contient une sous-

expression d’un certain type.
> hastype( sin( 1+sqrt(Pi) ), ‘+‘ );
true
Utilisez la combinaison select(hastype,...) pour choisir les opé-

randes d’une expression qui contient un certain type.
> select( hastype, expr, ‘+‘ );
√
(3 + x) sin(1 + π)
Si vous êtes intéressé aux sous-expressions d’un certain type plutôt

qu’aux opérandes qui les contiennent, utilisez la commande indets.
> indets( expr, ‘+‘ );

√
{3 + x, 1 + π}
Les deux RootOf contenus dans sol sont de type RootOf. Puisqu’ils
sont identiques, l’ensemble retourné par indets contient seulement un
élément.
> indets( sol, RootOf );
{RootOf(_Z 6 − b2 − a _Z 5 )}
À l’instar de RootOf, toutes les commandes n’ont pas leur propre

type ; vous pouvez cependant utiliser le type structuré specfunc(type,
nom ). Ce type identifie les fonctions appelées nom avec les arguments de
type type.
> type( diff(y(x), x), specfunc(anything, diff) );
true
Vous pouvez utiliser ceci pour trouver toutes les dérivées d’une
équation différentielle.
> DE := expand( diff( cos(y(t)+t)*sin(t*z(t)), t ) )
> + diff(x(t), t);
DE := −sin(t z(t)) sin(y(t)) cos(t) ( dt

d
y(t))
− sin(t z(t)) sin(y(t)) cos(t)
− sin(t z(t)) cos(y(t)) sin(t) ( dt
d
y(t))
− sin(t z(t)) cos(y(t)) sin(t)
+ cos(t z(t)) cos(y(t)) cos(t) z(t)
d
+ cos(t z(t)) cos(y(t)) cos(t) t ( dt z(t))
− cos(t z(t)) sin(y(t)) sin(t) z(t)
− cos(t z(t)) sin(y(t)) sin(t) t ( dt
d d
z(t)) + ( dt x(t))
> indets( DE, specfunc(anything, diff) );
∂ ∂ ∂
{ x(t), y(t), z(t)}
∂t ∂t ∂t
Les opérandes suivants de DE contiennent les dérivées.

> select( hastype, DE, specfunc(anything, diff) );
−sin(t z(t)) sin(y(t)) cos(t) ( dt

d
y(t))
− sin(t z(t)) cos(y(t)) sin(t) ( dt
d
y(t))
d
+ cos(t z(t)) cos(y(t)) cos(t) t ( dt z(t))
− cos(t z(t)) sin(y(t)) sin(t) t ( dt
d d
z(t)) + ( dt x(t))
DE ne possède qu’un seul opérande qui est lui-même une dérivée.
> select( type, DE, specfunc(anything, diff) );
d
x(t)
dt
Maple reconnaı̂t plusieurs types. Consultez la rubrique ?type pour en

obtenir une liste partielle, de même que ?type,structured pour obtenir
davantage d’information sur les types structurés comme specfunc.
La substitution
Il est souvent nécessaire de substituer une valeur à une variable (en
d’autres termes, d’évaluer une expression en un point). Par exemple, pour
résoudre le problème Si f (x) = ln(sin(xecos(x) )), trouvez f (2) , vous
devez substituer la valeur 2 à x dans la dérivée. La commande diff calcule
la dérivée.
> y := ln( sin( x * exp(cos(x)) ) );
y := ln(sin(x ecos(x) ))
> yprime := diff( y, x );
cos(x ecos(x) ) (ecos(x) − x sin(x) ecos(x) )

yprime :=
sin(x ecos(x) )
Utilisez maintenant la commande eval pour substituer une valeur à

x dans yprime.
> eval( yprime, x=2 );
cos(2 ecos(2) ) (ecos(2) − 2 sin(2) ecos(2) )

sin(2 ecos(2) )
La commande evalf retourne une approximation décimale du résul-

tat.
> evalf( % );
−0.1388047428
La commande effectue des substitutions syntaxiques, et non mathé-

matiques ; cela signifie que vous pouvez effectuer des substitutions pour
n’importe quelle sous-expression.
> subs( cos(x)=3, yprime );
cos(x e3 ) (e3 − x sin(x) e3 )

sin(x e3 )
Vous êtes cependant limité aux sous-expressions telles que Maple les
reconnaı̂t.
> expr := a * b * c * a^b;
expr := a b c ab
> subs( a*b=3, expr );
a b c ab
expr est un produit de quatre facteurs.

> op( expr );
a, b, c, ab
Le produit a*b n’est donc pas un facteur dans expr. Vous pouvez effec-
tuer la substitution a*b=3 de trois manières : résoudre la sous-expression
pour une des variables :
> subs( a=3/b, expr );
3
3 c ( )b
b
utiliser une relation accessoire dans simplify :

> simplify( expr, { a*b=3 } );
3 c ab
ou encore utiliser la commande algsubs qui effectue des substitutions

algébriques.
> algsubs( a*b=3, expr);
3 c ab
Remarquez que, dans le premier cas, toutes les occurrences de a ont

été remplacées par 3/b, tandis que, dans le deuxième et le troisième cas,
les variables a et b demeurent dans le résultat.
Vous pouvez effectuer plusieurs substitutions à la fois par un seul
appel à subs.
> expr := z * sin( x^2 ) + w;
expr := z sin(x2 ) + w
> subs( x=sqrt(z), w=Pi, expr );
z sin(z) + π
La commande subs effectue les substitutions de gauche à droite.

> subs( z=x, x=sqrt(z), expr );
√
z sin(z) + w
Si vous donnez un ensemble ou une liste de substitutions, la commande

subs effectue ces substitutions simultanément.
> subs( { x=sqrt(Pi), z=3 }, expr );
3 sin(π) + w
Remarquez que, en général, vous devez évaluer explicitement le

résultat d’un appel à subs.
> eval( % );
Utilisez la commande subsop pour remplacer un opérande spécifique

dans une expression.
> expr := 5^x;
expr := 5x
> op( expr );
5, x
> subsop( 1=t, expr );
tx
L’opérande d’ordre zéro est généralement le nom de la fonction.

> expr := cos(x);
expr := cos(x)
> subsop( 0=sin, expr );
sin(x)
La présente section, à la page 182, donne plus de détails sur les

opérandes d’une expression.
Changer le type d’une expression

Vous pouvez trouver nécessaire de convertir une expression dans un autre
type. Considérez la série de Taylor de sin(x).
> f := sin(x);
f := sin(x)
> t := taylor( f, x=0 );
1 3 1 5
t := x − x + x + O(x6 )
6 120
Puisque vous ne pouvez tracer le graphique d’une série, vous devez

utiliser convert(..., polynom) pour la convertir d’abord en approxi-
mation polynomiale.
> p := convert( t, polynom );
1 3 1 5
p := x − x + x
6 120
De manière similaire, le titre d’un graphique doit être une chaı̂ne, et

non une expression générale. Vous pouvez utiliser convert(..., string)
pour convertir une expression en chaı̂ne.
> p_txt := convert( p, string );
p_txt := “x-1/6*x^3+1/120*x^ 5”
> plot( p, x=-4..4, title=p_txt );
x–1/6*x^3+1/120*x^5
1.5
1
0.5
–4 –3 –2 –1 0 1 2 3 4
–0.5 x
–1
–1.5
La commande cat concatène tous ses arguments pour créer une nou-
velle chaîne.
> ttl := cat( convert( f, string ),
> " and its Taylor approximation ",
> p_txt );
ttl := “sin(x) and its Taylor approximation x-1/6*\

x^3+1/120*x^5”
> plot( [f, p], x=-4..4, title=ttl );
sin(x)anditsTaylorapproximationx–1/6*x^3+1/120*x^5
1.5
1
0.5
–4 –3 –2 –1 0 1 2 3 4
–0.5 x
–1
–1.5
Vous pouvez également convertir une liste en ensemble ou un ensemble

en liste.
> L := [1,2,5,2,1];
L := [1, 2, 5, 2, 1]
> S := convert( L, set );
S := {1, 2, 5}
> convert( S, list );
[1, 2, 5]
La commande convert peut effectuer plusieurs autres conversions

structurelles et mathématiques. Consultez la rubrique ?convert pour ob-
tenir davantage d’information à ce sujet.
5.4 Les règles d’évaluation

Dans un programme de mathématiques symboliques comme Maple, la
question de l’évaluation occupe une place importante. Lorsque vous as-
signez la valeur y à x, la valeur z à y et la valeur 5 à z, comment x doit-il
être évalué ?
Niveaux d’évaluation
Dans la plupart des cas, Maple effectue une évaluation complète des noms :
lorsque vous utilisez un nom ou un symbole, le logiciel vérifie si ce nom
ou ce symbole possède une valeur assignée. Le cas échéant, Maple rem-
place le nom par la valeur trouvée. Si cette valeur possède elle-même une
valeur assignée, Maple effectue une autre substitution, et ainsi de suite de
manière récursive jusqu’à ce qu’aucune substitution ne soit possible.
> x := y;
x := y
> y := z;
y := z
> z := 5;
z := 5
Maple évalue maintenant x intégralement : il remplace x par y, y par

z et finalement z par 5.
> x;
Vous pouvez utiliser la commande eval pour contrôler le niveau d’é-

valuation d’une expression. Lorsque vous appelez eval avec un seul argu-
ment, eval évalue intégralement son argument.
> eval(x);
5
5.4 Les règles d’évaluation • 197
Un deuxième argument à eval spécifie jusqu’où vous souhaitez évaluer

le premier argument.
> eval(x, 1);
> eval(x, 2);
> eval(x, 3);
Les principales exceptions à la règle de l’évaluation complète sont

les structures de données spéciales comme les tableaux, les matrices et
les procédures, de même que le comportement des variables locales à
l’intérieur d’une procédure.
Évaluation du dernier nom

Les structures de données array, table, matrix et proc possèdent un
comportement d’évaluation spécial appelé évaluation du dernier nom.
> x := y;
x := y
> y := z;
y := z
> z := array( [ [1,2], [3,4] ] );

1 2
z :=
3 4
Maple remplace x par y et y par z, mais arrête à ce point puisque

l’évaluation du dernier nom, z, produirait un tableau, l’un des quatre
types spéciaux de structures.
> x;
Maple utilise l’évaluation du dernier nom pour les tableaux, les tables,
les matrices et les procédures pour conserver la représentation compacte
des entrées de tableaux non assignées (par exemple T[3]) et les com-
mandes non évaluées (par exemple sin(x)). Vous pouvez forcer une
évaluation complète en appelant explicitement la commande eval.
> eval(x);

1 2
3 4
> add2 := proc(x,y) x+y; end proc;
add2 := proc(x, y) x + y end proc
> add2;
add2
Vous pouvez facilement forcer une évaluation complète en utilisant

eval ou print.
> eval(add2);
proc(x, y) x + y end proc
Remarquez qu’une évaluation complète des procédures contenues dans

la bibliothèque de Maple, par défaut, supprime le code de cette procédure.
Pour illustrer cette situation, examinez la commande erfi.
> erfi;
erfi
> eval(erfi);
proc(x : :algebraic) . . . end proc

Assignez à la variable verboseproc de la commande interface la

valeur 2, et essayez à nouveau.
> interface( verboseproc=2 );
> eval(erfi);
proc(x : :algebraic)
option‘Copyright (c) 1996 Waterloo Maple Inc.\
All rights reserved .‘;
if nargs = 1 then
error “expecting 1 argument, got %1”, nargs
elif type(x, ’complex(float )’) then evalf(’erfi ’(x))
elif x = 0 then 0
elif type(x, ’∞’) then
if type(x, ’{undefined , cx _infinity }’) then
undefined + undefined ∗ I
elif type(x, ’extended _numeric’) then x
elif type( (x), ’∞’) then ∞ + ∞ ∗ I
else CopySign(I,
(x))
end if
elif type(x, ’undefined ’) then
if type(x, ’extended _numeric’) then undefined
elif type(x, ’imaginary ’) then undefined ∗ I
else undefined + undefined ∗ I
end if
elif type(x, ‘ ∗ ‘) and member(I, {op(x)}) then
I ∗ erf(−I ∗ x)
elif type(x, ’complex(numeric)’) and csgn(x) < 0 then
− erfi(−x)
eliftype(x, ‘ ∗ ‘) and type(op(1, x), ’complex(numeric)’)
and csgn(op(1, x)) < 0then − erfi(−x)
elif type(x, ‘ + ‘) and traperror(sign(x)) = −1 then
− erfi(−x)
else ’erfi ’(x)
end if
end proc
La valeur par défaut de verboseproc est 1.
> interface( verboseproc=1 );
La rubrique d’aide ?interface explique les valeurs permises de

verboseproc et des autres variables d’interface.
Évaluation à un niveau
Les variables locales d’une procédure sont appliquées à l’évaluation à un
niveau : si vous assignez une variable locale, le résultat de l’évaluation est
la valeur la plus récemment assignée directement à cette variable.
> test:=proc()
> local x, y, z;
> x := y;
> y := z;
> z := 5;
> x;
> end proc:
> test();
Comparez cette évaluation à l’exemple similaire présenté à la

page 196. L’évaluation complète à l’intérieur d’une procédure est rare-
ment nécessaire et peut mener à une procédure inefficace. Lorsque vous
désirez obtenir de l’évaluation complète à l’intérieur d’une procédure, uti-
lisez eval.
Commandes avec des règles spéciales d’évaluation

Les commandes assigned et evaln Les fonctions assigned et evaln
évaluent leurs arguments seulement au point où les arguments deviennent
des noms pour la première fois.
> x := y;
x := y
> y := z;
y := z
> evaln(x);
x
La commande assigned vérifie si une valeur a été assignée à un nom.

> assigned( x );
true
La commande seq Pour créer des suites d’expressions, la commande seq

n’évalue pas ses arguments, de manière que si une valeur a été assignée à
une variable, elle peut toujours l’utiliser comme une variable d’indice.
> i := 2;
i := 2
> seq( i^2, i=1..5 );
1, 4, 9, 16, 25
> i;
Comparez ceci au comportement de sum.

> sum( i^2, i=1..5 );
Error, (in sum) summation variable previously assigned,

second argument evaluates to 2 = 1 .. 5
Vous pouvez facilement résoudre ce problème en utilisant les guille-

mets simples.
Emp
echer l’évaluation d’une expression
Le langage Maple supporte l’utilisation des guillemets pour retarder l’éva-
luation d’un niveau. Entourer un nom de guillemets simples (’) empêche
Maple d’évaluer celui-ci.
> i := 4;
i := 4
> i;
> ’i’;
Utilisez cette méthode pour éviter le problème suivant.

> i;
> sum( i^2, i=1..5 );
Error, (in sum) summation variable previously assigned,

second argument evaluates to 4 = 1 .. 5
> sum( ’i^2’, ’i’=1..5 );
55
> i;
L’évaluation complète d’une expression entourée de guillemets sup-

prime un niveau de ces guillemets.
> x := 0;
x := 0
> ’’’x’+1’’;
’’x’ + 1’
> %;
’x’ + 1
> %;
x+1
> %;
Entourer une expression de guillemets retarde l’évaluation, mais n’em-

pêche pas les simplifications automatiques ni les calculs arithmétiques.
> ’1-1’;
> ’p+q-i-p+3*q’;
4q − i
Lorsque vous entourez une simple variable de guillemets simples, le

résultat retourné est le nom de la variable. Vous pouvez employer cette
méthode pour désaffecter une variable.
> x := 1;
x := 1
> x;
> x := ’x’;
x := x
> x;
Cependant, en général, vous devez utiliser evaln.

> i := 4;
i := 4
> a[i] := 9;
a4 := 9
Remarquez que ’a[i]’ est a[i] et non a[4].

> ’a[i]’;
ai
Vous devez utilser evaln pour désaffecter a[i].

> evaln( a[i] );
a4
> a[i] := evaln( a[i] );
a4 := a4
Utiliser les variables entourées de guillemets comme arguments

de fonctions
Quelques commandes Maple se servent de noms comme moyen de retour-
ner de l’information en plus de la valeur retournée de manière standard.
La commande divide assigne le quotient au nom global q.
> divide( x^2-1, x-1, ’q’ );
true
> q;
x+1
Rappelez-vous d’utiliser un nom entouré de guillemets afin de vous

assurer de ne pas passer de variable allouée à la procédure. Vous pouvez
éviter d’utiliser les guillemets si vous vous assurez que le nom utilisé n’a
pas de valeur assignée.
> q := 2;
q := 2
> divide( x^2-y^2, x-y, q );
Error, wrong number (or type) of parameters in function

divide
> q := evaln(q);
q := q
> divide( x^2-y^2, x-y, q );
true
> q;
x+y
Les commandes rem, quo, irem et iquo se comportent de manière simi-

laire.
Concaténation de noms
La concaténation est une manière de former de nouveaux noms de va-
riables basés sur d’autres noms.
> a||b;
ab
L’opérateur de concaténation, || , dans un nom, entraı̂ne l’évalu-

ation du côté droit de l’opérateur, mais pas celui du côté gauche.
> a := x;
a := x
> b := 2;
b := 2
> a||b;
a2
> c := 3;
c := 3
> a||b||c;
a23
Si un nom issu d’une concaténation ne forme pas un seul symbole,

Maple n’évalue pas la concaténation.
> a := x;
a := x
> b := y+1;
b := y + 1
> new_name := a||b;
new _name := a||(y + 1)
> y := 3;
y := 3
> new_name;
a4
Vous pouvez vous servir des noms concaténés pour assigner et créer
des expressions.
> i := 1;
i := 1
> b||i := 0;
b1 := 0
Ici, les guillemets simples sont nécessaires.

> sum( ’a||k’ * x^k, k=0..8 );
a0 + a1 x + a2 x2 + a3 x3 + a4 x4 + a5 x5 + a6 x6 + a7 x7
+ a8 x8
Lorsque vous omettez les guillemets simples, Maple évalue a||k à ak.
> sum( a||k * x^k, k=0..8 );
ak + ak x + ak x2 + ak x3 + ak x4 + ak x5 + ak x6 + ak x7
+ ak x8
Vous pouvez également utiliser la concaténation pour former des titres
de graphiques.
5.5 Conclusion
Dans ce chapitre, vous avez vu comment effectuer plusieurs types de ma-
nipulations sur des expressions, depuis l’addition de deux équations à la
sélection de parties d’une expression générale. Cependant, les commandes
que vous avez vues ici vous permettent de transformer une expression sous
plusieurs formes, souvent celles que vous jugez les plus simples. Si tel n’est
pas le cas, vous pouvez utiliser les relations accessoires pour spécifier vos
propres règles de simplification, ou encore des hypothèses pour spécifier
des propriétés des inconnues.
Vous avez également vu que, dans la plupart des cas, Maple effectue
l’évaluation complète des variables. Il existe cependant quelques excep-
tions, comme l’évaluation du dernier nom pour certaines grandes struc-
tures de données, l’évaluation à un seul niveau des variables locales d’une
procédure ainsi que l’évaluation retardée au moyen des guillemets simples.
6 Exemples tirés du calcul
différentiel
Le présent chapitre illustre par quelques exemples la manière dont Maple

vous aide à présenter et à résoudre des problèmes de calcul différentiel. La
première section décrit les concepts élémentaires de la dérivée et de l’in-
tégrale ; la deuxième traite des équations différentielles ordinaires ; enfin,
la troisième section porte sur les équations aux dérivées partielles.
6.1 Calcul différentiel élémentaire

Vous verrez ici plusieurs exemples montrant la manière d’illustrer des
idées et de résoudre des problèmes de calcul différentiel. Le package
Student[Calculus1] contient plusieurs commandes qui s’avèrent par-
ticulièrement utiles dans ce domaine.
La dérivée
La prsente section illustre la signification graphique de la dérivée en tant
que pente de la droite tangente, puis montre comment déterminer l’en-
semble des points d’inflexion d’une fonction.
Définissez la fonction f : x → exp(sin(x)) de la manière suivante.
> f := x -> exp( sin(x) );
f := x → esin(x)
Trouvez la dérivée de f évaluée en x0 = 1.

> x0 := 1;
209
210 • Chapitre 6: Exemples tirés du calcul différentiel
x0 := 1
p0 et p1 sont deux points situés sur le graphique de f .

> p0 := [ x0, f(x0) ];
p0 := [1, esin(1) ]
> p1 := [ x0+h, f(x0+h) ];
p1 := [1 + h, esin(1+h) ]
La commande NewtonQuotient du package Student calcule la pente

de la sécante passant par p0 et p1 .
Utilisez NewtonQuotient pour trouver une expression pour la pente.
> m := NewtonQuotient(f(x), x=x0, h=h);
esin(1) − esin(1+h)
m := −
h
Si h = 1, la pente est donnée par

> eval( m, h=1 );
esin(2) − esin(1)
La commande evalf nous donne une approximation décimale de ce

résultat.
> evalf( % );
0.162800903
Lorsque h tend vers zéro, les valeurs de la pente de la sécante semblent

converger.
> h_values := seq( NewtonQuotient( f(x), x=1.0, h=1.0/i^2 ),
> i=1..20);
6.1 Calcul différentiel élémentaire • 211
h_values := 0.1628009030, 1.053234748, 1.174305789,

1.210917616, 1.226806975, 1.235154852, 1.240091510,
1.243256512, 1.245408615, 1.246939100, 1.248066842,
1.248921648, 1.249585493, 1.250111128, 1.250534250,
1.250880512, 1.251167122, 1.251406908, 1.251609743,
1.251782800
Voici l’équation de la pente de la sécante.
> y - p0[2] = m * ( x - p0[1] );
(esin(1+h) − esin(1) ) (x − 1)
y − esin(1) =
h
La commande isolate récrit l’équation sous la forme pente-ordonnée

à l’origine.
> isolate( %, y );
(esin(1+h) − esin(1) ) (x − 1)
y= + esin(1)
h
Vous devez faire de cette équation une fonction.

> secant := unapply( rhs(%), x );
(esin(1+h) − esin(1) ) (x − 1)
secant := x → + esin(1)
h
Vous pouvez maintenant tracer la sécante et la fonction elle-même

sur le même graphique pour différentes valeurs de h. Tout d’abord, vous
devez créer une suite de graphiques.
> S := seq( plot( [f(x), secant(x)], x=0..4,
> view=[0..4, 0..4] ),
> h=h_values ):
La commande display du package plots peut afficher les graphiques

de la suite sous forme d’animation.
> with(plots):

> display( S, insequence=true, view=[0..4, 0..4] );
x x x x x
x x x x x
x x x x x
x x x x x
Dans la limite lorsque h tend vers zéro, la pente est donnée par
> Limit( m, h=0 );
esin(1+h) − esin(1)
lim
h→0 h
La valeur de cette limite est

> value( % );
esin(1) cos(1)
Bien entendu, cette réponse est la valeur de f (x0 ). Pour vous assurer
de ceci, définissez d’abord la fonction f 1 comme étant la dérivée première
de f . Puisque f est une fonction, utilisez D. L’opérateur D calcule la dérivée
d’une fonction, alors que diff calcule la dérivée d’une expression. Pour
en savoir plus, consultez la rubrique ?operators,D.
> f1 := D(f);
f1 := x → cos(x) esin(x)
Maintenant, vous pouvez voir que f 1(x0 ) est égale à la limite ci-
dessus.
> f1(x0);
esin(1) cos(1)
Dans le cas présent, la dérivée seconde existe.

> diff( f(x), x, x );
−sin(x) esin(x) + cos(x)2 esin(x)
Encore une fois, définissez la fonction f 2 comme la dérivée seconde

de f .
> f2 := unapply( %, x );
f2 := x → −sin(x) esin(x) + cos(x)2 esin(x)
Lorsque vous tracez le graphique de f de même que ses dérivées

première et seconde, vous pouvez remarquer que f augmente lorsque f 1
est positive, et que la concavité de f est tournée vers le bas lorsque f 2
est négative.
> plot( [f(x), f1(x), f2(x)], x=0..10 );
0 2 4 6 8 10
x
–1
–2
Le graphique de f possède un point d’inflexion là où la dérivée seconde

change de signe ; ces changements de signe peuvent survenir aux valeurs
de x telles que f 2(x) s’annule.
> sol := { solve( f2(x)=0, x ) };
   
1√ 1 1√ 1
5− 5−
 2   2 2 
sol := arctan 2 2 √  , −arctan 2 √  + π,
−2 + 2 5 −2 + 2 5
1 1√ 1 √
arctan(− − 5, − −2 − 2 5),
2 2 2
1 1√ 1 √
arctan(− − 5, −2 − 2 5)
2 2 2
Deux de ces solutions sont complexes.

> evalf( sol );
{0.6662394321, 2.475353222,
−1.570796327 + 1.061275064 I,
−1.570796327 − 1.061275064 I, }
Dans cet exemple, seules les solutions réelles sont d’intérêt. Vous pou-
vez utiliser la commande select pour choisir les constantes réelles dans
l’ensemble solution.
> infl := select( type, sol, realcons );
     
 1√ 1 1√ 1 
 5− 5− 
 2 2   2 2 
infl := arctan 2 √  , −arctan 2 √ +π

 −2 + 2 5 −2 + 2 5 

> evalf( infl );
{0.6662394325, 2.475353222}
Du graphique tracé précédemment, vous pouvez remarquer que f 2

change en effet de signe en ces valeurs de x. L’ensemble des points d’in-
flexion devient donc
> { seq( [x, f(x)], x=infl ) };
  
    √ 
1√ 1 2 1/2
5−1/2 
 5−  √ √
√
(1/2 5−1/2) 2 
  2 2  −2+2 5 1+4 √

arctan 2 √ , e
−2+2 5
,
 −2 + 2 5 
 
  
   √  
 1√ 1 2 1/2
5−1/2 
 5−  √ √
√
(1/2 5−1/2) 2 
  2 2  −2+2 5 1+4 √

−arctan 2 √  + π, e −2+2 5

 −2 + 2 5 
 
> evalf( % );
{[2.475353222, 1.855276958],
[0.6662394325, 1.855276958]}
Puisque la fonction f est périodique, elle possède une infinité de points
d’inflexion. Vous pouvez les obtenir tous en déplaçant horizontalement les
deux points d’inflexion ci-dessus par des multiples entiers de 2π.
Une approximation de Taylor

Voyons maintenant comment utiliser Maple pour analyser le terme d’er-
reur d’une approximation par série de Taylor. Voici la formule de Taylor.
> taylor( f(x), x=a );
1 (2) 1
f(a) + D(f )(a) (x − a) + (D )(f )(a) (x − a)2 + (D(3) )(f )(a)
2 6
1 1
(x − a)3 + (D(4) )(f )(a) (x − a)4 + (D(5) )(f )(a) (x − a)5 +
24 120
O((x − a)6 )
Vous pouvez utiliser cette formule pour calculer une approximation
polynomiale d’une fonction f près de x = a.
> f := x -> exp( sin(x) );
f := x → esin(x)
> a := Pi;
a := π
> taylor( f(x), x=a );
1 1 1
1 − (x − π) + (x − π)2 − (x − π)4 + (x − π)5 +
2 8 15
O((x − π)6 )
Avant de tracer le graphique de l’approximation de Taylor, vous devez
convertir cette série en un polynôme.
> poly := convert( %, polynom );
1 1 1
poly := 1 − x + π + (x − π)2 − (x − π)4 + (x − π)5
2 8 15
Tracez maintenant le graphique de f avec celui de poly.

> plot( [f(x), poly], x=0..10, view=[0..10, 0..3] );
2.5
1.5
0.5
0 2 4 6 8 10
x
L’expression (1/6!)f (6) (ξ)(x − a)6 nous donne l’erreur de l’approxima-

tion, où ξ est un nombre compris entre x et a. La dérivée sixième de f
est
> diff( f(x), x$6 );
−sin(x) esin(x) + 16 cos(x)2 esin(x) − 15 sin(x)2 esin(x)

+ 75 sin(x) cos(x)2 esin(x) − 20 cos(x)4 esin(x)
− 15 sin(x)3 esin(x) + 45 sin(x)2 cos(x)2 esin(x)
− 15 sin(x) cos(x)4 esin(x) + cos(x)6 esin(x)
L’usage de l’opérateur séquentiel $ dans la commande précédente vous

permet de raccourcir l’appel de la fonction. Sans cet opérateur, vous de-
vriez entrer , x six fois pour calculer la dérivée d’ordre 6. Définissez la
fonction f 6 comme étant cette dérivée.
> f6 := unapply( %, x );
f6 := x → −sin(x) esin(x) + 16 cos(x)2 esin(x)

− 15 sin(x)2 esin(x) + 75 sin(x) cos(x)2 esin(x)
− 20 cos(x)4 esin(x) − 15 sin(x)3 esin(x)
+ 45 sin(x)2 cos(x)2 esin(x) − 15 sin(x) cos(x)4 esin(x)
+ cos(x)6 esin(x)
Vous pouvez maintenant calculer l’erreur de l’approximation.
> err := 1/6! * f6(xi) * (x - a)^6;
1
err := (−sin(ξ) esin(ξ) + 16 cos(ξ)2 esin(ξ)
720
− 15 sin(ξ)2 esin(ξ) + 75 sin(ξ) cos(ξ)2 esin(ξ)
− 20 cos(ξ)4 esin(ξ) − 15 sin(ξ)3 esin(ξ)
+ 45 sin(ξ)2 cos(ξ)2 esin(ξ) − 15 sin(ξ) cos(ξ)4 esin(ξ)
+ cos(ξ)6 esin(ξ) )(x − π)6
Le graphique précédent indique que l’erreur (en valeur absolue) est
faible pour x compris entre 2 et 4.
> plot3d( abs( err ), x=2..4, xi=2..4,
> style=patch, axes=boxed );
0.16
0
2 2
xi x
4 4
Pour déterminer l’erreur exacte, vous devez effectuer une analyse

complète de l’expression err dans les deux régions fermées par x = 2,
x = 4, ξ = a et ξ = x (soit pour x compris entre 2 et 4 et pour ξ com-
pris entre a et x). La commande curve du package plottools permet
d’illustrer ces deux régions.
> with(plots): with(plottools):

Warning, the name arrow has been redefined
> display( curve( [ [2,2], [2,a], [4,a], [4,4], [2,2] ] ),

> labels=[x, xi] );
3.5
xi 3
2.5
2
2 2.5 3 3.5 4
x
Les dérivées partielles de err vous permettent de déterminer les ex-

trémums de err à l’intérieur de ces deux régions. Vous devez alors étudier
err aux bords du domaine. Les dérivées partielles de err sont
> err_x := diff(err, x);
1
err _x := (−sin(ξ) esin(ξ) + 16 cos(ξ)2 esin(ξ)
120
− 15 sin(ξ)2 esin(ξ) + 75 sin(ξ) cos(ξ)2 esin(ξ)
− 20 cos(ξ)4 esin(ξ) − 15 sin(ξ)3 esin(ξ)
+ 45 sin(ξ)2 cos(ξ)2 esin(ξ) − 15 sin(ξ) cos(ξ)4 esin(ξ)
+ cos(ξ)6 esin(ξ) )(x − π)5
> err_xi := diff(err, xi);
1
err _xi := (−cos(ξ) esin(ξ) − 63 sin(ξ) cos(ξ) esin(ξ)
720
+ 91 cos(ξ)3 esin(ξ) − 210 sin(ξ)2 cos(ξ) esin(ξ)
+ 245 sin(ξ) cos(ξ)3 esin(ξ) − 35 cos(ξ)5 esin(ξ)
− 105 sin(ξ)3 cos(ξ) esin(ξ) + 105 sin(ξ)2 cos(ξ)3 esin(ξ)
− 21 sin(ξ) cos(ξ)5 esin(ξ) + cos(ξ)7 esin(ξ) )(x − π)6
Les deux dérivées partielles sont nulles au point critique.
> sol := solve( {err_x=0, err_xi=0}, {x, xi} );
sol := {x = π, ξ = ξ}
L’erreur est également nulle en ce point.

> eval( err, sol );
Vous devez maintenant regrouper un ensemble de valeurs critiques.

La plus grande valeur critique borne l’erreur maximale.
> critical := { % };
critical := {0}
La dérivée partielle err_xi est nulle en un point critique situé sur

l’une des deux frontières x = 2 ou x = 4.
> sol := { solve( err_xi=0, xi ) };
1
sol := { π, arctan(RootOf(%1, index = 4),
2
RootOf(_Z 2 + RootOf(%1, index = 4)2 − 1)), arctan(
RootOf(%1, index = 1),
RootOf(_Z 2 + RootOf(%1, index = 3)2 − 1))}
%1 := −56 − 161 _Z + 129 _Z 2 + 308 _Z 3 + 137 _Z 4
+ 21 _Z 5 + _Z 6
> evalf(sol);
{−1.570796327 + 0.8535664710 I, 1.570796327,

−0.3257026605, −1.570796327 + 2.473801030 I,
0.6948635283, −1.570796327 + 1.767486929 I,
−1.570796327 + 3.083849212 I}
Il est recommandé de vérifier l’ensemble solution en traçant le gra-
phique de la solution.
> plot( eval(err_xi, x=2), xi=2..4 );
0.6
0.4
0.2
0 2.2 2.4 2.6 2.8 3 3.2 3.4 3.6 3.8 4

xi
–0.2
Deux solutions de err_xi=0 semblent exister entre 2 et 4 là où solve

n’en a trouvé aucune : π/2 est inférieur à 2. Vous devez donc utiliser des
méthodes numériques. Si x = 2, alors ξ doit être situé dans l’intervalle
situé entre 2 et a.
> sol := fsolve( eval(err_xi, x=2), xi, 2..a );
sol := 2.446729125
En ce point, l’erreur est

> eval( err, {x=2, xi=sol});
0.07333000221 (2 − π)6
Ajoutez maintenant cette valeur à l’ensemble des valeurs critiques.

> critical := critical union {%};
critical := {0, 0.07333000221 (2 − π)6 }
Si x = 4, alors ξ doit être situé entre a et 4.

> sol := fsolve( eval(err_xi, x=4), xi, a..4 );
sol := 3.467295314
En ce point, l’erreur est

> eval( err, {x=4, xi=sol} );
−0.01542298119 (4 − π)6
> critical := critical union {%};
critical :=
{0, 0.07333000221 (2 − π)6 , −0.01542298119 (4 − π)6 }
À la frontière ξ = a, l’erreur est
> B := eval( err, xi=a );
1
B := − (x − π)6
240
La dérivée B1 de B est nulle en un point critique.

> B1 := diff( B, x );
1
B1 := − (x − π)5
40
> sol := { solve( B1=0, x ) };
sol := {π}
En ce point critique, l’erreur est

> eval( B, x=sol[1] );
> critical := critical union { % };
critical :=
{0, 0.07333000221 (2 − π)6 , −0.01542298119 (4 − π)6 }
À la dernière frontière, ξ = x, l’erreur est
> B := eval( err, xi=x );
1
B := (−sin(x) esin(x) + 16 cos(x)2 esin(x) − 15 sin(x)2 esin(x)
720
− 15 sin(x) cos(x)4 esin(x) + cos(x)6 esin(x) )(x − π)6
Encore une fois, vous devez trouver le point où la dérivée s’annule.
> B1 := diff( B, x );
1
B1 := (−cos(x) esin(x) − 63 sin(x) cos(x) esin(x)
720
+ 91 cos(x)3 esin(x) − 210 sin(x)2 cos(x) esin(x)
− 105 sin(x)3 cos(x) esin(x) + 105 sin(x)2 cos(x)3 esin(x)
1
− 21 sin(x) cos(x)5 esin(x) + cos(x)7 esin(x) )(x − π)6 + (
120
−sin(x) esin(x) + 16 cos(x)2 esin(x) − 15 sin(x)2 esin(x)
− 15 sin(x) cos(x)4 esin(x) + cos(x)6 esin(x) )(x − π)5
> sol := { solve( B1=0, x ) };
sol := {π}
Il est bon de vérifier la solution en traçant le graphique.

> plot( B1, x=2..4 );
0.8
0.6
0.4
0.2
0 2.2 2.4 2.6 2.8 3 3.2 3.4 3.6 3.8 4

x
Le graphique de B1 indique qu’une solution existe entre 2.1 et 2.3.

Puisque solve ne peut trouver cette solution, vous devez à nouveau re-
courir aux méthodes numériques.
> fsolve( B1=0, x, 2.1..2.3 );
2.180293062
Ajoutez cette solution numérique à l’ensemble des solutions symbo-

liques.
> sol := sol union { % };
sol := {2.180293062, π}
L’ensemble suivant contient les erreurs extrêmes à la frontière ξ = x.

> { seq( B, x=sol ) };
{0, 0.04005698601 (2.180293062 − π)6 }
Agrandissez maintenant l’ensemble des grandes erreurs.

> critical := critical union %;
critical := {0, −0.01542298119 (4 − π)6 ,

0.04005698601 (2.180293062 − π)6 ,
0.07333000221 (2 − π)6 }
Enfin, vous devez ajouter l’erreur aux quatre coins de l’ensemble des
valeurs critiques.
> critical := critical union
> { eval( err, {xi=2, x=2} ),
> eval( err, {xi=2, x=4} ),
> eval( err, {xi=4, x=2} ),
> eval( err, {xi=4, x=4} ) };
critical := {0, −0.01542298119 (4 − π)6 ,

0.04005698601 (2.180293062 − π)6 ,
1
0.07333000221 (2 − π)6 , (−sin(2) esin(2)
720
+ 16 cos(2)2 esin(2) − 15 sin(2)2 esin(2) + 75 sin(2) cos(2)2 esin(2)
− 20 cos(2)4 esin(2) − 15 sin(2)3 esin(2)
+ 45 sin(2)2 cos(2)2 esin(2) − 15 sin(2) cos(2)4 esin(2)
1
+ cos(2)6 esin(2) )(2 − π)6 , (−sin(2) esin(2)
720
− 20 cos(2)4 esin(2) − 15 sin(2)3 esin(2)
1
720
− 20 cos(4)4 esin(4) − 15 sin(4)3 esin(4)
1
720
− 20 cos(4)4 esin(4) − 15 sin(4)3 esin(4)
+ cos(4)6 esin(4) )(4 − π)6 }
Vous devez maintenant déterminer le maximum en valeur absolue des
éléments de critical. Tout d’abord, appliquez la commande abs aux
éléments de critical.
> map( abs, critical );
{0, 0.04005698601 (2.180293062 − π)6 ,

1
0.07333000221 (2 − π)6 , 0.01542298119 (4 − π)6 , − (
720
−sin(2) esin(2) + 16 cos(2)2 esin(2) − 15 sin(2)2 esin(2)
+ 75 sin(2) cos(2)2 esin(2) − 20 cos(2)4 esin(2) − 15 sin(2)3 esin(2)
1
+ cos(2)6 esin(2) )(2 − π)6 , − (−sin(2) esin(2)
720
− 20 cos(2)4 esin(2) − 15 sin(2)3 esin(2)
1
720
− 20 cos(4)4 esin(4) − 15 sin(4)3 esin(4)
1
720
− 20 cos(4)4 esin(4) − 15 sin(4)3 esin(4)
+ cos(4)6 esin(4) )(4 − π)6 }
Trouvez ensuite l’élément maximal. La commande max requiert une
suite de nombres ; vous devez donc utiliser la commande op pour trans-
former l’ensemble des valeurs en une suite.
> max_error := max( op(%) );
max _error := 0.07333000221 (2 − π)6
Ce nombre est approximativement

> evalf( max_error );
0.1623112756
Vous pouvez maintenant tracer f , son approximation de Taylor et une

paire de courbes indiquant la bande d’erreur.
> plot( [ f(x), poly, f(x)+max_error, f(x)-max_error ],
> x=2..4,
> color=[ red, blue, brown, brown ] );
2.5
1.5
0.5
2 2.2 2.4 2.6 2.8 3 3.2 3.4 3.6 3.8 4
x
Ce graphique montre que l’erreur réelle demeure bien en-déçà de l’es-

timation de l’erreur.
L’intégrale
L’intégrale d’une fonction peut être considérée comme une mesure de l’aire
comprise entre l’axe des x et la courbe de cette fonction. La définition
de l’intégrale de Riemann repose sur cette interprétation graphique de
l’intégrale.
> f := x -> 1/2 + sin(x);
1
f := x → + sin(x)
2
Par exemple, la commande ApproximateInt que l’on trouve dans

le package Student[Calculus1] avec pour paramètres method = left,
partition = 6 et output = plot dessine le graphique de f avec 6 boı̂tes.
La hauteur de chaque boı̂te est la valeur de f évaluée sur le coin gauche
de chacune d’entre elles.
> ApproximateInt( f(x), x=0..10, method=left, partition=6,

> output=plot);
f(x)=1/2+sin(x)
ontheInterval[0,10]
UsingaLeft-endpointRiemannSum
ApproximateValue:6.839071529
1.5
0.5
2 4 6 8 10
x
–0.5
–1
Area:6.845601763
f(x)
Changez output = plot pour output = sum pour calculer l’aire des
boı̂tes.
> ApproximateInt( f(x), x=0..10, method=left, partition=6,
> output=sum);
5
5 1 5
( + sin( i))
3 2 3
i=0
Ce nombre est approximativement

> evalf( % );
6.845601766
L’approximation de l’aire s’améliore à mesure que plus de boı̂tes sont

utilisées. Augmentez le nombre de boı̂tes jusqu’à 12 et calculez la valeur
de ApproximateInt pour chacune de ces boı̂tes.
> seq( evalf(ApproximateInt( f(x), x=0..10, method=left,
> partition=n^2)), n=3..14);
6.948089404, 6.948819107, 6.923289158, 6.902789479,

6.888196447, 6.877830054, 6.870316620, 6.864739771,
6.860504866, 6.857222010, 6.854630209, 6.852550665
Utilisez l’option output = animation pour créer une animation de la
somme de Riemann.
> ApproximateInt( f(x), x=0..4*Pi, method=left, partition=6,

> output=animation, iterations=7);
AnApproximationoftheIntegralof AnApproximationoftheIntegralof AnApproximationoftheIntegralof AnApproximationoftheIntegralof
f(x)=1/2+sin(x) f(x)=1/2+sin(x) f(x)=1/2+sin(x) f(x)=1/2+sin(x)
ontheInterval[0,4*Pi] ontheInterval[0,4*Pi] ontheInterval[0,4*Pi] ontheInterval[0,4*Pi]
UsingaLeft-endpointRiemannSum UsingaLeft-endpointRiemannSum UsingaLeft-endpointRiemannSum UsingaLeft-endpointRiemannSum
ApproximateValue:6.283185307 ApproximateValue:6.283185307 ApproximateValue:6.283185307 ApproximateValue:6.283185307
1.5 1.5 1.5 1.5
1 1 1 1
0.5 0.5 0.5 0.5
0 2 4 6 8 10 12 0 2 4 6 8 10 12 0 2 4 6 8 10 12 0 2 4 6 8 10 12
x x x x
–0.5 –0.5 –0.5 –0.5
–1 –1 –1 –1
Area:6.283185309 Area:6.283185308 Area:6.283185308 Area:6.283185311
f(x) f(x) f(x) f(x)
AnApproximationoftheIntegralof AnApproximationoftheIntegralof AnApproximationoftheIntegralof

f(x)=1/2+sin(x) f(x)=1/2+sin(x) f(x)=1/2+sin(x)
ontheInterval[0,4*Pi] ontheInterval[0,4*Pi] ontheInterval[0,4*Pi]
UsingaLeft-endpointRiemannSum UsingaLeft-endpointRiemannSum UsingaLeft-endpointRiemannSum
ApproximateValue:6.283185307 ApproximateValue:6.283185307 ApproximateValue:6.283185307
1.5 1.5 1.5
1 1 1
0.5 0.5 0.5
0 2 4 6 8 10 12 0 2 4 6 8 10 12 0 2 4 6 8 10 12
x x x
–0.5 –0.5 –0.5
–1 –1 –1
Area:6.283185308 Area:6.283185309 Area:6.283185309
f(x) f(x) f(x)
Dans la limite, à mesure que le nombre de boı̂tes augmente, le résultat

se rapproche de l’intégrale définie.
> Int( f(x), x=0..10 );
10
1
+ sin(x) dx
0 2
La valeur de l’intégrale est

> value( % );
6 − cos(10)
en nombres décimaux, cette valeur est approximativement

> evalf( % );
6.839071529
L’intégrale indéfinie de f est

> Int( f(x), x );

1
+ sin(x) dx
2
> value( % );
1
x − cos(x)
2
Définissez la fonction F comme étant l’inverse de la dérivée.

> F := unapply( %, x );
1
F := x → x − cos(x)
2
Choisissez la constante d’intégration de telle sorte que F (0) = 0.

> F(x) - F(0);
1
x − cos(x) + 1
2
> F := unapply( %, x );
1
F := x → x − cos(x) + 1
2
Lorsque vous tracez le graphique de F et les boı̂tes ensemble, vous

pouvez remarquer que F augmente davantage lorsque sa boı̂te correspon-
dante est plus grande.
> with(plots):
> display( [ plot( F(x), x=0..10, color=blue, legend="F(x)" ),
> ApproximateInt( f(x), x=0..10, partition=14,
> method=left, output=plot) ] );
f(x)=1/2+sin(x)
ontheInterval[0,10]
UsingaLeft-endpointRiemannSum
ApproximateValue:6.839071529
1.5
0.5
0 2 4 6 8 10
x
–0.5
–1
Area:6.954499888
F(x)
f(x)
En spécifiant method = right ou method = midpoint lorsque vous

utilisez la commande ApproximateInt, vous pouvez dessiner et addition-
ner des boı̂tes évaluées en leur coin droit ou en leur point milieu.
Dérivées partielles mixtes

Cette section décrit l’opérateur différentiel D et donne un exemple d’une
fonction dont les dérivées partielles mixtes sont différentes.
Considérez la fonction suivante.
> f := (x,y) -> x * y * (x^2-y^2) / (x^2+y^2);
x y (x2 − y 2 )
f := (x, y) →
x2 + y 2
La fonction f n’est pas définie à l’origine.

> f(0,0);
Error, (in f) numeric exception: division by zero
En (x, y) = (r cos(θ), r sin(θ)), la valeur de la fonction est

> f( r*cos(theta), r*sin(theta) );
r2 cos(θ) sin(θ) (r2 cos(θ)2 − r2 sin(θ)2 )

r2 cos(θ)2 + r2 sin(θ)2
La valeur de f tend vers zéro lorsque r tend vers zéro.

> Limit( %, r=0 );
r2 cos(θ) sin(θ) (r2 cos(θ)2 − r2 sin(θ)2 )

lim
r→0 r2 cos(θ)2 + r2 sin(θ)2
> value( % );
Ainsi, vous pouvez prolonger f par continuité à l’origine en la

définissant égale à zéro en ce point.
> f(0.,0.) := 0;
f(0., 0.) := 0
L’affectation précédente ajoute une entrée dans la table de rappels

(en anglais remember table) de Maple. Voici le graphique de f .
> plot3d( f, -3..3, -3..3 );
La dérivée partielle de f par rapport à son premier paramètre, x, est

> fx := D[1](f);
y (x2 − y 2 ) x2 y x2 y (x2 − y 2 )
fx := (x, y) → + 2 − 2
x2 + y 2 x2 + y 2 (x2 + y 2 )2
Cette formule n’est cependant pas valide à l’origine.

> fx(0,0);
Error, (in fx) division by zero
Vous devez donc utiliser la définition de la dérivée exprimée sous forme

d’une limite.
> fx(0,0) := limit( ( f(h,0) - f(0,0) )/h, h=0 );
fx(0, 0) := 0
En (x, y) = (r cos(θ), r sin(θ)), la valeur de fx est

> fx( r*cos(theta), r*sin(theta) );
r sin(θ) (r2 cos(θ)2 − r2 sin(θ)2 ) r3 cos(θ)2 sin(θ)

+ 2
r2 cos(θ)2 + r2 sin(θ)2 r2 cos(θ)2 + r2 sin(θ)2
r3 cos(θ)2 sin(θ) (r2 cos(θ)2 − r2 sin(θ)2 )
−2
(r2 cos(θ)2 + r2 sin(θ)2 )2
> combine( % );
3 1
r sin(3 θ) − r sin(5 θ)
4 4
Lorsque la distance r entre (x, y) et (0, 0) tend vers zéro, |fx (x, y) −
fx (0, 0)| tend également vers zéro.
> Limit( abs( % - fx(0,0) ), r=0 );

3 1

lim r sin(3 θ) − r sin(5 θ)
r→0 4 4
> value( % );
Ainsi, fx est continue en (0, 0).

Symétriquement, les mêmes arguments s’appliquent à la dérivée de f
par rapport à son second paramètre, y.
> fy := D[2](f);
x (x2 − y 2 ) x y2 x y 2 (x2 − y 2 )
fy := (x, y) → − 2 − 2
x2 + y 2 x2 + y 2 (x2 + y 2 )2
> fy(0,0) := limit( ( f(0,k) - f(0,0) )/k, k=0 );
fy(0, 0) := 0
Voici la dérivée seconde mixte de f .

> fxy := D[1,2](f);
x2 − y 2 x2 x2 (x2 − y 2 )
fxy := (x, y) → + 2 − 2
x2 + y 2 x2 + y 2 (x2 + y 2 )2
y2 y 2 (x2 − y 2 ) x2 y 2 (x2 − y 2 )
−2 − 2 + 8
x2 + y 2 (x2 + y 2 )2 (x2 + y 2 )3
Encore une fois, cette formule n’est pas valide à l’origine.
> fxy(0,0);
Error, (in fxy) numeric exception: division by zero
La définition de la dérivée sous forme de limite est

> Limit( ( fx(0,k) - fx(0,0) )/k, k=0 );
lim − 1
k→0
> fxy(0,0) := value( % );
fxy(0, 0) := −1
L’autre dérivée seconde mixte est

> fyx := D[2,1](f);
x2 − y 2 x2 x2 (x2 − y 2 )
fyx := (x, y) → + 2 − 2
x2 + y 2 x2 + y 2 (x2 + y 2 )2
y2 y 2 (x2 − y 2 ) x2 y 2 (x2 − y 2 )
−2 − 2 + 8
x2 + y 2 (x2 + y 2 )2 (x2 + y 2 )3
À l’origine, vous devez utiliser la définition de la dérivée sous forme
de limite.
> Limit( ( fy(h, 0) - fy(0,0) )/h, h=0 );
lim 1
h→0
> fyx(0,0) := value( % );
fyx(0, 0) := 1
6.2 Équations différentielles ordinaires • 235
Remarquez que les deux dérivées partielles mixtes sont différentes à

l’origine.
> fxy(0,0) <> fyx(0,0);
−1 = 1
> evalb( % );
true
Les dérivées partielles mixtes sont égales seulement si elles sont conti-
nues. En traçant le graphique de fxy, on peut remarquer que cette fonc-
tion n’est pas continue en (0, 0).
> plot3d( fxy, -3..3, -3..3 );
Maple peut vous aider à résoudre plusieurs autres problèmes de calcul

différentiel élémentaire. La rubrique ?Student[Calculus1] est une bonne
source de référence.
6.2 Équations différentielles ordinaires

Maple dispose de toute une gamme d’outils permettant de résoudre, de
manipuler et de tracer le graphique d’équations différentielles ordinaires
et de systèmes d’équations différentielles.
La commande dsolve
La commande la plus utilisée pour étudier le comportement des équations
différentielles ordinaires (EDO) dans Maple est dsolve. Vous pouvez uti-
liser cet outil polyvalent pour obtenir à la fois des solutions exactes et des
solutions numériques pour un grand nombre d’EDO. La syntaxe de base
de dsolve est la suivante.
dsolve(eqns, vars )
Ici, eqns représente un ensemble d’équations différentielles et de valeurs

initiales, et vars représente l’ensemble de variables pour lesquelles on sou-
haite résoudre.
Voici une équation différentielle et une condition initiale.
> eq := diff(v(t),t)+2*t = 0;
d
eq := ( v(t)) + 2 t = 0
dt
> ini := v(1) = 5;
ini := v(1) = 5
Utilisez dsolve pour obtenir la solution.

> dsolve( {eq, ini}, {v(t)} );
v(t) = −t2 + 6
Si vous omettez une ou plusieurs des conditions initiales, dsolve re-

tourne des constantes arbitraires de la forme _Cnumber . _Cnumber .
> eq := diff(y(x),x$2) - y(x) = 1;
d2
eq := ( y(x)) − y(x) = 1
dx2
> dsolve( {eq}, {y(x)} );
{y(x) = ex _C2 + e(−x) _C1 − 1}

Pour spécifier des conditions initiales pour la dérivée d’une fonction,

utilisez la notation suivante.
D(fcn )(var_valeur ) = valeur

(D@@n )(fcn )(var_valeur ) = valeur
La notation D correspond à la dérivée. La notation D@@n représente la

dérivée d’ordre n. Voici une équation différentielle et des conditions ini-
tiales requérant la dérivée.
> de1 := diff(y(t),t$2) + 5*diff(y(t),t) + 6*y(t) = 0;
d2 d
de1 := ( 2
y(t)) + 5 ( y(t)) + 6 y(t) = 0
dt dt
> ini := y(0)=0, D(y)(0)=1;
ini := y(0) = 0, D(y)(0) = 1
Encore une fois, utilisez dsolve pour trouver la solution.

> dsolve( {de1, ini}, {y(t)} );
y(t) = e(−2 t) − e(−3 t)
De plus, dsolve peut retourner une solution sous forme paramétrique,

[x=f(_T), y(x)=g(_T)], où _T est un paramètre.
L’option explicit Maple peut retourner la solution d’une équation

différentielle sous forme implicite.
> de2 := diff(y(x),x$2) = (ln(y(x))+1)*diff(y(x),x);
d2 d
de2 := 2
y(x) = (ln(y(x)) + 1) ( y(x))
dx dx
> dsolve( {de2}, {y(x)} );


y(x)
1
{y(x) = _C1 }, d_a − x − _C2 = 0
_a ln(_a) + _C1
Utilisez l’option explicit pour indiquer à Maple de chercher une

solution explicite du premier résultat.
> dsolve( {de2}, {y(x)}, explicit );
{y(x) = _C1 },
! _Z "#
1
y(x) = RootOf − d_f + x + _C2
_f ln(_f ) + _C1
Cependant, dans certains cas, Maple peut ne pas être en mesure de
trouver une solution explicite.
Il existe également une option implicit pour forcer Maple à donner
ses résultats sous forme implicite.
L’option method=laplace Il est souvent possible de réduire la com-

plexité d’un problème en utilisant les transformées de Laplace. Les trans-
formées font correspondre à une équation différentielle une équation algé-
brique, beaucoup plus simple à résoudre. La difficulté de cette méthode
réside dans la transformation des équations au nouveau domaine et par-
ticulièrement la transformation des solutions sous leur ancienne forme.
La méthode des transformées de Laplace peut gérer des EDO linéaires
d’ordre arbitraire, de même que certains cas d’EDO linéaires à coefficients
non constants, à supposer que Maple puisse trouver les transformées.
Cette méthode fonctionne également avec les systèmes d’équations cou-
plées.
Considérons le problème de dynamique classique suivant. Deux poids
de masses m et αm reposent sur un plan sans frottement et sont reliés par
un ressort dont la constante de rappel est k. Quelles sont les trajectoires
de chaque poids si le premier est sujet à une force ponctuelle unitaire u(t)
en t = 1 ?
Définissons tout d’abord les équations différentielles qui s’appliquent
au problème. La deuxième loi de Newton gouverne le mouvement du pre-
mier poids : la masse m multipliée par l’accélération doit être égale à
la somme des forces appliquées sur le premier poids, incluant la force
extérieure u(t).
> eqn1 :=
> alpha*m*diff(x[1](t),t$2) = k*(x[2](t) - x[1](t)) + u(t);
d2
eqn1 := α m ( x1 (t)) = k (x2 (t) − x1 (t)) + u(t)
dt2
Il en va de même pour le second poids.

> eqn2 := m*diff(x[2](t),t$2) = k*(x[1](t) - x[2](t));
d2
eqn2 := m ( x2 (t)) = k (x1 (t) − x2 (t))
dt2
Appliquez une force ponctuelle unitaire au premier poids en t = 1.

> u := t -> Heaviside(t-1);
u := t → Heaviside(t − 1)
Au temps t = 0, les deux masses sont au repos à leurs emplacements

respectifs.
> ini := x[1](0) = 2, D(x[1])(0) = 0,
> x[2](0) = 0, D(x[2])(0) = 0 ;
ini := x1 (0) = 2, D(x1 )(0) = 0, x2 (0) = 0, D(x2 )(0) = 0
Résolvez le problème en utilisant la méthode de la transformée de

Laplace.
> dsolve( {eqn1, eqn2, ini}, {x[1](t), x[2](t)},
> method=laplace );

1
x2 (t) = (t2 k α + α k − 2 t k α − 2 α m
2
√
%1 (t − 1)
+ 2 α cosh( ) m + t2 k + k − 2 t k)
α$m
Heaviside(t − 1) ((1 + 2 α + α2 ) k m)
√
%1 t
α (−1 + cosh( ))
−2 α m , x1 (t) =
1+α
√
%1 (t − 1)
Heaviside(t − 1) cosh( )
− αm
k (1 + α)2
√
%1 t
α cosh( ) √ √
−2 α m + e(− α%1 m
t
) %1 t
+ e( α m ) + (
1+α
1
k Heaviside(t − 1) (1 + α) t2
2
− k Heaviside(t − 1) (1 + α) t + 2 α2 m k
1
+ Heaviside(t − 1) m + Heaviside(t − 1) α k
2
1 $
+ 2 α m k + Heaviside(t − 1) k) ((1 + α)2 k m)
2
%1 := −α m k (1 + α)
Évaluez le résultat en fixant des valeurs pour les constantes.
> ans := eval( %, {alpha=1/10, m=1, k=1} );
50
ans := {x2 (t) =
121
11 2 9 11 1 1 √ √
( t + − t + cosh( −11 100 (t − 1)))
10 10 5 5 10
2 2 1 √ √
Heaviside(t − 1) + − cosh( −11 100 t), x1 (t)
11 11 10
100 1 √ √
=− Heaviside(t − 1) cosh( −11 100 (t − 1))
121 10
2 1 √ √ √ √
− cosh( −11 100 t) + e(−1/10 −11 100 t)
11 10
√ √ 5
+ e(1/10 −11 100 t) + Heaviside(t − 1) t2
11
10 2 155
− Heaviside(t − 1) t + + Heaviside(t − 1)}
11 11 121
Vous pouvez transformer la solution précédente en deux fonctions,
y1 (t) et y2 (t), de la manière suivante. Tout d’abord, évaluez l’expression
x[1](t) en sa solution pour extraire l’expression x1 (t).
> eval( x[1](t), ans );
100 1 √ √
− Heaviside(t − 1) cosh( −11 100 (t − 1))
121 10
2 1 √ √ √ √
− cosh( −11 100 t) + e(−1/10 −11 100 t)
11 10
√ √ 5
+ e(1/10 −11 100 t) + Heaviside(t − 1) t2
11
10 2 155
− Heaviside(t − 1) t + + Heaviside(t − 1)
11 11 121
Transformez ensuite l’expression en fonction au moyen d’unapply.
> y[1] := unapply( %, t );
y1 := t →
100 1 √ √
− Heaviside(t − 1) cosh( −11 100 (t − 1))
121 10
2 1 √ √ √ √
− cosh( −11 100 t) + e(−1/10 −11 100 t)
11 10
√ √ 5
+ e(1/10 −11 100 t) + Heaviside(t − 1) t2
11
10 2 155
− Heaviside(t − 1) t + + Heaviside(t − 1)
11 11 121
Vous pouvez également effectuer les deux étapes en même temps.

> y[2] := unapply( eval( x[2](t), ans ), t );
50
y2 := t →
121
11 2 9 11 1 1 √ √
( t + − t + cosh( −11 100 (t − 1)))
10 10 5 5 10
2 2 1 √ √
Heaviside(t − 1) + − cosh( −11 100 t)
11 11 10
Tracez maintenant les deux fonctions.
> plot( [ y[1](t), y[2](t) ], t=-3..6 );
14
12
10
8
6
4
2
–2 2 4 6
t
Plutôt que d’appliquer dsolve(..., method=laplace), vous pouvez

utiliser la transformée de Laplace à la main. Le package inttrans définit
la transformée de Laplace et son inverse (de même que plusieurs autres
transformées intégrales).
> with(inttrans);
[addtable, fourier , fouriercos , fouriersin, hankel , hilbert ,

invfourier , invhilbert , invlaplace, invmellin, laplace,
mellin, savetable]
Les transformées de Laplace des équations différentielles eqn1 et eqn2
sont :
> laplace( eqn1, t, s );
α m (s (s laplace(x1 (t), t, s) − x1 (0)) − D(x1 )(0)) =

e(−s)
k (laplace(x2 (t), t, s) − laplace(x1 (t), t, s)) +
s
et
> laplace( eqn2, t, s );
m (s (s laplace(x2 (t), t, s) − x2 (0)) − D(x2 )(0)) =

k (laplace(x1 (t), t, s) − laplace(x2 (t), t, s))
Évaluez l’ensemble formé des deux transformées en leurs conditions
initiales.
> eval( {%, %%}, {ini} );
{m s2 laplace(x2 (t), t, s) =
k (laplace(x1 (t), t, s) − laplace(x2 (t), t, s)),
α m s (s laplace(x1 (t), t, s) − 2) =
e(−s)
k (laplace(x2 (t), t, s) − laplace(x1 (t), t, s)) + }
s
Vous devez maintenant résoudre cet ensemble d’équations algébriques
pour les transformées de Laplace des deux fonctions x1 (t) et x2 (t).
> sol := solve( %, { laplace(x[1](t),t,s),
> laplace(x[2](t),t,s) } );
k (2 α m s2 es + 1)
sol := {laplace(x2 (t), t, s) = ,
es s3 m (k + α m s2 + α k)
(m s2 + k) (2 α m s2 es + 1)
laplace(x1 (t), t, s) = }
es s3 m (k + α m s2 + α k)
Maple a résolu le problème algébrique ; vous devez maintenant prendre
la transformée inverse de Laplace pour en extraire les fonctions x1 (t) et
x2 (t) .
> invlaplace( %, s, t );

1 2
x2 (t) = k (t k α + α k − 2 t k α − 2 α m
2
√
%1 (t − 1)
+ 2 α cosh( ) m + t2 k + k − 2 t k)
α$m
Heaviside(t − 1) ((1 + α)2 k 2 )
√
%1 t
α m (−1 + cosh( ))
−2 α m /m, x1 (t) =
k (1 + α)
√
%1 (t − 1)
Heaviside(t − 1) cosh( )
− αm
k (1 + α)2
√
%1 t
α cosh( ) √ √
−2 α m + e(− α%1 m
t
) %1 t
+ e( α m ) + (
1+α
1
k Heaviside(t − 1) (1 + α) t2
2
− k Heaviside(t − 1) (1 + α) t + 2 α2 m k
1
+ Heaviside(t − 1) m + Heaviside(t − 1) α k
2
1 $
+ 2 α m k + Heaviside(t − 1) k) ((1 + α)2 k m)
2
%1 := −α m k (1 + α)
Évaluez-les en fixant des valeurs pour les constantes.
> eval( %, {alpha=1/10, m=1, k=1} );
50
{x2 (t) =
121
11 9 11 1 1 √ √
( t2 + − t + cosh( −11 100 (t − 1)))
10 10 5 5 10
2 2 1 √ √
Heaviside(t − 1) + − cosh( −11 100 t), x1 (t)
11 11 10
100 1 √ √
=− Heaviside(t − 1) cosh( −11 100 (t − 1))
121 10
2 1 √ √ √ √
− cosh( −11 100 t) + e(−1/10 −11 100 t)
11 10
√ √ 5
+ e(1/10 −11 100 t) + Heaviside(t − 1) t2
11
10 2 155
− Heaviside(t − 1) t + + Heaviside(t − 1)}
11 11 121
Comme on devait s’y attendre, on obtient la même solution que par
la méthode précédente.
L’option type=series La méthode des séries pour résoudre des équa-

tions différentielles consiste à trouver une fonction symbolique approximée
des équations de la manière suivante. Maple trouve d’abord une ap-
proximation des équations sous forme de série. Il résout ensuite cette
approximation de manière symbolique au moyen de méthodes exactes.
Cette technique s’avère utile lorsque les algorithmes standard de Maple
ne suffisent pas à la tâche et qu’une solution symbolique est tout de même
préférable à une solution purement numérique. La méthode des séries est
souvent d’un grand secours avec les EDO non linéaires ou de grand ordre.
Lorsque Maple applique la méthode des séries, il assume qu’il existe
une solution de la forme ∞

c i
x ai x
i=0
où c est un nombre rationnel.

Considérez l’équation différentielle suivante.
> eq := 2*x*diff(y(x),x,x) + diff(y(x),x) + y(x) = 0;
d2 d
eq := 2 x ( 2
y(x)) + ( y(x)) + y(x) = 0
dx dx
Demandez à Maple de résoudre l’équation.

> dsolve( {eq}, {y(x)}, type=series );
√ 1 1 2 1 3 1
y(x) = _C1 x(1 − x+ x − x + x4 −
3 30 630 22680
1
x5 + O(x6 )) + _C2
1247400
1 1 3 1 1
(1 − x + x2 − x + x4 − x5 + O(x6 ))
6 90 2520 113400
Utilisez rhs pour extraire la solution ; convertissez-la ensuite en po-
lynôme.
> rhs(%);
√ 1 1 2 1 3 1 1
_C1 x(1 − x+ x − x + x4 −
3 30 630 22680 1247400
x5 + O(x6 )) + _C2
1 1 3 1 1
(1 − x + x2 − x + x4 − x5 + O(x6 ))
6 90 2520 113400
> poly := convert(%, polynom);
√
poly := _C1 x
1 1 2 1 3 1 1
(1 − x + x − x + x4 − x5 )
3 30 630 22680 1247400
1 1 3 1 1
+ _C2 (1 − x + x2 − x + x4 − x5 )
6 90 2520 113400
Vous pouvez maintenant tracer le graphique de la solution pour
différentes valeurs des constantes arbitraires _C1 et _C2.
> [ seq( _C1=i, i=0..5 ) ];
[_C1 = 0, _C1 = 1, _C1 = 2, _C1 = 3, _C1 = 4, _C1 = 5]
> map(subs, %, _C2=1, poly);

1 2 1 3 1 1
[1 − x + x − x + x4 − x5 ,
6 90 2520 113400
1 1 3 1 1
%1 + 1 − x + x2 − x + x4 − x5 ,
6 90 2520 113400
1 1 3 1 1
2 %1 + 1 − x + x2 − x + x4 − x5 ,
6 90 2520 113400
1 1 3 1 1
3 %1 + 1 − x + x2 − x + x4 − x5 ,
6 90 2520 113400
1 1 3 1 1
4 %1 + 1 − x + x2 − x + x4 − x5 ,
6 90 2520 113400
1 1 3 1 1
5 %1 + 1 − x + x2 − x + x4 − x5 ]
6 90 2520 113400
%1 :=
√ 1 1 2 1 3 1 1
x (1 − x + x − x + x4 − x5 )
3 30 630 22680 1247400
> plot( %, x=1..10 );
3
2
1 x 6
2 4 8 10
0
–1
–2
–3
–4
L’option type=numeric Bien que les méthodes des séries pour la ré-
solution des EDO soient bien comprises et adéquates pour trouver des
approximations justes de la variable dépendante, elles présentent cepen-
dant certaines limitations. Pour produire un résultat, la série résultante
doit converger ; de plus, Maple doit calculer plusieurs dérivées dans le pro-
cessus de recherche de la solution, ce qui peut s’avérer coûteux en temps
comme en mémoire. Pour ces raisons, des solveurs numériques alternatifs
ont été conçus.
Voici une équation différentielle et une condition initiale.
> eq := x(t) * diff(x(t), t) = t^2;
d
eq := x(t) ( x(t)) = t2
dt
> ini := x(1) = 2;
ini := x(1) = 2
Le résultat de la commande dsolve avec l’option numeric est une procé-

dure qui retourne une liste d’équations.
> sol := dsolve( {eq, ini}, {x(t)}, type=numeric );
sol := proc(rkf45 _x ) . . . end proc
La solution satisfait à la condition initiale.

> sol(1);
[t = 1, x(t) = 2.]
> sol(0);
[t = 0, x(t) = 1.82574790049820024]
Utilisez la commande eval pour choisir une valeur particulière de la

liste des équations.
> eval( x(t), sol(1) );
2.
Vous pouvez également créer une paire ordonnée.

> eval( [t, x(t)], sol(0) );
[0, 1.82574790049820024]
Le package plots contient une commande, odeplot, permettant de

tracer le résultat de dsolve( ..., type=numeric).
> with(plots):
> odeplot( sol, [t, x(t)], -1..2 );

2.8
2.6
2.4
x
2.2
2
1.8
–1 –0.5 0 0.5 1 1.5 2

t
Consultez la rubrique ?plots,odeplot pour obtenir la syntaxe de

odeplot.
Voici un système de deux EDO.
> eq1 := diff(x(t),t) = y(t);
∂
eq1 := x(t) = y(t)
∂t
> eq2 := diff(y(t),t) = x(t)+y(t);
∂
eq2 := y(t) = x(t) + y(t)
∂t
> ini := x(0)=2, y(0)=1;
ini := x(0) = 2, y(0) = 1
Dans ce cas particulier, la procédure de solution retourne une liste de

trois équations.
> sol1 := dsolve( {eq1, eq2, ini}, {x(t),y(t)},
> type=numeric );
sol1 := proc(rkf45 _x ) . . . end proc
> sol1(0);
[t = 0, x(t) = 2., y(t) = 1.]
> sol1(1);
[t = 1, x(t) = 5.58216755967155986,
y(t) = 7.82688931187210190]
La commande odeplot peut maintenant tracer y(t) en fonction de
x(t),
> odeplot( sol1, [x(t), y(t)], -3..1, labels=["x","y"] );
y 4
0 2 3 4 5 6
x
–2
–4
x(t) et y(t) en fonction de t,

> odeplot( sol1, [t, x(t), y(t)], -3..1,
> labels=["t","x","y"], axes=boxed );
–4
2 –3
x t
6 1
ou toute autre combinaison.

Soyez prudent lorsque vous utilisez des méthodes numériques. Il
n’existe pas de règles universelles permettant de prévenir ces effets ; ainsi,
aucun logiciel ne peut anticiper toutes les conditions. La solution consiste
à utiliser l’option startinit pour indiquer à la commande dsolve (ou
plutôt à la procédure retournée par dsolve) de commencer à la valeur
initiale pour chaque calcul en un point (x, y(x)).
Vous pouvez spécifier l’algorithme que dsolve(..., type=numeric)
doit utiliser en résolvant une équation différentielle. Reportez-vous à la
rubrique ?dsolve,numeric.
Un exemple : les séries de Taylor

Dans sa forme générale, une solution d’une EDO générée par une méthode
de séries demande la formation d’une série de Taylor autour de t = 0
pour une certaine fonction f (t). Vous devez ainsi obtenir et manipuler
les dérivées d’ordre supérieur de cette fonction, soit f (t), f (t), f (t) et
ainsi de suite.
Une fois les dérivées ainsi obtenues, vous pouvez les remplacer dans
la représentation de f (t) en série de Taylor.
> taylor(f(t), t);
1 (2) 1
f(0) + D(f )(0) t + (D )(f )(0) t2 + (D(3) )(f )(0) t3 +
2 6
1 1
(D(4) )(f )(0) t4 + (D(5) )(f )(0) t5 + O(t6 )
24 120
Comme exemple, considérez la loi du refroidissement de Newton :
dθ 1
= − (θ − 20), θ(0) = 100.
dt 10
En utilisant l’opérateur D, vous pouvez facilement introduire l’équa-
tion ci-dessus dans Maple.
> eq := D(theta) = -1/10*(theta-20);
1
eq := D(θ) = − θ+2
10
> ini := theta(0)=100;
ini := θ(0) = 100
La première étape consiste à obtenir le nombre requis de dérivées

d’ordre supérieur. Déterminez ce nombre en fonction de l’ordre de la série
de Taylor. Si vous utilisez la valeur par défaut de la variable Order fournie
par Maple,
> Order;
vous devez générer des dérivées jusqu’à l’ordre

> dev_order := Order - 1;
dev _order := 5
Vous pouvez maintenant utiliser seq pour générer une suite des déri-
vées d’ordre supérieur de theta(t).
> S := seq( (D@@(dev_order-n))(eq), n=1..dev_order );
1 1
S := (D(5) )(θ) = − (D(4) )(θ), (D(4) )(θ) = − (D(3) )(θ),
10 10
1 1
(D(3) )(θ) = − (D(2) )(θ), (D(2) )(θ) = − D(θ),
10 10
1
D(θ) = − θ + 2
10
La dérivée cinquième est une fonction de la dérivée quatrième, la
dérivée quatrième est une fonction de la dérivée troisième, et ainsi de
suite. Ainsi, si vous effectuez des substitutions par rapport à S, vous
pouvez exprimer toutes les dérivées comme des fonctions de theta. Par
exemple, le troisième élément de S est le suivant :
> S[3];
1
(D(3) )(θ) = − (D(2) )(θ)
10
En remplaçant par rapport à S sur le côté droit de l’égalité, on ob-

tient :
> lhs(%) = subs( S, rhs(%) );
1 1
(D(3) )(θ) = − θ+
1000 50
Pour effectuer cette substitution sur toutes les dérivées à la fois, uti-
lisez la commande map.
> L := map( z -> lhs(z) = eval(rhs(z), {S}), [S] );
1 1
L := [(D(5) )(θ) = (D(3) )(θ), (D(4) )(θ) = (D(2) )(θ),
100 100
1 1 1
(D(3) )(θ) = D(θ), (D(2) )(θ) = θ− ,
100 100 5
1
D(θ) = − θ + 2]
10
Vous devez évaluer les dérivées en t = 0.
> L(0);
1
[(D(5) )(θ)(0) = (D(3) )(θ)(0),
100
1
(D(4) )(θ)(0) = (D(2) )(θ)(0),
100
1 1 1
(D(3) )(θ)(0) = D(θ)(0), (D(2) )(θ)(0) = θ(0) − ,
100 100 5
1
D(θ)(0) = − θ(0) + 2]
10
Générez maintenant la série de Taylor.
> T := taylor(theta(t), t);
1 (2) 1
T := θ(0) + D(θ)(0) t + (D )(θ)(0) t2 + (D(3) )(θ)(0)
2 6
3 1 (4) 4 1
t + (D )(θ)(0) t + (D )(θ)(0) t + O(t6 )
(5) 5
24 120
Remplacez les dérivées dans la série.
> subs( op(L(0)), T );
1 1 1
θ(0) + (− θ(0) + 2) t + ( θ(0) − ) t2 +
10 200 10
1 1 1 1
(− θ(0) + 3
)t + ( θ(0) − ) t4 +
6000 300 240000 12000
1 1
(− θ(0) + ) t5 + O(t6 )
12000000 600000
Évaluez maintenant les séries aux conditions initiales et convertissez-
les en polynôme.
> eval( %, ini );
2 2 1 3 1 4 1
100 − 8 t + t − t + t − t5 + O(t6 )
5 75 3000 150000
> p := convert(%, polynom);
2 2 1 3 1 4 1
p := 100 − 8 t + t − t + t − t5
5 75 3000 150000
Vous pouvez maintenant tracer le graphique de la réponse.

> plot(p, t=0..30);
100
80
60
40
20
0 5 10 15 20 25 30
t
–20
Cet exemple particulier possède la solution analytique suivante.

> dsolve( {eq(t), ini}, {theta(t)} );
θ(t) = 20 + 80 e(−1/10 t)
> q := rhs(%);
q := 20 + 80 e(−1/10 t)
Vous pouvez maintenant comparer la série obtenue à la solution

exacte.
> plot( [p, q], t=0..30 );
100
80
60
40
20
0 5 10 15 20 25 30
t
–20
Plutôt que de calculer la série de Taylor manuellement, vous pouvez

utiliser l’option series de la commande dsolve.
> dsolve( {eq(t), ini}, {theta(t)}, ’series’ );
θ(t) =
2 2 1 3 1 4 1
100 − 8 t + t − t + t − t5 + O(t6 )
5 75 3000 150000
Lorsqu’une solution explicite est impossible à trouver

Dans certains cas, il peut être impossible d’exprimer la solution d’une
EDO linéaire explicitement. Dans ce cas, la commande dsolve peut re-
tourner des solutions contenant la structure de données DESol. DESol
est une expression représentant la solution d’une équation différentielle
sans la calculer explicitement. Ainsi, DESol est similaire à RootOf, qui
représente les racines d’une expression. Cela vous permet de manipuler
l’expression résultante de manière symbolique avant d’utiliser toute autre
approche.
> de := (x^7+x^3-3)*diff(y(x),x,x) + x^4*diff(y(x),x)
> + (23*x-17)*y(x);
de :=
d2
(x7 + x3 − 3) ( dx 2 y(x)) + x ( dx y(x)) + (23 x − 17) y(x)
4 d
dsolve ne peut trouver une solution exacte de de.

> dsolve( {de}, {y(x)} );

y(x) = DESol

d
d2 x4 ( dx _Y(x)) (23 x − 17) _Y(x)
( dx2
_Y(x)) + 7 + ,
x + x3 − 3 x7 + x3 − 3

{_Y(x)}
Vous pouvez maintenant essayer une autre méthode sur l’élément DESol
lui-même. Par exemple, trouvez une approximation sous forme de série.
> series(rhs(%), x);
17
_Y(0) + D(_Y )(0) x − _Y(0) x2 +
6
17 23
(−
D(_Y )(0) + _Y(0)) x3 +
18 18
289 23
( _Y(0) + D(_Y )(0)) x4 +
216 36
289 833
( D(_Y )(0) − _Y(0)) x5 + O(x6 )
1080 540
diff et int fonctionnent également avec DESol.
Tracer le graphique d’équations différentielles ordinaires

Plusieurs équations différentielles ne peuvent être résolues analytique-
ment. Dans ces cas, il peut être avantageux d’en tracer le graphique.
> ode1 :=
> diff(y(t), t$2) + sin(t)^2*diff(y(t),t) + y(t) = cos(t)^2;
d2 d
ode1 := ( 2
y(t)) + sin(t)2 ( y(t)) + y(t) = cos(t)2
dt dt
> ic1 := y(0) = 1, D(y)(0) = 0;
ic1 := y(0) = 1, D(y)(0) = 0
Essayez tout d’abord de résoudre cette EDO analytiquement au

moyen de dsolve.
> dsolve({ode1, ic1}, {y(t)} );

La commande dsolve n’a rien retourné, indiquant ainsi qu’elle ne pouvait
trouver de solution. Essayez alors les méthodes de Laplace.
> dsolve( {ode1, ic1}, {y(t)}, method=laplace );
Encore une fois, dsolve n’a pas trouvé de solution. Puisque l’usage de
dsolve s’est avéré infructueux, essayez la commande DEplot qui se trouve
dans le package DEtools.
> with(DEtools):
DEplot est un traceur général d’EDO que vous pouvez utiliser en suivant
la syntaxe ci-dessous :
DEplot( ode, dep-var, intervalle, [ini-conds ] )
Ici, ode est l’équation différentielle que vous souhaitez tracer, dep-var est
la variable dépendante, intervalle est le domaine de la variable indépen-
dante et ini-conds représente la liste des conditions initiales.
Voici un graphique de la fonction satisfaisant à la fois à l’équation
différentielle ode1 et aux conditions initiales ic1 ci-dessus.
> DEplot( ode1, y(t), 0..20, [ [ ic1 ] ] );
0.8
y(t) 0.6
0.4
0.2
0 5 10 15 20
t
Vous pouvez raffiner le graphique en spécifiant une échelle (stepsize)

plus fine.
> DEplot( ode1, y(t), 0..20, [ [ ic1 ] ], stepsize=0.2 );
0.8
y(t) 0.6
0.4
0.2
0 5 10 15 20
t
Si vous spécifiez plus qu’une liste de conditions initiales, DEplot trace

une solution pour chacune.
> ic2 := y(0)=0, D(y)(0)=1;
ic2 := y(0) = 0, D(y)(0) = 1
> DEplot( ode1, y(t), 0..20, [ [ic1], [ic2] ], stepsize=0.2 );
1.4
1.2
1
0.8
y(t)
0.6
0.4
0.2
5 10 15 20
t
DEplot peut également tracer les solutions d’un ensemble d’équations

différentielles.
> eq1 := diff(y(t),t) + y(t) + x(t) = 0;
d
eq1 := ( y(t)) + y(t) + x(t) = 0
dt
> eq2 := y(t) = diff(x(t), t);
d
eq2 := y(t) = x(t)
dt
> ini1 := x(0)=0, y(0)=5;
ini1 := x(0) = 0, y(0) = 5
> ini2 := x(0)=0, y(0)=-5;
ini2 := x(0) = 0, y(0) = −5
Le système {eq1, eq2} possède deux variables dépendantes, x(t) et

y(t) ; vous devez donc donner une liste de variables dépendantes.
> DEplot( {eq1, eq2}, [x(t), y(t)], -5..5,
> [ [ini1], [ini2] ] );
60
40
y
20
–60 –40 –20 0 20 40 60

x
–20
–40
–60
Remarquez que DEplot génère également un champ de vecteurs (ainsi

qu’illustré ci-dessus) dès qu’il est utile de le faire. Consultez la rubrique
?DEtools,DEplot pour obtenir davantage de détails sur la manière de
tracer des EDO.
DEplot3d est la version tridimensionnelle de DEplot. La syntaxe de
base de DEplot3d est similaire à celle de DEplot. Consultez la rubrique
?DEtools,DEplot3d pour obtenir plus de détails. Voici un graphique tri-
dimensionnel du système tracé en deux dimensions précédemment.
> DEplot3d( {eq1, eq2}, [x(t), y(t)], -5..5,
> [ [ini1], [ini2] ] );
40
20
y(t) 0
–20
–40
–60 –4
–40 –2
–20
0 0
x(t) 20 2 t
40 4
60
Voici un exemple d’un graphique d’un système de trois équations

différentielles.
> eq1 := diff(x(t),t) = y(t)+z(t);
d
eq1 := x(t) = y(t) + z(t)
dt
> eq2 := diff(y(t),t) = -x(t)-y(t);
d
eq2 := y(t) = −y(t) − x(t)
dt
> eq3 := diff(z(t),t) = x(t)+y(t)-z(t);
d
eq3 := z(t) = x(t) + y(t) − z(t)
dt
Voici deux listes de conditions initiales.

> ini1 := [x(0)=1, y(0)=0, z(0)=2];
ini1 := [x(0) = 1, y(0) = 0, z(0) = 2]
> ini2 := [x(0)=0, y(0)=2, z(0)=-1];
ini2 := [x(0) = 0, y(0) = 2, z(0) = −1]
La commande DEplot3d trace deux solutions au système d’équations

différentielles {eq1, eq2, eq3}, une solution pour chaque liste de valeurs
initiales.
> DEplot3d( {eq1, eq2, eq3}, [x(t), y(t), z(t)], t=0..10,

> [ini1, ini2], stepsize=0.1, orientation=[-171, 58] );
z 2
x
–1 –1
2
y –1
Coefficients discontinus d’une équation

Dans plusieurs situations pratiques, les coefficients d’une solution à un
système sont discontinus. Maple propose plusieurs manières par lesquelles
il est possible de décrire un système en termes d’EDO et d’inclure, de
manière significative, des descriptions de ces coefficients discontinus.
La fonction de Heaviside La fonction de Heaviside permet de modéliser

des coefficients retardés ou définis par morceaux. Vous pouvez utiliser
Heaviside avec dsolve pour trouver les solutions à la fois numériques et
symboliques.
> eq := diff(y(t),t) = -y(t)*Heaviside(t-1);
∂
eq := y(t) = −y(t) Heaviside(t − 1)
∂t
> ini := y(0) = 3;
ini := y(0) = 3
> dsolve({eq, ini}, {y(t)});
y(t) = 3 e((−t+1) Heaviside(t−1))
Transformez la solution en une fonction que l’on peut tracer.

> rhs( % );
3 e((−t+1) Heaviside(t−1))
> f := unapply(%, t);
f := t → 3 e((−t+1) Heaviside(t−1))
> plot(f, 0..4);
2.5
1.5
0.5
0 1 2 3 4
Résolvez la même équation numériquement.

> sol1 := dsolve({eq, ini}, {y(t)}, type=numeric);
Vous pouvez utiliser la commande odeplot du package plots pour

tracer le graphique de la solution.
> with(plots):
> odeplot( sol1, [t, y(t)], 0..4 );
2.5
2
y1.5
0.5
0 1 2 3 4
t
La fonction Delta de Dirac De manière similaire, vous pouvez utiliser

la fonction de Dirac pour produire des coefficients d’impulsion.
> eq := diff(y(t),t) = -y(t)*Dirac(t-1);
d
eq := y(t) = −y(t) Dirac(t − 1)
dt
> ini := y(0) = 3;
ini := y(0) = 3
> dsolve({eq, ini}, {y(t)});
y(t) = 3 e(−Heaviside(t−1))
Transformez la solution en une fonction que vous pouvez tracer.

> f := unapply( rhs( % ), t );
f := t → 3 e(−Heaviside(t−1))
> plot( f, 0..4 );
3
2.8
2.6
2.4
2.2
2
1.8
1.6
1.4
1.2
0 1 2 3 4
Cependant, la solution numérique ne considère pas la valeur non nulle

de Dirac(0).

Encore une fois, utilisez odeplot du package plots pour tracer la

solution numérique.
> with(plots, odeplot);
[odeplot ]
> odeplot( sol2, [t,y(t)], 0..4 );
3.5
y 3
2.5
2
0 1 2 3 4
t
Fonctions définies par morceaux La commande piecewise vous permet

de construire des fonctions compliquées par l’approximation de certaines
de ses sections par des fonctions analytiques, puis en regroupant ces mul-
tiples approximations pour représenter la fonction complète. Examinez
tout d’abord le comportement de piecewise.
> f:= x -> piecewise(1<=x and x<2, 1, 0);
f := x → piecewise(1 ≤ x and x < 2, 1, 0)
> f(x);
1, if , 1 − x ≤ 0 and x − 2 < 0 ;
0, otherwise.
Remarquez que l’ordre des conditions est important. La fonction retourne

la valeur true dès qu’une condition retourne la valeur true.
> plot(f, 0..3);
0.8
0.6
0.4
0.2
0 0.5 1 1.5 2 2.5 3
Ainsi, vous pouvez utiliser cette fonction définie par morceaux comme
coefficient.
> eq := diff(y(t),t) = 1-y(t)*f(t);
! "
∂ 1, if 1 − t ≤ 0 and t − 2 < 0 ;
eq := y(t) = 1 − y(t)
∂t 0, otherwise.
> ini := y(0)=3;
ini := y(0) = 3
Encore une fois, utilisez la commande odeplot du package plots pour

tracer le résultat.
> with(plots, odeplot):
> odeplot( sol3, [t, y(t)], 0..4 );
y5
3
0 1 2 3 4
t
Le package DEtools contient plusieurs commandes vous permettant

d’examiner, de manipuler, de tracer et de résoudre des équations différen-
tielles. Consultez la rubrique ?DEtools pour plus de détails.
6.3 Équations aux dérivées partielles

En général, les équations aux dérivées partielles (EDP) sont très difficiles à
résoudre. Maple fournit plusieurs commandes permettant de résoudre, de
manipuler et de tracer les EDP. Certaines de ces commandes se trouvent
dans la bibliothèque standard, mais la plupart d’entre elles sont situées
dans le package PDEtools.
La commande pdsolve
La commande pdsolve permet de résoudre plusieurs équations aux
dérivées partielles. La syntaxe de base de la commande pdsolve est la
suivante :
pdsolve( pde, var )
Ici, pde est l’équation aux dérivées partielles et var est la variable pour
laquelle on souhaite résoudre.
Voici une équation ondulatoire unidimensionnelle.
> wave := diff(u(x,t), t,t) - c^2 * diff(u(x,t), x,x);
∂2 2 ∂
2
wave := ( u(x, t)) − c ( u(x, t))
∂t2 ∂x2
On souhaite résoudre pour u(x,t). Chargeons d’abord en mémoire

PDEtools.
> with(PDEtools):
> sol := pdsolve( wave, u(x,t) );
sol := u(x, t) = _F1(c t + x) + _F2(c t − x)
Remarquez que la solution est en termes de deux fonctions arbitraires,

_F1 et _F2. Pour tracer la solution, il vous faut un ensemble particulier
de fonctions.
6.3 Équations aux dérivées partielles • 267
> f1 := xi -> exp(-xi^2);

2)
f1 := ξ → e(−ξ
> f2 := xi -> piecewise(-1/2<xi and xi<1/2, 1, 0);
−1 1
f2 := ξ → piecewise( < ξ and ξ < , 1, 0)
2 2
Substituez ces expressions dans la solution.

> eval( sol, {_F1=f1, _F2=f2, c=1} );

1 1
u(x, t) = e (−(t+x)2 )
+ 1 −t + x < and t − x <
2 2
0 otherwise
Vous pouvez utiliser la commande rhs pour extraire la solution.

> rhs(%);

1 1
e (−(t+x)2 )
+ 1 −t + x < and t − x <
2 2
0 otherwise
unapply transforme l’expression en fonction.

> f := unapply(%, x,t);
f := (x, t) →
2 1 1
e(−(t+x) ) + piecewise(−t + x < and t − x < , 1, 0)
2 2
Vous pouvez maintenant tracer la solution.
> plot3d( f, -8..8, 0..5, grid=[40,40] );
Changer la variable dépendante dans une EDP

Voici l’équation de la chaleur en une dimension.
> heat := diff(u(x,t),t) - k*diff(u(x,t), x,x) = 0;
d d2
heat := ( u(x, t)) − k ( 2 u(x, t)) = 0
dt dx
Essayez de trouver une solution de la forme X(x)T (t). Pour ce faire,

utilisez l’option HINT de pdsolve pour suggérer à Maple une piste à
suivre.
> pdsolve( heat, u(x,t), HINT=X(x)*T(t));
(u(x, t) = X(x) T(t)) &where

d d2
[{ dt T(t) = k _c 1 T(t), dx2
X(x) = _c 1 X(x)}]
Le résultat est correct, mais difficile à lire.
De manière alternative, vous pouvez spécifier à pdsolve d’utiliser une
séparation de variables (sous forme de produit, ‘*‘) et ensuite de résoudre
l’EDO résultante en utilisant l’option ’build’.
> sol := pdsolve(heat, u(x,t), HINT=‘*‘, ’build’);
√ _C3 e(k _c 1 t) _C2

sol := u(x, t) = e( _c 1 x) _C3 e(k _c 1 t) _C1 + √
e( _c 1 x)
Évaluez la solution en des valeurs spécifiques pour les constantes.

> S := eval( rhs(sol), {_C3=1, _C1=1, _C2=1, k=1, _c[1]=1} );
6.3 Équations aux dérivées partielles • 269
et
S := ex et +
ex
Vous pouvez tracer le graphique de la solution.

> plot3d( S, x=-5..5, t=0..5 );
Il peut être avisé de vérifier la solution avec l’équation originale.

> eval( heat, u(x,t)=rhs(sol) );
_C3 k _c 1 e(k _c 1 t) _C2

%1 _C3 k _c 1 e(k _c 1 t) _C1 +
%1
(k _c 1 t)
_C3 e _C2 _c 1
− k (_c 1 %1 _C3 e(k _c 1 t) _C1 + )=0
%1
√
%1 := e( _c 1 x)
> simplify(%);
0=0
Tracer le graphique d’équations aux dérivées partielles

Les solutions de plusieurs EDP peuvent être tracées grâce à la com-
mande PDEplot que l’on trouve dans le package PDEtools.
> with(PDEtools):
Vous pouvez utiliser la commande PDEplot avec la syntaxe suivante.
PDEplot( pde, var, ini, s =intervalle )
Ici, pde est l’EDP, var est la variable indépendante, ini est une courbe
paramétrique de l’espace tridimensionnel de paramètre s et intervalle est
le domaine de s.
Considérez cette équation aux dérivées partielles.

> pde := diff(u(x,y), x) + cos(2*x) * diff(u(x,y), y) = -sin(y);
∂ ∂
pde := ( u(x, y)) + cos(2 x) ( u(x, y)) = −sin(y)
∂x ∂y
Utilisez la courbe donnée par z = 1 + y 2 comme condition initiale,

c’est-à-dire x = 0, y = s et z = 1 + s2 .
> ini := [0, s, 1+s^2];
ini := [0, s, 1 + s2 ]
PDEplot trace la courbe des conditions initiales et la surface de solu-

tion.
> PDEplot( pde, u(x,y), ini, s=-2..2 );
u(x,y)
1
–2 –2
y x
2 2
Pour tracer la surface, Maple calcule ces courbes caractéristiques de

base. La courbe des conditions initiales est ici plus facile à distinguer.
> PDEplot( pde, u(x,y), ini, s=-2..2, basechar=only );
u(x,y)
1
–2 –2
y x
2 2
L’option basechar=true indique à PDEplot de dessiner à la fois les

courbes caractéristiques et la surface, de même que la courbe des condi-
tions initiales qui est toujours présente.
> PDEplot( pde, u(x,y), ini, s=-2..2, basechar=true );
u(x,y)
1
–2 –2
y x
2 2
Plusieurs des options usuelles de plot3d sont également disponibles ;

consultez la rubrique ?plot3d,options. L’option initcolor modifie la
couleur de la courbe des valeurs initiales.
> PDEplot( pde, u(x,y), ini, s=-2..2,
> basechar=true, initcolor=white,
> style=patchcontour, contours=20,
> orientation=[-43,45] );
u(x,y)
1
–2 2
x y
2 –2
6.4 Conclusion
Ce chapitre vous a démontré l’utilité de Maple lorsque vient le temps
d’étudier et de résoudre des problèmes faisant usage du calcul différentiel.
Vous avez vu comment Maple peut illustrer des concepts comme la dérivée
et les intégrales de Riemann, comment Maple vous aide à analyser le
terme d’erreur d’une approximation de Taylor de même que sa puissance

dans la résolution et la manipulation, tant symbolique que numérique,
des équations différentielles et des équations aux dérivées partielles.
7 Entrées et sorties
Vous pouvez effectuer la majeure partie de votre travail à l’intérieur des

feuilles de calcul de Maple : calculer, tracer des fonctions et documenter
les résultats. Cependant, il est possible qu’à un certain moment vous de-
viez importer des données ou exporter des résultats pour interagir avec
une autre personne ou un autre logiciel. Les données peuvent être des me-
sures expérimentales ou des nombres générés par d’autres programmes.
Une fois les données importées dans Maple, vous pouvez utiliser les ca-
pacités graphiques du logiciel pour visualiser les résultats et les capacités
algébriques pour construire ou examiner un modèle mathématique.
Maple propose plusieurs manières d’importer et d’exporter des don-
nées numériques brutes et des graphiques. Il présente les résultats
algébriques et numériques dans des formats compatibles à leur utilisa-
tion sous FORTRAN ou C, ou le système de typographie mathématique
LATEX. Vous pouvez même exporter une feuille de calcul entière en un
fichier texte (pour inclusion dans un courriel) ou sous forme d’un docu-
ment LATEX. Vous pouvez couper et coller des résultats et exporter des
expressions isolées ou des feuilles entières.
Le présent chapitre aborde les aspects les plus courants de l’expor-
tation et de l’importation d’information vers et depuis des fichiers. On y
verra comment Maple interagit avec le système de fichiers et avec d’autres
logiciels.
7.1 Lire des fichiers

On utilise généralement la lecture de fichiers dans Maple pour deux rai-
sons : pour obtenir des données et pour récupérer une liste de commandes
Maple enregistrées dans un fichier.
273
274 • Chapitre 7: Entrées et sorties
La première situation survient généralement dans le cas de données

expérimentales. Vous pouvez sauvegarder les nombres en les séparant par
des espaces et des sauts de ligne dans un fichier texte, puis les faire lire
par Maple pour les étudier. Vous pouvez très facilement effectuer ces
opérations en utilisant respectivement les commandes ExportMatrix et
ImportMatrix.
Dans la seconde situation, on cherche à lire des commandes Maple se
trouvant dans un fichier texte. Vous recevez peut-être une feuille de calcul
sous format texte, ou vous écrivez une procédure Maple en utilisant votre
éditeur de texte favori et en le sauvegardant dans un fichier texte avant
de l’exécuter. Pour ce faire, vous pouvez couper et coller des commandes
dans Maple ou encore utiliser la commande read. La présente section
discute de cette seconde option.
Lire des colonnes de nombres depuis un fichier

Maple manipule les données aisément, mais lorsque ces dernières sont
générées hors du logiciel, vous devez préalablement les importer avant de
les manipuler. Très souvent, ces données externes sont stockées sous la
forme de colonnes de nombres dans un fichier texte. Le fichier data.txt
ci-dessous en est un exemple.
0 1 0
1 .5403023059 .8414709848
2 -.4161468365 .9092974268
3 -.9899924966 .1411200081
4 -.6536436209 -.7568024953
5 .2836621855 -.9589242747
6 .9601702867 -.2794154982
La commande ImportMatrix permet de lire de telles colonnes de nombres.
Utilisez ImportMatrix de la manière suivante.
ImportMatrix( "nomfichier ", delimiter=cha

ıne )
Ici, nomfichier est le nom du fichier que vous souhaitez lire au moyen
d’ImportMatrix, et chaı̂ne est le caractère qui délimite les entrées. La
valeur par défaut de chaı̂ne est un caractère de tabulation représenté par
"\t". Dans le fichier data.txt, les entrées sont séparées par des espaces.
La valeur de chaı̂ne est donc " ".
> L := ImportMatrix( "data.txt", delimiter=" " );
7.1 Lire des fichiers • 275
 
0 1 0
1 0.5403023059 0.8414709848 
 
2 −0.4161468365 0.9092974268 
 
L := 
3 −0.9899924966 0.1411200081 

4 −0.6536436209 −0.7568024953 
 
5 0.2836621855 −0.9589242747 
6 0.9601702867 −0.2794154982
Maintenant, par exemple, vous pouvez tracer le graphique de la troi-

sième colonne en fonction de la première. Utilisez la commande convert
pour choisir les première et troisième entrées dans chaque colonne.
> convert( L[[1..-1],[1,3]], listlist );
[[0, 0], [1, 0.8414709848], [2, 0.9092974268],

[3, 0.1411200081], [4, −0.7568024953],
[5, −0.9589242747], [6, −0.2794154982]]
La commande plot peut tracer le graphique de telles listes directe-
ment.
> plot(%);
0.8
0.6
0.4
0.2
1 2 3 4 5 6
0
–0.2
–0.4
–0.6
–0.8
Pour sélectionner la seconde colonne de nombres, vous devez tenir

compte du fait que L[5,2] est le second nombre de la cinquième sous-
liste.
> L[5,2];
−0.6536436209
Les données souhaitées sont donc les suivantes.

> L[ 1..-1, 2 ];
 
1
 0.5403023059 
 
 −0.4161468365 
 
 −0.9899924966 
 
 −0.6536436209 
 
 0.2836621855 
0.9601702867
Convertissons ces données sous forme de liste.

> convert(L[1..-1,2],list);
[1, 0.5403023059, −0.4161468365, −0.9899924966,

−0.6536436209, 0.2836621855, 0.9601702867]
> stats[describe,mean](%) ;
0.1034788321
Vous pouvez aussi effectuer des calculs sur la matrice L en utilisant

le package LinearAlgebra.
> LinearAlgebra[Transpose](L) . L;
[91. , 1.30278930720000119 , −6.41489848119999984]

[1.30278930720000119 , 3.87483111270157598 ,
−0.109078174475632172]
[−6.41489848119999984 , −0.109078174475632172 ,
3.12516888746710864]
Pour plus d’information au sujet des options de commandes telles que
ImportMatrix, consultez la rubrique d’aide ?ImportMatrix .
Lire des commandes depuis un fichier

Certains utilisateurs Maple trouvent utile d’écrire des programmes Maple
dans un fichier texte au moyen de leur éditeur favori, puis de les importer
dans Maple. Vous pouvez coller les commandes du fichier texte dans votre
feuille de calcul ou utiliser la commande read.
7.1 Lire des fichiers • 277
Lorsque vous lisez un fichier au moyen de la commande read, Maple

traite chaque ligne du fichier comme une commande. Il exécute les com-
mandes et affiche les résultats dans votre feuille de calcul, mais il ne place
pas, par défaut, les commandes du fichier dans votre feuille de calcul.
Utilisez la commande read en suivant cette syntaxe.
read "nomfichier " ;
Voici le fichier de commandes Maple ks.tst.
S := n -> sum( binomial(n, beta)

* ( (2*beta)!/2^beta - beta!*beta ), beta=1..n );
S( 19 );
Lorsque vous lisez le fichier, Maple affiche les résultats, mais pas les com-
mandes.
> read "ks.tst";

n
(2 β)!
S := n → binomial(n, β) ( − β! β)
2β
β=1
1024937361666644598071114328769317982974
Lorsque vous fixez la valeur de la variable interface echo à 2, Maple

insère les commandes du fichier dans votre feuille de calcul.
> interface( echo=2 );
> read "ks.tst";
> S := n -> sum( binomial(n, beta)

> * ( (2*beta)!/2^beta - beta!*beta ), beta=1..n );

n
(2 β)!
S := n → binomial(n, β) ( − β! β)
2β
β=1
> S( 19 );
1024937361666644598071114328769317982974
La commande read peut également lire des fichiers dans le format

interne de Maple ; consultez la section 7.2.
7.2 Écrire des données dans un fichier

Après avoir utilisé Maple pour effectuer un calcul, vous pouvez enregistrer
le résultat dans un fichier. Vous pouvez traiter le résultat ultérieurement,
avec Maple ou avec un autre programme.
Écrire des colonnes de données numériques dans un fichier

Si le résultat d’un calcul Maple est une longue liste ou un grand tableau
de nombres, vous pouvez le convertir en une matrice et écrire les nombres
dans un fichier de manière structurée. La commande ExportMatrix écrit
les colonnes de données numériques dans un fichier, vous permettant d’im-
porter les nombres dans un autre programme. Vous pouvez utiliser la
commande ExportMatrix avec la syntaxe suivante.
ExportMatrix( "nomfichier ", données )
Ici, nomfichier est la chaı̂ne contenant le nom du fichier où ExportMatrix

doit sauvegarder les données, et données est une matrice. Remarquez
que toute liste, tout vecteur, toute liste de listes ou toute matrice créée à
partir d’une table peut également être converti en une matrice en utilisant
le constructeur Matrix (consultez la rubrique d’aide ?Matrix ).
> L:=LinearAlgebra[RandomMatrix](5);
 
−66 −65 20 −90 30
 55 5 −7 −21 62 
 

L :=  68 66 16 −56 −79  
 26 −36 −34 −8 −71 
13 −41 −62 −50 28
> ExportMatrix("matrixdata.txt", L):
Si les données sont placées dans un vecteur ou dans tout autre ob-
jet qui peut être converti au type Vector, il est possible d’utiliser la
commande ExportVector. Pour plus d’information, reportez-vous à la
rubrique ?Vector.
> L := [ 3, 3.1415, -65, 0 ];
L := [3, 3.1415, −65, 0]
> V := Vector(L);
7.2 Écrire des données dans un fichier • 279
 
3
 3.1415 
V := 
 −65 

> ExportVector( "vectordata.txt", V ):
Vous pouvez étendre ces routines de manière qu’elles écrivent des

données plus complexes, comme des nombres complexes ou des expres-
sions symboliques. Consultez les rubriques d’aide ?ExportMatrix et
?ExportVector pour obtenir plus d’information.
Sauvegarder des expressions au format interne de Maple

Lorsque vous construisez une expression ou une procédure compliquée,
vous pouvez avoir besoin de la sauvegarder pour un usage ultérieur à
l’intérieur de Maple. Si vous sauvegardez cette expression ou cette procé-
dure au format interne de maple, ce dernier pourra ensuite la récupérer
efficacement. Cela s’accomplit en utilisant la commande save pour écrire
l’expression dans un fichier dont le nom se termine par les caractères
.m . Utilisez la commande save avec la syntaxe suivante.
save seqnoms, "nomfichier .m" ;
Ici, seqnoms est une suite de noms. Remarquez que vous ne pouvez
enregistrer que des objets qui ont au préalable été nommés. La commande
save enregistre les objets dans nomfichier.m. Le .m indique que save
écrit le fichier en utilisant le format interne de Maple.
Voici quelques expressions.
> qbinomial := (n,k) -> product(1-qî, i=n-k+1..n) /
> product(1-qî, i=1..k );
%
n
(1 − q i )
i=n−k+1
qbinomial := (n, k) →
%k
(1 − q i )
i=1
> expr := qbinomial(10, 4);

(1 − q 7 ) (1 − q 8 ) (1 − q 9 ) (1 − q 10 )
expr :=
(1 − q) (1 − q 2 ) (1 − q 3 ) (1 − q 4 )
> nexpr := normal( expr );
nexpr := (q 6 + q 5 + q 4 + q 3 + q 2 + q + 1) (q 4 + 1) (q 6 + q 3 + 1)
(q 8 + q 6 + q 4 + q 2 + 1)
Vous pouvez maintenant enregistrer ces expressions dans le fichier
qbinom.m.
> save qbinomial, expr, nexpr, "qbinom.m";
La commande efface les trois expressions de la mémoire. Ainsi, expr
s’évalue à son propre nom.
> restart:
> expr;
expr
Utilisez la commande read pour récupérer les expressions sauve-

gardées dans qbinom.m.
> read "qbinom.m";
Remarquez que expr a retrouvé sa valeur originale.

> expr;
(1 − q 7 ) (1 − q 8 ) (1 − q 9 ) (1 − q 10 )
(1 − q) (1 − q 2 ) (1 − q 3 ) (1 − q 4 )
Consultez la section 7.1 pour plus d’information sur la commande

read.
Convertir au format LATEX

TEX est un programme permettant la présentation de textes mathéma-
tiques. De son côté, LATEX est un package macro de TEX. La commande
latex convertit les expressions Maple au format LATEX. Ainsi, vous pouvez
utiliser Maple pour résoudre un problème, convertir le résultat en code
LATEX et l’inclure dans un document LATEX. Utilisez la commande latex
de la manière suivante.
7.2 Écrire des données dans un fichier • 281
latex( expr, "nomfichier " )
L’objet expr peut être n’importe quelle expression mathématique. Les

expressions spécifiques à Maple, comme les procédures, ne peuvent être
exportées en format LATEX. Le champ nomfichier est optionnel ; il spécifie
à Maple d’écrire le résultat de la commande dans le fichier indiqué. Si vous
ne spécifiez pas de nom de fichier, Maple écrit le résultat directement dans
votre feuille.
La commande latex écrit le code LATEX correspondant de l’expression
Maple expr dans le fichier filename. Si filename existe, latex l’écrase
pour écrire le nouveau fichier. Vous pouvez omettre filename ; dans ce
cas, latex affiche le code LATEX à l’écran et vous pouvez le couper et le
coller dans votre document LATEX.
> latex( a/b );
{\frac {a}{b}}
> latex( Limit( int(f(x), x=-n..n), n=infinity ) );
\lim _{n\rightarrow \infty }\int _{-n}^{n}\!f

\left( x \right) {dx}
La commande latex produit des commandes lisibles en mode math.

Cependant, elle ne produit pas la commande pour entrer et sortir du mode
math et ne tente aucun saut de ligne ni aucun alignement particulier.
La commande latex peut traduire la plupart des types d’expres-
sions mathématiques, incluant les intégrales, les limites, les sommes, les
produits et les matrices. Vous pouvez étendre les possibilités de la com-
mande latex en définissant des procédures portant des noms de la forme
‘latex/nomfonction ‘. De telles procédures formatent les appels de la
fonction functionname . Il est suggéré de produire le résultat de telles
commandes de formatage au moyen de la commande printf. La com-
mande latex se sert de writeto pour rediriger le résultat lorsqu’un nom
de fichier est spécifié.
La commande latex ne génère pas les commandes requises par LATEX
pour mettre le système de typographie en mode mathématique ($...$, par
exemple).
L’exemple suivant montre la génération de code LATEX pour une équa-
tion formée d’une intégrale et de sa valeur. Remarquez l’usage de Int,
la forme inerte de int, pour empêcher l’évaluation du côté gauche de
l’équation.
> Int(1/(x^4+1),x) = int(1/(x^4+1),x);
√
1 1√ x2 + x 2 + 1 1√ √
dx = 2 ln( √ )+ 2 arctan(x 2 + 1)
4
x +1 8 x −x 2+1
2 4
1 √ √
+ 2 arctan(x 2 − 1)
4
> latex(%);
\int \! \left( {x}^{4}+1 \right) ^{-1}{dx}=1/8

\,\sqrt {2}\ln \left( {\frac {{x}^{2}+x\sqrt
{2}+1}{{x}^{2}-x\sqrt {2}+1}} \right) +1/4\,
\sqrt {2}\arctan \left( x\sqrt {2}+1 \right) +
1/4\,\sqrt {2}\arctan \left( x\sqrt {2}-1
\right)
La section 7.3 explique comment enregistrer une feuille complète en

format LATEX.
7.3 Exporter des feuilles complètes

Bien entendu, vous pouvez enregistrer vos feuilles de calcul au moyen des
options Save ou Save As du menu File. Vous pouvez également exporter
une feuille sous six autres formats : texte, texte Maple, LATEX, HTML,
HTML avec MathML, RTF et XML au moyen du sous-menu Export As
que l’on trouve également dans le menu File. Cela vous permet de traiter
une feuille de calcul hors de Maple.
Texte
Vous pouvez enregistrer une feuille de calcul en texte en choisissant l’op-
tion Export As du menu File et Plain Text du sous-menu qui apparaı̂t.
Dans ce cas, Maple fait précéder chaque entrée du signe > et d’un espace.
Maple reproduit les symboles spéciaux comme les intégrales et les expo-
sants au moyen de caractères ; cependant, vous ne pouvez exporter les
graphiques sous forme de texte. L’exemple suivant est une portion de
feuille Maple exportée en format texte.
An Indefinite Integral
by Jane Maplefan
Calculation
Look at the integral Int(x^2*sin(x-a),x);. Notice that its
7.3 Exporter des feuilles complètes • 283
integrand, x^2*sin(x-a);, depends on the parameter a;.

Give the integral a name so that you can refer to it later.
> expr := Int(x^2 * sin(x-a), x);
/
| 2
expr := | x sin(x - a) dx
|
/
The value of the integral is an anti-derivative of the

integrand.
> answer := value( % );
Texte Maple
Le texte Maple n’est que du texte spécialement marqué qui conserve la
distinction entre le texte, les entrées de Maple et ses sorties. Ainsi, vous
pouvez exporter une feuille de calcul en texte Maple, envoyer le texte par
courriel et votre destinataire peut importer ce texte dans son programme
et régénérer une grande part de la structure originale de votre feuille.
En lisant ou en collant du texte, Maple traite chacune des lignes qui
commencent par un prompt Maple suivi d’un espace (> ) comme une
entrée Maple, chaque ligne qui commence avec un dièse (#) comme du
texte, et ignore toutes les autres lignes.
Vous pouvez exporter une feuille entière en texte Maple en choisissant
Export As du menu File et Maple Text dans le sous-menu qui apparaı̂t
alors. Le texte suivant est une portion d’une feuille exportée en texte
Maple.
# An Indefinite Integral
# by Jane Maplefan
# Calculation
# Look at the integral Int(x^2*sin(x-a),x);. Notice that its
# integrand, x^2*sin(x-a);, depends on the parameter a;.
# Give the integral a name so that you can refer to it later.
> expr := Int(x^2 * sin(x-a), x);
/
| 2
expr := | x sin(x - a) dx
|
/
# The value of the integral is an anti-derivative of the

# integrand.
> answer := value( % );
Pour ouvrir une feuille en format texte Maple, choisissez Open du
menu File. Dans la boîte de dialogue qui apparaı̂t alors, choisissez Maple
Text dans la liste déroulante des types de fichiers. Double-cliquez sur le
fichier souhaité et choisissez encore Maple Text dans la boı̂te de dialogue
qui apparaı̂t.
Vous pouvez également copier et coller du texte Maple grâce au menu
Edit. Si vous copiez une partie de votre feuille en texte Maple et le collez
ensuite dans une autre application, le texte collé apparaı̂t sous forme de
texte Maple. De manière similaire, si vous collez du texte Maple dans votre
feuille en utilisant Paste Maple Text du menu Edit, Maple conserve
la structure du texte Maple. Par contre, si vous utilisez l’option Paste
habituelle, Maple ne conserve aucune structure : si vous collez dans une
zone d’entrée, il interprète tout le texte collé comme une entrée, et si
vous le collez dans une zone de texte, Maple interprète tout le texte collé
comme du texte standard.
LATEX
Vous pouvez exporter une feuille Maple en format LATEX en choisissant
Export As du menu File et LaTeX du sous-menu qui apparaı̂t. Le
fichier .tex que Maple génère est prêt à être compilé par LATEX. Toutes
les distributions de Maple incluent les fichiers de style nécessaires.
Si votre feuille contient des graphiques incorporés, Maple génère les
fichiers PostScript correspondant aux graphiques de même que le code
LATEX permettant d’inclure ces fichiers PostScript dans votre document
LATEX.
L’exemple suivant est une portion d’une feuille Maple exportée en
format LATEX.
%% Created by Maple 8.00 (IBM INTEL NT)
%% Source Worksheet: tut1.mws
%% Generated: Thu Apr 18 9:47:33 2002
\documentclass{article}
\usepackage{maple2e}
\DefineParaStyle{Author}
\DefineParaStyle{Heading 1}
\DefineParaStyle{Maple Output}
\DefineParaStyle{Maple Plot}
\DefineParaStyle{Title}
\DefineCharStyle{2D Comment}
\DefineCharStyle{2D Math}
\DefineCharStyle{2D Output}
\DefineCharStyle{Hyperlink}
\begin{document}
\begin{maplegroup}
\begin{Title}
An Indefinite Integral
\end{Title}
\begin{Author}
by Jane Maplefan
\end{Author}
\end{maplegroup}
\section{Calculation}
Look at the integral

\mapleinline{inert}{2d}{Int(x^2*sin(x-a),x);}{%
$\int x^{2}\,\mathrm{sin}(x - a)\,dx$%
}. Notice that its integrand,
\mapleinline{inert}{2d}{x^2*sin(x-a);}{%
$x^{2}\,\mathrm{sin}(x - a)$%
}, depends on the parameter
\mapleinline{inert}{2d}{a;}{%
$a$%
}.
Les fichiers de style LATEX supposent que vous imprimez le fichier .tex
en utilisant le pilote d’imprimante dvips. Vous pouvez changer ce défaut
en spécifiant une option à la commande LATEX \usepackage dans l’en-tête
de votre fichier .tex.
La section Imprimer des graphiques de la page 288 explique com-
ment enregistrer des graphiques directement. Vous pouvez inclure ces fi-
chiers graphiques dans votre document LATEX à l’aide de la commande
LATEX \mapleplot.
HTML et HTML avec MathML

Vous pouvez exporter une feuille Maple en format HTML (HyperText
Markup Language) en choisissant Export As du menu File et HTML
du sous-menu qui apparaı̂t. Le fichier .html généré par Maple peut être
chargé dans n’importe quel navigateur HTML. Vous pouvez également

exporter une feuille Maple en format HTML avec MathML (Mathema-
tical Markup Language) en choisissant Export As du menu File, puis
HTML with MathML. MathML est la norme Internet sanctionnée par
le World Wide Web Consortium (W3C) pour la communication de for-
mules mathématiques structurées entre des applications mathématiques.
Pour plus d’information à propos de MathML, consultez la rubrique
?MathML.
Maple génère des fichiers .gif pour représenter les équations et les
graphiques de votre feuille de calcul. Il convertit les formules mathéma-
tiques et les graphiques en format MathML ou .gif, selon que vous ayiez
choisi l’exportation en format HTML avec MathML ou HTML seul.
L’exemple suivant est une feuille Maple exportée en HTML. Remar-
quez que les autres documents HTML (incluant une table des matières),
qui ont été créés lors de l’exportation de la feuille originale, sont appelés
par cette portion de code.
<html>
<head>
<title>tut1.htm</title>

</head>
<frameset cols="25%,*">
<frame src="tut1TOC.htm" name="TableOfContents">
<frame src="tut11.htm" name="Content">
<noframes>
Sorry, this document requires that your browser support
frames.
<a href="tut11.htm" target="Content">This link</a>
will take you to a non-frames presentation of the document.
</noframes>
</frameset>
</html>
L’exemple suivant est une portion du fichier tut11.htm mentionné
dans le fichier précédent.
Calculation


Look at the integral 
<img src="tut11.gif" width=120 height=60 alt="[Maple Math]"
align=middle>
. Notice that its integrand, 

align=middle>
, depends on the parameter 
align=middle>
.


Give the integral a name so that you
can refer to it later.

<a name="expr command">
<tt>> </tt>
expr := Int(x^2 * sin(x-a),
x);


<img src="tut14.gif" width=169 height=49 alt="[Maple Math]">


The value of the integral is 
<a href="tut4.html" target="_top">an anti-derivative</a>
 of the integrand.

RTF
Vous pouvez exporter une feuille Maple en format RTF (Rich Text For-
mat ) en choisissant Export As du menu File et RTF du sous-menu
qui apparaı̂t. Le fichier .rtf généré par Maple peut être chargé dans
n’importe quel traitement de texte qui supporte le format RTF. Maple
incorpore les graphiques et les éléments mathématiques formatés sous la
forme de bitmaps inclus dans des métafichiers Windows. Les feuilles de
calcul (spreadsheets ) ne sont pas pleinement exportées, mais les cellules
visibles de même que les en-têtes de colonnes et de lignes sont exportés.
L’exemple suivant est le début d’une feuille Maple exportée en format
RTF.
{\rtf1\ansi\ansicpg1252\deff0\deflang1033
{\fonttbl
{\f0 Times New Roman}
{\f1 Symbol}
{\f2 Courier New}

}
{\colortbl
\red205\green205\blue205;
\red0\green0\blue0;
}
{\stylesheet
{\s0 \widctlpar}
{\s1\qr footer_header}
{\*\cs12\f2\fs24\cf1\i0 \b \ul0 \additive Maple Input}
{\*\cs13\f0\fs24\cf2\i0 \b0 \ul0 \additive 2D Comment}
{\*\cs14\f0\fs24\cf1\i0 \b0 \ul0 \additive 2D Input}
{\*\cs15\f0\fs24\cf3\i0 \b0 \ul0 \additive 2D Output}
XML
Pour exporter une feuille Maple en format XML (Extensible Markup
Language), choisissez Export As du menu File, puis XML. Le fichier
.xml généré par Maple peut être chargé comme une feuille Maple tradi-
tionnelle. Les documents XML sont chargés en choisissant Open du menu
File.
Le texte suivant est un extrait d’une feuille Maple exportée en XML.
<section><exchange><para pstyle=’Normal’ prompt=’> ’><mapletext
maple-input=’true’ cstyle=’Maple Input’>a;</mapletext></para>
</exchange></section>
7.4 Imprimer des graphiques

Sur la plupart des plateformes, Maple affiche par défaut les graphiques di-
rectement dans la feuille (on parle de graphiques insérés ). Vous pouvez
utiliser la commande plotsetup pour changer ce comportement. La com-
mande suivante indique à Maple d’afficher le graphique dans une fenêtre
séparée de votre écran.
> plotsetup(window);
Lorsque votre graphique s’affiche dans une fenêtre séparée, vous pou-
vez l’imprimer par le menu File comme toute autre feuille Maple.
7.4 Imprimer des graphiques • 289
On appelle la commande plotsetup en appliquant la syntaxe sui-

vante.
plotsetup( TypePilote, plotoutput="nomfichier ",

plotoption="options " )
Ici, TypePilote est le pilote graphique que Maple doit utiliser, nomfichier
est le nom du fichier de sortie et options est une chaı̂ne d’options reconnues
par le pilote spécifié.
La commande suivante indique à Maple d’envoyer le graphique en
format PostScript dans le fichier myplot.ps.
> plotsetup( postscript, plotoutput="myplot.ps" );
Le graphique généré par la commande plot ci-dessous n’apparaı̂t pas

à l’écran ; il est envoyé dans le fichier myplot.ps.
> plot( sin(x^2), x=-4..4 );
Maple peut également générer des graphiques au format HP Laser-

jet. Il envoie le graphique généré par la commande plot3d au fichier
myplot.hp.
> plotsetup( hpgl, plotoutput="myplot.hp",
> plotoptions=laserjet );
> plot3d( tan(x*sin(y)), x=-Pi/3..Pi/3, y=-Pi..Pi);
Si vous souhaitez imprimer plus d’un graphique, vous devez modi-

fier l’option plotoutput entre chaque graphique ; sinon, chaque nouveau
graphique écrasera le précédent.
> plotsetup( plotoutput="myplot2.hp" );
> plot( exp@sin, 0..10 );
Une fois les graphiques exportés, vous devez spécifier à Maple que les
graphiques doivent de nouveau être insérés à travers les feuilles.
> plotsetup( inline );
Consultez la rubrique ?plot,device pour une description des pilotes

graphiques reconnus par Maple.
7.5 Conclusion
Dans ce chapitre, nous avons vu un grand nombre de possibilités d’entrées
et de sorties de Maple : comment imprimer des graphiques, comment
enregistrer et récupérer des expressions Maple individuellement, comment
lire et écrire des données numériques et comment exporter une feuille
Maple en document LATEX ou HTML.
De plus, Maple possède plusieurs commandes d’entrées et de sorties
de bas niveau comme fprintf, fscanf, writeline, readbytes, fopen et
fclose. Consultez les pages d’aide pour plus de détails.
Les pages d’aide sont en quelque sorte un manuel de référence inter-
actif. Elles sont toujours au bout des doigts lorsque vous utilisez Maple.
Tout comme un manuel de référence traditionnel, utilisez-les en étudiant
l’index ou en les cherchant une à une. En particulier, l’option de recherche
d’un texte entier est une méthode de recherche de l’information supérieure
à un index traditionnel. Les hyperliens rendent aisée la recherche de sujets
connexes.
Le but de ce livre est de donner au lecteur une bonne base de connais-
sances à partir de laquelle il pourra explorer Maple. Il se concentre donc
sur l’usage interactif du logiciel. Bien entendu, Maple est un langage com-
plet et fournit plusieurs outils de programmation. En fait, la majorité des
commandes de Maple sont enregistrées dans le langage Maple, puisque
ce langage de haut niveau est de loin supérieur aux langages de pro-
grammation traditionnels pour des tâches mathématiques. Le Guide de
programmation de Maple 8 vous introduit à la programmation sous
Maple.
8 Les maplets
En utilisant le package Maplets, vous pouvez créer des fenêtres, des boı̂tes
de dialogue et d’autres interfaces visuelles qui interagissent avec l’utilisa-
teur.
Les utilisateurs peuvent effectuer des calculs ou tracer des graphiques
de fonctions sans utiliser l’interface de la feuille de travail.
Le présent chapitre est destiné en priorité aux utilisateurs des maplets.
Son contenu peut également s’avérer utile aux programmeurs de maplets.
8.1 Exemple de maplet

Vous pouvez créer une interface qui demande l’entrée d’information de
la part de l’utilisateur. Par exemple, une maplet d’intégration pourrait
ressembler à l’exemple suivant.
291
292 • Chapitre 8: Les maplets
8.2 Terminologie
maplet Une maplet est une collection d’éléments incluant, sans s’y limi-
ter, des fenêtres et leur disposition, des boı̂tes de dialogue et des actions.
Une mapplet diffère des autres fenêtres et boı̂tes de dialogue en ce qu’elle
contient elle-même des fenêtres et des boı̂tes de dialogue.
auteur de maplet Un auteur de maplet est un programmeur qui utilise

du code Maple pour créer une maplet.
utilisateur de maplet Un utilisateur de maplet est quelqu’un qui inter-

agit avec une maplet.
disposition La disposition définit comment les éléments d’une maplet

sont affichés.
fenetre Une fenêtre est un élément d’une maplet. Une fenêtre ne doit pas
être vue comme une maplet, mais plutôt comme un élément de maplet.
Une maplet peut contenir plus d’une fenêtre, et chaque fenêtre, à son tour,
peut contenir plusieurs éléments régissant la disposition et la fonction de
cette fenêtre.
8.3 Comment démarrer le package Maplets • 293
boıte de dialogue Une boı̂te de dialogue est un élément d’une maplet.

Contrairement à une fenêtre, qui peut contenir d’autres éléments comme
des boutons, une boı̂te de dialogue possède une structure prédéfinie : un
auteur peut spécifier les options d’une boı̂te de dialogue, mais ne peut lui
ajouter d’éléments.
8.3 Comment démarrer le package Maplets

Si vous recevez une feuille Maple contenant du code provenant du package
Maplets, vous devez d’abord charger ce dernier en mémoire. Appuyez sur
Enter après ces deux groupes d’exécution possibles.
> restart:
> with(maplets[Elements]);
Important : Vous devez posséder la version 1.2.2 du JavaTM Runtime

Environment Version (ou la version 1.3 si vous travaillez sous Red Hat
Linux 7.0) sur votre système local. Si cet environnement n’est pas installé,
communiquez avec votre administrateur de système.
8.4 Comment appeler une maplet à partir d’une

feuille Maple
Pour démarrer une maplet, appuyez sur Enter après les derniers deux-
points (:) ou le dernier point-virgule (;), ou n’importe où dans un groupe
d’exécution pour lancer l’exécution du code Maplets. Dans l’exemple sui-
vant, la maplet est écrite en un seul groupe d’exécution. Vous pouvez ap-
puyer sur Enter n’importe où dans le groupe d’exécution pour démarrer
la maplet.
> mymaplet := Maplet ([
> ["Hello World", Button("OK", Shutdown())]
> ]):
> maplets[Display](mymaplet);
Dans l’exemple suivant, la maplet est écrite comme deux groupes

d’exécution. Elle doit être définie avant d’utiliser la commande Display.
> with(maplets[Elements]):
> my2maplet := Maplet ([
> ["Hello World #2", Button("OK", Shutdown())]
> ]):
> maplets[Display](my2maplet);
8.5 Comment fermer une maplet

Si la maplet contient un bouton Cancel, cliquez sur ce bouton. Sinon,
cliquez sur le bouton de fermeture approprié pour votre plateforme. Par
exemple :
Sous UNIX :
1. Cliquez sur l’icône – située dans le coin supérieur gauche de la fenêtre
de la maplet. Un menu déroulant apparaı̂t.
Note : Cette icône varie selon votre gestionnaire de thèmes.
2. Choisissez Close.
Sous Windows :
– Cliquez sur l’icône X située dans le coin supérieur droit de la barre
de titre de votre maplet. Cette dernière se ferme.
8.6 Comment utiliser les Maplets et la fen

etre
Maple (modalité)
Lorsqu’une maplet est en cours d’exécution, la feuille Maple est inac-
cessible. Si vous déplacez le curseur au-dessus de cette feuille, une icône
(horloge sous UNIX, sablier sous Windows) apparaı̂t, indiquant que la
feuille de travail est inaccessible. La maplet doit être fermée ou auto-
risée à compléter une action avant que la feuille Maple soit de nouveau
accessible.
8.7 Comment activer la fen

etre d’une maplet
1. Cliquez sur un champ de saisie de la maplet. Ce champ apparaı̂t en
surbrillance.
8.8 Comment arreter puis redémarrer une maplet • 295
2. Entrez l’expression, les nombres ou le texte appropriés.
8.8 Comment arr

eter puis redémarrer une maplet
Lorsque les calculs à effectuer par une maplet sont longs, il vous est tou-
jours possible d’interrompre le processus en cours.
1. Pour arrêter la maplet en cours, cliquez sur le bouton X (ou l’icône de
fermeture appropriée pour votre plateforme) qui figure dans sa barre
de titre.
2. Pour redémarrer la maplet, exécutez-la à nouveau au moyen de l’outil
lastmaplet.
> maplets[Display](lastmaplet);
8.9 Comment utiliser les raccourcis de l’interface

graphique
Listes déroulantes
Certaines maplets contiennent des listes déroulantes. Voici comment les
utiliser efficacement.
1. Entrez le premier caractère de l’élément de la liste que vous souhaitez
atteindre. La liste se déplace automatiquement jusqu’à un élément
commençant par la lettre saisie.
2. Continuez à ajouter des caractères du nom de l’élément voulu jusqu’à
ce que la sélection désirée soit affichée en surbrillance.
Remarquez que cette méthode ne s’applique pas aux listes déroulantes
créées avec l’élément ComboBox.
La barre d’espacement et la touche TAB

Vous pouvez utiliser la souris pour cliquer sur un bouton comme Can-
cel ou OK. Vous pouvez également utiliser les touches Tab et la barre
d’espacement de la manière suivante.
1. Utilisez la touche Tab pour positionner le curseur sur le bouton de
votre choix.
2. Appuyez sur la barre d’espacement. La commande choisie est
exécutée.
8.10 Conclusion
Pour obtenir plus d’information sur les maplets, reportez-vous à la ru-
brique ?maplets ou au Guide d’introduction à la programmation (Maple
Introductory Programming Guide), au chapitre 9.
Index
!, 8 images des, 126, 128, 133

π, 12 paramétriques, 3-D, 128
%, 8 paramétriques, 2-D, 127
->, 19 tridimensionnelles, 128
:, 28 annotations, 129, 134
:=, 18 ApproximateInt, 89–91, 227–
;, 28 229
_C, 78 approximation de fonctions en
_Z, 55 séries, 68–70
\, 8 approximations
à virgule flottante, 9
about, 168 décimales, 9
add, 176 arbre des expressions, 186
additionally, 168 arithmétique élémentaire, 6
affectation multiple, 94 arrow, 140
affectations assign, 53
invalides, 20 assignations
nommer, 18 d’ensembles d’équations, 53
noms valides, 19 multiples, 21
affichage du résultat assigned, 200
supprimer, 28 assume, 172
afficher additionally, 168
procédures, 198 integer, 169
algèbre linéaire, 91 nonnegative, 168
algsubs, 192 assuming, 172
algsubs, 41 axes, 131
animate, 125
coords, 127 boı̂te de dialogue, see ma-
frames, 126 plets,boı̂te de dialogue
animate3d, 128 bordure (bounding box), 116
coords, 129
frames, 128 côté droit, 182
animations, 211 côté gauche, 182
afficher, 126, 133 cônes, tracer le graphique, 122
en coordonnées sphériques, côté droit d’une égalité, 39
129 côté gauche d’une égalité, 39
en deux dimensions, 125 calcul différentiel, 209
297
298 • Index
calcul différentiel, 66–72, 86 list, 35, 195, 276

Calculus1 ln, 166
ApproximateInt, 89–91, parfrac, 167
227–229 polynom, 194, 216
Hint, 87–89 rational, 167
Roots, 89 set, 35, 195
Rule, 86–89 sincos, 166
Tangent, 89 string, 194
Understand, 87 convertir, 35
chaı̂nes, 31 des expressions en fonctions,
concaténer, 194 51
champ de vecteurs, 138 en chaînes, 194
coeff, 65 en listes et en ensembles, 195
coefficients, 65 séries en polynômes, 194, 216
collect séries en polynômes, 68
distributed, 154 coordonnées
coloriage, 124 cylindriques, 121
combine, 37, 158 polaires, 105, 127
combiner des listes, 178 et fonctions explicites, 106
commandes, see noms de com- et fonctions paramé-
mandes spécifiques triques, 107
compter, 40 sphériques, 119
concaténation, 194, 205–207 coordonnées polaires, 127
concaténation coordonnées sphériques, 119
chaı̂nes, 32 correspondance
suites d’expressions, 21 sur des ensembles, 174
conditions sur des expressions, 187
initiales, 237, 270 sur des listes, 174
cone, 142 courbes dans l’espace, 138
conformal, 137 cutout, 144
constantes, 12 cylinderplot, 121
d’intégration, 230
continuité, prolonger par, 231 D, 231, 237, 251
contourplot, 137 dénominateurs, 183
conversion dérivées, 70, 209
sous forme de listes, 276 définition, 210
convert, 35, 275 partielles, 218, 232
binary, 14 dérivées partielles, 218
exp, 35, 166 définition, 232
factorial, 166 mixtes, 233
hex, 14 désaffectation, 203
Index • 299
dénominateurs, 39 EDP, 266

commun, 37, 159 conditions initiales, 270
développer tracer le graphique, 269
des expressions, 34 empty_set, 25
modulo m, 152 ensembles, 23
degré d’un polynôme, 65 convertir en, 195
degree, 65 correspondances, 38
denom, 39, 183 différence, 26
densityplot, 137 intersection, 24
DEplot, 257 minus, 26
DEplot3d, 259 opérandes des, 186
DESol, 255 opérations sur les, 25–26
deux-points, 28 sélectionner dans, 176
Diff, 86 union, 24
diff, 190 vides, 25
differentiation, 86 entiers, 7
Digits, 13 calculs sur, 7
Dirac, 75, 263 commandes pour, 8–9
display, 140 précision arbitraire, 8
display, 132, 211 solutions entières, 60
divide, 64 entiers gaussiens, 15
dodecahedron, 140 équation
dsolve, 73, 236 d’onde, 266
explicit, 238 de la chaleur, 268
implicit, 238 équations
method=laplace, 239 aux dérivées partielles, 266
startinit, 250 côté droit d’une égalité, 39
type=numeric, 248 côté gauche d’une égalité, 39
type=series, 245 équations différentielles
dynamique classique, 238 systèmes d’, 78
ordinaires, 73, 236
écart type, 95 erreurs d’arrondi, 250
echo, 277 eval, 64, 73, 190, 196
EDO, 73 evalf, 10, 210
conditions initiales, 237 evaln, 200
dsolve, 236 évaluation, 196–207
méthode des transformées de à un niveau, 200
Laplace, 238 à un nom, 200
numériques, 247 assigned, 200
séries, 245 complète, 196
tracer le graphique, 256 du dernier nom, 197
300 • Index
en un point, 47 factorielle, 8
et les guillemets, 201 factorisation, 157
et substitution, 193 modulo p, 157
evaln, 200 factoriser, 34, 154
forcer l’évaluation complète, feuilles
198 sauvegarder, 282
niveaux, 197 fichiers
numérique, 10, 12, 13 écrire des colonnes dans, 278
retardée, 201 lecture de colonnes depuis,
évaluer 274
des variables locales, 200 lecture de commandes de-
matrices, 197 puis, 276
procédures, 197 lecture de données depuis,
tableaux, 30, 197 274
tables, 197 fieldplot, 138
exp, 11 fonction de Heaviside, 261
Expand, 152 fonction delta de Dirac, 263
expand, 34, 150 fonctions
exporter à partir d’expressions, 51
en HTML, 285 affectation, 19
en HTML avec MathML, 286 arguments, 20
en LATEX, 284 définies par morceaux, 264
en RTF, 287 de coloriage, 124
en texte, 282 discontinues
en texte Maple, 283 tracer le graphique, 108
XML, 288 mathématiques, 15–16
ExportMatrix, 278 prolongement par continuité,
ExportVector, 278 231
expressions rationnelles
convertir en fonctions, 51 factoriser, 154
identification de, 184 forme normale factorisée, 159
indéterminées des, 188 frac, 169
non évaluées, 15, 201 fractions
opérandes des, 184 dénominateurs de, 39, 183
requête sur le contenu des, numérateurs de, 39, 183
187 partielles, 167
types des, 188 sur le même dénominateur,
37, 159
Factor, 157 fsolve, 56, 221
factor, 34
vs. solve, 65 graphiques, 101–148
Index • 301
graphiques listes de nombres, 275

échelle de type Matrices, 139
constrained, 104 modèles d’éclairage, 124
root loci, 139 niveaux de gris, 124
afficher, 132 objets, 140
afficher les coordonnées, 101 pilotes, 288
algorithme adaptatif pour, plusieurs, 132
115 raffiner, 115, 123
animations, see animations, séries, 194
211 singularités, 109
annotations, 129, 134 sphères, 120
bordure (bounding box), sphereplot, 119
116 styles de lignes, 112
cartes topographiques, 137 styles de lignes, spécifier, 112
champs de vecteurs, 138 styles de points, spécifier,
coloriage, 124 114
conformes, 137 sur un axe logarithmique,
contours, 137 136
coordonnées polaires, 105 surface colorée, 117
coordonnées sphériques, 119 surfaces, 116
couleurs, spécifier, 113 surfaces paramétriques, 118,
courbes dans l’espace, 138 120
courbes dans l’espace tridi- tangente, 89
mensionnel, 138 texte, 134
courbes paramétriques, 103 titres, 129, 194, 207
cylinderplot, 121 tourner, 116, 142
cylindres, 121, 122 tracer des points, 113
dans des fenêtres séparées, tracer plusieurs courbes, 111
288 translater, 142
de densité, 137 tridimensionnels, 116
domaine, 117 tubes, 138
EDO, 256 graphiques paramétriques
EDP, 269 2-D, 103
exporter vers un fichier, 288 3-D, 118
fonctions de coloriage, 124 cylindres, 122
fonctions discontinues, 108 en coordonnées polaires, 107
fonctions explicites, 101, 116 sphères, 120
fonctions implicites, 135 guillemets, 201
imprimer, 288 guillemets anglais, 31
inégalités, 135
insérés, 288 hastype, 188
302 • Index
Heaviside, 239, 261 de fichiers, 276

hemisphere, 143 length, 32, 181
Hint, 87–89 lhs, 39, 182
histogrammes, 97, 139 lightmode, 124
HP Laserjet, 289 Limit, 66, 87, 91
HTML, 285 limites, 66, 87, 212
hypothèses LinearAlgebra, 91
poser, 168 listes, 22
retirer, 72, 171 éléments de, 22
voir, 168 combiner, 178
convertir en, 195
implicitplot, 135 correspondances, 38
ImportMatrix, 274 désordonnés, 23
imprimer opérandes des, 186
des graphiques, 288 opérations sur les, 25–26
indéterminées, 188 ordonnées, 22
indets, 188 sélectionner dans, 176
inequal, 135 trier, 179
infolevel, 158, 169 vides, 25
intégrales, 70, 227, 230 loglogplot, 136
constantes des, 230 logplot, 136
définies, 71, 229 Loi du refroidissement de New-
de Riemann, 227 ton, 251
indéfinies, 70, 229
intégrales, 91 majuscules-minuscules, 12
interface map, 24, 38, 174
echo, 277 map2, 174
verboseproc, 199 Maple Animation Gallery, 145
inttrans package, 242 Maple Application Center, 145
invlaplace, 243 Maple Graphics Gallery, 145
is, 170, 180 Maple Introductory Program-
isolate, 211 ming Guide, 296
isolve, 60 Maplets, 291–296
maplets
Java Runtime Environment, 293 activer, 294
arrêter, 295
laplace, 242
auteur, 292
LATEX, 280, 284
boı̂te de dialogue, 292
lecture
champ de saisie, 294
de code, 276
ComboBox, 295
de colonnes, 274
Display, 293
de commandes, 276
Index • 303
disposition, 292 nommer, 18

Elements, 293 nops, 23, 40, 184
exemple de l’intégration, 291 normal, 37
fenêtre, 292 expanded, 160
fermer, 294 notation flèche, 19
listes déroulantes, 295 notation indicée, 25
raccourcis, 295 noyau, 79
redémarrer, 295 numérateurs, 183
travailler avec, 294 numérateurs, 39
utilisateur, 292 numer, 39, 183
MathML, 286
Matlab, 93 objet
matrices graphique, 140
évaluer, 197 objets graphiques, 140
Transpose, 276 odeplot, 248, 264
matrixplot, 139 oleplot, 262
max, 226 op, 40, 184
mise en page, 280 op, 226
mod, 14 opérandes
développer, 152 de listes et d’ensembles, 186
factorisation, 157 des expressions, 184
modèles d’éclairage, 124 nombre de, 40, 184
modp, 15 sélectionner, 184
mods, 15 opérateur idem, 8
modulo, 14–15 optimisation
moyenne, 95 linéaire, 97
msolve, 60 Order, 68, 251
mul, 176
packages
niveaux d’évaluation, 197 charger, 80
nombre d’opérandes, 40 liste des, 81
nombres à virgule flottante, 12– utiliser des commandes dans
14 les, 79
précision par défaut, 12 PDEplot, 270–271
vs. nombres rationnels, 9–11 pi, 12
nombres complexes, 14 piecewise, 264
nombres décimaux, 12–14 graphiques, 108
nombres imaginaires, 14 plex, 62
nombres rationnels, 7–10 color
vs. nombres à virgule flot- color, 113
tante, 9–11 plot
304 • Index
color, 112 entiers, 8

discont, 109, 111 print, 27
labels, 130 procédures
évaluer, 197
labelsfont, 130 afficher, 198
legend, 131 prolonger par continuité, 231
linestyle, 112
numpoints, 115 quo, 63
style=hidden, 117 quotient
style=line, 114 polynômes, 63
symbol, 114
remember tables, 232
symbolsize, 114
résultats, exacts vs. approxima-
title, 129, 194
tifs, 9
plot3d, 116
résoudre
axes, 131
ensembles d’équations, 45
grid, 123
ensembles de variables, 45
lightmodel, 124
et vérifier, 47–49
shading, 124
inégalités, 49
plots
modulo m, 60
animate, 125
numériquement, 56
animate3d, 128
récurrences, 61
arrow, 140
solutions entières, 60
plotsetup, 288
systèmes d’équations, 46, 49
plottools, 140
rationalize, 157
plusieurs assignations, 21
read, 277
plusieurs courbes dans un gra-
relations accessoires, 33, 41, 192
phique, 111
relations de récurrence, 61
plusieurs graphiques, 132
rem, 63
point-virgule, 28
remove, 177
pointplot, 113
restart, 280
polynômes, 61–66
reste de polynômes, 63
coefficients de, 63, 65
retarder l’évaluation, 201
développer, 150
retirer des hypothèses, 171
degré de, 65
rhs, 39, 182
division de, 63
rootlocus, 139
factoriser, 154
RootOf, 55, 187
regrouper les termes, 152
supprimer les occurrences
reste, 63
de, 55
trier les éléments, 164–166
Roots, 89
PostScript, 289
rotate, 142
précision
Index • 305
RowSpace, 92 singularités, graphiques, 109

rsolve, 61 NewtonQuotient, 210
RTF, 287 solutions
Rule, 86–89 multiples, 49
paramétriques, 46
sélectionner solve, 219
dans des listes et des en- vs. factor, 65
sembles, 176 sommes de Riemann, 89, 228
des constantes réelles, 214 sort, 62, 164–166, 179
des sous-expressions, 184, sous-expressions, 40
187 spacecurve, 138
opérandes, 184 specfunc, 189
séries, 245 sphères, 120
convertir en polynômes, 194 sphere, 141
séries de Taylor, 193, 215, 227, sphereplot, 119
251, 253 spirales, 107, 123
séparateurs de commandes, 28 sqrt, 11
sauvegarder startinit, 250
listes de nombres, 278 stats, 94
matrices, 278 stellate, 143
tableaux de nombres, 278 Student
save, 279 Calculus1, 86–91
select, 176 subs, 29, 191, 192
has, 188 subsop, 193
hastype, 188 substitutions, 29, 190
realcons, 214 suites d’expressions, 20
type, 188 sum, 201
selectremove, 177 supprimer l’affichage du résultat,
semilogplot, 136 28
seq, 201, 252
seq, 175 tableaux, 26
series, 68 évaluer, 30, 197
simplex, 97 choisir les éléments, 28
simplifications, 32–35 correspondances, 38
au moyen des relations acces- imprimer, 27
soires, 33, 41 tables, 30
spécifier les règles, 33 évaluer, 197
simplify, 33, 41, 161–164 tables de rappel, 232
au moyen des relations acces- Tangent, 89
soires, 163, 192 tangente
avec hypothèses, 163 tracer le graphique, 89
306 • Index
tests de primalité, 8 verboseproc, 199

TEX, 280
texte Maple, 283 whattype, 184
texte, exporter, 282
XML, 288
textplot, 134
textplot3d, 134 zip, 178
titres
de graphiques, 129, 194, 207
tourner des graphiques tridimen-
sionnels, 116
tracé adaptatif de graphiques,
115
transformées de Laplace, 238,
242
inverse, 243
translate, 142
Transpose, 276
triangle de Pascal, 175
trier
définir une relation d’ordre,
180
des listes, 179
des polynômes, 62
en ordre lexicographique, 62,
166, 179
en ordre numérique, 179
les éléments d’une expres-
sion, 164–166
par degré total, 165
par longueur, 181
tubeplot, 138
type, 177, 188
specfunc, 189
types de données, 20
unapply, 51, 211

Understand, 87
variables locales, évaluer, 200

vecteurs, 92
transposée de, 92

Utiliser Maple 8

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Utiliser Maple 8

Uploaded by

Copyright:

Available Formats

Utiliser

Inspiré du travail de B.W. Char

Waterloo Maple Inc.

Maple et Maple 8 sont des marques déposées de Waterloo Maple Inc.

Tous droits réservés. La reproduction ou la traduction, même partielle,

L’utilisation de noms descriptifs généraux, de noms déposés, de

2 Mathématiques de base avec Maple 5

Les commandes numer et denom . . . . . . . . . . . . . . . 39

3 Trouver des solutions 45

4 Tracer des graphiques 101

Graphiques multiples . . . . . . . . . . . . . . . . . . . . . 111

5 L’évaluation et la simpliﬁcation 149

Les parties d’une expression . . . . . . . . . . . . . . . . . 182

6 Exemples tirés du calcul diﬀérentiel 209

7 Entrées et sorties 273

8 Les maplets 291

On appelle le logiciel Maple un système de calcul symbolique, évoquant

la formulation, la résolution et l’exploration de modèles mathématiques.

complémentaire. Enﬁn, la nature interactive de Maple permet de calcu-

1.1 Les autres manuels

de Maple pour résoudre des problèmes mathématiques et créer des do-

Ce chapitre commence par une discussion à propos des calculs numériques

nombres à virgule ﬂottante. Entrez l’expression en utilisant la syntaxe

Lorsque vous commencerez à travailler avec des expressions plus com-

2.2 Calculs numériques

Maple peut également travailler avec des nombres entiers arbitraire-

La réponse indique le nombre de chiﬀres contenus dans le dernier

(2)2 (3) (5)

En plus de ifactor, Maple possède plusieurs commandes pour tra-

Tab. 2.1 – Commandes opérant sur des entiers

Arithmétique exacte – Rationnels, irrationnels et constantes

Maple gère les nombres rationnels et produit un résultat exact. La

> evalf(Pi, 100);

Le nombre suivant est son approximation décimale (avec une précision

Ces résultats ne sont pas les mêmes mathématiquement, et ne sont

Ainsi, il est recommandé de n’utiliser des nombres décimaux que

Voici un autre exemple de racine carrée.

Maple connaı̂t les constantes arithmétiques standard comme π et la

La fonction exponentielle est représentée par la fonction Maple exp.

Le deuxième exemple peut paraı̂tre étrange. Souvenez-vous que

vous les écririez vous-même. Ainsi, vous entrez π comme Pi et Maple

Approximations à virgule ﬂottante

Par défaut, Maple calcule le résultat à l’aide de dix chiﬀres de préci-

> evalf(Pi, 200);

Alors que le second argument optionnel de la commande evalf

Digits est maintenant ﬁxé à vingt, le nombre de chiﬀres que Maple

Arithmétique avec des nombres spéciaux

> (1 + I)/(3 - 2*I);

> convert(1023, hex);

> convert(17, base, 3);

Maple retourne une conversion en base entière comme une liste de

Les représentations symétriques et positives sont également dispo-

La valeur par défaut de la commande mod est la représentation posi-

Tab. 2.2 – Quelques fonctions mathématiques connues de Maple

2.3 Calculs symboliques de base

Remarquez que Maple simpliﬁe automatiquement la seconde expres-

Comme il est mentionné à la section Calculs numériques de la page 7,

> Sum(n^2, n);

Divisez un polynôme en x par un autre.

Créez une série.

Toutes les fonctions mathématiques mentionnées dans la section

2.4 Aﬀecter des noms à des expressions

Vous pouvez aﬀecter un nom à n’importe quelle expression Maple.

> polynomes := [x^2+3, x^2+3x-1, 2x];