Vous êtes sur la page 1sur 313

Utiliser

Maple 8

Inspiré du travail de B.W. Char


Traduit de l’anglais par Sylvain Hallé


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 déposées de Waterloo Maple Inc.


c 2002, 2001, 2000, 1998, 1996 Waterloo Maple Inc.

Tous droits réservés. La reproduction ou la traduction, même partielle,


par quelque procédé que ce soit, est interdite sans l’autorisation écrite du
détenteur des droits d’auteur, à 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 électronique, de logiciel d’ordinateur, ou avec toute autre méthode
semblable ou différente, connue ou conue ultérieurement, est interdite.

L’utilisation de noms descriptifs généraux, de noms déposés, de


marques de commerce, etc., dans la présente publication, même s’ils ne
sont pas expressément désignés, n’est pas une indication que de tels noms,
en vertu de la Loi sur les marques de commerce, peuvent conséquemment
être librement employés par quiconque.

Imprimé au Canada

ISBN 1-894511-33-6
Table des matières

1 Introduction à Maple 1
1.1 Les autres manuels . . . . . . . . . . . . . . . . . . . . . . 3

2 Mathématiques de base avec Maple 5


2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Calculs numériques . . . . . . . . . . . . . . . . . . . . . . 7
Calculs sur des entiers . . . . . . . . . . . . . . . . . . . . 7
Arithmétique exacte – Rationnels, irrationnels et constantes 9
Approximations à virgule flottante . . . . . . . . . . . . . 12
Arithmétique avec des nombres spéciaux . . . . . . . . . . 14
Fonctions mathématiques . . . . . . . . . . . . . . . . . . 15
2.3 Calculs symboliques de base . . . . . . . . . . . . . . . . . 16
2.4 Affecter des noms à des expressions . . . . . . . . . . . . . 18
2.5 Les principaux types d’objets Maple . . . . . . . . . . . . 20
Les suites d’expressions . . . . . . . . . . . . . . . . . . . 20
Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . 23
Les opé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 matiè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 Résolution au moyen de solve . . . . . . . . . . . . . . . 45
Vé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 Résoudre numériquement : fsolve . . . . . . . . . . . . . 56
Les limites de solve . . . . . . . . . . . . . . . . . . . . . 57
3.3 D’autres solveurs . . . . . . . . . . . . . . . . . . . . . . . 60
Trouver des solutions entières . . . . . . . . . . . . . . . . 60
Trouver des solutions modulo m . . . . . . . . . . . . . . 60
Résoudre des relations de récurrence . . . . . . . . . . . . 61
3.4 Les polynômes . . . . . . . . . . . . . . . . . . . . . . . . 61
Tri et regroupement . . . . . . . . . . . . . . . . . . . . . 62
Opérations mathématiques . . . . . . . . . . . . . . . . . 64
Coefficients et degrés . . . . . . . . . . . . . . . . . . . . . 65
Recherche de racines et factorisation . . . . . . . . . . . . 65
3.5 Le calcul différentiel . . . . . . . . . . . . . . . . . . . . . 67
3.6 Les équations diffé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 linéaire . . . . . . . . . . . . . 97
3.9 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 99

4 Tracer des graphiques 101


4.1 Graphiques en deux dimensions . . . . . . . . . . . . . . . 101
Les graphiques paramétriques . . . . . . . . . . . . . . . . 103
Les coordonnées polaires . . . . . . . . . . . . . . . . . . . 105
Les fonctions discontinues . . . . . . . . . . . . . . . . . . 108
Table des matières • v

Graphiques multiples . . . . . . . . . . . . . . . . . . . . . 111


Tracer des points . . . . . . . . . . . . . . . . . . . . . . . 113
Raffiner des graphiques . . . . . . . . . . . . . . . . . . . 115
4.2 Graphiques en trois dimensions . . . . . . . . . . . . . . . 116
Les graphiques paramétriques . . . . . . . . . . . . . . . . 118
Les coordonnées sphériques . . . . . . . . . . . . . . . . . 119
Les coordonnées cylindriques . . . . . . . . . . . . . . . . 121
Raffiner des graphiques . . . . . . . . . . . . . . . . . . . 123
Modèles de coloriage et d’é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’évaluation et la simplification 149


5.1 Manipulations mathématiques . . . . . . . . . . . . . . . . 149
Développer des polynômes en sommes . . . . . . . . . . . 150
Regrouper les coefficients de même degré . . . . . . . . . . 152
Factoriser des polynômes et des fonctions rationnelles . . 154
Supprimer des exposants rationnels . . . . . . . . . . . . . 157
Combiner des termes . . . . . . . . . . . . . . . . . . . . . 158
Forme normale factorisée . . . . . . . . . . . . . . . . . . 159
Simplifier des expressions . . . . . . . . . . . . . . . . . . 161
Simplification avec des hypothèses . . . . . . . . . . . . . 163
Simplification au moyen des relations accessoires . . . . . 163
Trier des expressions algébriques . . . . . . . . . . . . . . 164
Conversion entre différentes formes . . . . . . . . . . . . . 166
5.2 Les hypothèses . . . . . . . . . . . . . . . . . . . . . . . . 168
La commande assume . . . . . . . . . . . . . . . . . . . . 168
La commande assuming . . . . . . . . . . . . . . . . . . . 172
5.3 Manipulations structurelles . . . . . . . . . . . . . . . . . 173
Appliquer une fonction à une liste ou un ensemble . . . . 174
Choisir des éléments dans une liste ou un ensemble . . . . 176
Combiner deux listes . . . . . . . . . . . . . . . . . . . . . 178
Trier des listes . . . . . . . . . . . . . . . . . . . . . . . . 179
vi • Table des matières

Les parties d’une expression . . . . . . . . . . . . . . . . . 182


La substitution . . . . . . . . . . . . . . . . . . . . . . . . 190
Changer le type d’une expression . . . . . . . . . . . . . . 193
5.4 Les règles d’évaluation . . . . . . . . . . . . . . . . . . . . 196
Niveaux d’évaluation . . . . . . . . . . . . . . . . . . . . . 196
Évaluation du dernier nom . . . . . . . . . . . . . . . . . 197
Évaluation à un niveau . . . . . . . . . . . . . . . . . . . . 200
Commandes avec des règles spéciales d’évaluation . . . . . 200
Empêcher l’évaluation d’une expression . . . . . . . . . . 201
Utiliser les variables entourées de guillemets comme argu-
ments de fonctions . . . . . . . . . . . . . . . . . . 204
Concaténation de noms . . . . . . . . . . . . . . . . . . . 205
5.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 207

6 Exemples tirés du calcul différentiel 209


6.1 Calcul différentiel élémentaire . . . . . . . . . . . . . . . . 209
La dérivée . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
Une approximation de Taylor . . . . . . . . . . . . . . . . 215
L’intégrale . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Dérivées partielles mixtes . . . . . . . . . . . . . . . . . . 231
6.2 Équations différentielles ordinaires . . . . . . . . . . . . . 235
La commande dsolve . . . . . . . . . . . . . . . . . . . . 236
Un exemple : les séries de Taylor . . . . . . . . . . . . . . 251
Lorsqu’une solution explicite est impossible à trouver . . . 255
Tracer le graphique d’équations différentielles ordinaires . 256
Coefficients discontinus d’une équation . . . . . . . . . . . 261
6.3 Équations aux dérivées partielles . . . . . . . . . . . . . . 266
La commande pdsolve . . . . . . . . . . . . . . . . . . . . 266
Changer la variable dépendante dans une EDP . . . . . . 268
Tracer le graphique d’équations aux dérivées partielles . . 269
6.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 271

7 Entré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 Écrire des données dans un fichier . . . . . . . . . . . . . 278
Écrire des colonnes de données numériques dans un fichier 278
Sauvegarder des expressions au format interne de Maple . 279
Convertir au format LATEX . . . . . . . . . . . . . . . . . . 280
7.3 Exporter des feuilles complètes . . . . . . . . . . . . . . . 282
Table des matiè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 démarrer le package Maplets . . . . . . . . . . 293
8.4 Comment appeler une maplet à partir d’une feuille Maple 293
8.5 Comment fermer une maplet . . . . . . . . . . . . . . . . 294
8.6 Comment utiliser les Maplets et la fenêtre Maple (modalité)294
8.7 Comment activer la fenêtre d’une maplet . . . . . . . . . 294
8.8 Comment arrêter puis redémarrer une maplet . . . . . . . 295
8.9 Comment utiliser les raccourcis de l’interface graphique . 295
Listes déroulantes . . . . . . . . . . . . . . . . . . . . . . . 295
La barre d’espacement et la touche Tab . . . . . . . . . . 295
8.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . 296
1 Introduction à Maple

On appelle le logiciel Maple un système de calcul symbolique, évoquant


ainsi sa capacité à manipuler l’information de manière symbolique ou
algébrique. En effet, contrairement aux logiciels mathématiques stan-
dard, qui requièrent des valeurs numériques pour toutes leurs variables,
Maple, tout en demeurant capable d’évaluer des expressions numériques,
sait également manipuler les expressions et les symboles sous-jacents.
Cette capacité symbolique permet à Maple de calculer des solutions
analytiques exactes à de nombreux problèmes mathématiques incluant
systèmes d’équations, intégrales, équations différentielles et problèmes
d’algèbre linéaire. En complément à ces opérations symboliques, une vaste
gamme de routines graphiques facilite la visualisation de données mathé-
matiques complexes ; des algorithmes numériques fournissent des réponses
approximées aux problèmes ne possédant pas de solution exacte, et un lan-
gage de programmation complet et accessible permet le développement sur
mesure de nouvelles fonctions et applications.
On accède facilement à l’étendue des fonctions mathématiques de
Maple par son interface graphique prenant la forme de feuilles (work-
sheets ). Une feuille est un document flexible permettant d’explorer des
idées mathématiques et de créer des rapports complexes.
Les utilisateurs de Maple ont trouvé plusieurs manières d’utiliser son
langage et ses feuilles.
Les ingénieurs et les professionnels dans des industries aussi variées
que l’agriculture et l’aérospatiale utilisent Maple comme un outil puissant
remplaçant à la fois leurs manuels de référence, leurs calculatrices, leurs
chiffriers et même leurs langages de programmation tel FORTRAN. Ces
utilisateurs gagnent en rapidité dans la résolution de problèmes mathé-
matiques courants et consignent les résultats de leurs calculs dans des
rapports techniques professionnels.
Les chercheurs de plusieurs domaines considèrent également Maple
comme un outil essentiel à leur travail. Maple est en effet tout indiqué pour

1
2 • Chapitre 1: Introduction à Maple

la formulation, la résolution et l’exploration de modèles mathématiques.


Son caractère symbolique élargit grandement l’éventail des problèmes
qu’ils peuvent ainsi traiter.
Les professeurs emploient Maple en classe, ravivant l’enseignement
traditionnel au collège et à l’université en introduisant des problèmes
et des exercices qui exploitent l’interactivité du logiciel. Plutôt que de
s’astreindre à des manipulations algébriques fastidieuses, leurs étudiants
peuvent ainsi se concentrer sur les concepts fondamentaux.
Chacun utilise Maple d’une manière toute personnelle selon ses be-
soins ; cependant, deux grandes catégories d’utilisation dominent.
La première catégorie consiste en l’utilisation de Maple comme d’un
environnement interactif de résolution de problèmes. Traditionnellement,
lorsqu’on travaille sur un problème, l’essai d’une méthode de résolution
nécessite parfois plusieurs heures et plusieurs pages. Maple permet à son
utilisateur de se concentrer sur de beaucoup plus grands problèmes en
le libérant d’erreurs mécaniques ; son interface documente les étapes de
sa recherche d’une solution. Elle permet aussi de modifier aisément l’une
de ces étapes, ou même d’en insérer une nouvelle. Que ce soit pour le
développement d’un nouveau modèle mathématique ou pour l’analyse
d’une stratégie financière, il est possible d’en apprendre beaucoup sur
un problème, facilement et efficacement.
La seconde catégorie utilise Maple en tant que système de création
de documents techniques. Il est en effet possible de créer des documents
interactifs, structurés et dynamiques ou de modifier une équation et d’ac-
tualiser sa solution automatiquement. Le langage mathématique naturel
de Maple facilite l’entrée des équations, et permet le calcul et le tracé
de graphiques sur demande. De plus, les documents Maple peuvent être
structurés en utilisant des outils modernes tels les styles, la division en
sous-sections et les hyperliens, créant ainsi des feuilles qui sont non seule-
ment claires et faciles à créer, mais également faciles à mettre à jour.
Puisque les composantes des feuilles sont directement associées à 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 caractéristiques
des feuilles Maple. Ces caractéristiques facilitent la rédaction de rapports
ou même d’ouvrages mathématiques et sont aussi appropriées pour la
création et la présentation d’exposés. Par exemple, la division en sous-
sections cache des sections arides et riches en détails qui peuvent être
distrayantes aux yeux de l’observateur ; les styles font clairement ressortir
les mots clés et les titres ; les hyperliens autorisent la création de références
dynamiques qui amènent le lecteur aux pages renfermant de l’information
1.1 Les autres manuels • 3

complémentaire. Enfin, la nature interactive de Maple permet de calcu-


ler et de répondre à des questions durant une présentation. On peut ainsi
clairement et efficacement démontrer pourquoi une méthode de résolution
a priori acceptable s’avère en fait inappropriée, ou pourquoi une modifi-
cation à un processus de manufacturation entraı̂ne des pertes ou engendre
des profits.
Ce livre constitue votre introduction à Maple. Il discute systémati-
quement des concepts clé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 aperçu des fonctionnalités de Maple, décrivant à
la fois ses capacités symboliques et numériques, et introduisant les ob-
jets Maple, les commandes et les méthodes mises à votre disposition. Une
attention particulière est placée non seulement sur la recherche de solu-
tions, mais également sur le tracé de graphiques, la création d’animations
et l’exportation de feuilles en d’autres formats. Plus important encore,
il présente la philosophie et les méthodes d’utilisation suggérées par les
concepteurs du système. Ces quelques concepts simples vous permettront
d’utiliser Maple à son meilleur.
Considérez ce livre d’abord comme un guide ; l’aide en ligne consti-
tuera votre manuel de référence. En effet, puisque l’on peut y rechercher
de l’information de plusieurs manières et qu’il se trouve toujours acces-
sible, le système d’aide de Maple se révèle plus pratique que tout autre
texte traditionnel. Vous trouverez également des exemples que vous pou-
vez copier, coller et exécuter immédiatement.

1.1 Les autres manuels


Trois autres manuels (en anglais) décrivent le fonctionnement de Maple :
le Guide de prise en main (Maple 8 Getting Started Guide), le Guide
d’introduction à la programmation (Maple 8 Introductory Program-
ming Guide) et le Guide de programmation avancée (Maple 8 Advanced
Programming Guide)1 .
Le Guide de prise en main (Getting Started Guide) contient une
introduction à l’interface graphique et un tutoriel résumant l’utilisation

1
La version étudiante n’inclut pas les deux guides de programmation. Ces guides
peuvent toutefois etre achetés chez des libraires spécialisés ou directement auprès de
Waterloo Maple Inc.
4 • Chapitre 1: Introduction à Maple

de Maple pour résoudre des problèmes mathématiques et créer des do-


cuments techniques. À l’intérieur, vous y trouverez de l’information sup-
plémentaire à l’intention des nouveaux utilisateurs au sujet du système
d’aide en ligne, sur le tour guidé 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 à la programmation (Introductory Program-
ming Guide) présente les concepts fondamentaux de la programmation
sous Maple : les expressions, les structures de données, les boucles et les
mécanismes de décision, les procédures, les entrées-sorties, le débogage et
les Maplets.
Enfin, le Guide de programmation avancée (Advanced Programming
Guide) couvre des concepts de programmation comme les modules, les
entrées-sorties, la programmation numérique, les graphiques et le code
compilé.
2 Mathématiques de base
avec Maple

Ce chapitre commence par une discussion à propos des calculs numériques


exacts avec Maple, qui diffèrent légèrement de ceux effectués par d’autres
applications. Des renseignements sur les calculs symboliques de base et les
commandes d’affectation suivent. Les deux dernières sections énoncent les
principaux types d’objets de base et donnent des instructions concernant
la manipulation d’objets et les commandes les plus utiles à cet égard.
Vous tirerez le meilleur parti de ce livre en utilisant votre ordinateur
pour esssayer les différents exemples que vous rencontrerez au fil de votre
lecture. Ce chapitre explique les commandes nécessaires pour commencer
à travailler. Les chapitres subséquents donneront à ces commandes ainsi
qu’à d’autres un traitement plus approfondi.
Si vous souhaitez comprendre davantage les rouages du système
Maple, vous pouvez utiliser le système d’aide en ligne. Pour obtenir de
l’aide à propos d’une commande, tapez simplement à 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 numériques. Maple peut
fonctionner comme une calculatrice traditionnelle avec les entiers et les

5
6 • Chapitre 2: Mathématiques de base avec Maple

nombres à 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 bientôt.
Pour le moment, considérez cet exemple simple.
> 1 + 1/2;

3
2

Remarquez que Maple effectue des calculs exacts avec des nombres
rationnels. Le résultat de 1 + 1/2 est 3/2, et non 1.5. Pour Maple, le
nombre rationnel 3/2 et son approximation décimale 1.5 sont deux objets
complètement différents.
La possibilité de représenter des expressions de manière exacte permet
à Maple de préserver beaucoup plus d’information à 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 représentation
des nombres décimaux. C’est donc le point, et non la virgule, qu’il faut utiliser pour
saisir de tels nombres.
2.2 Calculs numériques • 7

0.5235987758

est beaucoup moins évidente que pour une quantité exacte comme
1
π
6

Lorsque vous commencerez à 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 également avec des expressions arbitraires. Il peut manipuler les
entiers, les nombres à virgule flottante, les variables, les ensembles, les
suites, les polynômes sur un anneau ainsi que plusieurs autres construc-
tions mathématiques. De plus, Maple est un langage de programmation
complet contenant des procédures, des tableaux et d’autres structures de
données.

2.2 Calculs numé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
8 • Chapitre 2: Mathématiques de base avec Maple

Maple peut é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’éprouve aucun problème à calculer de grands entiers,
compter le nombre de chiffres d’un nombre ou factoriser des entiers. Pour
des nombres et d’autres types de données qui s’étendent sur plus d’une
ligne à l’écran, Maple utilise le caractère (\) pour indiquer que le résultat
est continu. La barre oblique et la coupure de ligne doivent être ignorées.
> 100!;

933262154439441526816992388562667004907\
15968264381621468592963895217599993229\
91560894146397615651828625369792082722\
37582511852109168640000000000000000000\
00000
> length(%);

158

La réponse indique le nombre de chiffres contenus dans le dernier


exemple. L’opérateur idem (%) est tout simplement une notation abrégée
affichant le résultat précédent. Pour rappeler le deuxième ou le troisième
résultat précédent, utilisez respectivement %% et %%%.
> ifactor(60);

(2)2 (3) (5)

En plus de ifactor, Maple possè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
primalité. Consultez les exemples ci-dessous ainsi que la table 2.1.
> igcd(123, 45);

> iquo(25,3);
2.2 Calculs numériques • 9

Tab. 2.1 – Commandes opérant sur des entiers


Fonction Description
abs valeur absolue d’une expression
factorial factorielle d’un entier
iquo quotient d’une division entière
irem reste d’une division entière
iroot racine entière approximée d’un entier
isqrt racine carrée entière approximée d’un entier
max, min maximum et minimum d’un ensemble d’entrées
mod arithmétique modulo
surd racine réelle d’un entier

> isprime(18002676583);

true

Arithmétique exacte – Rationnels, irrationnels et constantes


Une propriété importante de Maple est sa capacité à effectuer l’arithmé-
tique rationnelle exacte, et ainsi de travailler avec des nombres rationnels
(fractions) sans avoir à les réduire à leurs approximations décimales.
> 1/2 + 1/3;

5
6

Maple gère les nombres rationnels et produit un résultat exact. La


distinction entre des résultats exacts et approximatifs est importante. La
faculté d’effectuer des calculs exacts au moyen d’ordinateurs vous permet
de résoudre une toute nouvelle gamme de problèmes.
Maple peut effecter des approximations en virgule flottante si néces-
saire. En fait, le logiciel peut travailler avec des nombres à virgule flottante
de plusieurs milliers de chiffres pour des estimations précises d’expressions
exactes.
> Pi;
10 • Chapitre 2: Mathématiques de base avec Maple

> evalf(Pi, 100);

3.1415926535897932384626433832795028841\
97169399375105820974944592307816406286\
208998628034825342117068
Il est important d’apprendre comment Maple distingue les représen-
tations exactes des valeurs de leurs approximations décimales.
Voici un exemple de nombre rationnel (exact).
> 1/3;

1
3

Le nombre suivant est son approximation décimale (avec une précision


par défaut de dix chiffres).
> evalf(%);

0.3333333333

Ces résultats ne sont pas les mêmes mathématiquement, et ne sont


pas non plus les mêmes pour Maple.
Chaque fois que vous entrez un nombre sous forme décimale,
Maple le considère comme une approximation à virgule flottante. En
fait, la présence d’un nombre décimal dans une expression force Maple à
produire un résultat en virgule flottante, puisqu’il ne peut être certain
de produire une solution exacte, même à partir de données partiellement
exactes.
> 3/2*5;

15
2

> 1.5*5;

7.5
2.2 Calculs numériques • 11

Ainsi, il est recommandé de n’utiliser des nombres décimaux que


lorsque vous souhaitez forcer Maple à travailler avec des expressions
non exactes.
Vous pouvez saisir des quantités exactes en utilisant la représentation
symbolique, comme π, comparativement à 3.14. Maple traite les nombres
irrationnels comme des quantités exactes. Voici comment représenter la
racine carrée de 2 dans Maple.
> sqrt(2);

2

Voici un autre exemple de racine carrée.


> sqrt(3)^2;

Maple connaı̂t les constantes arithmétiques standard comme π et la


base des logarithmes naturels, e. Il travaille avec ces nombres comme avec
des quantités exactes.
> Pi;

> sin(Pi);

La fonction exponentielle est représentée par la fonction Maple exp.


> exp(1);

> ln(exp(5));

Le deuxième exemple peut paraı̂tre étrange. Souvenez-vous que


lorsque Maple produit une notation mathématique  typographique ,
il essaie de représenter les expressions mathématiques de la manière dont
12 • Chapitre 2: Mathématiques de base avec Maple

vous les écririez vous-mê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 référence à ces constantes. Les noms
Pi, pi et PI ne sont pas équivalents ! Les noms Pi et PI sont employés
pour afficher respectivement les lettres grecques minuscule et majuscule π
et Π. Pour obtenir davantage d’information sur les constantes de Maple,
tapez ?constants à l’invite.

Approximations à virgule flottante


Même si Maple préfère travailler avec des valeurs exactes, il peut retour-
ner une approximation décimale d’une longueur maximale de 238 chiffres
lorsque cela lui est demandé.
Dix ou vingt chiffres exacts semblent adéquats pour la plupart des
situations ; cependant, deux problèmes particuliers limitent sérieusement
l’utilité d’un tel système.
Tout d’abord, en soustrayant deux nombres décimaux d’ordres de
grandeur presque identiques, l’erreur relative de la différence peut être
très grande : si chacun des deux nombres originaux sont identiques pour
leurs dix-sept premiers chiffres (sur vingt), leur différence est un nombre
de vingt chiffres dont on ne connaı̂t que trois chiffres significatifs ! Dans
ce cas, une précision de quarante chiffres serait nécessaire pour obtenir en
fin de calcul un résultat précis à environ vingt chiffres significatifs.
Ensuite, la forme mathématique d’un résultat est plus concise, com-
pacte et utile que sa valeur numérique. Par exemple, une fonction expo-
nentielle fournit plus d’information sur la nature d’un phénomène qu’un
grand ensemble de nombres de vingt chiffres significatifs. Une descrip-
tion analytique exacte peut également déterminer le comportement d’une
fonction en extrapolant à des régions pour lesquelles aucune donnée n’est
disponible.
La commande evalf convertit une expression numérique exacte en un
nombre décimal.
> evalf(Pi);

3.141592654

Par défaut, Maple calcule le résultat à l’aide de dix chiffres de préci-


sion ; vous pouvez cependant spécifier un nombre arbitraire de chiffres. Il
suffit de le spécifier après l’expression numérique en utilisant la notation
suivante.
2.2 Calculs numériques • 13

> evalf(Pi, 200);

3.1415926535897932384626433832795028841\
97169399375105820974944592307816406286\
20899862803482534211706798214808651328\
23066470938446095505822317253594081284\
81117450284102701938521105559644622948\
9549303820
Vous pouvez également forcer Maple à effectuer tous ses calculs avec
des approximations décimales en incluant au moins un nombre décimal
dans chaque expression. Les nombres à virgule flottante sont  conta-
gieux  : si une expression contient ne serait-ce qu’un seul nombre décimal,
Maple évalue l’expression entière en arithmétique à 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


détermine le nombre de chiffres à afficher pour ce calcul en particulier, la
variable spéciale Digits fixe le nombre de chiffres décimaux pour tous les
calculs subséquents.
> Digits := 20;

Digits := 20

> sin(0.2);

0.19866933079506121546

Digits est maintenant fixé à vingt, le nombre de chiffres que Maple


utilisera maintenant pour chaque étape d’un calcul. Sur ce plan, Maple
fonctionne comme une calculatrice ou un ordinateur classique. Souvenez-
vous que, lorsque vous évaluez une expression numérique compliquée, des
erreurs peuvent s’accumuler et rendre le résultat final moins précis que
14 • Chapitre 2: Mathématiques de base avec Maple

les vingt chiffres qu’il contient. En général, déterminer la valeur que doit
prendre Digits pour obtenir une précision donnée n’est pas chose facile,
le résultat final dépendant du problème. Cependant, il est en général de
mise d’en augmenter la valeur pour obtenir plus de précision. Maple est
très flexible si une grande précision décimale est importante dans votre
travail.

Arithmétique avec des nombres spéciaux


Maple peut également travailler avec des nombres complexes. Par ex-
emple, I est le symbole par√ défaut de Maple pour la racine carrée de
moins un, c’est-à-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 systèmes
de nombres.
> convert(247, binary);

11110111

> convert(1023, hex);

3FF

> convert(17, base, 3);

[2, 2, 1]

Maple retourne une conversion en base entière comme une liste de


nombres ; autrement, une ligne de nombres comme 221 peut devenir am-
biguë, spécialement pour de grandes bases. Remarquez que Maple liste
les chiffres dans l’ordre, du plus significatif au moins significatif.
Maple effectue également l’arithmétique dans des anneaux finis et des
corps.
2.2 Calculs numériques • 15

> 27 mod 4;

Les représentations symétriques et positives sont également dispo-


nibles.
> mods(27,4);

−1

> modp(27,4);

La valeur par défaut de la commande mod est la représentation posi-


tive, mais vous pouvez changer cette option (consultez l’écran d’aide ?mod
pour plus de détails).
Maple peut également travailler avec les entiers gaussiens. Le package
GaussInt contient une trentaine de commandes permettant de travailler
avec ces nombres spéciaux. Tapez ?GaussInt pour plus d’information sur
ces commandes.

Fonctions mathématiques
Maple connaı̂t toutes les fonctions mathé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 plutôt que de la convertir en une forme inexacte.
> ln(Pi);

ln(π)
16 • Chapitre 2: Mathématiques de base avec Maple

Tab. 2.2 – Quelques fonctions mathématiques connues de Maple


Fonction Description
sin, cos, tan, etc. fonctions trigonométriques
sinh, cosh, tanh, etc. fonctions trigonométriques
hyperboliques
arcsin, arccos, arctan, etc. fonctions trigonométriques
inverses
exp fonction exponentielle
ln logarithme naturel
log[10] logarithme en base 10
sqrt racine carrée algébrique
round arrondir à l’entier le plus près
trunc tronquer à la partie entière
frac partie fractionnaire
BesselI, BesselJ, fonctions de Bessel
BesselK, BesselY
binomial fonction binomiale
erf, erfc fonctions d’erreur et
d’erreur complé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 intégrales elliptiques de Legendre
hypergeom fonction hypergéomé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 possè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 mentionné à la section Calculs numériques de la page 7,


l’opérateur idem, %, est une notation abrégée de la commande précé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
18 • Chapitre 2: Mathématiques de base avec Maple

Divisez un polynôme en x par un autre.


> rem(x^3+x+1, x^2+x+1, x);

2+x

Créez une sé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 mathématiques mentionnées dans la section


précédente acceptent également les inconnues comme arguments.

2.4 Affecter des noms à des expressions


Utiliser l’opérateur idem ou taper une expression chaque fois que vous
souhaitez l’employer peut s’avérer fastidieux. C’est pourquoi Maple vous
permet de nommer des objets. Appliquez la syntaxe suivante.

nom := expression ;

Vous pouvez affecter un nom à n’importe quelle expression Maple.


> var := x;

var := x

> terme := x*y;

terme := x y

Vous pouvez même donner des noms à des équations.


> eqs := x = y + 2;

eqs := x = y + 2
2.4 Affecter des noms à des expressions • 19

Sous Maple, les noms peuvent contenir n’importe quel caractère al-
phanumérique en plus du caractère souligné (underscore en anglais),
mais ils ne peuvent pas commencer par un nombre. De plus, évitez
de commencer un nom par le caractère souligné ; Maple utilise ces noms
à 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 caractère alphanumérique) sont des noms invalides.
Vous pouvez définir vos propres fonctions à l’aide de la notation
flèche (->) de Maple. Cela indique à Maple comment évaluer la fonc-
tion lorsqu’elle apparaı̂t dans les expressions Maple. À 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’opération d’affectation (:=) peut ensuite associer le nom d’une fonc-
tion à la définition de cette fonction. Le nom de la fonction se place à
gauche du signe :=, tandis que sa définition de la fonction (utilisant la
notation flèche) est à droite. L’expression suivante définit f comme étant
la fonction  mettre au carré .
> f := x -> x^2;

f := x → x2
20 • Chapitre 2: Mathématiques de base avec Maple

Puis, en évaluant f en un argument, on obtient le carré 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


prédéfini et réservé quelques-uns. Si vous tentez d’assigner un objet à un
nom qui est prédéfini ou réservé, Maple affiche un message vous informant
que le nom choisi est protégé.
> 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 pré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 données de base de Maple est la suite d’expressions .
C’est un groupe d’expressions Maple séparé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 données particulière qui possède ses caractéristiques propres.
Par exemple, elle préserve l’ordre et la répétition des éléments. Les objets
respectent l’ordre dans lequel ils ont été entrés et si un objet est entré deux
fois, les deux copies demeurent dans la suite. Vous remarquerez d’autres
propriétés des suites à mesure que vous parcourrez ce manuel. Les suites
sont souvent utilisées pour construire d’autres objets complexes par des
opérations comme la concaténation.
Les suites permettent d’étendre les capacités de plusieurs opérations
de base de Maple. Par exemple, la concaténation est une opération de
base permettant de former des noms. L’opérateur de concaténation sous
Maple est le  || , et vous pouvez l’utiliser de la manière suivante.
> a||b;

ab

Lorsque vous appliquez la concaténation à une séquence, l’opération


touche à chacun de ses éléments. Ainsi, pour une suite S, vous pouvez
ajouter à un nom a des suffixes formés de chaque élément de S en
concaté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
22 • Chapitre 2: Mathématiques de base avec Maple

> f;

> h;

Les listes
Une liste est formée en encadrant un nombre quelconque d’objets Maple
(séparé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 encadrée par des crochets.
Maple conserve l’ordre et la répétition des éléments dans une liste.
Ainsi, [a,b,c], [b,c,a] et [a,a,b,c,a] sont trois listes diffé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 élément par-


ticulier d’une liste sans avoir à vous soucier d’un possible déplacement de
celui-ci.
> lettres := [a,b,c];

lettres := [a, b, c]
2.5 Les principaux types d’objets Maple • 23

> lettres[2];

Utilisez la commande nops pour déterminer le nombre total d’élé-


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 mathématique du terme.
Tout comme dans une suite ou dans une liste, des virgules séparent les
objets ; cependant, les accolades dé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 encadrée par des acco-
lades.
Maple ne conserve ni l’ordre, ni la répétition des éléments dans les
ensembles : ces derniers possèdent ainsi les mêmes propriétés que leurs
équivalents mathé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 numérique 2.0. L’ensemble suivant contient donc trois éléments,
et non deux.
24 • Chapitre 2: Mathématiques de base avec Maple

> {1, 2, 2.0};

{1, 2, 2.0}

Les propriétés que revêtent les ensembles font de ceux-ci des outils par-
ticulièrement utiles dans Maple, tout comme ils le sont en mathématiques.
Maple fournit plusieurs opérateurs ensemblistes, incluant les opé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’élé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 utilisée, la commande map s’avère très utile pour les en-
sembles. L’opération de correspondance (mapping ) vous permet d’appli-
quer une fonction simultanément à tous les élé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
2.5 Les principaux types d’objets Maple • 25

> map(sin, nombres);

1√
{0, 1, 3}
2

D’autres exemples démontrant l’utilisation de map figurent dans la


section La commande map de la page 38 et Appliquer une fonction à
une liste ou un ensemble à la page 174.

Les opérations sur les ensembles et les listes


La commande member permet de vérifier l’appartenance d’un objet à un
ensemble ou à 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 éléments depuis une liste, utilisez la notation indicée
[n ] , où n désigne la position de l’élément désiré dans la liste.
> participants[2];

Sophie

Maple reconnaı̂t les ensembles et les listes vides (qui ne contiennent


aucun élément).
> empty_set := {};
26 • Chapitre 2: Mathématiques de base avec Maple

empty _set := {}

> empty_list := [];

empty _list := []

Vous pouvez créer un nouvel ensemble à partir d’autres ensembles à


l’aide, par exemple, de la commande union. Supprimez des élé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 données : la liste. Imaginez une liste comme un groupe d’éléments où
chacun est associé à un nombre entier positif, son indice, qui représente
sa position dans la liste. La structure de tableau (array) est une
généralisation de cette idée. Chaque élément est toujours associé à un
indice, mais cet indice n’est pas forcément unidimensionnel. De plus, les
indices peuvent être nuls ou négatifs. Vous pouvez également définir ou
modifier individuellement chacun des éléments d’un tableau sans pour
autant redéfinir ce dernier entièrement.
On doit déclarer le tableau de manière que Maple connaisse le nombre
de dimensions souhaité.
> carres := array(1..3);

carres := array(1..3, [])


2.5 Les principaux types d’objets Maple • 27

Assignez des éléments au tableau. Plusieurs commandes peuvent être


entrées à la mê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 préférez, effectuez toutes ces opérations en même temps.


> cubes := array( 1..3, [1,8,27] );

cubes := [1, 8, 27]

Vous pouvez choisir un seul élément en utilisant la notation appliquée


aux listes.
> carres[2];

Vous devez déclarer les tableaux à l’avance. Pour afficher le contenu


du tableau, vous devez utiliser une commande comme print.
> carres;

carres

> print(carres);

[1, 4, 9]

Le tableau précédent ne possède qu’une dimension. Cependant, en


général, les tableaux peuvent en avoir plus d’une. Définissez un tableau
de dimensions 3 × 3.
> pwrs := array(1..3,1..3);

pwrs := array(1..3, 1..3, [])


28 • Chapitre 2: Mathématiques de base avec Maple

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


d’abord les éléments de la première rangé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 préférez, vous


pouvez terminer chaque commande par le deux-points (:) plutôt que par
le point-virgule habituel (;), pour supprimer l’affichage du résultat. Le
deux-points, tout comme le point-virgule, est un sé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 sélectionner un élément en spécifiant à la fois sa rangée


et sa colonne.
> pwrs[2,3];

Vous pouvez définir un tableau bidimensionnel et ses éléments tout à


la fois en appliquant une méthode similaire à celle qui a été employée pour
l’exemple unidimensionnel montré précédemment. Pour ce faire, utilisez
des listes imbriquées dans d’autres listes : créez une liste dans laquelle
chaque élément est une autre liste qui contient les éléments d’une rangée
du tableau. Ainsi, vous pouvez définir le tableau pwrs de la manière sui-
vante :
> pwrs2 := array( 1..3, 1..3, [[1,1,1], [2,4,8], [3,9,27]] );
2.5 Les principaux types d’objets Maple • 29
 
1 1 1

pwrs2 := 2 4 8 
3 9 27

Les tableaux ne sont pas limités à deux dimensions ; cependant, ceux


qui contiennent plus de deux dimensions sont difficiles à afficher. Si vous
le souhaitez, vous pouvez également déclarer les éléments du tableau en
même temps que vous déclarez le tableau lui-mê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’étend pas automatiquement le nom d’un tableau à la
représentation de tous ses éléments. Ainsi, pour certaines commandes,
vous devez spécifier que vous souhaitez effectuer une opération sur les
élé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 équation.
> expr := z^2 + 3;

expr := z 2 + 3
30 • Chapitre 2: Mathématiques de base avec Maple

> subs( {z=x+y}, expr);

(x + y)2 + 3

Cependant, vous pourriez être déçu de découvrir que la commande


suivante ne fonctionne pas.
> subs( {2=9}, pwrs );

pwrs

En effet, vous devez forcer Maple à évaluer complè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’é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 éléments


comme il est souhaité, mais encore l’évaluation complète affiche également
les éléments du tableau, de la même manière que grâce à la commande
print.
> evalm(pwrs);
 
1 1 1
2 4 8
3 9 27

Les tables
Une table est une extension de tableau. À la différence d’un tableau, les
indices d’une table peuvent être quelconques, et non seulement limités à
des nombres entiers.
> traduit := table([one=un,two=deux,three=trois]);

traduit := table([two = deux , three = trois , one = un])


2.5 Les principaux types d’objets Maple • 31

> traduit[two];

deux

Même si les tables semblent à première vue revêtir peu d’intérêt,


elles sont en fait des structures puissantes. Les tables vous permettent
de travailler avec des notations naturelles dans vos structures de données.
Par exemple, vous pouvez afficher les propriétés physiques de certains
maté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 entrée est
une liste. Ce n’est en fait qu’un exemple très simple ; la plupart du temps,
des indices beaucoup plus généraux sont préférables. Ainsi, vous pourriez
construire une table dont les indices sont des formules algébriques et dont
les valeurs sont les dérivées de ces formules.

Les chaınes
Une chaıne est un autre objet Maple créé en encadrant un nombre quel-
conque de caractères par des guillemets anglais.
> "Ceci est une chaine.";

“Ceci est une chaine.”

Les chaı̂nes sont des unités indivisibles que l’on peut considérer comme
des constantes : on ne peut leur assigner une valeur.
> "mon age" := 22;

Error, invalid left hand side of assignment


32 • Chapitre 2: Mathématiques de base avec Maple

Comme les éléments des listes ou des tableaux, on peut accéder indivi-
duellement aux différents caractè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’opérateur de concaténation (“||”) ou la commande cat sont utilisés


pour joindre deux chaı̂nes ensemble. La commande length, de son côté,
est employée pour déterminer le nombre de caractè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 à l’é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 résultats de commandes
Maple en des formes familiè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 utilisées à cet effet.
2.6 La manipulation d’expressions • 33

La commande simplify
Vous pouvez choisir cette commande pour appliquer des règles de simpli-
fication à une expression. Maple connaı̂t certaines règles de simplification
pour divers types d’expressions et de formes comme les fonctions trigo-
nométriques, les radicaux, les fonctions logarithmiques, les fonctions ex-
ponentielles, les puissances ainsi que plusieurs autres fonctions spé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, spécifiez le


type souhaité.
> 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


également appliquer vos propres rè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;


34 • Chapitre 2: Mathématiques de base avec Maple

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 numérateur et le dé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 polynômes univariés et multivariés sur le


domaine de coefficients spécifié. Vous pouvez également factoriser les
polynômes sur des extensions algébriques. Voyez ?factor pour plus de
détails à ce sujet.

La commande expand
Essentiellement, la commande expand est l’inverse de la commande
factor. Elle permet l’expansion de termes multipliés de mê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
2.6 La manipulation d’expressions • 35

son nom que le ré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 très flexible ; non seulement il est pos-


sible de préciser que certaines sous-expressions doivent être laissées telles
quelles au cours de l’expansion, mais des règles d’expansion personnalisées
peuvent également être programmées.
Lorsqu’on utilise Maple pour la première fois, on est porté à croire que
la commande simplify est la commande la plus utile. Malheureusement,
le mot simplify est plutôt vague. Lorsqu’on lui demande de simplifier une
expression, Maple examine cette dernière, essaie plusieurs techniques, puis
tente d’appliquer la règle de simplification la plus appropriée. Cela peut
prendre du temps. De plus, Maple peut ne pas être en mesure de devi-
ner ce que vous souhaitez accomplir, puisque aucune règle mathématique
universelle ne définit ce qui est  plus simple .
Lorsque vous connaissez quelles manipulations rendront votre expres-
sion plus simple à vos yeux, spécifiez-les directement. En particulier, la
commande expand figure parmi les plus utiles. Elle permet souvent une
simplification substantielle des expressions et reformule ces dernières sous
une forme pratique pour plusieurs autres commandes.

La commande convert
Cette commande convertit les expressions entre différentes formes.
> convert(cos(x),exp);

1 (I x) 1 1
e +
2 2 e(I x)
36 • Chapitre 2: Mathématiques de base avec Maple

Tab. 2.3 – Conversions courantes


Argument Description
polynom d’une série à un polynôme
exp, expln, expsincos d’une expression trigonométrique à une
forme exponentielle
parfrac d’une expression rationnelle à une
fraction partielle
rational d’un nombre à virgule flottante à une
forme rationnelle
radians, degrees des degrés aux radians
set, list, listlist entre différentes structures de donné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]
2.6 La manipulation d’expressions • 37

La commande normal
Cette commande transforme les expressions rationnelles en forme nor-
male factorisée (factored normal form),

numérateur
dénominateur
où numérateur et dénominateur sont deux polynômes relativement pre-
miers à coefficients entiers. Ainsi, la commande normal met les fractions
au même dé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 factorisé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 appliquées par la commande expand.
> combine(exp(x)^2*exp(y),exp);

e(2 x+y)

> combine((x^a)^2, power);

x(2 a)
38 • Chapitre 2: Mathématiques de base avec Maple

La commande map
Cette commande est très utile lorsque vous travaillez sur des listes, des en-
sembles et des tableaux. Elle fournit un moyen commode de gérer plusieurs
solutions ou d’appliquer une opération à chaque élément d’un tableau. La
commande map applique une commande à chaque élément de la structure
de données ou de l’expression fournie. Même s’il est possible d’écrire des
boucles dans un programme pour accomplir ces tâches, l’utilité et la puis-
sance de la commande map ne devraient pas être sous-estimées. Prenez le
temps né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 à la commande map plus de deux arguments, Maple


passe les derniers à 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 dériver chaque élément d’une liste par rapport à
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
2.6 La manipulation d’expressions • 39

> map(value, %);

1
[cos(x), , 2 x]
x

Non seulement la procédure peut être une commande existante, mais


vous pouvez également créer une opération à appliquer sur une liste. Par
exemple, supposons que vous voulez mettre au carré chaque élé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 côté
gauche (left-hand side) et le côté 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 à extraire respectivement le numérateur et
le dénominateur d’une expression rationnelle.
> numer(3/4);

> denom(1/(1 + x));


40 • Chapitre 2: Mathématiques de base avec Maple

x+1

Les commandes nops et op


Ces deux commandes s’avè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’accéder aux différentes parties d’une


expression, qu’elle retourne sous forme de suite d’expressions.
> op(x^2);

x, 2

Vous pouvez également accéder à des éléments en particulier en


spé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
2.6 La manipulation d’expressions • 41

Questions courantes sur la manipulation d’expressions


Comment substituer un produit de deux inconnues ? Utilisez les rela-
tions accessoires pour spécifier une  identité . La substituion directe ne
fonctionne géné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 échoué dans sa tentative de substitution.


Utilisez la commande simplify pour obtenir la réponse souhaitée.
> simplify(expr, {a*b=5});

25 a

Vous pouvez également essayer la commande algsubs, qui effectue


une substitution algébrique.
> algsubs(a*b=5, expr);

25 a

Pourquoi le ré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 était sin(x)2 .


42 • Chapitre 2: Mathématiques de base avec Maple

Encore une fois, utilisez les relations accessoires pour spécifier l’iden-
tité.
> simplify(%, {1-cos(x)^2=sin(x)^2});

sin(x)2

La question de la simplification est compliquée en raison de la dif-


ficulté à définir ce qu’est une forme  simple  pour une expression. La
conception d’une forme simple pour un utilisateur peut être très différente
de celle d’un autre utilisateur ; de plus, l’idée d’une forme la plus simple
peut varier d’une situation à l’autre.

Comment mettre en évidence la constante dans 2x + 2y ? Actuel-


lement, cette opé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 gérer de telles expressions, lorsque l’on doit
mettre des constantes ou des signes négatifs en é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 également
vu plusieurs commandes, dont expand, factor et simplify, qui figurent
parmi les plus utiles pour manipuler et simplifier des expressions algé-
briques. D’autres, comme map, sont utiles pour les ensembles, les listes et
les tableaux. De son côté, la commande subs sert dans presque toutes les
situations.
Dans le prochain chapitre, vous apprendrez à manipuler ces concepts
pour aborder un des problèmes fondamentaux des mathématiques : la
résolution des systèmes d’équations. À mesure que vous apprendrez de
nouvelles commandes, observez comment les concepts de ce chapitre sont
utilisés pour poser les problèmes et manipuler leurs solutions.
44 • Chapitre 2: Mathématiques de base avec Maple
3 Trouver des solutions

Ce chapitre introduit les concepts clés nécessaires à une résolution de


problèmes rapide et efficace dans Maple. En apprenant comment utiliser
des outils comme solve, map, subs et unapply, vous gagnerez du temps
et économiserez de nombreux efforts. De plus, le présent chapitre examine
l’interaction entre ces différentes commandes.

3.1 Résolution au moyen de solve


La commande solve de Maple est un solveur d’équations tout usage.
Dans un ensemble d’une ou de plusieurs équations, solve tente de
résoudre le système de manière exacte pour l’ensemble d’inconnues
spécifié. (Souvenez-vous que, dans la section Les ensembles de la page 23,
on utilisait les accolades pour encadrer les éléments d’un ensemble.) Dans
les exemples suivants, vous résolvez une équation pour une inconnue, et
chaque ensemble contient conséquemment un seul élé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 équations précédentes possèdent deux solutions, Maple

45
46 • Chapitre 3: Trouver des solutions

retourne une suite d’ensembles solutions. Si aucune inconnue n’est


spécifiée dans l’équation, Maple résout pour toutes celles-ci.
> solve({x+y=0});

{x = −y, y = y}

Ici, une seule solution est obtenue, contenant deux équations. Ce


résultat signifie que y peut prendre n’importe quelle valeur, tandis que x
est l’opposé de y. Cette solution est paramétrisée par rapport à y.
Si vous donnez une expression plutôt qu’une équation, Maple assume
automatiquement que l’équation est égale à zéro.
> solve({x^3-13*x+12}, {x});

{x = 1}, {x = 3}, {x = −4}

La commande solve peut également gérer les systèmes d’équations.


> solve({x+2*y=3, y+1/x=1}, {x,y});

1
{x = −1, y = 2}, {x = 2, y = }
2

Même si les accolades (dénotant un ensemble) ne sont obligatoires ni


autour de l’équation, ni autour de la variable, leur utilisation force Maple
à retourner la solution sous la forme d’un ensemble, ce qui représente
généralement la manière la plus commode. En effet, la première chose à
faire avec une solution est généralement de la vérifier en la substituant
à nouveau dans les équations originales. L’exemple suivant montre cette
procédure.
Étant un ensemble d’équations, la solution est une forme idéale pour
la commande subs. Vous pouvez d’abord donner un nom à l’ensemble
d’équations, par exemple eqns.
> eqns := {x+2*y=3, y+1/x=1};

1
eqns := {x + 2 y = 3, y + = 1}
x

Puis, résolvez.
> soln := solve( eqns, {x,y} );
3.1 Ré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

Vérifier les solutions


Pour vérifier les solutions ainsi produites, il suffit de les substituer à nou-
veau dans l’ensemble d’équations original en utilisant la commande eval.
> eval( eqns, soln[1] );

{3 = 3, 1 = 1}

> eval( eqns, soln[2] );

{3 = 3, 1 = 1}

Vous découvrirez que cette méthode de vérification est généralement


la plus commode.
Remarquez que cette application de la commande eval se prête à
d’autres usages. Supposons que vous voulez extraire la valeur de x de la
première solution. Encore une fois, la commande eval s’avère le meilleur
outil.
> x1 := eval( x, soln[1] );

x1 := −1

Vous pouvez également extraire la première solution pour y.


> y1 := eval(y, soln[1]);
48 • Chapitre 3: Trouver des solutions

y1 := 2

Vous pouvez même appliquer ce truc d’évaluation pour convertir


des ensembles solutions sous d’autres formes. Par exemple, vous pou-
vez construire une liste (list) à partir de la première solution, où x sera
le premier élément et y le second. D’abord, construisez une liste dont
les variables sont dans le même ordre que souhaité dans les solutions
correspondantes.
> [x,y];

[x, y]

Puis, évaluez simplement cette liste à la première solution.


> eval([x,y], soln[1]);

[−1, 2]

La première solution est maintenant une liste.


Si vous préférez obtenir d’abord la solution pour y dans la liste, évaluez
[y,x] à 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 méthode d’extraction des solutions.
Une autre commande utile, map, vous permet d’appliquer une opéra-
tion à toutes les solutions. Par exemple, essayez de substituer les deux
solutions.
La commande map applique l’opération spécifiée comme premier ar-
gument à son deuxième argument.
> map(f, [a,b,c], y, z);

[f(a, y, z), f(b, y, z), f(c, y, z)]


3.1 Résolution au moyen de solve • 49

En raison de la syntaxe de map, cette dernière ne peut appliquer en


même temps plusieurs fonctions à des suites. Par exemple, considérez la
suite de solutions précé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 simultanément dans les équations originales, eqns.
> map(subs, [soln], eqns);

[{3 = 3, 1 = 1}, {3 = 3, 1 = 1}]

Cette méthode peut s’avérer précieuse si votre équation possède plu-


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

Restreindre les solutions


Vous pouvez limiter les solutions en spécifiant les inégalité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}

Considérez ce système de cinq équations à cinq inconnues.


50 • Chapitre 3: Trouver des solutions

> 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:
Résolvez maintenant le systè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 également choisir de ré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 paramétriques calculées à la fin de la
section précédente. Par exemple, é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 à la page 47, supposons que vous nécessitiez que les cinq
solutions trouvées par solve soient placées dans un ordre particulier.
Puisqu’il est impossible de fixer l’ordre des éléments dans un ensemble,
solve ne retournera pas nécessairement les solutions dans l’ordre x, y, z.
Cependant, les listes préservent l’ordre de leurs élé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
3.1 Résolution au moyen de solve • 51

Non seulement cette commande a fixé l’ordre des solutions, mais elle
en a également extrait le côté droit de l’égalité (puisque vous connais-
sez toujours quelle solution s’applique à quelle variable en raison de leur
ordre). Cette possibilité est particulièrement utile lorsque vous souhaitez
tracer la surface qui repré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-
modité, définissez x = x(u, t), y = y(u, t) et z = z(u, t) (c.-à-d. convertis-
sez les solutions en fonctions). Souvenez-vous que vous pouvez facilement
choisir l’expression d’une solution pour une variable particuliè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 très importante, unapply. Pour ce faire, il suffit de fournir à
unapply l’expression et les variables à partir desquelles Maple doit faire
une fonction. Ainsi, par exemple,
> f := unapply(x^2 + y^2 + 4, x, y);
52 • Chapitre 3: Trouver des solutions

f := (x, y) → x2 + y 2 + 4

produit la fonction f de x et y, qui fait correspondre à un couple (x, y) le


polynôme x2 + y 2 + 4. Cette nouvelle fonction est facile à utiliser.
> f(a,b);

a2 + b2 + 4

Ainsi, pour transformer la solution pour x en une fonction à la fois de


u et de t, la première étape consiste à obtenir l’expression pour x, comme
il a été mentionné précé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 crée les fonctions y et z de la même maniè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
3.1 Résolution au moyen de solve • 53

> 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 également d’affecter des valeurs à des in-
connues. Par exemple, plutôt que de définir x, y et z en tant que fonc-
tions, assignez chacune d’elles à l’expression du côté droit de l’égalité de
l’é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 é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
créer de fonctions.
Le prochain exemple comprend la résolution d’équations différen-
tielles, dont la section 3.6 discute plus en détail. Pour commencer, assignez
un nom à la solution.

> s3 := dsolve( {diff(f(x),x)=6*x^2+1, f(0)=0}, {f(x)} );


54 • Chapitre 3: Trouver des solutions

s3 := f(x) = 2 x3 + x

> assign( s3 );

Il vous reste cependant à créer une fonction.


> f(x);

2 x3 + x

produit la réponse attendue ; cependant, malgré 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 étrange vient du fait que


assign demande à Maple l’affectation
> f(x) := 2*x^3 + x;

f(x) := 2 x3 + x

qui n’est pas du tout semblable à l’affectation


> f := x -> 2*x^3 + x;

f := x → 2 x3 + x

La première définit seulement la valeur de la fonction f pour l’argu-


ment spécial x ; la seconde définit la fonction f : x → 2x3 + x de manière
à fonctionner, que l’on écrive f (x), f (y) ou f (1).
Pour définir la solution f comme une fonction de x, utilisez unapply.

> eval(f(x),s3);

2 x3 + x
3.1 Résolution au moyen de solve • 55

> f := unapply(%, x);

f := x → 2 x3 + x

> f(1);

La commande RootOf
À l’occasion, Maple retourne ses solutions à l’aide de la commande
RootOf. Considé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 générique pour toutes les racines de expr,
et _Z est un nom générique pour x. Cela signifie que x est une racine
du polynôme z 5 − 2z + 3, où le paramètre index numérote et ordonne les
solutions. Cela peut s’avérer fort utile lorsqu’on fait de l’algèbre sur un
corps diffé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 générale pour désigner les racines des polynômes de
degré cinq sous forme de radicaux n’existe pas.
56 • Chapitre 3: Trouver des solutions

3.2 Résoudre numériquement : fsolve


La commande fsolve est l’équivalent numérique de solve. Elle trouve
les racines d’une ou de plusieurs équations en utilisant une variante de la
méthode de Newton, et produit des solutions numériques approximées.
> fsolve({cos(x)-x = 0}, {x});

{x = .7390851332}

Pour une équation générale, fsolve cherche une racine réelle simple.
Pour un polynôme, cependant, la commande cherche toutes les racines
ré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 équation géné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 déterminé de racines d’un polynôme, utilisez


l’option maxsols.
> fsolve({poly}, {x}, maxsols=1);

{x = 1.324717957}

L’option complex force Maple à chercher des racines complexes en


plus des racines réelles.
3.2 Résoudre numériquement : fsolve • 57

> fsolve({poly}, {x}, complex);

{x = −.6623589786 − .5622795121 I},


{x = −.6623589786 + .5622795121 I},
{x = 1.324717957}, {x = 5.333333333}
Vous pouvez également spé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 échouer dans sa recherche d’une ra-
cine, même si une telle racine existe. Dans ces situations, spécifier un
intervalle peut aider Maple. Pour améliorer la précision de solutions,
vous pouvez augmenter la valeur de la variable spéciale, Digits. Remar-
quez que dans l’exemple suivant, la solution trouvée ne garantit pas une
précision de trente décimales ; cependant, Maple effectue toutes les étapes
de ses calculs à une précision d’au moins trente chiffres significatifs au lieu
des dix chiffres par défaut.
> Digits := 30;

Digits := 30

> fsolve({cos(x)=0}, {x});

{x = 1.57079632679489661923132169164}

Les limites de solve


La commande solve ne s’applique pas à toutes les situations. Souvenez-
vous que l’approche employée par Maple est algorithmique et que ce der-
nier ne possède pas nécessairement la capacité de faire appel aux trucs
que vous pouvez utiliser lorsque vous résolvez un problème à la main.
Mathématiquement parlant, les polynômes de degré supérieur ou égal
à cinq ne possèdent pas de solution générale sous forme de radicaux. Maple
tente de les résoudre symboliquement le mieux possible, mais il est fort
possible que vous deviez avoir recours à une solution numérique en cas
d’échec.
58 • Chapitre 3: Trouver des solutions

La résolution d’équations trigonométriques peut également être dif-


ficile. En fait, le travail avec toutes les équations transcendantes s’avère
plutôt difficile.
> solve({sin(x)=0}, {x});

{x = 0}

Remarquez que Maple retourne seulement une solution parmi une in-
finité. Cependant, si vous fixez la valeur de la variable _EnvAllSolutions
à true (vrai), Maple retourne alors l’ensemble complet des solutions.
> _EnvAllSolutions := true;

_EnvAllSolutions := true

> solve({sin(x)=0}, {x});

{x = π _Z1 ~}

Le préfixe _Z de la variable indique que cette dernière possède des


valeurs entières. Le tilde (~) indique qu’une hypothèse a été placée sur
cette variable ; dans le cas présent, on suppose qu’il s’agit d’une variable
entière. De plus, la commande fsolve vous permet de spécifier l’intervalle
dans lequel Maple cherchera une solution. Ainsi, vous pouvez obtenir plus
de contrôle sur les solutions calculées.
> fsolve({sin(x)=0}, {x}, 3..4);

{x = 3.14159265358979323846264338328}

Ces types de problèmes sont communs à tous les sytèmes de calcul


symbolique et témoignent des limites naturelles d’une approche algorith-
mique à la résolution d’équations.
Lorsque vous utilisez solve, rappelez-vous de bien vérifier vos résul-
tats. Le prochain exemple met en évidence une incompréhension qui peut
survenir en raison de la gestion des singularités par Maple.
> expr := (x-1)^2/(x^2-1);
3.2 Résoudre numé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 évalué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 à l’endroit de l’asymptote, à moins de


spé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 enlève la singularité x = 1 de l’expression avant de la résoudre.


Peu importe la méthode ou les outils utilisés pour résoudre les équations,
il est crucial de vérifier les résultats obtenus. Fort heureusement, ces
vérifications sont faciles au moyen de Maple.
60 • Chapitre 3: Trouver des solutions

3.3 D’autres solveurs


Maple contient plusieurs commandes solve spécialisées. Puisque vous ris-
quez de ne pas les trouver aussi utiles que les fonctions plus générales
solve et fsolve, cette section n’en signale que quelques-unes. Si vous
désirez obtenir plus de détail à propos de ces commandes, utilisez le
système d’aide en ligne en entrant ? suivi du nom de commande sou-
haité à l’invite de Maple.

Trouver des solutions entières


La commande isolve trouve des solutions entières aux équations en ré-
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 résout des équations entières modulo m (la repré-
sentation positive pour les entiers) en ré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 dénoter les pa-
ramètres entiers de la solution.
> msolve({2^n=3},19);

{n = 13 + 18 _Z1 ~}

Le tilde (~) sur _Z1 indique que msolve a placé une hypothèse à 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 décrit comment vous pouvez placer vous-même des


hypothèses à propos d’inconnues.

Résoudre des relations de récurrence


La commande rsolve résout des relations de récurrence, retournant une
expression correspondant au terme géné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 é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 polynôme contient un produit des inconnues. Par
exemple, si le polynôme contient seulement une inconnue, x, les termes
peuvent contenir x3 , x1 = x et x0 = 1, comme dans le cas du polynôme
x3 − 2x + 1. Si plus d’une inconnue existe, un terme peut également conte-
nir un produit des inconnues, comme dans le polynôme x3 +3x2 y +y 2 . Les
coefficients peuvent être entiers (comme dans les exemples précédents), ra-
tionnels, irrationnels, décimaux, complexes ou même faire appel à d’autres
variables.
> x^2 - 1;

x2 − 1

> x + y + z;
62 • Chapitre 3: Trouver des solutions

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 possède des commandes permettant plusieurs types de mani-


pulations et de calculs mathématiques sur les polynômes ; les prochaines
sections en examinent quelques-uns.

Tri et regroupement
La commande sort arrange les termes d’un polynôme dans l’ordre
décroissant des degrés de leurs inconnues. Plutôt que de conserver une
deuxième copie du polynôme original dont les termes ont été triés, sort
modifie directement la manière dont les termes sont emmagasinés dans
le polynôme de départ. Ainsi, si vous affichez le polynôme après l’avoir
passé à sort, vous remarquerez qu’il demeure trié :
> 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 polynômes multivariés de deux manières. La méthode


par défaut classe les termes selon leur degré total. Ainsi, x2 y 2 sera placé
avant x3 et y 3 . Selon l’autre option, les termes sont classés selon l’ordre
lexicographique pur (plex). Lorsque vous choisissez cette option, le tri
examine d’abord les puissances de la premiè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 différence entre ces deux types
de tri se conç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 même degré dans


un polynôme. Par exemple, lorsque les termes ax et bx se trouvent dans
le même polynô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
64 • Chapitre 3: Trouver des solutions

Opérations mathématiques
Vous pouvez effectuer plusieurs opérations mathématiques sur les po-
lynômes. Parmi les opérations les plus fondamentales, on trouve la division
(c’est-à-dire diviser un polynôme par un autre et en déterminer le quotient
et le reste). Maple fournit les commandes rem et quo pour dé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 déterminer si un polynôme


divise exactement un autre polynôme. La commande divide vérifie la
division polynomiale exacte.
> divide(x^3 - y^3, x - y);

true

> rem(x^3 - y^3, x - y, x);

Vous évaluez les polynô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 à déterminer les coefficients polynomiaux


Commande Description
coeff extraire un coefficient
lcoeff trouver le coefficient du terme de plus haut degré
tcoeff trouver le coefficient du terme de plus faible degré
coeffs retourner une suite de tous les coefficients
degree déterminer le degré (supérieur) du polynôme
ldegree déterminer le degré inférieur du polynô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 degrés
Les commandes degree et coeff déterminent le degré d’un polynôme et
fournissent un mé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 détermine les racines d’un polynôme tandis que
factor exprime le polynôme sous une forme complètement factorisée.
66 • Chapitre 3: Trouver des solutions

> 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 polynôme sur l’anneau contenant les coefficients


(entiers, rationnels, etc.). La commande factor vous permet également de
spécifier un corps algébrique de nombres sur lequel factoriser le polynôme.
Consultez la rubrique d’aide ?factor pour obtenir plus de renseigne-
ments.
3.5 Le calcul différentiel • 67

Tab. 3.2 – D’autres fonctions agissant sur des polynômes


Fonction Description
content contenu d’un polynôme multivarié
compoly décomposition polynomiale
discrim discriminant d’un polynôme
gcd plus grand commun diviseur
gcdex algorithme étendu de division euclidienne
interp interpolation polynomiale
lcm plus petit commun multiple
norm norme d’un polynôme
prem pseudo-reste
primpart partie primitive d’un polynôme multivarié
randpoly polynôme aléatoire
recipoly polynôme réciproque
resultant résultante de deux polynômes
roots racines sur un corps algébrique de nombres
sqrfree factorisation libre de carrés

3.5 Le calcul différentiel


Maple offre plusieurs outils puissants permettant la résolution de
problèmes de calcul diffé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
68 • Chapitre 3: Trouver des solutions

Il est également possible de calculer les limites à gauche et à droite


d’une fonction. Par exemple, considérez la limite de tan(x) lorsque x tend
vers π/2.
Calculez la limite à gauche en utilisant l’option left.
> Limit(tan(x), x=Pi/2, left);

lim tan(x)
x→(1/2 π)−

> value(%);

Faites de même pour la limite à droite.


> Limit(tan(x), x=Pi/2, right);

lim tan(x)
x→(1/2 π)+

> value(%);

−∞

Une autre opération facile à effectuer est la création d’une série ap-
proximant une fonction donné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 défaut, la commande series produit un po-


lynôme d’ordre 6. En modifiant la valeur de la variable spéciale Order, il
est possible d’augmenter ou de diminuer l’ordre d’une série polynomiale.
L’utilisation de convert(fs1, polynom) supprime le terme d’ordre
de la série de manière que Maple puisse en tracer le graphique.
3.5 Le calcul différentiel • 69

> 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 série à 12 et en recommen-


ant les opérations précédentes, on remarque l’amélioration escomptée de
la pré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);
70 • Chapitre 3: Trouver des solutions

–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 dérivées et les intégrales. Par


exemple, dérivez une expression, intégrez son résultat et comparez celui-ci
à 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)
3.5 Le calcul différentiel • 71

Il n’est pas nécessaire d’utiliser les formes inertes Diff et Int en con-
jonction avec la commande value pour calculer symboliquement la dérivée
et l’intégrale. Les résultats peuvent être calculés en une seule commande
en utilisant respectivement diff et int.
Vous pouvez également effectuer des intégrales définies. Par exemple,
recalculez l’intégrale précédente sur l’intervalle de x = 1 à 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)

Considérez une intégrale plus compliquée.


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

2
e(−x ) dx

> value(%);

1√
π erf(x)
2

À quelques occasions, Maple ne peut déterminer si une variable est


réelle ou complexe, et retourne donc un ré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(%);
72 • Chapitre 3: Trouver des solutions

e(−a t) ln(t) + Ei(1, a t) + γ + ln(a)


lim −
t→∞ a

Ici, Maple assume que le paramètre est un nombre complexe. Il re-


tourne donc une réponse plus générale.
Dans les situations où vous savez que a est un nombre positif réel,
spécifiez-le à 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 résultat est beaucoup plus simple. Le seul terme non élémentaire est
la constante gamma. Le tilde (~) indique que a porte une hypothèse. Vous
devez maintenant supprimer cette hypothèse pour parcourir les exemples
ultérieurs. Deux étapes sont nécessaires. La réponse, ans, contient a avec
des hypothèses. Si vous souhaitez repartir de zéro et continuer à 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’, mérite une attention particulière. Si


vous tapez a après avoir placé une hypothèse sur a, Maple assume auto-
matiquement que vous parlez de la variable a~. En Maple, les guillemets
simples retardent l’évaluation. Dans ce cas, ils assurent que Maple in-
terprète le deuxième a comme a et non a~.
Maintenant que vous avez supprimé l’hypothèse sur a dans ans, vous
pouvez supprimer l’hypothèse sur a elle-même en lui affectant son propre
nom.
> a := ’a’:
Utilisez les guillemets simples pour la même raison que précédemment.
Pour plus de renseignements, consultez la section 5.2.
3.6 Les équations différentielles : dsolve • 73

3.6 Les équations différentielles : dsolve


Maple peut résoudre symboliquement plusieurs équations différentielles
ordinaires (EDO), incluant les problèmes de conditions initiales et de
conditions aux limites.
Dé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

Définissez les conditions initiales.


> ic := {y(0)=0, D(y)(0)=1};

ic := {y(0) = 0, D(y)(0) = 1}

Résolvez au moyen de dsolve, en utilisant l’opé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’évaluer en certains


points ou pour en tracer le graphique, rappelez-vous d’utiliser la com-
mande unapply pour dé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 définir y comme une fonction de t en


utilisant unapply :
> y1:= unapply(%, t );

y1 := t → −e(−3 t) + e(−2 t)
74 • Chapitre 3: Trouver des solutions

> y1(a);

−e(−3 a) + e(−2 a)

Vé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 méthode de vérification des solutions est également dispo-


nible, bien qu’elle puisse sembler déroutante au premier abord. Donnez à
la nouvelle solution le nom y plutôt que y1.
> y := unapply( eval(y(t), soln), t );

y := t → −e(−3 t) + e(−2 t)

Maintenant, lorsque vous entrez une équation contenant y, Maple uti-


lise cette fonction et en évalue le résultat, en une seule étape.
> ode1;

{0 = 0}

> ic;

{1 = 1, 0 = 0}

Si vous souhaitez modifier l’équation différentielle, vous ne voudrez


plus de cette définition pour y(x) ; vous devrez donc supprimer cette
définition au moyen de la commande suivante :
> y := ’y’;
3.6 Les équations différentielles : dsolve • 75

y := y

Maple reconnaı̂t également les fonctions spéciales, comme la fonction


de Dirac utilisé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

Spé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}

spécifiez é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
− Heaviside(x − 4) x3
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);
76 • Chapitre 3: Trouver des solutions

1 1
Heaviside(x − 2) x3 − Heaviside(x − 2)
6000000 750000
1
+ Heaviside(x − 2) x
500000
1
− Heaviside(x − 2) x2
1000000
1
− Heaviside(x − 4) x3
6000000
1 1
+ Heaviside(x − 4) − Heaviside(x − 4) x
93750 125000
1 1
+ Heaviside(x − 4) x2 − x3
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
− Heaviside(x − 2) x2
1000000
1
− Heaviside(x − 4) x3
6000000
1 1
+ Heaviside(x − 4) − Heaviside(x − 4) x
93750 125000
1 1
+ Heaviside(x − 4) x2 − x3
500000 15000000
1
+ x
1250000
Cette valeur de y satisfait à l’équation différentielle, à la condition
aux limites et à la valeur initiale.
> ode2;
3.6 Les équations différentielles : dsolve • 77

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


référence.
78 • Chapitre 3: Trouver des solutions

> y := ’y’;

y := y

Maple peut également résoudre des systèmes d’équations différen-


tielles ; par exemple, le système suivant formé de deux équations simul-
tané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 résolvez le système sans spécifier de conditions supplémen-
taires, Maple produit automatiquement les constantes appropriées _C1,
. . ., _C4.
Observez encore qu’il est possible d’extraire et de définir les solutions
à 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 déréférencer les solutions lorsque vous en avez terminé.


> y := ’y’;

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

3.7 L’organisation de Maple


Au démarrage, Maple ne charge en mémoire que le noyau (en anglais
kernel ) de son programme. Ce noyau constitue la base du système, car
il contient les commandes fondamentales et primitives : l’interpré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 numérique élémentaire ainsi que des routines d’af-
fichage des résultats et d’opérations d’entrée-sortie.
Le noyau est formé de code C hautement optimisé et totalise environ
10% de la taille du système. Les programmeurs de Maple ont délibérément
conservé sa taille petite pour en préserver la rapidité d’exécution. Le
noyau de Maple exécute les routines les plus fréquentes en arithmétique
entière et rationnelle et dans la manipulation des polynômes.
Les 90% restants du savoir mathématique de Maple sont écrits dans
le langage Maple et résident dans sa bibliothèque (library en anglais). La
bibliothèque se divise en deux groupes : la bibliothèque principale (main
library ) et les packages. Hiérarchiquement, ces groupes de fonctions se
situent au-dessus du noyau.
La bibliothèque principale contient les commandes Maple les plus
fréquemment utilisées (excluant celles déjà contenues dans le noyau).
Ces commandes sont chargées lorsqu’elles sont appelées — il n’est pas
nécessaire de les charger explicitement. Le langage Maple produit des
procédures très compactes qui n’affichent pas de délai observable : vous
ne remarquerez probablement pas la différence entre ces dernières et les
commandes du noyau écrites en C.
Les dernières commandes de la bibliothèque sont les packages. Chacun
des nombreux packages de Maple contient un groupe de commandes ef-
fectuant des calculs apparentés. Par exemple, le package LinearAlgebra
contient des commandes pour la manipulation des matrices.
Vous pouvez utiliser une commande d’un package de trois manières.
1. Utilisez le nom complet du package, suivi de la commande désirée.

package [cmd ]( ... )

Si le package possède un sous-package, utilisez le nom complet du pac-


kage, le nom complet du sous-package, suivi de la commande désirée.

package[souspackage][cmd] (...)

Puis, entrez le nom abrégé de la commande.


80 • Chapitre 3: Trouver des solutions

cmd (...)

2. Activez les noms abrégés pour toutes les commandes d’un package en
utilisant la commande with.

with(package )

Si le package possède un sous-package, utilisez la commande with de


la manière suivante.

with(package[souspackage] )

Puis, entrez le nom abrégé de la commande.

cmd (...)

3. Activez le nom abrégé d’une seule commande d’un package.

with(package, cmd )

Si le package possède un sous-package, utilisez la commande with de


la manière suivante.

with(package[souspackage], cmd )

Puis, entrez le nom abrégé de la commande.

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 abrégés des commandes du package. De plus, Maple vous
avertit lorsqu’il redéfinit des noms déjà existants.

3.8 Les packages Maple


Les packages inclus dans Maple permettent d’effectuer des tâches dans
de nombreuses disciplines, du calcul différentiel élémentaire à la théorie
générale de la relativité. Les exemples de cette section ne se veulent pas
détaillés et complets : ils ne sont que des illustrations de quelques com-
mandes dans des packages particuliers qui vous donneront un aperçu des
capacités de Maple.

Liste des packages


Vous trouverez la liste de packages suivante dans la page d’aide
?packages. Pour obtenir une liste complète des commandes d’un package
en particulier, consultez la page d’aide ?nomdupackage .
algcurves Outils pour l’étude des variétés (courbes) algébriques unidi-
mensionnelles définies par des polynômes multivariés.
codegen Outils de création, de manipulation et de traduction de procé-
dures Maple en d’autres langages. Ce package permet la différentiation
82 • Chapitre 3: Trouver des solutions

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 même que les parti-
tions entières. (Utilisez plutôt le package combstruct lorsque cela est
possible.)
combstruct Commandes qui permettent de générer et de compter les
structures combinatoires ainsi que de déterminer les équations des
fonctions génératrices permettant ce comptage.
context Outils de construction et de modification des menus contextuels
de l’interface graphique de Maple (affiché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 résolution et d’affichage des systèmes
d’équations différentielles ; espaces de phases et graphiques de champs.
diffalg Commandes de manipulation de systèmes d’équations différen-
tielles polynomiales (EDO ou EDP).
difforms Commandes de gestion des formes différentielles ; dédié aux
problèmes de géométrie différentielle.
Domains Commandes qui permettent de créer des domaines de calcul
(domains of computation en anglais) ; supporte le calcul sur les
polynômes, les matrices de même que les séries sur des anneaux de
nombres, les anneaux finis, les anneaux de polynô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 (où a et b sont entiers) que l’on appelle les entiers
gaussiens ; commandes de calcul du PGCD, de factorisation et de
tests de primalité.
genfunc Commandes de manipulation des fonctions génératrices ration-
nelles.
geom3d Commandes de géométrie euclidienne tridimensionnelle pour
définir et manipuler en trois dimensions points, lignes, plans, triangles,
sphères, polyèdres, etc.
3.8 Les packages Maple • 83

geometry Commandes de géométrie euclidienne bidimensionnelle servant


à définir et à manipuler en deux dimensions points, lignes, triangles
et cercles.
Groebner Commandes pour les calculs en base de Gröbner ; en particu-
lier, outils de calcul pour les algèbres de Ore et les D-modules.
group Commandes permettant de travailler avec les groupes de permu-
tations et les groupes finiment présentés.
inttrans Commandes qui permettent de travailler avec les transforma-
tions d’intégrales et leurs inverses.
LibraryTools Commandes de manipulation et de traitement de biblio-
thèques.
liesymm Commandes servant à caractériser les symétries de contact des
systèmes d’équations aux dérivé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’algèbre linéaire améliorées servant à créer
des types spéciaux de matrices, calculer avec de grandes matrices nu-
mériques et effectuer des opérations d’algèbre matricielle.
LinearFunctionalSystems Commandes qui permettent de résoudre des
systèmes linéaires de fonctions avec des coefficients polynomiaux,
déterminent le dénominateur universel d’une solution rationnelle et
transforment un système de récurrence matriciel en un système
équivalent avec une matrice de tête ou de queue non singulière.
ListTools Commandes de manipulation de listes.
LREtools Commandes de manipulation, d’affichage et de résolution de
relations de récurrence linéaire.
Maplets Commandes permettant de créer des fenê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-
mériques de Matlab, incluant les valeurs et les vecteurs propres, les
déterminants et la décomposition LU. (Ce package est accessible seule-
ment si Matlab est installé sur votre système.)
MatrixPolynomialAlgebra Ensemble d’outils de manipulation algé-
brique des polynômes matriciels.
84 • Chapitre 3: Trouver des solutions

networks Outils de construction, de traçage et d’analyse des réseaux


combinatoires. Outils de gestion des graphes orientés et d’expressions
arbitraires pour les poids des nœuds et des arêtes.
numapprox Commandes de calcul d’approximations polynomiales de fonc-
tions sur un intervalle donné.
numtheory Commandes de théorie des nombres classique, tests de pri-
malité, calcul du n-ième nombre premier, génération de polynômes
d’unités cyclotomiques. Ce package contient également des com-
mandes de gestion des convergents.
Ore_algebra Routines de calcul de base dans les algèbres d’opérateurs
linéaires.
OrthogonalSeries Commandes de manipulation de séries de polynômes
orthogonaux classiques ou, de manière plus générale, de polynômes
hypergéométriques.
orthopoly Commandes servant à générer différents types de polynômes
orthogonaux ; ce package s’avère utile pour la résolution d’équations
différentielles.
padic Commandes de calcul des approximations p-adiques de nombres
réels.
PDEtools Outils de manipulation, de résolution et d’affichage d’équations
aux dérivées partielles.
plots Commandes pour différents types de graphiques spécialisés, in-
cluant les graphiques d’isovaleurs, les graphiques bidimensionnels et
tridimensionnels de fonctions implicites, l’affichage de texte et de gra-
phiques dans différents systèmes de coordonnées.
plottools Commandes servant à générer et à manipuler des objets gra-
phiques.
PolynomialTools Commandes de manipulation d’objets polynomiaux.
polytools Commandes de manipulation d’objets polynomiaux.
powseries Commandes servant à créer et manipuler des séries entières
formelles représentées par leur terme général.
process Commandes permettant d’écrire des programmes Maple multi-
processus sous UNIX.
RandomTools Commandes permettant de travailler avec des objets aléa-
toires.
RationalNormalForms Commandes permettant de construire la forme
normale polynomiale ou les formes rationnelles canoniques d’une fonc-
tion rationnelle, ou la représentation minimale d’un terme hypergéo-
métrique.
3.8 Les packages Maple • 85

RealDomain Fournit un environnement dans lequel le système de nombres


assumé est le système des nombres réels, et non le système des nombres
complexes.
ScientificConstants Commandes donnant accès aux valeurs de diffé-
rentes quantités physiques utilisées couramment en physique ou en
chimie.
simplex Commandes d’optimisation linéaire utilisant la méthode du sim-
plexe.
Slode Commandes servant à trouver des solutions à des EDO linéaires
sous forme de séries entières.
Sockets Commandes permettant les communications réseau avec Maple.
Les routines de ce package vous permettent de vous connecter à des
processus situés sur des hôtes distants (par Internet ou Intranet) et
échanger des données avec ces processus.
SolveTools Commandes qui permettent de résoudre des systèmes
d’équations algébriques. Ce package donne aux utilisateurs expéri-
mentés l’accès aux routines appliquées par la commande solve pour
un meilleur contrôle du processus de résolution.
Spread Outils permettant de travailler avec les feuilles de calcul dans
Maple.
stats Manipulation statistique de données ; inclut des commandes pour
le calcul de la moyenne, l’écart type, les coefficients de corrélation, la
variance et l’analyse de régression.
StringTools Commandes optimisées de manipulation des chaı̂nes de ca-
ractères.
Student Sous-packages spécifiques à certains cours. Dans des versions
futures de Maple, ce package sera élargi pour inclure d’autres sous-
packages liés à l’enseignement. Le premier de ceux-ci est Calculus1.
Calculus1 Commandes permettant de décortiquer les étapes de la
différentiation, de l’intégration et du calcul des limites, la visua-
lisation de la méthode de Newton, les sommes de Riemann, la
longueur d’arc, les volumes de révolution, de même que des rou-
tines pour trouver les points critiques d’une expression.
sumtools Commandes de calcul de sommes définies et indéfinies. Com-
prend les algorithmes de Gosper et de Zeilberger.
Sumtools Outils permettant de calculer des formes fermées de sommes
définies et indéfinies.
tensor Commandes permettant le calcul tensoriel et ses applications à
la théorie générale de la relativité.
86 • Chapitre 3: Trouver des solutions

Le package Student Calculus1 (une variable)


Le package Student[Calculus1] vous aide à effectuer les calculs de
différentiation, d’intégration et de limites. Considérez le problème sui-
vant : trouvez la dérivée de la fonction 4 ∗ x2 .
> with(Student[Calculus1]):
> infolevel[Student] := 1:
Pour voir la liste de toutes les commandes chargées par Maple, remplacez
les deux points par le point-virgule à la fin de la commande.
> Diff(4*x^2, x);

d
(4 x2 )
dx

Utilisez la règle constantmultiple.


> Rule[constantmultiple](%);

Creating problem #1

d d
(4 x2 ) = 4 ( (x2 ))
dx dx

Utilisez la règle power.


> Rule[power](%);

d
(4 x2 ) = 8 x
dx

Considérez maintenant cet exemple d’intégration. Inté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 règle sum.


> Rule[sum](%);

Creating problem #2
3.8 Les packages Maple • 87

 π  π  π
x cos(x) + x dx = x cos(x) dx + x dx
0 0 0

Utilisez la rè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


étape de résolution du problè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 rè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 spécifier des règles qui servi-
ront au calcul d’une limite par la commande Limit sans les appliquer
directement. Spécifiez à Understand les rè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);
88 • Chapitre 3: Trouver des solutions

Limit = [constant , constantmultiple, power , sum]

> Limit((1 + 1/x)^x, x=infinity);

1 x
lim (1 + )
x→∞ x

Demandez un indice à propos de la prochaine étape à 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 règle donné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[%](%%);
3.8 Les packages Maple • 89
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

Considérez la fonction −2/3 ∗ x2 + x. Tracez-en le graphique, de mê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.
90 • Chapitre 3: Trouver des solutions

> 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 résultat n’est pas une bonne approximation, augmentez


à 40 le nombre de boı̂tes utilisées.
> ApproximateInt(-2/3*x^2+x, x=0..3/2, method=midpoint,
> output=plot, view=[0..1.6, -0.15..0.4],
> partition=40);
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:.3751171867

f(x)

Quelle est la valeur exacte ? Utilisez d’abord n boı̂tes et calculez la


formule de la somme.
> ApproximateInt(-2/3*x^2+x, x=0..3/2, method=midpoint,
> 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
3.8 Les packages Maple • 91

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 même résultat au


moyen d’une inté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 différentiel avec Maple, reportez-


vous au chapitre 6.

Le package LinearAlgebra
En algèbre linéaire, un ensemble de vecteurs linéairement indépendants
qui engendrent l’espace vectoriel se nomme une base. Il est possible d’ex-
primer n’importe quel élément de l’espace vectoriel comme une combinai-
son linéaire des éléments de la base.
Un ensemble de vecteurs {v1 , v2 , v3 , . . . , vn } est linéairement indépen-
dant si et seulement si, lorsque

c1 v1 + c2 v2 + c3 v3 + · · · + cn vn = 0

alors
c1 = c2 = c3 = · · · = cn = 0.
92 • Chapitre 3: Trouver des solutions

Problème : Déterminer une base de l’espace vectoriel généré 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 à 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 linéairement indépendants, il forment une base.


Pour vérifier l’indépendance linéaire, écrivez l’é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 équation est équivalente à

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 linéairement dépendants puisque chacun est un pro-


duit linéaire d’une variable. Ils ne peuvent donc pas former une base. La
commande RowSpace retourne une base pour un espace vectoriel donné.
> b:=RowSpace(vector_space);

b := [[1, 0, 1, −1], [0, 1, 1, −2]]


3.8 Les packages Maple • 93

> 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 coordonnées par rapport à cette base.


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

Pour obtenir davantage d’information à propos de ce package, exécu-


tez la commande ?LinearAlgebra.

Le package Matlab
Le package Matlab vous permet d’appeler certaines fonctions de Matlab à
partir d’une session Maple, en supposant que Matlab soit installé sur votre
système 1 . Matlab est une abréviation de matrix laboratory (laboratoire
de matrices) et est un package de calcul numérique fort populaire, utilisé
par des ingénieurs et d’autres professionnels.
On doit d’abord établir une connexion entre les deux produits avec
> Matlab[openlink]();

Pour déterminer les valeurs et les vecteurs propres d’une matrice d’en-
tiers, on définit d’abord la matrice souhaité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 également un Symbolic Computation Toolbox disponible pour Matlab qui
vous permet d’appeler des commandes Maple depuis Matlab.
94 • Chapitre 3: Trouver des solutions

> P,W := Matlab[eig](A, eigenvectors=true):

Remarquez ce qui se trouve à la gauche de l’opérateur d’affectation.


Le (P,W) spécifie que deux objets seront générés et assignés aux variables
— les valeurs propres, à W, et les vecteurs propres, à P. L’affectation
multiple est également possible avec les commandes Maple, mais, puisque
les commandes Maple existantes sont conçues pour ne retourner qu’un
seul résultat, cette fonctionnalité est peu utilisée.
Examinons les ré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 également prendre comme pa-


ramètres des données en format Matlab. Consultez l’aide sous la rubrique
Matlab pour obtenir plus d’information sur les données Matlab acceptées
par Maple.

Le package Statistics
Le package stats possède plusieurs commandes d’analyse et de mani-
pulation de données, de même que plusieurs types de graphiques utilisés
en statistique. Il contient également un grand éventail de distributions
statistiques.
stats est un exemple de package renfermant des sous-packages (sub-
packages en anglais). À l’intérieur de chaque sous-package se trouvent
plusieurs commandes groupées par fonctionnalité.
> with(stats);

[anova, describe, fit , importdata, random, statevalf ,


statplots , transform]
3.8 Les packages Maple • 95

Le package stats traite les données sous la forme de listes statis-


tiques , qui peuvent être de simples listes Maple. Une liste statistique peut
également contenir des intervalles et des valeurs auxquelles des poids ont
été assignés. La diffé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 équivalentes à 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 différences de moins de 0, 01 sont suffisamment petites pour
être négligeables, il est possible de les regrouper et de ne spé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 à l’analyse
de données.
> describe[mean](marks);
96 • Chapitre 3: Trouver des solutions
729
10

> describe[range](marks);

45..93

> describe[range](readings);

.002..1.01

> describe[standarddeviation](readings);

.4038750456

Ce package contient plusieurs distributions statistiques. Générez des


données alé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];
3.8 Les packages Maple • 97

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 linéaire


Le package simplex contient des commandes d’optimisation linéaire grâce
à l’utilisation de l’algorithme du simplexe. L’optimisation linéaire permet
de trouver des solutions optimales à des équations soumises à certaines
contraintes.
Un exemple classique d’optimisation est le problème de la livraison de
pizza. Imaginez-vous en livreur de pizza : vous devez livrer quatre pizzas
en quatre endroits différents dispersés dans la ville. Vous souhaitez livrer
toutes les quatre en utilisant le moins de carburant possible. Vous devez
également vous rendre aux quatre endroits en moins de vingt minutes,
de manière que les pizzas demeurent chaudes. Si vous créez des équations
mathématiques représentant les routes menant aux quatre endroits ainsi
que leurs distances respectives, vous pouvez trouver la solution optimale,
c’est-à-dire la solution qui vous fera utiliser le moins de carburant tout
en atteignant toutes les adresses dans le plus court délai possible. Les
contraintes de ce système particulier sont que vous devez avoir livré toutes
les quatre pizzas vingt minutes après avoir quitté le restaurant.
Voici un petit système en guise d’exemple.
> with(simplex);
98 • Chapitre 3: Trouver des solutions

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 réponse signifie que Maple ne peut trouver de
solution. Vous pouvez utiliser la commande feasible pour vérifier que
l’ensemble des contraintes est valide.
> feasible({c1,c2,c3});

true

Essayez à nouveau, en ajoutant une restriction à la solution.


> maximize(w, {c1,c2,c3}, NONNEGATIVE);
3.9 Conclusion • 99
1 49
{x = 0, z = , y = }
2 8

3.9 Conclusion
Ce chapitre vous a présenté des caractéristiques fondamentales de Maple
qui vous aideront grandement à mesure que vous apprendrez de nouvelles
méthodes de résolution de problèmes plus complexes. La section 3.1 vous
a introduit aux commandes solve et fsolve de même qu’à leur utilisation
adéquate. Que vous utilisiez ou non les commandes solve, ces méthodes
s’avèreront utiles à de nombreuses reprises.
Les dernières sections du présent chapitre ont introduit les mani-
pulations, la commande solve et l’organisation de Maple et de ses bi-
bliothèques de manière à vous donner un avant-goût de son potentiel. À
ce point de votre lecture, vous ne connaissez pas encore tout à fait ce
logiciel. Vous en savez cependant suffisamment pour commencer à utiliser
Maple de manière efficace.
À votre guise, vous pouvez interrompre ici votre étude pour travailler
(ou jouer !) avec Maple.
100 • Chapitre 3: Trouver des solutions
4 Tracer des graphiques

Quelquefois, la meilleure manière de mieux comprendre une structure


mathématique consiste à en tracer le graphique. Maple peut produire
plusieurs formes de graphiques : en deux ou trois dimensions, animés ou
non, affichables selon n’importe quel angle. Maple peut gérer les formes
explicites, implicites et paramétriques et exploiter plusieurs systèmes de
coordonnées. La flexibilité de Maple vous permet de manipuler aisément
des graphiques dans de nombreuses situations.

4.1 Graphiques en deux dimensions


Lorsqu’on lui demande de tracer une fonction donné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 fenêtre du graphique fait af-


ficher les coordonné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-même) vous permettent de modifier plusieurs caractéristiques

101
102 • Chapitre 4: Tracer des graphiques

des graphiques et d’utiliser des options d’affichage résumées sous la ru-


brique ?plot,options.
Maple peut également tracer le graphe de fonctions dé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 détail des intervalles, à 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 même gérer des domaines infinis.


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

0 infinity
x

Les graphiques paramétriques


Certains graphiques ne peuvent être spécifiés explicitement ; en d’autres
mots, il est impossible d’exprimer la variable dé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 à rendre à la fois
x et y dépendantes d’un autre paramètre, par exemple t. Le graphique
généré à partir de ces fonctions se nomme un graphique paramétrique.
Utilisez la syntaxe suivante pour utiliser les graphiques paramétriques.

plot( [ x-expr, y-expr, parametre =intervalle ] )

Vous tracez ainsi une liste contenant x-expr, y-expr, le nom et l’intervalle
du paramè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 ] );
104 • Chapitre 4: Tracer des graphiques

0.5

–1 –0.5 0.5 1

–0.5

–1

Plutôt que de produire un cercle, le graphique ci-dessus ressemble da-


vantage à une ellipse puisque Maple, par défaut, déforme le graphique
pour lui faire prendre les dimensions de la fenêtre. Voici le même gra-
phique pour lequel on a spécifié le paramètre scaling=constrained. Il
est possible de changer l’é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 désavantage de constrained réside dans le fait que cette option


peut cacher d’importants détails lorsque les caractéristiques d’une dimen-
sion apparaissent à une échelle beaucoup plus petite que les autres. Le
graphique suivant est tracé sans l’option constrained (unconstrained).
> plot( exp(x), x=0..3 );
4.1 Graphiques en deux dimensions • 105

20
18
16
14
12
10
8
6
4
2
0 0.5 1 1.5 2 2.5 3
x

Voici maintenant le même graphique, tracé 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 coordonnées polaires


Les coordonnées cartésiennes (ordinaires) sont les coordonnées par défaut
de Maple et ne représentent qu’une des multiples manières de spécifier un
point dans l’espace ; les coordonnées polaires, (r, θ), peuvent également
être utilisées.
En coordonnées polaires, r est la distance du point à l’origine, et θ
représente l’angle entre l’axe des x et la ligne passant par le point donné
et l’origine.
Maple peut tracer une fonction en coordonnées polaires à l’aide de
la commande polarplot. Pour accéder à la forme abrégée de cette com-
mande, vous devez d’abord appeler la commande with(plots).
> with(plots):
106 • Chapitre 4: Tracer des graphiques

Figure 4.1 Le système de coordonnées polaires

r
y

0 x

Utilisez la syntaxe suivante pour tracer les graphiques en coordonnées


polaires.

polarplot( r-expr, angle =intervalle )

En coordonnées polaires, vous pouvez spé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 à la page 103, le paramètre


scaling=constrained fait apparaı̂tre le cercle rond. Voici le graphique
de r = sin(3θ).
> polarplot( sin(3*theta), theta=0..2*Pi );
4.1 Graphiques en deux dimensions • 107

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 également les graphiques paramétri-


sés ; vous pouvez donc exprimer le rayon et les coordonnées angulaires en
fonction d’un paramètre, par exemple t. La syntaxe est similaire aux gra-
phiques paramétriques en coordonnées cartésiennes. Consultez la présente
section, page 103.

polarplot( [ r-expr, angle-expr, paramètre =intervalle ] )

Les équations r = sin(t) et θ = cos(t) définissent le graphique suivant.


> polarplot( [ sin(t), cos(t), t=0..2*Pi ] );
108 • Chapitre 4: Tracer des graphiques

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 possédant des discontinuités demandent davantage d’at-
tention. Considérez par exemple la fonction suivante, qui possède deux
discontinuités en x = 1 et x = 2.

 −1 si x < 1,
f (x) = 1 si 1 ≤ x < 2,

3 sinon.

Voici comment dé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);


4.1 Graphiques en deux dimensions • 109

0 0.5 1 1.5 2 2.5 3


x
–1

Maple dessine des lignes presque verticales près d’un point de discon-
tinuité. L’option discont=true indique qu’il peut y avoir des disconti-
nuités.
> plot(f(x), x=0..3, discont=true);

0 0.5 1 1.5 2 2.5 3


x
–1

Les fonctions qui possèdent des singularités (qui deviennent arbitrai-


rement grandes en un certain point) forment un autre cas particulier. La
fonction x → 1/(x − 1)2 possède une singularité en x = 1.
> plot( 1/(x-1)^2, x=-5..6 );

250000

200000

150000

100000

50000

–4 –2 0 2 4 6
x
110 • Chapitre 4: Tracer des graphiques

Dans le graphique précédent, tous les détails intéressants du graphique


sont perdus en raison du pic en x = 1. La solution consiste à 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 possède plusieurs singularités en x = 2 + πn, où
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 détails, on ré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
4.1 Graphiques en deux dimensions • 111

Maple dessine des lignes presque verticales près des singularité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 même graphique, il suffit de
donner à 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 );
112 • Chapitre 4: Tracer des graphiques

–2 –1 0 1 2
x
–1

Cette technique fonctionne également pour les graphiques paramé-


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 différents styles de ligne (par exemple continue ou poin-


tillée), il est aisé de distinguer différentes fonctions dans un même gra-
phique en spécifiant le paramètre linestyle. Dans l’exemple suivant,
Maple utilise linestyle=SOLID pour la premiè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] );
4.1 Graphiques en deux dimensions • 113

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 également changer le style de ligne en utilisant les menus


standard et contextuels. De manière similaire, vous pouvez spécifier les
couleurs des graphiques au moyen de l’option color. (Vous pouvez en
voir l’effet sur un affichage en couleurs, contrairement au présent livre qui
n’affiche les lignes que selon diffé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 détails sur


les couleurs dans Maple.

Tracer des points


Pour tracer des données numériques, appelez la fonction pointplot en
spécifiant les donné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]];
114 • Chapitre 4: Tracer des graphiques

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 défaut, Maple ne relie pas les points par des lignes droites ; l’option
style=line oblige à tracer ces lignes. Vous pouvez également utiliser les
menus pour indiquer à 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-mêmes à 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);
4.1 Graphiques en deux dimensions • 115

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 résultat.
Pour plus d’information, reportez-vous à la rubrique ?CurveFitting.

Raffiner des graphiques


Maple comporte un algorithme de tracé adaptatif. Il calcule la valeur de
la fonction en un nombre raisonnable de points approximativement é-
quidistants dans l’intervalle spécifié. Il décide ensuite de calculer plus de
points dans les intervalles où les valeurs fluctuent davantage. Cependant,
il peut arriver que cet algorithme adaptatif ne donne pas de ré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 à Maple de calculer da-


vantage de points.
> plot(sum((-1)^(i)*abs(x-i/10), i=0..30), x=-1..4,
> numpoints=500);
116 • Chapitre 4: Tracer des graphiques

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 dernière. La syntaxe de plot3d est similaire à celle de plot. Encore
une fois, une fonction donnée explicitement, z = f (x, y), est la plus facile
à tracer.
> plot3d( sin(x*y), x=-2..2, y=-2..2 );

Vous pouvez faire tourner le graphique en cliquant sur la fenêtre avec


votre souris et en faisant bouger la boı̂te qui en définit le contour. Les
menus vous permettent de modifier plusieurs caractéristiques d’un gra-
phique.
Tout comme plot, plot3d peut tracer des fonctions dé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 défaut, Maple affiche le graphique comme une surface colorée,


mais il est possible de modifier cette option en utilisant les menus ou
le paramè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 deuxième paramètre peut dépendre du premier pa-
ramètre.
> plot3d( sqrt(x-y), x=0..9, y=-x..x );
118 • Chapitre 4: Tracer des graphiques

Les graphiques paramétriques


Certains graphiques ne peuvent être spécifiés explicitement ; en d’autres
mots, il est impossible d’exprimer la variable dépendante sous forme de
fonction z = f (x, y). La sphère en est un exemple. Comme pour les
graphiques bidimensionnels (consultez la section Les graphiques pa-
ramétriques de la page 103), une solution consiste à rendre à la fois
x, y et z dépendantes de deux autres paramètres, par exemple s et t.
Le graphique produit à partir de ces fonctions se nomme un graphique
paramétrique. Utilisez la syntaxe suivante pour spécifier les graphiques
paramé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 );
4.2 Graphiques en trois dimensions • 119

Les coordonnées sphériques


Les coordonnées cartésiennes (ordinaires) sont les coordonnées par défaut
de Maple et ne représentent qu’une des multiples manières de spécifier un
point dans l’espace en trois dimensions ; les coordonnées sphériques sont
une autre option.
En coordonnées sphériques, les trois coordonnées sont r, la distance
du point à 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 système de coordonnées sphériques

φ r

0
y
x θ

Maple peut tracer une fonction en coordonnées sphériques en utilisant


la commande sphereplot du package plots. Pour accéder à la forme
abrégée de cette commande, vous devez d’abord appeler la commande
with(plots). Pour éviter d’afficher la liste de toutes les commandes de
plots, tapez les deux-points plutôt que le point-virgule.
> with(plots):
Vous pouvez utiliser la commande sphereplot de la manière suivante.
120 • Chapitre 4: Tracer des graphiques

sphereplot( r-expr, theta =intervalle, phi =intervalle )

Le graphique de r = (4/3)θ sin φ ressemble à ceci :


> sphereplot( (4/3)^theta * sin(phi),
> theta=-1..2*Pi, phi=0..Pi );

Le tracé d’une sphère en coordonnées sphériques est simple : il suffit


de spécifier le rayon, par exemple 1, et de laisser θ tourner tout le long de
l’équateur et φ tourner du pôle nord (φ = 0) au pô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 également les graphiques para-
métrisés, c’est-à-dire les graphiques qui spécifient le rayon et les deux
coordonnées d’angle en fonction de deux autres paramètres, par exemple s
et t. La syntaxe est similaire à celle d’un graphique paramétrique en deux
dimensions en coordonnées cartésiennes ; consultez la présente section à
la page 118.
4.2 Graphiques en trois dimensions • 121

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 coordonnées cylindriques


On peut également spécifier un point dans le système cylindrique en
spécifiant les coordonnées r, θ et z. Ici, r et θ sont les cooronnées polaires
(voir la section 4.1) dans le plan xy et z est la coordonnée cartésienne
usuelle en z.
Figure 4.3 Le système de coordonnées cylindriques

0
y
x θ r

Maple trace les fonctions en coordonnées cylindriques au moyen de la


commande cylinderplot du package plots.
> with(plots):
Vous pouvez tracer les graphiques en coordonnées cylindriques en appli-
quant la syntaxe suivante :
122 • Chapitre 4: Tracer des graphiques

cylinderplot( r-expr, angle =intervalle, z =intervalle )

Voici une version tridimensionnelle de la spirale montrée dans la sec-


tion 4.1.
> cylinderplot( theta, theta=0..4*Pi, z=-1..1 );

Les cônes sont facilement tracés en coordonnées cylindriques : il suffit


de spécifier r = z et de faire varier θ de 0 à 2π.
> cylinderplot( z, theta=0..2*Pi, z=0..1 );

cylinderplot accepte également les graphiques paramétriques. Leur


syntaxe est similaire à celle des graphiques paramétriques en coordonnées
cartésiennes. Consultez la section Les graphiques paramétriques de la
page 118.

cylinderplot( [ r-expr, theta-expr, z-expr ],


paramètre1 =intervalle,
paramètre2 =intervalle )

L’image suivante est un graphique de la fonction r = st, θ = s et


z = cos(t2 ).
4.2 Graphiques en trois dimensions • 123

> 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 précis que vous le souhaitez,
vous pouvez indiquer à Maple d’en calculer plus de points. L’option le
permettant est

grid=[m, n ]

où m est le nombre de points à utiliser pour la première coordonnée, et n


le nombre de points à utiliser pour la seconde coordonné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


première coordonné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] );
124 • Chapitre 4: Tracer des graphiques

La valeur par défaut de grid est d’environ 25 points sur 25.

Modèles de coloriage et d’éclairage


Deux méthodes permettent colorier une surface en trois dimensions. Dans
la première, une ou plusieurs sources lumineuses colorées illuminent la
surface. Dans la seconde, la couleur de chaque point est fonction directe
de ses coordonnées.
Maple possède un grand nombre de configurations de sources lumi-
neuses donnant des résultats esthé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 prédéfinies est également disponible par les menus
ou au moyen de l’option shading.
L’usage simultané de sources lumineuses et de coloriage direct peut
compliquer le rendu des couleurs. Utilisez des sources lumineuses ou un
coloriage direct. Voici une surface coloriée avec un shading zgrayscale
sans é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 même surface illuminée par le modèle d’é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 présent manuel, les graphiques apparaissent en noir et blanc.


Essayez-les vous-même pour voir les effets de la couleur.

4.3 L’animation
Tracer des graphiques constitue une excellente manière de représenter
l’information ; cependant, des images statiques ne mettent pas toujours
en évidence certains comportements graphiques, comme la déformation
d’une balle qui rebondit.
Une animation Maple ressemble à une séquence d’images d’un film :
une suite de graphiques s’affichent rapidement l’un après l’autre. Les deux
commandes utilisées pour les animations, animate et animate3d, sont
dé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 abrégée.

L’animation en deux dimensions


Vous pouvez spé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):
126 • Chapitre 4: Tracer des graphiques

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 défiler une animation, vous devez d’abord la sélectionner


en cliquant dessus. Puis, choisissez Play dans le menu Animation.
Par défaut, une animation en deux dimensions est formée de seize
graphiques (frames). Si le mouvement vous semble saccadé, 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
mémoire. La commande suivante peut être collé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 é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 préfériez une animation ou un graphique est une question de


goût et dépend des concepts que l’animation ou le graphique doit mettre
en évidence.
L’animation de graphiques paramétriques est é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 à la commande animate d’utiliser un système


de coordonnées autre que les coordonnées cartésiennes.
> animate( theta*t, theta=0..8*Pi, t=1..4, coords=polar );
128 • Chapitre 4: Tracer des graphiques

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 maniè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 défaut, une animation tridimensionnelle est formée de huit gra-


phiques. De la même manière que pour les animations en deux dimensions,
vous pouvez indiquer à Maple le nombre de graphiques à tracer au moyen
du paramè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 paramétriques, que vous pouvez é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 système de coordonnées différent


des coordonnées cartésiennes, utilisez l’option coords. Pour les coor-
données sphé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 coordonné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 systèmes de coordonnées accepté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 fenêtre du gra-
phique, centré et près du haut.
> plot( sin(x), x=-2*Pi..2*Pi, title="Plot of Sine" );
130 • Chapitre 4: Tracer des graphiques

PlotofSine
1

0.5

–6 –4 –2 0 2 4 6
x
–0.5

–1

Prenez note qu’en spécifiant le titre, vous devez placer des guillemets
doubles (") aux deux extrémités du texte. Ce détail est très important.
Maple utilise des guillemets doubles pour délimiter les chaı̂nes de ca-
ractères : il considère tout ce qui apparaı̂t entre les guillemets doubles
comme du texte qu’il doit prendre tel quel. Vous pouvez spé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):

Warning, the name changecoords has been redefined

> 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 créer des étiquettes aux axes, l’op-
tion labelsfont définit la police et le style des étiquettes et l’option
labeldirections permet de placer les étiquettes des axes verticale-
ment ou horizontalement. Remarquez que les étiquettes ne doivent pas
4.4 Annoter des graphiques • 131

forcément ê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 étiquettes s’affichent seulement si les axes sont également affichés.


Dans le cas des graphiques tridimensionnels, les axes ne sont pas affichés
par défaut ; vous devez donc les spé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 légende de texte à votre


graphique.
> plot( [sin(x), cos(x)], x=-3*Pi/2..3*Pi/2, linestyle=[1,4],
> legend=["The Sine Function", "The Cosine Function"] );
132 • Chapitre 4: Tracer des graphiques

0.5

–4 –2 2x 4
–0.5

–1

TheSineFunction
TheCosineFunction

Voyez également la section 4.5 à la page 134.

4.5 Les graphiques composites


Maple vous permet d’afficher plusieurs graphiques simultanément, après
avoir donné des noms aux graphiques individuels. Puisque la structure
interne des graphiques est généralement très longue à afficher, terminez
vos commandes d’affectation par deux points plutôt que par un point-
virgule.
> mon_graphique := plot( sin(x), x=-10..10 ):
Vous pouvez conserver le graphique pour un usage ultérieur, comme toute
autre expression. Affichez-le en utilisant la commande display dé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 à la fois.


Il suffit de lui spé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-


férents types sur les mêmes axes. Vous pouvez également afficher des
graphiques tridimensionnels et mê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 définition précédente de b et les commandes suivantes dans


Maple pour voir une animation et un graphique avec les mê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 dernières possèdent toutes le même nombre d’images. Entrez l’exemple
suivant dans Maple pour voir deux animations simultané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] );
134 • Chapitre 4: Tracer des graphiques

Placer du texte dans les graphiques


Les options title et labels des commandes graphiques vous permettent
de placer des titres et des étiquettes dans vos graphiques. Les commandes
textplot et textplot3d vous donnent encore plus de flexibilité en vous
permettant de spécifier la position exacte des éléments de texte. Le pa-
ckage plots contient ces deux commandes.
> with(plots):
Vous pouvez utiliser textplot and textplot3d de la maniè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 détails


sur la manière de placer les éléments de texte avec précision. Utilisez l’op-
tion font pour spécifier la police de caractères employée pour l’affichage.
Dans le graphique suivant, l’origine, un point de selle, est indiqué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 particulière, consultez la rubrique ?plots,commande .
> with(plots):

Tracez des fonctions dé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 région satisfaisant aux


inégalité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) );
136 • Chapitre 4: Tracer des graphiques

10

–1 1 2 3 4 5

–5

–10

Dans l’exemple suivant, l’axe vertical est tracé à une é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 possè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 également tracer des graphiques où les deux axes pos-
sèdent des échelles logarithmiques.
> loglogplot( x^17, x=1..7 );
4.6 Quelques graphiques particuliers • 137

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 );
138 • Chapitre 4: Tracer des graphiques

–4 –2 0 2 4

La commande fieldplot dessine un vecteur donné pour plusieurs


valeurs de x et y ; le graphique ainsi formé est un champ de vecteurs de
même type qu’un champ magné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 à trois dimensions.


> spacecurve( [cos(t),sin(t),t], t=0..12 );

Ici, Maple  gonfle  la courbe précédente pour en faire un tube.


> tubeplot( [cos(t),sin(t),t], t=0..4*Pi, radius=0.5 );
4.6 Quelques graphiques particuliers • 139

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 dé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


140 • Chapitre 4: Tracer des graphiques

La commande arrow affiche des flè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 à 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 créer des
objets graphiques et de manipuler leurs graphiques correspondants. Utili-
sez with(plottools) pour accéder aux commandes par leur nom abrégé.
> with(plottools):

Les objets dans le package plottools ne s’affichent pas par eux-


mêmes ; on doit y accéder par la commande display définie dans le
package plots à l’aide de la commande with.
> with(plots):

Considérez l’exemple suivant.


> display( dodecahedron(), scaling=constrained, style=patch );
4.7 Manipuler des objets graphiques • 141

Donnez un nom à 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 sphè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 );
142 • Chapitre 4: Tracer des graphiques

–0.4 0.6
–0.20.4
0
1.3 0.2
1.4 0.4
1.5
1.6
1.7

Vous pouvez également créer des cô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

Expérimentez la capacité de Maple à 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 crée un hémisphère. Vous pouvez spécifier


le rayon et les coordonnées de son centre ; sinon, n’écrivez rien entre les
parenthèses pour accepter les valeurs par défaut.
> cup := hemisphere():
> display( cup );

> cap := rotate( cup, Pi, 0, 0 ):


> display( cap );

Les côtés du dodécaèdre mentionné plus tôt dans cette section sont
tous des pentagones. Si vous élevez le point milieu de chaque penta-
gone au moyen de la commande stellate, l’objet résultant se nomme
144 • Chapitre 4: Tracer des graphiques

un dodécaèdre étoilé.
> a := stellate( dodecahedron() ):
> display( a, scaling=constrained, style=patch );

> stelhs := stellate(cap, 2):


> display( stelhs );

Plutôt que de rendre le dodécaèdre étoilé, vous pouvez supprimer les


trois quarts de l’inté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, créer des graphiques impressionnants ne nécessite souvent
que quelques lignes de code, ainsi que le montrent les exemples de la
présente section. Cependant, d’autres graphiques demandent plusieurs
lignes de code. Les commandes utilisées pour les planches en couleurs1 qui
ne sont pas indiquées ici se trouvent dans le Maple Application Center.
Il existe deux manières d’accé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 accéder au code des planches qui n’est pas affiché dans ce manuel :
1. Accé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
accéder à ces galeries, rendez-vous au Maple Application Center et cli-
quez sur Maple Graphics.

1
La plupart des planches en couleurs ont été exportées et dessinées dans POV-
RayTM . La duplication exacte des images peut de ce fait s’avérer difficile.
146 • Chapitre 4: Tracer des graphiques

Note : Sur certains ordinateurs, il peut être nécessaire de diminuer la


valeur de l’option numpoints pour dessiner le graphique.
1. Problè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 mathé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 être affiché 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 appliquée à 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
4.9 Conclusion • 147

> 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. Icosaè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 révolution paramétrisé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 coordonnées carté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 présenté les capacités d’affichage graphique de Maple en
deux et trois dimensions pour des fonctions explicites, implicites et pa-
ramétriques. Les coordonnées cartésiennes, polaires, sphériques et cylin-
driques ne sont que quelques-uns des systèmes de coordonnées exploités
par Maple. De plus, vous pouvez animer un graphique et le colorier de
plusieurs manières pour vous assurer d’une bonne compréhension de sa
nature.
148 • Chapitre 4: Tracer des graphiques

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 créer en utilisant ces
commandes sont les graphiques logarithmiques, de contour et de densité.
Les commandes du package plottools permettent de créer et de mani-
puler des objets. Ces commandes rendent possibles la translation et la
rotation des entités graphiques, et peuvent même les rendre étoilés.
5 L’évaluation et la
simplification

Dans Maple, beaucoup de temps et d’efforts sont consacrés à la manipu-


lation d’expressions. Celle-ci sert à convertir des résultats sous une forme
familière et vérifier une réponse, ou à convertir une expression sous une
forme particulière requise par certaines routines Maple.
Le problème de la simplification s’avère étonnamment complexe en
mathématiques symboliques. Ce qui est simple dans un contexte peut ne
pas l’être dans un autre ; chaque situation peut avoir sa propre définition
d’une forme  simple .
Maple fournit un jeu d’outils permettant de travailler avec les ex-
pressions pour y effectuer à la fois des manipulations mathématiques et
structurelles. Les manipulations mathématiques sont celles correspondant
à une forme de processus mathématique, par exemple la factorisation d’un
polynôme ou la rationalisation du dénominateur d’une expression ration-
nelle. Les manipulations structurelles sont quant à elles des outils fournis
par Maple pour accéder à certaines parties des structures de données du
logiciel qui représentent des expressions et d’autres types d’objets, et les
modifier.

5.1 Manipulations mathématiques


La résolution d’équations à la main demande normalement d’effectuer une
séquence de manipulations algébriques. Vous pouvez également effectuer
ces étapes au moyen de Maple.
> eq := 4*x + 17 = 23;

eq := 4 x + 17 = 23

149
150 • Chapitre 5: L’évaluation et la simplification

Ici, vous devez soustraire 17 des deux côtés de l’équation. Pour ce faire,
il suffit de soustraire l’équation 17=17 de eq. Assurez-vous de mettre des
parenthèses autour de l’équation sans nom.
> eq - ( 17 = 17 );

4x = 6

Divisez maintenant le résultat par 4. Remarquez qu’il n’est pas


nécessaire d’utiliser 4=4 dans ce cas.
> % / 4;

3
x=
2

Les sections suivantes présentent plusieurs autres manipulations com-


plexes.

Développer des polyn


omes en sommes
Les sommes sont généralement plus faciles à comprendre que les produits ;
vous pouvez donc trouver utile de développer un polynô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 développe le numé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 mathématiques • 151

Utilisez la commande normal pour annuler les facteurs communs ;


consultez la section Forme normale factorisée de la page 159.
La commande expand applique également les règles d’expansion de
plusieurs fonctions mathé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 mêmes règles, mais dans le sens


opposé. Consultez la présente section à la page 158.
Vous pouvez aussi spécifier des sous-expressions que vous ne voulez
pas dé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 développer une expression sur un domaine spé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
152 • Chapitre 5: L’évaluation et la simplification

> % 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
intermédiaires en arithmétique modulo. Vous pouvez également écrire vos
propres routines pour expand ; consultez la rubrique ?expand pour plus
de détails.

Regrouper les coefficients de m


eme degré
Une expression comme x2 + 2x + 1 − ax + b − cx2 peut être plus facile à
lire si vous regroupez les coefficients de x2 , x et les constantes à 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 deuxième argument de la commande collect spé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 évalués.
5.1 Manipulations mathématiques • 153

> 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 problème, effectuez d’abord une substitution.


Dans l’exemple précédent, créez une variable remplaç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
154 • Chapitre 5: L’évaluation et la simplification

> 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 à la fois, deux
options s’offrent à vous : employer la forme récursive ou la forme dis-
tribuée. La forme récursive regroupe d’abord les termes autour de la
première variable spécifiée, puis la deuxième, et ainsi de suite. C’est la
forme par dé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 distribuée regroupe les coefficients de toutes les variables en


mê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 présente section à la page 164.

Factoriser des polyn


omes et des fonctions rationnelles
Vous pouvez écrire un polynôme sous forme d’un produit de termes de plus
faible degré. Utilisez la commande factor pour factoriser des polynômes.
> factor( x^2-1 );

(x − 1) (x + 1)

> factor( x^3+y^3 );


5.1 Manipulations mathématiques • 155

(x + y) (x2 − y x + y 2 )

Vous pouvez également factoriser des fonctions rationnelles. La com-


mande factor factorise à la fois le numérateur et le dé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

Spécifier le corps de nombres algébriques La commande factor fac-


torise un polynôme sur l’anneau indiqué par les coefficients. Le polynôme
suivant possède des coefficients entiers ; ainsi, les termes de sa forme fac-
torisée possèdent é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
différence dans le résultat.
156 • Chapitre 5: L’évaluation et la simplification

> 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 étendre explicitement le corps des coefficients en four-


nissant un deuxième argument à 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 également spécifier l’extension en utilisant √ Ici,


√ RootOf.
RootOf(x^2-2) représente une solution à 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 algébrique de nombres.
5.1 Manipulations mathématiques • 157

Factoriser dans des domaines spéciaux Utilisez la commande Factor


pour factoriser une expression sur les entiers modulo p pour un p premier.
La syntaxe est similaire à celle de la commande Expand.
> Factor( x^2+3*x+3 ) mod 7;

(x + 6) (x + 4)

La commande Factor permet également les extensions algé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 détails sur l’algorithme utilisé, la factorisation des
polynômes multivariés ou la factorisation de polynômes sur des corps
algébriques de nombres, consultez la rubrique ?Factor.

Supprimer des exposants rationnels


En général, il est préférable de présenter les expressions rationnelles sans
exposant rationnel au dénominateur. La commande rationalize enlève
les racines du dé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));


158 • Chapitre 5: L’évaluation et la simplification

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 résultat de rationalize est souvent plus long que l’original.

Combiner des termes


La commande combine applique certaines règles de transformation pour
de nombreuses fonctions mathé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^a)^2 );

x(2 a)

Pour voir comment combine permet d’obtenir le résultat, donnez au


paramètre infolevel[combine] une valeur positive.
> infolevel[combine] := 1;

infolevel combine := 1

> expr := Int(1, x) + Int(x^2, x);


5.1 Manipulations mathématiques • 159
 
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 linear
combine: combining with respect to Int
combine: combining with respect to linear
combine: combining with respect to int
combine: combining with respect to linear
combine: combining with respect to Int
combine: combining with respect to linear
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 règles de transforma-


tion en sens inverse. Consultez la section Développer des polyn
omes en
sommes à la page 150.

Forme normale factorisé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-
mérateur et du dénominateur. La commande normal effectue ce processus,
qui mène généralement à 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 );


160 • Chapitre 5: L’évaluation et la simplification
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 deuxième argument, expanded, si vous souhaitez que


normal développe le numérateur et le dénominateur.
> normal( expr, expanded );

x2 − 1
x2 − 2 x

La commande normal agit ré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;
5.1 Manipulations mathématiques • 161

(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 trigonométriques.

Un cas particulier La commande normal peut retourner une expression


sous forme étendue qui n’est pas aussi simple que la forme factorisé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 numérateur et du dé-
nominateur, utilisez la commande factor. Consultez la section 5.1 à la
page 154.
> factor(expr);

(x4 + x3 + x2 + x + 1) (x20 + x15 + x10 + x5 + 1)

Simplifier des expressions


Les résultats des calculs de simplification de Maple peuvent être très com-
pliqués. La commande simplify tente de trouver une expression plus
simple en effectuant une série de manipulations.
> expr := 4^(1/2) + 3;

expr := 4+3
162 • Chapitre 5: L’évaluation et la simplification

> 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 possède des règles de simplification pour les expressions trigo-


nométriques, logarithmiques et exponentielles de même que pour les ex-
pressions contenant des radicaux, des puissances, des expressions RootOf
ainsi que d’autres fonctions spéciales.
Lorsque vous spécifiez une règle particulière de simplification comme
argument à la commande simplify, seule cette règle (ou cette classe de
règles) sera utilisé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 règles de


simplification intégrées.
5.1 Manipulations mathématiques • 163

Simplification avec des hypothèses


Il est possible que Maple n’effectue pas une simplification comme vous
l’entendez ; cela survient lorsque vous connaissez les propriétés spéciales
d’une variable mais que Maple la traite d’une manière plus générale.
> expr := sqrt( (x*y)^2 );

expr := x2 y 2

> simplify( expr );



x2 y 2

L’option assume=propriété indique à la commande simplify d’as-


sumer que toutes les inconnues de l’expression possèdent la propriété.
> simplify( expr, assume=real );

|x y|

> simplify( expr, assume=positive );

xy

Vous pouvez également vous servir de la commande assume pour pla-


cer des hypothè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
rè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
164 • Chapitre 5: L’évaluation et la simplification

Vous pouvez spécifier une ou plusieurs relations accessoires dans un


ensemble ou une liste. La commande simplify considère les équations
données comme des simplifications additionnelles.
Il est également possible de spécifier l’ordre dans lequel simplify
effectue l’opé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


première expression, puis tente d’effectuer une substituion pour les termes
en y 2 ; n’en trouvant aucun, l’exécution est arrêtée.
Dans le second cas, Maple effectue la substitution y 2 = 1 − x2 dans
la première expression, puis tente d’effectuer des substitutions pour les
termes en x2 ; n’en trouvant aucun, l’exécution est arrêtée.
Les manipulations de polynômes en base de Gröbner sont à la base du
fonctionnement de simplify. Pour obtenir davantage d’information sur
cette commande, consultez la rubrique ?simplify,siderels.

Trier des expressions algébriques


Maple affiche les termes d’un polynôme dans l’ordre où le polynôme a
d’abord été créé. Vous pouvez en trier les termes par ordre décroissant de
degré à l’aide de la commande sort.
> poly := 1 + x^4 - x^2 + x + x^3;

poly := 1 + x4 − x2 + x + x3
5.1 Manipulations mathématiques • 165

> sort( poly );

x4 + x3 − x2 + x + 1

Remarquez que sort réorganise les expressions algébriques sur place


en remplaçant le polynôme original par sa copie triée.
> poly;

x4 + x3 − x2 + x + 1

Vous pouvez trier des polynômes multivariés de deux manières : par


degré total ou en ordre lexicographique. Maple utilise par défaut le tri
par degré total ; les termes sont alors réarrangés en ordre décroissant de
degré. Avec ce tri, lorsque deux termes ont le même degré, 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 dé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
166 • Chapitre 5: L’évaluation et la simplification

Vous pouvez également trier l’expression entiè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 données les inconnues au
moment de l’appel à sort dé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 également trier des listes. Consultez la sec-


tion 5.3.

Conversion entre différentes formes


Vous pouvez écrire plusieurs fonctions mathématiques selon diverses
formes é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)!
5.1 Manipulations mathématiques • 167

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 également utiliser convert pour trouver une approxima-


tion fractionnelle à un nombre décimal.
> convert( .3284879342, rational );

19615
59713

Remarquez que les conversions ne sont pas nécessairement ré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 révèle que cette expression est tan(x).


> simplify( % );

sin(x)
cos(x)

Vous pouvez également vous servir de la commande convert pour


effectuer des manipulations structurelles sur des objets Maple. Consultez
la section 5.3.
168 • Chapitre 5: L’évaluation et la simplification

5.2 Les hypothèses


Il existe deux manières d’imposer des hypothèses sur des inconnues. Pour
modifier globalement les propriétés des inconnues, utilisez la commande
assume. Pour effectuer une seule opération avec des hypothèses sur des
inconnues, utilisez la commande assuming. Les commandes assume et
assuming sont expliquées dans les sous-sections suivantes.

La commande assume
Le système d’hypothèses de Maple est un ensemble de routines permettant
de gérer les propriétés des inconnues. La commande assume permet une
meilleure simplification d’expressions symboliques, particulièrement avec
les fonctions retournant plusieurs valeurs comme les racines carrées.
> sqrt(a^2);

a2

Maple ne peut simplifier cette expression, étant donné que le résultat


est différent pour les valeurs positives et négatives de a. Fournir une hy-
pothèse sur la valeur de a permet à Maple de simplifier l’expression.
> assume( a>0 );
> sqrt(a^2);

a~

Utilisez la commande about pour obtenir de l’information sur les hy-


pothèses à 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 hypothèses


supplémentaires sur une inconnue.
> assume(m, nonnegative);
> additionally( m<=0 );
> about(m);

Originally m, renamed m~:


is assumed to be: 0
5.2 Les hypothèses • 169

Plusieurs fonctions font usage des hypothè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 dé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


détaillé de l’activité 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
170 • Chapitre 5: L’évaluation et la simplification

int/indef1: first-stage indefinite integration

e(c x) − 1
lim
x→∞ c

La commande int doit connaı̂tre le signe de c (ou plutô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 ; généralement, pour des


valeurs complexes de x, ln(ex ) est différent de x.
> ln( exp( 3*Pi*I ) );

πI

Ainsi, Maple ne simplifie pas l’expression suivante, à moins de la savoir


correcte, par exemple lorsque x est réel.
> ln(exp(x));

ln(ex )

> assume(x, real);


> ln(exp(x));

x~

Vous pouvez utiliser la commande is pour vérifier directement les


propriétés des inconnues.
5.2 Les hypothè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


négative.
> eq := xi^2 = a;

eq := ξ 2 = a~

> solve( eq, {xi} );

√ √
{ξ = −a~ I}, {ξ = −I −a~}

Pour retirer des hypothèses sur une variable, il suffit d’en désaffecter
le nom. Cependant, l’expression eq renvoie toujours à a~.
> eq;

ξ 2 = a~

Vous devez retirer l’hypothèse sur a à l’intérieur de eq avant


de retirer l’hypothèse sur a. Tout d’abord, retirez les hypothèses sur a à
l’intérieur de eq.
> eq := subs( a=’a’, eq );

eq := ξ 2 = a

Puis, désaffectez a.
172 • Chapitre 5: L’évaluation et la simplification

> a := ’a’;

a := a

Consultez la rubrique ?assume pour obtenir davantage d’information.


S’il ne vous est nécessaire de poser une hypothèse que pour une
seule évaluation, vous pouvez utiliser la commande assuming dé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 hypothèses
sur les inconnues et les équations.

La commande assuming
Pour n’effectuer qu’une seule évaluation avec des hypothèses sur les noms
d’une expression, utilisez la commande assuming. Son utilisation est
équivalente à la procédure consistant à appeler la commande assume,
à évaluer l’expression, puis à retirer les hypothèses sur l’expression et ses
composantes. Cela facilite l’expérimentation de l’évaluation d’une expres-
sion sous différentes hypothè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 évaluer une expression avec une hypothèse sur tous les
noms dans une expression :
5.3 Manipulations structurelles • 173

> sqrt((a*b)^2) assuming positive;

a b~

ou avec des hypothè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 propriété. En général, les doubles deux-points sont utilisés pour
vérifier le type d’un objet. Pour plus d’information, référez-vous à 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 représentation interne d’un
objet plutôt que de travailler avec l’expression comme un objet purement
mathématique. Dans les cas particuliers des listes et des ensembles, choisir
un élément est direct.
> L := { Z, Q, R, C, H, O };

L := {O, R, Z, Q, H, C}

> L[3];

Choisir des éléments de listes et d’ensembles est facile, ce qui rend leur
manipulation aisée. Le concept de ce qui constitue les parties d’une ex-
pression générale est plus difficile. Cependant, plusieurs des commmandes
qui manipulent les listes et les ensembles s’appliquent également aux ex-
pressions générales.
174 • Chapitre 5: L’évaluation et la simplification

Appliquer une fonction à une liste ou un ensemble


Vous pouvez appliquer une fonction ou une commande à chacun des
éléments plutôt qu’à 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 appelée avec plus de deux arguments, les arguments
supplémentaires sont passés à 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 étroitement liée à map. Là où map remplace
séquentiellement le premier argument d’une fonction, map2 remplace le
deuxiè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)]


5.3 Manipulations structurelles • 175

> 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 dérivé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 même utiliser seq conjointement avec map lorsque vous
les appliquez à des sous-éléments. Ici, seq produit une suite en appliquant
la fonction f aux élé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, % );
176 • Chapitre 5: L’évaluation et la simplification

[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, à 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 également agir
sur des expressions générales. Consultez la section Les parties d’une
expression de la page 182.

Choisir des éléments dans une liste ou un ensemble


Vous pouvez choisir certains éléments d’une liste ou d’un ensemble en four-
nissant une fonction booléenne qui détermine les éléments à sélectionner.
La fonction booléenne suivante retourne true si son argument est supé-
rieur à 3.
> large := x -> is(x > 3);

large := x → is(3 < x)

Vous pouvez maintenant utiliser la commande select pour choisir les


éléments dans une liste ou un ensemble qui satisfont à la propriété large.
> L := [ 8, 2.95, Pi, sin(9) ];

L := [8, 2.95, π, sin(9)]


5.3 Manipulations structurelles • 177

> select( large, L );

[8, π]

De façon similaire, la commande remove retire les éléments de L qui


satisfont à la propriété large et affiche comme résultat les éléments res-
tants.
> remove( large, L );

[2.95, sin(9)]

Pour effectuer les deux opérations simultanément, utilisez la com-


mande selectremove.
> selectremove( large, L);

[8, π], [2.95, sin(9)]

Servez-vous de la commande type pour déterminer le type d’une ex-


pression.
> type( 3, numeric );

true

> type( cos(1), numeric );

false

Ici, la syntaxe de select passe le troisième argument, numeric, à la


commande type.
> select( type, L, numeric );

[8, 2.95]

Consultez la section Les parties d’une expression à la page 182 pour


obtenir davantage d’information sur les types de données et sur la manière
d’utiliser select et remove sur des expressions en général.
178 • Chapitre 5: L’évaluation et la simplification

Combiner deux listes


Il est possible de combiner des listes de plusieurs maniè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 élé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 différente, zip retourne une liste
de la longueur de la plus courte.
5.3 Manipulations structurelles • 179

> zip( (x,y) -> x.y, [a,b,c,d,e,f], [1,2,3] );

[a, 2 b, 3 c]

Vous pouvez spécifier un quatrième argument à zip qui lui fait retour-
ner une liste aussi longue que la plus longue des deux listes, en utilisant
le quatrième paramè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 é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 données fondamentale qui
préserve l’ordre des éléments. Les éléments d’une liste demeurent dans le
même ordre que lorsque la liste a été créée. Vous pouvez cependant créer
une copie d’une liste trié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 numérique.
> sort( [1,3,2,4,5,3,6,3,6] );

[1, 2, 3, 3, 3, 4, 5, 6, 6]

La commande sort peut également trier une liste chaı̂nes de ca-


ractères en ordre lexicographique.
> sort( ["Mary", "has", "a", "little", "lamb"] );

[“Mary”, “a”, “has”, “lamb”, “little”]


180 • Chapitre 5: L’évaluation et la simplification

Lorsque vous mé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 à 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 spécifier une fonction booléenne pour définir un ordre


à la liste. Cette fonction booléenne doit avoir deux arguments et retour-
ner true si le premier argument doit être placé avant le second. Vous
pouvez employer cette méthode pour trier une liste de nombres en ordre
décroissant.
> sort( [3.12, 1, 1/2], (x,y) -> evalb( x>y ) );

1
[3.12, 1, ]
2

La commande is sert à 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
5.3 Manipulations structurelles • 181

Vous pouvez également trier des chaı̂nes de caractè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 possède pas de méthode intégrée pour trier des listes mixtes
de chaı̂nes de caractères et de nombres (sauf par adresse machine). Pour
trier une liste mixte de chaı̂nes et de nombres, vous pouvez effectuer les
opérations suivantes.
> big_list := [1,"d",3,5,2,"a","c","b",9];

big _list := [1, “d”, 3, 5, 2, “a”, “c”, “b”, 9]

Créez deux listes à partir de l’originale, l’une contenant des nombres,


et l’autre des chaı̂nes de caractè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 indépendamment.


> list1 := sort(list1);

list1 := [“a”, “b”, “c”, “d”]

> list2 := sort(list2);

list2 := [1, 2, 3, 5, 9]

Finalement, regroupez les deux listes.


182 • Chapitre 5: L’évaluation et la simplification

> sorted_list := [ op(list1), op(list2) ];

sorted _list := [“a”, “b”, “c”, “d”, 1, 2, 3, 5, 9]

La commande sort peut également servir à trier des expressions


algébriques. Consultez la section 5.1.
La présente section, à la page 176, donne davantage d’information à
propos des commandes de cet exemple.

Les parties d’une expression


Pour manipuler les détails d’une expression, vous devez en choisir les
parties individuelles. Trois cas simples pour illustrer cette situation font
appel aux équations, aux intervalles et aux fractions. La commande lhs
sélectionne le côté gauche d’une équation.
> eq := a^2 + b^ 2 = c^2;

eq := a2 + b2 = c2

> lhs( eq );

a2 + b2

La commande rhs, de manière similaire, en sélectionne le côté droit.


> rhs( eq );

c2

Les commandes lhs et rhs fonctionnent également pour les inter-


valles.
> lhs( 2..5 );

> rhs( 2..5 );

> eq := x = -2..infinity;
5.3 Manipulations structurelles • 183

eq := x = −2..∞

> lhs( eq );

> rhs( eq );

−2..∞

> lhs( rhs(eq) );

−2

> rhs( rhs(eq) );

Les commandes numer et denom extraient respectivement le numéra-


teur et le dé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 );


184 • Chapitre 5: L’évaluation et la simplification

x (y 2 − 1 + x)

Considé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 considère expr comme une somme.


> whattype( expr );

Utilisez la commande op pour lister les termes d’une somme ou, en


général, les opérandes d’une expression.
> op( expr );

3, sin(x), 2 cos(x)2 sin(x)

L’expression expr est formée de trois éléments. Utilisez la commande


nops pour compter le nombre d’opérandes d’une expression.
> nops( expr );

Par exemple, vous pouvez choisir le troisième terme de la manière


suivante.
> term3 := op(3, expr);

term3 := 2 cos(x)2 sin(x)

term3 est un produit de trois facteurs.


> whattype( term3 );

> nops( term3 );


5.3 Manipulations structurelles • 185

> op( term3 );

2, cos(x)2 , sin(x)

Obtenez le second facteur de term3 de la manière suivante.


> factor2 := op(2, term3);

factor2 := cos(x)2

C’est une exponentiation.


> whattype( factor2 );

factor2 possède deux opérandes.


> op( factor2 );

cos(x), 2

Le premier opérande est une fonction et ne contient qu’un seul


opérande.
> op1 := op(1, factor2);

op1 := cos(x)

> whattype( op1 );

function

> op( op1 );

x est un symbole.
186 • Chapitre 5: L’évaluation et la simplification

> whattype( op(op1) );

symbol

Puisque vous n’avez pas assigné une valeur à x, il ne contient qu’un


seule opérande, soit lui-même.
> nops( x );

> op( x );

Vous pouvez représenter le résultat de la recherche des opérandes


d’une expression par un graphique appelé arbre des expressions. L’arbre
des expressions de expr ressemble à ceci.
+

3 * sin

x
sin ^ 2

x
cos 2

x
Les opérandes d’une liste ou d’un ensemble sont ses éléments.
> op( [a,b,c] );

a, b, c

> op( {d,e,f} );

e, f, d
5.3 Manipulations structurelles • 187

À la présente section (page 174), on décrit comment la commande map


applique une fonction à tous les éléments d’une liste ou d’un ensemble.
La fonctionnalité de map s’étend aux expressions en général.
> map( f, x^2 );

f(x)f(2)

Les commandes select et remove décrites dans la section 5.3 de la


page 176 fonctionnent également pour des expressions en géné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 possède plusieurs commandes utiles, comme la fonction boolé-


enne dans un appel à select ou remove. La commande has détermine si
une expression contient une sous-expression spécifique.
> has( x*exp(cos(t^2)), t^2 );

true

> has( x*exp(cos(t^2)), cos );

true

Quelques-unes des solutions du système d’équations suivant con-


tiennent des références à 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 )}}
188 • Chapitre 5: L’évaluation et la simplification

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 également choisir ou retirer des sous-expressions par
type. La commande type détermine si une expression est d’un type donné.
> type( 3+x, ‘+‘ );

true

Dans cet exemple, la commande select passe son troisième argument,


‘+‘, à type.
> expr := ( 3+x ) * x^2 * sin( 1+sqrt(Pi) );

expr := (3 + x) x2 sin(1 + π)

> select( type, expr, ‘+‘ );

3+x

La commande hastype dé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 opé-


randes d’une expression qui contient un certain type.
> select( hastype, expr, ‘+‘ );

(3 + x) sin(1 + π)

Si vous êtes intéressé aux sous-expressions d’un certain type plutôt


qu’aux opérandes qui les contiennent, utilisez la commande indets.
5.3 Manipulations structurelles • 189

> indets( expr, ‘+‘ );



{3 + x, 1 + π}

Les deux RootOf contenus dans sol sont de type RootOf. Puisqu’ils
sont identiques, l’ensemble retourné par indets contient seulement un
élément.
> indets( sol, RootOf );

{RootOf(_Z 6 − b2 − a _Z 5 )}

À l’instar de RootOf, toutes les commandes n’ont pas leur propre


type ; vous pouvez cependant utiliser le type structuré specfunc(type,
nom ). Ce type identifie les fonctions appelé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 dérivées d’une
équation diffé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
190 • Chapitre 5: L’évaluation et la simplification

Les opérandes suivants de DE contiennent les dérivé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 possède qu’un seul opérande qui est lui-même une dérivé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 même que ?type,structured pour obtenir
davantage d’information sur les types structurés comme specfunc.

La substitution
Il est souvent nécessaire de substituer une valeur à une variable (en
d’autres termes, d’évaluer une expression en un point). Par exemple, pour
résoudre le problème  Si f (x) = ln(sin(xecos(x) )), trouvez f  (2) , vous
devez substituer la valeur 2 à x dans la dérivée. La commande diff calcule
la dérivé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 à


x dans yprime.
> eval( yprime, x=2 );
5.3 Manipulations structurelles • 191

cos(2 ecos(2) ) (ecos(2) − 2 sin(2) ecos(2) )


sin(2 ecos(2) )

La commande evalf retourne une approximation décimale du résul-


tat.
> evalf( % );

−0.1388047428

La commande effectue des substitutions syntaxiques, et non mathé-


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 êtes cependant limité 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 manières : résoudre la sous-expression
pour une des variables :
> subs( a=3/b, expr );
192 • Chapitre 5: L’évaluation et la simplification
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


algébriques.
> algsubs( a*b=3, expr);

3 c ab

Remarquez que, dans le premier cas, toutes les occurrences de a ont


été remplacées par 3/b, tandis que, dans le deuxième et le troisième cas,
les variables a et b demeurent dans le résultat.
Vous pouvez effectuer plusieurs substitutions à la fois par un seul
appel à 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 à 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 simultanément.
> subs( { x=sqrt(Pi), z=3 }, expr );

3 sin(π) + w
5.3 Manipulations structurelles • 193

Remarquez que, en général, vous devez évaluer explicitement le


résultat d’un appel à subs.
> eval( % );

Utilisez la commande subsop pour remplacer un opérande spécifique


dans une expression.
> expr := 5^x;

expr := 5x

> op( expr );

5, x

> subsop( 1=t, expr );

tx

L’opérande d’ordre zéro est généralement le nom de la fonction.


> expr := cos(x);

expr := cos(x)

> subsop( 0=sin, expr );

sin(x)

La présente section, à la page 182, donne plus de détails sur les


opérandes d’une expression.

Changer le type d’une expression


Vous pouvez trouver nécessaire de convertir une expression dans un autre
type. Considérez la série de Taylor de sin(x).
> f := sin(x);
194 • Chapitre 5: L’évaluation et la simplification

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 sé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 manière similaire, le titre d’un graphique doit être une chaı̂ne, et


non une expression géné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 concatène tous ses arguments pour créer une nou-
velle chaîne.
> ttl := cat( convert( f, string ),
> " and its Taylor approximation ",
> p_txt );
5.3 Manipulations structurelles • 195

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 é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 mathématiques. Consultez la rubrique ?convert pour ob-
tenir davantage d’information à ce sujet.
196 • Chapitre 5: L’évaluation et la simplification

5.4 Les règles d’évaluation


Dans un programme de mathématiques symboliques comme Maple, la
question de l’évaluation occupe une place importante. Lorsque vous as-
signez la valeur y à x, la valeur z à y et la valeur 5 à z, comment x doit-il
être évalué ?

Niveaux d’évaluation
Dans la plupart des cas, Maple effectue une évaluation complète des noms :
lorsque vous utilisez un nom ou un symbole, le logiciel vérifie si ce nom
ou ce symbole possède une valeur assignée. Le cas échéant, Maple rem-
place le nom par la valeur trouvée. Si cette valeur possède elle-même une
valeur assignée, Maple effectue une autre substitution, et ainsi de suite de
manière récursive jusqu’à ce qu’aucune substitution ne soit possible.
> x := y;

x := y

> y := z;

y := z

> z := 5;

z := 5

Maple évalue maintenant x intégralement : il remplace x par y, y par


z et finalement z par 5.
> x;

Vous pouvez utiliser la commande eval pour contrôler le niveau d’é-


valuation d’une expression. Lorsque vous appelez eval avec un seul argu-
ment, eval évalue intégralement son argument.
> eval(x);

5
5.4 Les règles d’évaluation • 197

Un deuxième argument à eval spécifie jusqu’où vous souhaitez évaluer


le premier argument.
> eval(x, 1);

> eval(x, 2);

> eval(x, 3);

Les principales exceptions à la règle de l’évaluation complète sont


les structures de données spéciales comme les tableaux, les matrices et
les procédures, de même que le comportement des variables locales à
l’intérieur d’une procédure.

Évaluation du dernier nom


Les structures de données array, table, matrix et proc possèdent un
comportement d’évaluation spécial appelé é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 arrête à ce point puisque


l’évaluation du dernier nom, z, produirait un tableau, l’un des quatre
types spéciaux de structures.
198 • Chapitre 5: L’évaluation et la simplification

> x;

Maple utilise l’évaluation du dernier nom pour les tableaux, les tables,
les matrices et les procédures pour conserver la représentation compacte
des entrées de tableaux non assignées (par exemple T[3]) et les com-
mandes non évaluées (par exemple sin(x)). Vous pouvez forcer une
évaluation complè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 évaluation complète en utilisant


eval ou print.
> eval(add2);

proc(x, y) x + y end proc

Remarquez qu’une évaluation complète des procédures contenues dans


la bibliothèque de Maple, par défaut, supprime le code de cette procédure.
Pour illustrer cette situation, examinez la commande erfi.
> erfi;

erfi

> eval(erfi);

proc(x : :algebraic) . . . end proc


5.4 Les règles d’évaluation • 199

Assignez à la variable verboseproc de la commande interface la


valeur 2, et essayez à 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 défaut de verboseproc est 1.
200 • Chapitre 5: L’évaluation et la simplification

> interface( verboseproc=1 );

La rubrique d’aide ?interface explique les valeurs permises de


verboseproc et des autres variables d’interface.

Évaluation à un niveau
Les variables locales d’une procédure sont appliquées à l’évaluation à un
niveau : si vous assignez une variable locale, le résultat de l’évaluation est
la valeur la plus récemment assignée directement à cette variable.
> test:=proc()
> local x, y, z;
> x := y;
> y := z;
> z := 5;
> x;
> end proc:
> test();

Comparez cette évaluation à l’exemple similaire présenté à la


page 196. L’évaluation complète à l’intérieur d’une procédure est rare-
ment nécessaire et peut mener à une procédure inefficace. Lorsque vous
désirez obtenir de l’évaluation complète à l’intérieur d’une procédure, uti-
lisez eval.

Commandes avec des règles spéciales d’évaluation


Les commandes assigned et evaln Les fonctions assigned et evaln
évaluent leurs arguments seulement au point où les arguments deviennent
des noms pour la première fois.
> x := y;

x := y

> y := z;

y := z

> evaln(x);

x
5.4 Les règles d’évaluation • 201

La commande assigned vérifie si une valeur a été assignée à un nom.


> assigned( x );

true

La commande seq Pour créer des suites d’expressions, la commande seq


n’évalue pas ses arguments, de manière que si une valeur a été assignée à
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 résoudre ce problème en utilisant les guille-


mets simples.

Emp
echer l’évaluation d’une expression
Le langage Maple supporte l’utilisation des guillemets pour retarder l’éva-
luation d’un niveau. Entourer un nom de guillemets simples (’) empêche
Maple d’évaluer celui-ci.
> i := 4;

i := 4

> i;
202 • Chapitre 5: L’évaluation et la simplification

> ’i’;

Utilisez cette méthode pour éviter le problè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’évaluation complète d’une expression entourée de guillemets sup-


prime un niveau de ces guillemets.
> x := 0;

x := 0

> ’’’x’+1’’;

’’x’ + 1’

> %;

’x’ + 1

> %;
5.4 Les règles d’évaluation • 203

x+1

> %;

Entourer une expression de guillemets retarde l’évaluation, mais n’em-


pêche pas les simplifications automatiques ni les calculs arithmétiques.
> ’1-1’;

> ’p+q-i-p+3*q’;

4q − i

Lorsque vous entourez une simple variable de guillemets simples, le


résultat retourné est le nom de la variable. Vous pouvez employer cette
méthode pour désaffecter une variable.
> x := 1;

x := 1

> x;

> x := ’x’;

x := x

> x;

Cependant, en général, vous devez utiliser evaln.


> i := 4;
204 • Chapitre 5: L’évaluation et la simplification

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 désaffecter a[i].


> evaln( a[i] );

a4

> a[i] := evaln( a[i] );

a4 := a4

Utiliser les variables entouré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 retournée de maniè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 entouré de guillemets afin de vous


assurer de ne pas passer de variable allouée à la procédure. Vous pouvez
éviter d’utiliser les guillemets si vous vous assurez que le nom utilisé n’a
pas de valeur assignée.
5.4 Les règles d’évaluation • 205

> 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 manière simi-


laire.

Concaténation de noms
La concaténation est une manière de former de nouveaux noms de va-
riables basés sur d’autres noms.
> a||b;

ab

L’opérateur de concaténation,  || , dans un nom, entraı̂ne l’évalu-


ation du côté droit de l’opérateur, mais pas celui du côté gauche.
> a := x;

a := x

> b := 2;
206 • Chapitre 5: L’évaluation et la simplification

b := 2

> a||b;

a2

> c := 3;

c := 3

> a||b||c;

a23

Si un nom issu d’une concaténation ne forme pas un seul symbole,


Maple n’évalue pas la concaté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 concaténés pour assigner et créer
des expressions.
5.5 Conclusion • 207

> i := 1;

i := 1

> b||i := 0;

b1 := 0

Ici, les guillemets simples sont né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 évalue a||k à 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 également utiliser la concaté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 équations à la
sélection de parties d’une expression géné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 spécifier vos
propres règles de simplification, ou encore des hypothèses pour spécifier
des propriétés des inconnues.
Vous avez également vu que, dans la plupart des cas, Maple effectue
l’évaluation complète des variables. Il existe cependant quelques excep-
tions, comme l’évaluation du dernier nom pour certaines grandes struc-
tures de données, l’évaluation à un seul niveau des variables locales d’une
procédure ainsi que l’évaluation retardée au moyen des guillemets simples.
208 • Chapitre 5: L’évaluation et la simplification
6 Exemples tirés du calcul
différentiel

Le présent chapitre illustre par quelques exemples la manière dont Maple


vous aide à présenter et à résoudre des problèmes de calcul différentiel. La
première section décrit les concepts élémentaires de la dérivée et de l’in-
tégrale ; la deuxième traite des équations différentielles ordinaires ; enfin,
la troisième section porte sur les équations aux dérivées partielles.

6.1 Calcul différentiel élémentaire


Vous verrez ici plusieurs exemples montrant la manière d’illustrer des
idées et de résoudre des problèmes de calcul différentiel. Le package
Student[Calculus1] contient plusieurs commandes qui s’avèrent par-
ticulièrement utiles dans ce domaine.

La dérivée
La prsente section illustre la signification graphique de la dérivée en tant
que pente de la droite tangente, puis montre comment déterminer l’en-
semble des points d’inflexion d’une fonction.
Définissez la fonction f : x → exp(sin(x)) de la manière suivante.
> f := x -> exp( sin(x) );

f := x → esin(x)

Trouvez la dérivée de f évaluée en x0 = 1.


> x0 := 1;

209
210 • Chapitre 6: Exemples tirés du calcul différentiel

x0 := 1

p0 et p1 sont deux points situé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 sécante passant par p0 et p1 .
> with(Student[Calculus1]):
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 donnée par


> eval( m, h=1 );

esin(2) − esin(1)

La commande evalf nous donne une approximation décimale de ce


résultat.
> evalf( % );

0.162800903

Lorsque h tend vers zéro, les valeurs de la pente de la sécante semblent


converger.
> h_values := seq( NewtonQuotient( f(x), x=1.0, h=1.0/i^2 ),
> i=1..20);
6.1 Calcul différentiel élé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’équation de la pente de la sécante.
> y - p0[2] = m * ( x - p0[1] );

(esin(1+h) − esin(1) ) (x − 1)
y − esin(1) =
h

La commande isolate récrit l’équation sous la forme pente-ordonnée


à l’origine.
> isolate( %, y );

(esin(1+h) − esin(1) ) (x − 1)
y= + esin(1)
h

Vous devez faire de cette équation une fonction.


> secant := unapply( rhs(%), x );

(esin(1+h) − esin(1) ) (x − 1)
secant := x → + esin(1)
h

Vous pouvez maintenant tracer la sécante et la fonction elle-même


sur le même graphique pour différentes valeurs de h. Tout d’abord, vous
devez cré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):

Warning, the name changecoords has been redefined


212 • Chapitre 6: Exemples tirés du calcul différentiel

> 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 zéro, la pente est donné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 réponse est la valeur de f  (x0 ). Pour vous assurer
de ceci, définissez d’abord la fonction f 1 comme étant la dérivée première
de f . Puisque f est une fonction, utilisez D. L’opérateur D calcule la dérivée
d’une fonction, alors que diff calcule la dérivé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 égale à la limite ci-
dessus.
> f1(x0);

esin(1) cos(1)
6.1 Calcul différentiel élémentaire • 213

Dans le cas présent, la dérivée seconde existe.


> diff( f(x), x, x );

−sin(x) esin(x) + cos(x)2 esin(x)

Encore une fois, définissez la fonction f 2 comme la dérivé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 même que ses dérivées


première et seconde, vous pouvez remarquer que f augmente lorsque f 1
est positive, et que la concavité de f est tournée vers le bas lorsque f 2
est négative.
> plot( [f(x), f1(x), f2(x)], x=0..10 );

0 2 4 6 8 10
x
–1

–2

Le graphique de f possède un point d’inflexion là où la dérivé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 ) };
214 • Chapitre 6: Exemples tirés du calcul différentiel

   
 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 réelles sont d’intérêt. Vous pou-
vez utiliser la commande select pour choisir les constantes ré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 tracé précé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 ) };
6.1 Calcul différentiel élémentaire • 215

  

    √ 
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 périodique, elle possède une infinité de points
d’inflexion. Vous pouvez les obtenir tous en déplaç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 sé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 près de x = a.
> f := x -> exp( sin(x) );

f := x → esin(x)

> a := Pi;
216 • Chapitre 6: Exemples tirés du calcul différentiel

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 série en un polynô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, où ξ est un nombre compris entre x et a. La dérivée sixiè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)
6.1 Calcul différentiel élémentaire • 217

L’usage de l’opérateur séquentiel $ dans la commande précédente vous


permet de raccourcir l’appel de la fonction. Sans cet opérateur, vous de-
vriez entrer , x six fois pour calculer la dérivée d’ordre 6. Définissez la
fonction f 6 comme étant cette dérivé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 précé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
218 • Chapitre 6: Exemples tirés du calcul différentiel

Pour déterminer l’erreur exacte, vous devez effectuer une analyse


complète de l’expression err dans les deux régions fermé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 régions.
> with(plots): with(plottools):

Warning, the name changecoords has been redefined


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 dérivées partielles de err vous permettent de déterminer les ex-


trémums de err à l’intérieur de ces deux régions. Vous devez alors étudier
err aux bords du domaine. Les dérivé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);
6.1 Calcul différentiel élémentaire • 219

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 dérivées partielles sont nulles au point critique.
> sol := solve( {err_x=0, err_xi=0}, {x, xi} );

sol := {x = π, ξ = ξ}

L’erreur est é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 dérivée partielle err_xi est nulle en un point critique situé sur


l’une des deux frontières x = 2 ou x = 4.
> sol := { solve( err_xi=0, xi ) };
220 • Chapitre 6: Exemples tirés du calcul différentiel

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 = 1)2 − 1)), arctan(
RootOf(%1, index = 5),
RootOf(_Z 2 + RootOf(%1, index = 5)2 − 1)), arctan(
RootOf(%1, index = 2),
RootOf(_Z 2 + RootOf(%1, index = 2)2 − 1)), arctan(
RootOf(%1, index = 6),
RootOf(_Z 2 + RootOf(%1, index = 6)2 − 1)), arctan(
RootOf(%1, index = 3),
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 recommandé de vérifier l’ensemble solution en traç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
6.1 Calcul différentiel élémentaire • 221

Deux solutions de err_xi=0 semblent exister entre 2 et 4 là où solve


n’en a trouvé aucune : π/2 est inférieur à 2. Vous devez donc utiliser des
méthodes numériques. Si x = 2, alors ξ doit être situé dans l’intervalle
situé 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 à l’ensemble des valeurs critiques.


> critical := critical union {%};

critical := {0, 0.07333000221 (2 − π)6 }

Si x = 4, alors ξ doit être situé 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 }
À la frontière ξ = a, l’erreur est
> B := eval( err, xi=a );
222 • Chapitre 6: Exemples tirés du calcul différentiel
1
B := − (x − π)6
240

La dérivé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 }
À la dernière frontiè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
+ 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) )(x − π)6
Encore une fois, vous devez trouver le point où la dérivée s’annule.
> B1 := diff( B, x );
6.1 Calcul différentiel élémentaire • 223

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)
+ 245 sin(x) cos(x)3 esin(x) − 35 cos(x)5 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)
+ 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) )(x − π)5
> sol := { solve( B1=0, x ) };

sol := {π}

Il est bon de vérifier la solution en traç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 à nouveau re-
courir aux méthodes numériques.
> fsolve( B1=0, x, 2.1..2.3 );

2.180293062

Ajoutez cette solution numérique à l’ensemble des solutions symbo-


liques.
224 • Chapitre 6: Exemples tirés du calcul différentiel

> sol := sol union { % };

sol := {2.180293062, π}

L’ensemble suivant contient les erreurs extrêmes à la frontiè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} ) };
6.1 Calcul différentiel élémentaire • 225

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
+ 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) )(4 − π)6 , (−sin(4) esin(4)
720
+ 16 cos(4)2 esin(4) − 15 sin(4)2 esin(4) + 75 sin(4) cos(4)2 esin(4)
− 20 cos(4)4 esin(4) − 15 sin(4)3 esin(4)
+ 45 sin(4)2 cos(4)2 esin(4) − 15 sin(4) cos(4)4 esin(4)
1
+ cos(4)6 esin(4) )(2 − π)6 , (−sin(4) esin(4)
720
+ 16 cos(4)2 esin(4) − 15 sin(4)2 esin(4) + 75 sin(4) cos(4)2 esin(4)
− 20 cos(4)4 esin(4) − 15 sin(4)3 esin(4)
+ 45 sin(4)2 cos(4)2 esin(4) − 15 sin(4) cos(4)4 esin(4)
+ cos(4)6 esin(4) )(4 − π)6 }
Vous devez maintenant déterminer le maximum en valeur absolue des
éléments de critical. Tout d’abord, appliquez la commande abs aux
éléments de critical.
> map( abs, critical );
226 • Chapitre 6: Exemples tirés du calcul différentiel

{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)
+ 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
+ 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) )(4 − π)6 , − (−sin(4) esin(4)
720
+ 16 cos(4)2 esin(4) − 15 sin(4)2 esin(4) + 75 sin(4) cos(4)2 esin(4)
− 20 cos(4)4 esin(4) − 15 sin(4)3 esin(4)
+ 45 sin(4)2 cos(4)2 esin(4) − 15 sin(4) cos(4)4 esin(4)
1
+ cos(4)6 esin(4) )(2 − π)6 , − (−sin(4) esin(4)
720
+ 16 cos(4)2 esin(4) − 15 sin(4)2 esin(4) + 75 sin(4) cos(4)2 esin(4)
− 20 cos(4)4 esin(4) − 15 sin(4)3 esin(4)
+ 45 sin(4)2 cos(4)2 esin(4) − 15 sin(4) cos(4)4 esin(4)
+ cos(4)6 esin(4) )(4 − π)6 }
Trouvez ensuite l’élé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
6.1 Calcul différentiel élémentaire • 227

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 réelle demeure bien en-déçà de l’es-


timation de l’erreur.

L’intégrale
L’intégrale d’une fonction peut être considérée comme une mesure de l’aire
comprise entre l’axe des x et la courbe de cette fonction. La définition
de l’intégrale de Riemann repose sur cette interprétation graphique de
l’inté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 paramè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 évaluée sur le coin gauche
de chacune d’entre elles.
> with(Student[Calculus1]):

> ApproximateInt( f(x), x=0..10, method=left, partition=6,


> output=plot);
228 • Chapitre 6: Exemples tirés du calcul différentiel

AnApproximationoftheIntegralof
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’améliore à mesure que plus de boı̂tes sont


utilisées. Augmentez le nombre de boı̂tes jusqu’à 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 créer une animation de la
somme de Riemann.
6.1 Calcul différentiel élémentaire • 229

> 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, à mesure que le nombre de boı̂tes augmente, le résultat


se rapproche de l’intégrale définie.
> Int( f(x), x=0..10 );
 10
1
+ sin(x) dx
0 2

La valeur de l’intégrale est


> value( % );

6 − cos(10)

en nombres décimaux, cette valeur est approximativement


> evalf( % );

6.839071529

L’intégrale indéfinie de f est


> Int( f(x), x );

1
+ sin(x) dx
2
230 • Chapitre 6: Exemples tirés du calcul différentiel

> value( % );

1
x − cos(x)
2

Définissez la fonction F comme étant l’inverse de la dérivée.


> F := unapply( %, x );

1
F := x → x − cos(x)
2

Choisissez la constante d’inté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) ] );
AnApproximationoftheIntegralof
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)
6.1 Calcul différentiel élémentaire • 231

En spécifiant method = right ou method = midpoint lorsque vous


utilisez la commande ApproximateInt, vous pouvez dessiner et addition-
ner des boı̂tes évaluées en leur coin droit ou en leur point milieu.

Dérivées partielles mixtes


Cette section décrit l’opérateur différentiel D et donne un exemple d’une
fonction dont les dérivées partielles mixtes sont différentes.
Considé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 définie à 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 zéro lorsque r tend vers zé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 continuité à l’origine en la


définissant égale à zéro en ce point.
> f(0.,0.) := 0;
232 • Chapitre 6: Exemples tirés du calcul différentiel

f(0., 0.) := 0

L’affectation précédente ajoute une entrée dans la table de rappels


(en anglais remember table) de Maple. Voici le graphique de f .
> plot3d( f, -3..3, -3..3 );

La dérivée partielle de f par rapport à son premier paramè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 à l’origine.


> fx(0,0);

Error, (in fx) division by zero

Vous devez donc utiliser la définition de la dérivée exprimé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) );
6.1 Calcul différentiel élémentaire • 233

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 zéro, |fx (x, y) −
fx (0, 0)| tend également vers zé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).


Symétriquement, les mêmes arguments s’appliquent à la dérivée de f
par rapport à son second paramè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 dérivée seconde mixte de f .


> fxy := D[1,2](f);
234 • Chapitre 6: Exemples tirés du calcul différentiel

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 à l’origine.
> fxy(0,0);

Error, (in fxy) numeric exception: division by zero

La définition de la dérivé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 dérivé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
À l’origine, vous devez utiliser la définition de la dérivé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 Équations différentielles ordinaires • 235

Remarquez que les deux dérivées partielles mixtes sont différentes à


l’origine.
> fxy(0,0) <> fyx(0,0);

−1 = 1

> evalb( % );

true

Les dérivées partielles mixtes sont égales seulement si elles sont conti-
nues. En traç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 à résoudre plusieurs autres problèmes de calcul


différentiel élémentaire. La rubrique ?Student[Calculus1] est une bonne
source de référence.

6.2 Équations différentielles ordinaires


Maple dispose de toute une gamme d’outils permettant de résoudre, de
manipuler et de tracer le graphique d’équations différentielles ordinaires
et de systèmes d’équations différentielles.
236 • Chapitre 6: Exemples tirés du calcul différentiel

La commande dsolve
La commande la plus utilisée pour étudier le comportement des équations
différentielles ordinaires (EDO) dans Maple est dsolve. Vous pouvez uti-
liser cet outil polyvalent pour obtenir à la fois des solutions exactes et des
solutions numériques pour un grand nombre d’EDO. La syntaxe de base
de dsolve est la suivante.

dsolve(eqns, vars )

Ici, eqns représente un ensemble d’équations différentielles et de valeurs


initiales, et vars représente l’ensemble de variables pour lesquelles on sou-
haite résoudre.
Voici une équation diffé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}


6.2 Équations différentielles ordinaires • 237

Pour spécifier des conditions initiales pour la dérivée d’une fonction,


utilisez la notation suivante.

D(fcn )(var_valeur ) = valeur


(D@@n )(fcn )(var_valeur ) = valeur

La notation D correspond à la dérivée. La notation D@@n représente la


dérivée d’ordre n. Voici une équation différentielle et des conditions ini-
tiales requérant la dérivé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 paramétrique,


[x=f(_T), y(x)=g(_T)], où _T est un paramètre.

L’option explicit Maple peut retourner la solution d’une équation


diffé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)} );


238 • Chapitre 6: Exemples tirés du calcul différentiel

 
y(x)
1
{y(x) = _C1 }, d_a − x − _C2 = 0
_a ln(_a) + _C1

Utilisez l’option explicit pour indiquer à Maple de chercher une


solution explicite du premier ré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 être en mesure de
trouver une solution explicite.
Il existe également une option implicit pour forcer Maple à donner
ses résultats sous forme implicite.

L’option method=laplace Il est souvent possible de réduire la com-


plexité d’un problème en utilisant les transformées de Laplace. Les trans-
formées font correspondre à une équation différentielle une équation algé-
brique, beaucoup plus simple à résoudre. La difficulté de cette méthode
réside dans la transformation des équations au nouveau domaine et par-
ticulièrement la transformation des solutions sous leur ancienne forme.
La méthode des transformées de Laplace peut gérer des EDO linéaires
d’ordre arbitraire, de même que certains cas d’EDO linéaires à coefficients
non constants, à supposer que Maple puisse trouver les transformées.
Cette méthode fonctionne également avec les systèmes d’équations cou-
plées.
Considérons le problème de dynamique classique suivant. Deux poids
de masses m et αm reposent sur un plan sans frottement et sont reliés par
un ressort dont la constante de rappel est k. Quelles sont les trajectoires
de chaque poids si le premier est sujet à une force ponctuelle unitaire u(t)
en t = 1 ?
Définissons tout d’abord les équations différentielles qui s’appliquent
au problème. La deuxième loi de Newton gouverne le mouvement du pre-
mier poids : la masse m multipliée par l’accélération doit être égale à
la somme des forces appliquées sur le premier poids, incluant la force
extérieure u(t).
6.2 Équations différentielles ordinaires • 239

> 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 mê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 à 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

Résolvez le problème en utilisant la méthode de la transformée de


Laplace.
> dsolve( {eqn1, eqn2, ini}, {x[1](t), x[2](t)},
> method=laplace );
240 • Chapitre 6: Exemples tirés du calcul différentiel


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 + α)
Évaluez le résultat en fixant des valeurs pour les constantes.
> ans := eval( %, {alpha=1/10, m=1, k=1} );
6.2 Équations différentielles ordinaires • 241

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 précédente en deux fonctions,
y1 (t) et y2 (t), de la manière suivante. Tout d’abord, é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
242 • Chapitre 6: Exemples tirés du calcul différentiel

Vous pouvez également effectuer les deux étapes en mê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

Plutôt que d’appliquer dsolve(..., method=laplace), vous pouvez


utiliser la transformée de Laplace à la main. Le package inttrans définit
la transformée de Laplace et son inverse (de même que plusieurs autres
transformées intégrales).
> with(inttrans);

[addtable, fourier , fouriercos , fouriersin, hankel , hilbert ,


invfourier , invhilbert , invlaplace, invmellin, laplace,
mellin, savetable]
Les transformées de Laplace des équations diffé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
6.2 Équations différentielles ordinaires • 243

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))
Évaluez l’ensemble formé des deux transformé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 résoudre cet ensemble d’équations algébriques
pour les transformé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 résolu le problème algébrique ; vous devez maintenant prendre
la transformée inverse de Laplace pour en extraire les fonctions x1 (t) et
x2 (t) .
> invlaplace( %, s, t );
244 • Chapitre 6: Exemples tirés du calcul différentiel

 
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 + α)
Évaluez-les en fixant des valeurs pour les constantes.
> eval( %, {alpha=1/10, m=1, k=1} );
6.2 Équations différentielles ordinaires • 245

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 même solution que par
la méthode précédente.

L’option type=series La méthode des séries pour résoudre des équa-


tions différentielles consiste à trouver une fonction symbolique approximée
des équations de la manière suivante. Maple trouve d’abord une ap-
proximation des équations sous forme de série. Il résout ensuite cette
approximation de manière symbolique au moyen de méthodes exactes.
Cette technique s’avère utile lorsque les algorithmes standard de Maple
ne suffisent pas à la tâche et qu’une solution symbolique est tout de même
préférable à une solution purement numérique. La méthode des séries est
souvent d’un grand secours avec les EDO non linéaires ou de grand ordre.
Lorsque Maple applique la méthode des séries, il assume qu’il existe
une solution de la forme ∞ 

c i
x ai x
i=0

où c est un nombre rationnel.


Considérez l’équation diffé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 à Maple de résoudre l’équation.


246 • Chapitre 6: Exemples tirés du calcul différentiel

> 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-
lynô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
diffé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);


6.2 Équations différentielles ordinaires • 247

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 méthodes des séries pour la ré-
solution des EDO soient bien comprises et adéquates pour trouver des
approximations justes de la variable dépendante, elles présentent cepen-
dant certaines limitations. Pour produire un résultat, la série résultante
doit converger ; de plus, Maple doit calculer plusieurs dérivées dans le pro-
cessus de recherche de la solution, ce qui peut s’avérer coûteux en temps
comme en mémoire. Pour ces raisons, des solveurs numériques alternatifs
ont été conçus.
Voici une équation différentielle et une condition initiale.

> eq := x(t) * diff(x(t), t) = t^2;

d
eq := x(t) ( x(t)) = t2
dt
248 • Chapitre 6: Exemples tirés du calcul différentiel

> ini := x(1) = 2;

ini := x(1) = 2

Le résultat de la commande dsolve avec l’option numeric est une procé-


dure qui retourne une liste d’équations.
> sol := dsolve( {eq, ini}, {x(t)}, type=numeric );

sol := proc(rkf45 _x ) . . . end proc

La solution satisfait à 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 particulière de la


liste des équations.
> eval( x(t), sol(1) );

2.

Vous pouvez également créer une paire ordonnée.


> eval( [t, x(t)], sol(0) );

[0, 1.82574790049820024]

Le package plots contient une commande, odeplot, permettant de


tracer le résultat de dsolve( ..., type=numeric).
> with(plots):

> odeplot( sol, [t, x(t)], -1..2 );


6.2 Équations différentielles ordinaires • 249

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 systè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 procédure de solution retourne une liste de


trois é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);
250 • Chapitre 6: Exemples tirés du calcul différentiel

[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 méthodes numériques. Il
n’existe pas de règles universelles permettant de prévenir ces effets ; ainsi,
aucun logiciel ne peut anticiper toutes les conditions. La solution consiste
à utiliser l’option startinit pour indiquer à la commande dsolve (ou
plutôt à la procédure retournée par dsolve) de commencer à la valeur
initiale pour chaque calcul en un point (x, y(x)).
Vous pouvez spécifier l’algorithme que dsolve(..., type=numeric)
doit utiliser en résolvant une équation différentielle. Reportez-vous à la
rubrique ?dsolve,numeric.
6.2 Équations différentielles ordinaires • 251

Un exemple : les séries de Taylor


Dans sa forme générale, une solution d’une EDO générée par une méthode
de séries demande la formation d’une série de Taylor autour de t = 0
pour une certaine fonction f (t). Vous devez ainsi obtenir et manipuler
les dérivées d’ordre supérieur de cette fonction, soit f  (t), f  (t), f  (t) et
ainsi de suite.
Une fois les dérivées ainsi obtenues, vous pouvez les remplacer dans
la représentation de f (t) en sé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, considérez la loi du refroidissement de Newton :
dθ 1
= − (θ − 20), θ(0) = 100.
dt 10
En utilisant l’opérateur D, vous pouvez facilement introduire l’é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 première étape consiste à obtenir le nombre requis de dérivées


d’ordre supérieur. Déterminez ce nombre en fonction de l’ordre de la série
de Taylor. Si vous utilisez la valeur par défaut de la variable Order fournie
par Maple,
> Order;

vous devez générer des dérivées jusqu’à l’ordre


252 • Chapitre 6: Exemples tirés du calcul différentiel

> dev_order := Order - 1;

dev _order := 5

Vous pouvez maintenant utiliser seq pour générer une suite des déri-
vées d’ordre supé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 dérivée cinquième est une fonction de la dérivée quatrième, la
dérivée quatrième est une fonction de la dérivée troisième, et ainsi de
suite. Ainsi, si vous effectuez des substitutions par rapport à S, vous
pouvez exprimer toutes les dérivées comme des fonctions de theta. Par
exemple, le troisième élément de S est le suivant :
> S[3];

1
(D(3) )(θ) = − (D(2) )(θ)
10

En remplaçant par rapport à S sur le côté droit de l’égalité, on ob-


tient :
> lhs(%) = subs( S, rhs(%) );

1 1
(D(3) )(θ) = − θ+
1000 50

Pour effectuer cette substitution sur toutes les dérivées à la fois, uti-
lisez la commande map.
> L := map( z -> lhs(z) = eval(rhs(z), {S}), [S] );
6.2 Équations différentielles ordinaires • 253

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 évaluer les dérivé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
Générez maintenant la sé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 dérivées dans la sé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
Évaluez maintenant les séries aux conditions initiales et convertissez-
les en polynôme.
> eval( %, ini );
254 • Chapitre 6: Exemples tirés du calcul différentiel
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 réponse.


> plot(p, t=0..30);

100
80
60
40
20

0 5 10 15 20 25 30
t
–20

Cet exemple particulier possè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 série obtenue à la solution


exacte.
> plot( [p, q], t=0..30 );
6.2 Équations différentielles ordinaires • 255

100
80
60
40
20

0 5 10 15 20 25 30
t
–20

Plutôt que de calculer la sé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 à trouver


Dans certains cas, il peut être impossible d’exprimer la solution d’une
EDO linéaire explicitement. Dans ce cas, la commande dsolve peut re-
tourner des solutions contenant la structure de données DESol. DESol
est une expression représentant la solution d’une équation différentielle
sans la calculer explicitement. Ainsi, DESol est similaire à RootOf, qui
représente les racines d’une expression. Cela vous permet de manipuler
l’expression résultante de maniè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)} );
256 • Chapitre 6: Exemples tirés du calcul différentiel


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 méthode sur l’élément DESol
lui-même. Par exemple, trouvez une approximation sous forme de sé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 également avec DESol.

Tracer le graphique d’équations différentielles ordinaires


Plusieurs équations différentielles ne peuvent être résolues analytique-
ment. Dans ces cas, il peut ê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 résoudre cette EDO analytiquement au


moyen de dsolve.
6.2 Équations différentielles ordinaires • 257

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


La commande dsolve n’a rien retourné, indiquant ainsi qu’elle ne pouvait
trouver de solution. Essayez alors les méthodes de Laplace.
> dsolve( {ode1, ic1}, {y(t)}, method=laplace );
Encore une fois, dsolve n’a pas trouvé de solution. Puisque l’usage de
dsolve s’est avéré infructueux, essayez la commande DEplot qui se trouve
dans le package DEtools.
> with(DEtools):
DEplot est un traceur général d’EDO que vous pouvez utiliser en suivant
la syntaxe ci-dessous :

DEplot( ode, dep-var, intervalle, [ini-conds ] )

Ici, ode est l’équation différentielle que vous souhaitez tracer, dep-var est
la variable dépendante, intervalle est le domaine de la variable indépen-
dante et ini-conds représente la liste des conditions initiales.
Voici un graphique de la fonction satisfaisant à la fois à l’équation
diffé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 spécifiant une échelle (stepsize)


plus fine.
> DEplot( ode1, y(t), 0..20, [ [ ic1 ] ], stepsize=0.2 );
258 • Chapitre 6: Exemples tirés du calcul différentiel

0.8

y(t) 0.6

0.4

0.2
0 5 10 15 20
t

Si vous spé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 également tracer les solutions d’un ensemble d’équations


diffé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
6.2 Équations différentielles ordinaires • 259

> 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 système {eq1, eq2} possède deux variables dépendantes, x(t) et


y(t) ; vous devez donc donner une liste de variables dé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 génère également un champ de vecteurs (ainsi


qu’illustré ci-dessus) dès qu’il est utile de le faire. Consultez la rubrique
?DEtools,DEplot pour obtenir davantage de détails sur la manière de
tracer des EDO.
DEplot3d est la version tridimensionnelle de DEplot. La syntaxe de
base de DEplot3d est similaire à celle de DEplot. Consultez la rubrique
?DEtools,DEplot3d pour obtenir plus de détails. Voici un graphique tri-
dimensionnel du système tracé en deux dimensions précédemment.
> DEplot3d( {eq1, eq2}, [x(t), y(t)], -5..5,
> [ [ini1], [ini2] ] );
260 • Chapitre 6: Exemples tirés du calcul différentiel

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 système de trois équations


diffé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 système d’équations


différentielles {eq1, eq2, eq3}, une solution pour chaque liste de valeurs
initiales.
6.2 Équations différentielles ordinaires • 261

> 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 équation


Dans plusieurs situations pratiques, les coefficients d’une solution à un
système sont discontinus. Maple propose plusieurs manières par lesquelles
il est possible de décrire un système en termes d’EDO et d’inclure, de
manière significative, des descriptions de ces coefficients discontinus.

La fonction de Heaviside La fonction de Heaviside permet de modéliser


des coefficients retardés ou définis par morceaux. Vous pouvez utiliser
Heaviside avec dsolve pour trouver les solutions à la fois numé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( % );
262 • Chapitre 6: Exemples tirés du calcul différentiel

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

Résolvez la même équation numériquement.


> sol1 := dsolve({eq, ini}, {y(t)}, type=numeric);

sol1 := proc(rkf45 _x ) . . . end proc

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
6.2 Équations différentielles ordinaires • 263

La fonction Delta de Dirac De maniè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 numérique ne considère pas la valeur non nulle


de Dirac(0).
> sol2 := dsolve({eq, ini}, {y(t)}, type=numeric);

sol2 := proc(rkf45 _x ) . . . end proc


264 • Chapitre 6: Exemples tirés du calcul différentiel

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


solution numé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 définies par morceaux La commande piecewise vous permet


de construire des fonctions compliquées par l’approximation de certaines
de ses sections par des fonctions analytiques, puis en regroupant ces mul-
tiples approximations pour représenter la fonction complè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 dès qu’une condition retourne la valeur true.
> plot(f, 0..3);
6.2 Équations différentielles ordinaires • 265

0.8

0.6

0.4

0.2

0 0.5 1 1.5 2 2.5 3

Ainsi, vous pouvez utiliser cette fonction dé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

> sol3 := dsolve({eq, ini}, {y(t)}, type=numeric);

sol3 := proc(rkf45 _x ) . . . end proc

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


tracer le résultat.
> with(plots, odeplot):
> odeplot( sol3, [t, y(t)], 0..4 );

y5

3
0 1 2 3 4
t
266 • Chapitre 6: Exemples tirés du calcul différentiel

Le package DEtools contient plusieurs commandes vous permettant


d’examiner, de manipuler, de tracer et de résoudre des équations différen-
tielles. Consultez la rubrique ?DEtools pour plus de détails.

6.3 Équations aux dérivées partielles


En général, les équations aux dérivées partielles (EDP) sont très difficiles à
résoudre. Maple fournit plusieurs commandes permettant de résoudre, de
manipuler et de tracer les EDP. Certaines de ces commandes se trouvent
dans la bibliothèque standard, mais la plupart d’entre elles sont situées
dans le package PDEtools.

La commande pdsolve
La commande pdsolve permet de résoudre plusieurs équations aux
dérivées partielles. La syntaxe de base de la commande pdsolve est la
suivante :

pdsolve( pde, var )

Ici, pde est l’équation aux dérivées partielles et var est la variable pour
laquelle on souhaite résoudre.
Voici une é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 résoudre pour u(x,t). Chargeons d’abord en mé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 Équations aux dérivé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] );
268 • Chapitre 6: Exemples tirés du calcul différentiel

Changer la variable dépendante dans une EDP


Voici l’é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 suggérer à Maple une piste à
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 résultat est correct, mais difficile à lire.
De manière alternative, vous pouvez spécifier à pdsolve d’utiliser une
séparation de variables (sous forme de produit, ‘*‘) et ensuite de résoudre
l’EDO ré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)

Évaluez la solution en des valeurs spécifiques pour les constantes.


> S := eval( rhs(sol), {_C3=1, _C1=1, _C2=1, k=1, _c[1]=1} );
6.3 Équations aux dérivé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 être avisé de vérifier la solution avec l’é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’équations aux dérivées partielles


Les solutions de plusieurs EDP peuvent être tracées grâce à 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 indépendante, ini est une courbe
paramétrique de l’espace tridimensionnel de paramètre s et intervalle est
le domaine de s.
270 • Chapitre 6: Exemples tirés du calcul différentiel

Considérez cette équation aux dérivé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 donnée par z = 1 + y 2 comme condition initiale,


c’est-à-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 caractéristiques de


base. La courbe des conditions initiales est ici plus facile à distinguer.
> PDEplot( pde, u(x,y), ini, s=-2..2, basechar=only );

u(x,y)
1
–2 –2
y x
2 2
6.4 Conclusion • 271

L’option basechar=true indique à PDEplot de dessiner à la fois les


courbes caractéristiques et la surface, de même que la courbe des condi-
tions initiales qui est toujours pré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 é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 démontré l’utilité de Maple lorsque vient le temps
d’étudier et de résoudre des problèmes faisant usage du calcul différentiel.
Vous avez vu comment Maple peut illustrer des concepts comme la dérivée
et les intégrales de Riemann, comment Maple vous aide à analyser le
272 • Chapitre 6: Exemples tirés du calcul différentiel

terme d’erreur d’une approximation de Taylor de même que sa puissance


dans la résolution et la manipulation, tant symbolique que numérique,
des équations différentielles et des équations aux dérivées partielles.
7 Entrées et sorties

Vous pouvez effectuer la majeure partie de votre travail à l’intérieur des


feuilles de calcul de Maple : calculer, tracer des fonctions et documenter
les résultats. Cependant, il est possible qu’à un certain moment vous de-
viez importer des données ou exporter des résultats pour interagir avec
une autre personne ou un autre logiciel. Les données peuvent être des me-
sures expérimentales ou des nombres générés par d’autres programmes.
Une fois les données importées dans Maple, vous pouvez utiliser les ca-
pacités graphiques du logiciel pour visualiser les résultats et les capacités
algébriques pour construire ou examiner un modèle mathématique.
Maple propose plusieurs manières d’importer et d’exporter des don-
nées numériques brutes et des graphiques. Il présente les résultats
algébriques et numériques dans des formats compatibles à leur utilisa-
tion sous FORTRAN ou C, ou le système de typographie mathématique
LATEX. Vous pouvez même exporter une feuille de calcul entière en un
fichier texte (pour inclusion dans un courriel) ou sous forme d’un docu-
ment LATEX. Vous pouvez couper et coller des résultats et exporter des
expressions isolées ou des feuilles entières.
Le pré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 système de fichiers et avec d’autres
logiciels.

7.1 Lire des fichiers


On utilise généralement la lecture de fichiers dans Maple pour deux rai-
sons : pour obtenir des données et pour récupérer une liste de commandes
Maple enregistrées dans un fichier.

273
274 • Chapitre 7: Entrées et sorties

La première situation survient généralement dans le cas de données


expérimentales. Vous pouvez sauvegarder les nombres en les séparant par
des espaces et des sauts de ligne dans un fichier texte, puis les faire lire
par Maple pour les étudier. Vous pouvez très facilement effectuer ces
opérations en utilisant respectivement les commandes ExportMatrix et
ImportMatrix.
Dans la seconde situation, on cherche à lire des commandes Maple se
trouvant dans un fichier texte. Vous recevez peut-être une feuille de calcul
sous format texte, ou vous écrivez une procédure Maple en utilisant votre
éditeur de texte favori et en le sauvegardant dans un fichier texte avant
de l’exécuter. Pour ce faire, vous pouvez couper et coller des commandes
dans Maple ou encore utiliser la commande read. La présente section
discute de cette seconde option.

Lire des colonnes de nombres depuis un fichier


Maple manipule les données aisément, mais lorsque ces dernières sont
générées hors du logiciel, vous devez préalablement les importer avant de
les manipuler. Très souvent, ces données externes sont stocké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 maniè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 caractère qui délimite les entrées. La
valeur par défaut de chaı̂ne est un caractère de tabulation représenté par
"\t". Dans le fichier data.txt, les entrées sont séparé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-


sième colonne en fonction de la première. Utilisez la commande convert
pour choisir les première et troisième entré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 sélectionner la seconde colonne de nombres, vous devez tenir


compte du fait que L[5,2] est le second nombre de la cinquième sous-
liste.
> L[5,2];

−0.6536436209

Les données souhaitées sont donc les suivantes.


276 • Chapitre 7: Entrées et sorties

> L[ 1..-1, 2 ];
 
1
 0.5403023059 
 
 −0.4161468365 
 
 −0.9899924966 
 
 −0.6536436209 
 
 0.2836621855 
0.9601702867

Convertissons ces donné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’écrire des programmes Maple
dans un fichier texte au moyen de leur é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 exécute les com-
mandes et affiche les résultats dans votre feuille de calcul, mais il ne place
pas, par dé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 résultats, mais pas les com-
mandes.
> read "ks.tst";


n
(2 β)!
S := n → binomial(n, β) ( − β! β)

β=1

1024937361666644598071114328769317982974

Lorsque vous fixez la valeur de la variable interface echo à 2, Maple


insè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, β) ( − β! β)

β=1

> S( 19 );

1024937361666644598071114328769317982974

La commande read peut également lire des fichiers dans le format


interne de Maple ; consultez la section 7.2.
278 • Chapitre 7: Entrées et sorties

7.2 Écrire des données dans un fichier


Après avoir utilisé Maple pour effectuer un calcul, vous pouvez enregistrer
le résultat dans un fichier. Vous pouvez traiter le résultat ultérieurement,
avec Maple ou avec un autre programme.

Écrire des colonnes de données numériques dans un fichier


Si le résultat d’un calcul Maple est une longue liste ou un grand tableau
de nombres, vous pouvez le convertir en une matrice et écrire les nombres
dans un fichier de manière structurée. La commande ExportMatrix écrit
les colonnes de données numé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 ", données )

Ici, nomfichier est la chaı̂ne contenant le nom du fichier où ExportMatrix


doit sauvegarder les données, et données est une matrice. Remarquez
que toute liste, tout vecteur, toute liste de listes ou toute matrice créée à
partir d’une table peut également ê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 données sont placées dans un vecteur ou dans tout autre ob-
jet qui peut être converti au type Vector, il est possible d’utiliser la
commande ExportVector. Pour plus d’information, reportez-vous à la
rubrique ?Vector.
> L := [ 3, 3.1415, -65, 0 ];

L := [3, 3.1415, −65, 0]

> V := Vector(L);
7.2 Écrire des données dans un fichier • 279
 
3
 3.1415 
V := 
 −65 

> ExportVector( "vectordata.txt", V ):

Vous pouvez étendre ces routines de manière qu’elles écrivent des


donné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 procédure compliquée,
vous pouvez avoir besoin de la sauvegarder pour un usage ultérieur à
l’intérieur de Maple. Si vous sauvegardez cette expression ou cette procé-
dure au format interne de maple, ce dernier pourra ensuite la récupérer
efficacement. Cela s’accomplit en utilisant la commande save pour écrire
l’expression dans un fichier dont le nom se termine par les caractè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 préalable été nommés. La commande
save enregistre les objets dans nomfichier.m. Le .m indique que save
écrit le fichier en utilisant le format interne de Maple.
Voici quelques expressions.
> qbinomial := (n,k) -> product(1-q^i, i=n-k+1..n) /
> product(1-q^i, i=1..k );

%
n
(1 − q i )
i=n−k+1
qbinomial := (n, k) →
%k
(1 − q i )
i=1

> expr := qbinomial(10, 4);


280 • Chapitre 7: Entrées et sorties

(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 mémoire. Ainsi, expr
s’évalue à son propre nom.

> restart:
> expr;

expr

Utilisez la commande read pour récupérer les expressions sauve-


gardées dans qbinom.m.
> read "qbinom.m";

Remarquez que expr a retrouvé 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 présentation de textes mathéma-
tiques. De son côté, LATEX est un package macro de TEX. La commande
latex convertit les expressions Maple au format LATEX. Ainsi, vous pouvez
utiliser Maple pour résoudre un problème, convertir le résultat en code
LATEX et l’inclure dans un document LATEX. Utilisez la commande latex
de la manière suivante.
7.2 Écrire des données dans un fichier • 281

latex( expr, "nomfichier " )

L’objet expr peut être n’importe quelle expression mathématique. Les


expressions spécifiques à Maple, comme les procédures, ne peuvent être
exportées en format LATEX. Le champ nomfichier est optionnel ; il spécifie
à Maple d’écrire le résultat de la commande dans le fichier indiqué. Si vous
ne spécifiez pas de nom de fichier, Maple écrit le résultat directement dans
votre feuille.
La commande latex écrit le code LATEX correspondant de l’expression
Maple expr dans le fichier filename. Si filename existe, latex l’écrase
pour écrire le nouveau fichier. Vous pouvez omettre filename ; dans ce
cas, latex affiche le code LATEX à l’é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 mathématiques, incluant les intégrales, les limites, les sommes, les
produits et les matrices. Vous pouvez étendre les possibilités de la com-
mande latex en définissant des procédures portant des noms de la forme
‘latex/nomfonction ‘. De telles procédures formatent les appels de la
fonction functionname . Il est suggéré de produire le résultat de telles
commandes de formatage au moyen de la commande printf. La com-
mande latex se sert de writeto pour rediriger le résultat lorsqu’un nom
de fichier est spécifié.
La commande latex ne génère pas les commandes requises par LATEX
pour mettre le système de typographie en mode mathématique ($...$, par
exemple).
L’exemple suivant montre la génération de code LATEX pour une équa-
tion formée d’une intégrale et de sa valeur. Remarquez l’usage de Int,
la forme inerte de int, pour empêcher l’évaluation du côté gauche de
l’équation.
282 • Chapitre 7: Entrées et sorties

> 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 complète en


format LATEX.

7.3 Exporter des feuilles complètes


Bien entendu, vous pouvez enregistrer vos feuilles de calcul au moyen des
options Save ou Save As du menu File. Vous pouvez é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 é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 précéder chaque entrée du signe > et d’un espace.
Maple reproduit les symboles spéciaux comme les intégrales et les expo-
sants au moyen de caractères ; cependant, vous ne pouvez exporter les
graphiques sous forme de texte. L’exemple suivant est une portion de
feuille Maple exporté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 complè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 spécialement marqué qui conserve la
distinction entre le texte, les entré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 régéné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
entrée Maple, chaque ligne qui commence avec un dièse (#) comme du
texte, et ignore toutes les autres lignes.
Vous pouvez exporter une feuille entiè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 exporté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
|
/
284 • Chapitre 7: Entrées et sorties

# 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 boîte de dialogue qui apparaı̂t alors, choisissez Maple
Text dans la liste déroulante des types de fichiers. Double-cliquez sur le
fichier souhaité et choisissez encore Maple Text dans la boı̂te de dialogue
qui apparaı̂t.
Vous pouvez également copier et coller du texte Maple grâ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 collé apparaı̂t sous forme de
texte Maple. De maniè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’entrée, il interprète tout le texte collé comme une entrée, et si
vous le collez dans une zone de texte, Maple interprète tout le texte collé
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 génère est prêt à être compilé par LATEX. Toutes
les distributions de Maple incluent les fichiers de style nécessaires.
Si votre feuille contient des graphiques incorporés, Maple génère les
fichiers PostScript correspondant aux graphiques de mê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 exporté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}
7.3 Exporter des feuilles complètes • 285

\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 défaut
en spécifiant une option à la commande LATEX \usepackage dans l’en-tê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 à 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 généré par Maple peut être
286 • Chapitre 7: Entrées et sorties

chargé dans n’importe quel navigateur HTML. Vous pouvez é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 sanctionnée par
le World Wide Web Consortium (W3C) pour la communication de for-
mules mathématiques structurées entre des applications mathématiques.
Pour plus d’information à propos de MathML, consultez la rubrique
?MathML.
Maple génère des fichiers .gif pour représenter les équations et les
graphiques de votre feuille de calcul. Il convertit les formules mathé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 exportée en HTML. Remar-
quez que les autres documents HTML (incluant une table des matières),
qui ont été créés lors de l’exportation de la feuille originale, sont appelés
par cette portion de code.
<html>
<head>
<title>tut1.htm</title>
<!-- Created by Maple 8.00, IBM INTEL NT -->
</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 mentionné
dans le fichier précédent.
<b><font color=#000000 size=5>Calculation</font></b>
</p>
<p align=left>
<font color=#000000>Look at the integral </font>
<img src="tut11.gif" width=120 height=60 alt="[Maple Math]"
align=middle>
7.3 Exporter des feuilles complètes • 287

<font color=#000000>. Notice that its integrand, </font>


<img src="tut12.gif" width=89 height=50 alt="[Maple Math]"
align=middle>
<font color=#000000>, depends on the parameter </font>
<img src="tut13.gif" width=13 height=32 alt="[Maple Math]"
align=middle>
<font color=#000000>.</font>
</p>
<p align=left>
<font color=#000000>Give the integral a name so that you
can refer to it later.</font>
</p>
<p align=left><a name="expr command">
<tt>&gt; </tt>
<b><font color=#FF0000>expr := Int(x^2 * sin(x-a),
x);</font></b>
</p>
<p align=center>
<img src="tut14.gif" width=169 height=49 alt="[Maple Math]">
</p>
<p align=left>
<font color=#000000>The value of the integral is </font>
<a href="tut4.html" target="_top">an anti-derivative</a>
<font color=#000000> of the integrand.</font>
</p>

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 généré par Maple peut être chargé dans
n’importe quel traitement de texte qui supporte le format RTF. Maple
incorpore les graphiques et les éléments mathématiques formatés sous la
forme de bitmaps inclus dans des métafichiers Windows. Les feuilles de
calcul (spreadsheets ) ne sont pas pleinement exportées, mais les cellules
visibles de même que les en-têtes de colonnes et de lignes sont exportés.
L’exemple suivant est le début d’une feuille Maple exportée en format
RTF.
{\rtf1\ansi\ansicpg1252\deff0\deflang1033
{\fonttbl
{\f0 Times New Roman}
{\f1 Symbol}
288 • Chapitre 7: Entrées et sorties

{\f2 Courier New}


}
{\colortbl
\red205\green205\blue205;
\red255\green0\blue0;
\red0\green0\blue0;
\red0\green0\blue255;
}
{\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 généré par Maple peut être chargé comme une feuille Maple tradi-
tionnelle. Les documents XML sont chargés en choisissant Open du menu
File.
Le texte suivant est un extrait d’une feuille Maple exporté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 défaut les graphiques di-
rectement dans la feuille (on parle de graphiques insérés ). Vous pouvez
utiliser la commande plotsetup pour changer ce comportement. La com-
mande suivante indique à Maple d’afficher le graphique dans une fenêtre
séparée de votre écran.
> plotsetup(window);

Lorsque votre graphique s’affiche dans une fenêtre séparé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 spécifié.
La commande suivante indique à Maple d’envoyer le graphique en
format PostScript dans le fichier myplot.ps.
> plotsetup( postscript, plotoutput="myplot.ps" );

Le graphique généré par la commande plot ci-dessous n’apparaı̂t pas


à l’écran ; il est envoyé dans le fichier myplot.ps.
> plot( sin(x^2), x=-4..4 );

Maple peut également générer des graphiques au format HP Laser-


jet. Il envoie le graphique généré 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 écrasera le précédent.
> plotsetup( plotoutput="myplot2.hp" );
> plot( exp@sin, 0..10 );

Une fois les graphiques exportés, vous devez spécifier à Maple que les
graphiques doivent de nouveau être insérés à travers les feuilles.
> plotsetup( inline );

Consultez la rubrique ?plot,device pour une description des pilotes


graphiques reconnus par Maple.
290 • Chapitre 7: Entrées et sorties

7.5 Conclusion
Dans ce chapitre, nous avons vu un grand nombre de possibilités d’entrées
et de sorties de Maple : comment imprimer des graphiques, comment
enregistrer et récupérer des expressions Maple individuellement, comment
lire et écrire des données numériques et comment exporter une feuille
Maple en document LATEX ou HTML.
De plus, Maple possède plusieurs commandes d’entrées et de sorties
de bas niveau comme fprintf, fscanf, writeline, readbytes, fopen et
fclose. Consultez les pages d’aide pour plus de détails.
Les pages d’aide sont en quelque sorte un manuel de référence inter-
actif. Elles sont toujours au bout des doigts lorsque vous utilisez Maple.
Tout comme un manuel de référence traditionnel, utilisez-les en étudiant
l’index ou en les cherchant une à une. En particulier, l’option de recherche
d’un texte entier est une méthode de recherche de l’information supérieure
à un index traditionnel. Les hyperliens rendent aisée la recherche de sujets
connexes.
Le but de ce livre est de donner au lecteur une bonne base de connais-
sances à 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 majorité des
commandes de Maple sont enregistrées dans le langage Maple, puisque
ce langage de haut niveau est de loin supérieur aux langages de pro-
grammation traditionnels pour des tâches mathématiques. Le Guide de
programmation de Maple 8 vous introduit à la programmation sous
Maple.
8 Les maplets

En utilisant le package Maplets, vous pouvez créer des fenê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 présent chapitre est destiné en priorité aux utilisateurs des maplets.
Son contenu peut également s’avérer utile aux programmeurs de maplets.

8.1 Exemple de maplet


Vous pouvez créer une interface qui demande l’entrée d’information de
la part de l’utilisateur. Par exemple, une maplet d’intégration pourrait
ressembler à l’exemple suivant.

291
292 • Chapitre 8: Les maplets

8.2 Terminologie
maplet Une maplet est une collection d’éléments incluant, sans s’y limi-
ter, des fenêtres et leur disposition, des boı̂tes de dialogue et des actions.
Une mapplet diffère des autres fenêtres et boı̂tes de dialogue en ce qu’elle
contient elle-même des fenêtres et des boı̂tes de dialogue.

auteur de maplet Un auteur de maplet est un programmeur qui utilise


du code Maple pour créer une maplet.

utilisateur de maplet Un utilisateur de maplet est quelqu’un qui inter-


agit avec une maplet.

disposition La disposition définit comment les éléments d’une maplet


sont affichés.

fenetre Une fenêtre est un élément d’une maplet. Une fenêtre ne doit pas
être vue comme une maplet, mais plutôt comme un élément de maplet.
Une maplet peut contenir plus d’une fenêtre, et chaque fenêtre, à son tour,
peut contenir plusieurs éléments régissant la disposition et la fonction de
cette fenêtre.
8.3 Comment démarrer le package Maplets • 293

boıte de dialogue Une boı̂te de dialogue est un élément d’une maplet.


Contrairement à une fenêtre, qui peut contenir d’autres éléments comme
des boutons, une boı̂te de dialogue possède une structure prédéfinie : un
auteur peut spécifier les options d’une boı̂te de dialogue, mais ne peut lui
ajouter d’éléments.

8.3 Comment dé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 mémoire. Appuyez sur
Enter après ces deux groupes d’exécution possibles.
> restart:
> with(maplets[Elements]);

Important : Vous devez possé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 système local. Si cet environnement n’est pas installé,
communiquez avec votre administrateur de système.

8.4 Comment appeler une maplet à partir d’une


feuille Maple
Pour démarrer une maplet, appuyez sur Enter après les derniers deux-
points (:) ou le dernier point-virgule (;), ou n’importe où dans un groupe
d’exécution pour lancer l’exécution du code Maplets. Dans l’exemple sui-
vant, la maplet est écrite en un seul groupe d’exécution. Vous pouvez ap-
puyer sur Enter n’importe où dans le groupe d’exécution pour démarrer
la maplet.
> mymaplet := Maplet ([
> ["Hello World", Button("OK", Shutdown())]
> ]):
> maplets[Display](mymaplet);

Dans l’exemple suivant, la maplet est écrite comme deux groupes


d’exécution. Elle doit être définie avant d’utiliser la commande Display.
294 • Chapitre 8: Les maplets

> 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 approprié pour votre plateforme. Par
exemple :
Sous UNIX :
1. Cliquez sur l’icône – située dans le coin supérieur gauche de la fenêtre
de la maplet. Un menu déroulant apparaı̂t.
Note : Cette icône varie selon votre gestionnaire de thèmes.
2. Choisissez Close.
Sous Windows :
– Cliquez sur l’icône X située dans le coin supérieur droit de la barre
de titre de votre maplet. Cette dernière se ferme.

8.6 Comment utiliser les Maplets et la fen


etre
Maple (modalité)
Lorsqu’une maplet est en cours d’exécution, la feuille Maple est inac-
cessible. Si vous déplacez le curseur au-dessus de cette feuille, une icône
(horloge sous UNIX, sablier sous Windows) apparaı̂t, indiquant que la
feuille de travail est inaccessible. La maplet doit être fermée ou auto-
risée à complé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 redémarrer une maplet • 295

2. Entrez l’expression, les nombres ou le texte appropriés.

8.8 Comment arr


eter puis redémarrer une maplet
Lorsque les calculs à effectuer par une maplet sont longs, il vous est tou-
jours possible d’interrompre le processus en cours.
1. Pour arrêter la maplet en cours, cliquez sur le bouton X (ou l’icône de
fermeture appropriée pour votre plateforme) qui figure dans sa barre
de titre.
2. Pour redémarrer la maplet, exécutez-la à nouveau au moyen de l’outil
lastmaplet.
> maplets[Display](lastmaplet);

8.9 Comment utiliser les raccourcis de l’interface


graphique
Listes déroulantes
Certaines maplets contiennent des listes déroulantes. Voici comment les
utiliser efficacement.
1. Entrez le premier caractère de l’élément de la liste que vous souhaitez
atteindre. La liste se déplace automatiquement jusqu’à un élément
commençant par la lettre saisie.
2. Continuez à ajouter des caractères du nom de l’élément voulu jusqu’à
ce que la sélection désirée soit affichée en surbrillance.
Remarquez que cette méthode ne s’applique pas aux listes déroulantes
créées avec l’élé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 également utiliser les touches Tab et la barre
d’espacement de la maniè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
exécutée.
296 • Chapitre 8: Les maplets

8.10 Conclusion
Pour obtenir plus d’information sur les maplets, reportez-vous à la ru-
brique ?maplets ou au Guide d’introduction à la programmation (Maple
Introductory Programming Guide), au chapitre 9.
Index

!, 8 images des, 126, 128, 133


π, 12 paramétriques, 3-D, 128
%, 8 paramé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 séries, 68–70
\, 8 approximations
à virgule flottante, 9
about, 168 décimales, 9
add, 176 arbre des expressions, 186
additionally, 168 arithmétique élémentaire, 6
affectation multiple, 94 arrow, 140
affectations assign, 53
invalides, 20 assignations
nommer, 18 d’ensembles d’équations, 53
noms valides, 19 multiples, 21
affichage du résultat assigned, 200
supprimer, 28 assume, 172
afficher additionally, 168
procédures, 198 integer, 169
algèbre liné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 côté droit, 182
animations, 211 côté gauche, 182
afficher, 126, 133 cônes, tracer le graphique, 122
en coordonnées sphériques, côté droit d’une égalité, 39
129 côté gauche d’une égalité, 39
en deux dimensions, 125 calcul différentiel, 209

297
298 • Index

calcul diffé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,
concaténer, 194 51
champ de vecteurs, 138 en chaînes, 194
coeff, 65 en listes et en ensembles, 195
coefficients, 65 séries en polynômes, 194, 216
collect séries en polynômes, 68
distributed, 154 coordonné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 paramé-
mandes spécifiques triques, 107
compter, 40 sphériques, 119
concaténation, 194, 205–207 coordonnées polaires, 127
concaténation coordonnées sphé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’intégration, 230
continuité, prolonger par, 231 D, 231, 237, 251
contourplot, 137 dénominateurs, 183
conversion dérivées, 70, 209
sous forme de listes, 276 définition, 210
convert, 35, 275 partielles, 218, 232
binary, 14 dérivées partielles, 218
exp, 35, 166 définition, 232
factorial, 166 mixtes, 233
hex, 14 désaffectation, 203
Index • 299

dénominateurs, 39 EDP, 266


commun, 37, 159 conditions initiales, 270
développer tracer le graphique, 269
des expressions, 34 empty_set, 25
modulo m, 152 ensembles, 23
degré d’un polynôme, 65 convertir en, 195
degree, 65 correspondances, 38
denom, 39, 183 différence, 26
densityplot, 137 intersection, 24
DEplot, 257 minus, 26
DEplot3d, 259 opérandes des, 186
DESol, 255 opérations sur les, 25–26
deux-points, 28 sé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 précision arbitraire, 8
display, 132, 211 solutions entières, 60
divide, 64 entiers gaussiens, 15
dodecahedron, 140 équation
dsolve, 73, 236 d’onde, 266
explicit, 238 de la chaleur, 268
implicit, 238 équations
method=laplace, 239 aux dérivées partielles, 266
startinit, 250 côté droit d’une égalité, 39
type=numeric, 248 côté gauche d’une égalité, 39
type=series, 245 équations différentielles
dynamique classique, 238 systèmes d’, 78
ordinaires, 73, 236
é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 évaluation, 196–207
méthode des transformées de à un niveau, 200
Laplace, 238 à un nom, 200
numériques, 247 assigned, 200
séries, 245 complè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’évaluation complète, feuilles
198 sauvegarder, 282
niveaux, 197 fichiers
numérique, 10, 12, 13 écrire des colonnes dans, 278
retardée, 201 lecture de colonnes depuis,
évaluer 274
des variables locales, 200 lecture de commandes de-
matrices, 197 puis, 276
procédures, 197 lecture de donné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 à partir d’expressions, 51
en HTML, 285 affectation, 19
en HTML avec MathML, 286 arguments, 20
en LATEX, 284 définies par morceaux, 264
en RTF, 287 de coloriage, 124
en texte, 282 discontinues
en texte Maple, 283 tracer le graphique, 108
XML, 288 mathématiques, 15–16
ExportMatrix, 278 prolongement par continuité,
ExportVector, 278 231
expressions rationnelles
convertir en fonctions, 51 factoriser, 154
identification de, 184 forme normale factorisée, 159
indéterminées des, 188 frac, 169
non évaluées, 15, 201 fractions
opérandes des, 184 dénominateurs de, 39, 183
requête sur le contenu des, numérateurs de, 39, 183
187 partielles, 167
types des, 188 sur le même dénominateur,
37, 159
Factor, 157 fsolve, 56, 221
factor, 34
vs. solve, 65 graphiques, 101–148
Index • 301

graphiques listes de nombres, 275


échelle de type Matrices, 139
constrained, 104 modèles d’éclairage, 124
root loci, 139 niveaux de gris, 124
afficher, 132 objets, 140
afficher les coordonnées, 101 pilotes, 288
algorithme adaptatif pour, plusieurs, 132
115 raffiner, 115, 123
animations, see animations, séries, 194
211 singularités, 109
annotations, 129, 134 sphères, 120
bordure (bounding box), sphereplot, 119
116 styles de lignes, 112
cartes topographiques, 137 styles de lignes, spécifier, 112
champs de vecteurs, 138 styles de points, spécifier,
coloriage, 124 114
conformes, 137 sur un axe logarithmique,
contours, 137 136
coordonnées polaires, 105 surface colorée, 117
coordonnées sphériques, 119 surfaces, 116
couleurs, spécifier, 113 surfaces paramétriques, 118,
courbes dans l’espace, 138 120
courbes dans l’espace tridi- tangente, 89
mensionnel, 138 texte, 134
courbes paramétriques, 103 titres, 129, 194, 207
cylinderplot, 121 tourner, 116, 142
cylindres, 121, 122 tracer des points, 113
dans des fenêtres séparées, tracer plusieurs courbes, 111
288 translater, 142
de densité, 137 tridimensionnels, 116
domaine, 117 tubes, 138
EDO, 256 graphiques paramétriques
EDP, 269 2-D, 103
exporter vers un fichier, 288 3-D, 118
fonctions de coloriage, 124 cylindres, 122
fonctions discontinues, 108 en coordonnées polaires, 107
fonctions explicites, 101, 116 sphères, 120
fonctions implicites, 135 guillemets, 201
imprimer, 288 guillemets anglais, 31
inégalités, 135
inséré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
hypothèses LinearAlgebra, 91
poser, 168 listes, 22
retirer, 72, 171 éléments de, 22
voir, 168 combiner, 178
convertir en, 195
implicitplot, 135 correspondances, 38
ImportMatrix, 274 désordonnés, 23
imprimer opérandes des, 186
des graphiques, 288 opérations sur les, 25–26
indéterminées, 188 ordonnées, 22
indets, 188 sélectionner dans, 176
inequal, 135 trier, 179
infolevel, 158, 169 vides, 25
intégrales, 70, 227, 230 loglogplot, 136
constantes des, 230 logplot, 136
définies, 71, 229 Loi du refroidissement de New-
de Riemann, 227 ton, 251
indéfinies, 70, 229
inté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
arrê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’intégration, 291 normal, 37
fenêtre, 292 expanded, 160
fermer, 294 notation flèche, 19
listes déroulantes, 295 notation indicée, 25
raccourcis, 295 noyau, 79
redémarrer, 295 numérateurs, 183
travailler avec, 294 numérateurs, 39
utilisateur, 292 numer, 39, 183
MathML, 286
Matlab, 93 objet
matrices graphique, 140
é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 opérandes
développer, 152 de listes et d’ensembles, 186
factorisation, 157 des expressions, 184
modèles d’éclairage, 124 nombre de, 40, 184
modp, 15 sélectionner, 184
mods, 15 opérateur idem, 8
modulo, 14–15 optimisation
moyenne, 95 linéaire, 97
msolve, 60 Order, 68, 251
mul, 176
packages
niveaux d’évaluation, 197 charger, 80
nombre d’opérandes, 40 liste des, 81
nombres à virgule flottante, 12– utiliser des commandes dans
14 les, 79
précision par défaut, 12 PDEplot, 270–271
vs. nombres rationnels, 9–11 pi, 12
nombres complexes, 14 piecewise, 264
nombres décimaux, 12–14 graphiques, 108
nombres imaginaires, 14 plex, 62
nombres rationnels, 7–10 color
vs. nombres à virgule flot- color, 113
tante, 9–11 plot
304 • Index

color, 112 entiers, 8


discont, 109, 111 print, 27
labels, 130 procédures
évaluer, 197
labelsfont, 130 afficher, 198
legend, 131 prolonger par continuité, 231
linestyle, 112
numpoints, 115 quo, 63
style=hidden, 117 quotient
style=line, 114 polynômes, 63
symbol, 114
remember tables, 232
symbolsize, 114
résultats, exacts vs. approxima-
title, 129, 194
tifs, 9
plot3d, 116
résoudre
axes, 131
ensembles d’équations, 45
grid, 123
ensembles de variables, 45
lightmodel, 124
et vérifier, 47–49
shading, 124
inégalités, 49
plots
modulo m, 60
animate, 125
numériquement, 56
animate3d, 128
récurrences, 61
arrow, 140
solutions entières, 60
plotsetup, 288
systèmes d’é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 récurrence, 61
plusieurs graphiques, 132
rem, 63
point-virgule, 28
remove, 177
pointplot, 113
restart, 280
polynômes, 61–66
reste de polynômes, 63
coefficients de, 63, 65
retarder l’évaluation, 201
développer, 150
retirer des hypothèses, 171
degré 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 éléments, 164–166
Roots, 89
PostScript, 289
rotate, 142
précision
Index • 305

RowSpace, 92 singularités, graphiques, 109


rsolve, 61 NewtonQuotient, 210
RTF, 287 solutions
Rule, 86–89 multiples, 49
paramétriques, 46
sélectionner solve, 219
dans des listes et des en- vs. factor, 65
sembles, 176 sommes de Riemann, 89, 228
des constantes réelles, 214 sort, 62, 164–166, 179
des sous-expressions, 184, sous-expressions, 40
187 spacecurve, 138
opérandes, 184 specfunc, 189
séries, 245 sphères, 120
convertir en polynômes, 194 sphere, 141
séries de Taylor, 193, 215, 227, sphereplot, 119
251, 253 spirales, 107, 123
sé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 résultat,
semilogplot, 136 28
seq, 201, 252
seq, 175 tableaux, 26
series, 68 évaluer, 30, 197
simplex, 97 choisir les éléments, 28
simplifications, 32–35 correspondances, 38
au moyen des relations acces- imprimer, 27
soires, 33, 41 tables, 30
spécifier les règles, 33 évaluer, 197
simplify, 33, 41, 161–164 tables de rappel, 232
au moyen des relations acces- Tangent, 89
soires, 163, 192 tangente
avec hypothèses, 163 tracer le graphique, 89
306 • Index

tests de primalité, 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
tracé adaptatif de graphiques,
115
transformées de Laplace, 238,
242
inverse, 243
translate, 142
Transpose, 276
triangle de Pascal, 175
trier
définir une relation d’ordre,
180
des listes, 179
des polynômes, 62
en ordre lexicographique, 62,
166, 179
en ordre numérique, 179
les éléments d’une expres-
sion, 164–166
par degré total, 165
par longueur, 181
tubeplot, 138
type, 177, 188
specfunc, 189
types de données, 20

unapply, 51, 211


Understand, 87

variables locales, évaluer, 200


vecteurs, 92
transposée de, 92

Vous aimerez peut-être aussi