Table des matières
Introduction à Maple	1
I. L'interface utilisateur	1
II. Les entrées d'expression et d'instructions	1
III. Les fonctions Maple	2
IV. Sauvegarde des sessions	3
V. Observation et recherche des erreurs	3
1. L'instruction trace	3
2. La variable printlevel	4
3. La variable infolevel et le suivi algorithmique	6
4. Les instructions print et lprint	7
VI. Facilités supplémentaires	7
Calculer sur des nombres	8
I. Calculer sur des entiers	8
1.Fonctions utilisées	8
2.Exemples d'utilisation	9
II. Calculer sur des rationnels	9
III. Calculer sur des nombres algébriques	10
IV. Calculer sur des réels	11
1.Fonctions classiques	11
2.Evaluation des réels en virgule flottante	11
3.Evaluations exactes et évaluations en virgules flottantes	12
VI.Calculer sur des complexes	12
VII. Exercices	13
Calculer avec des symboles	14
I.Expressions algébriques	14
1.Transformations d'expressions algébriques	14
2.Calculs modulo un nombre premier	18
3.Racines communes, racines multiples	18
II.Substitutions, affectations	19
1.Substitutions	19
2.Affectation immédiate, affectation différée	21
3. Suppression d'une affectation	22
III. Sommation, dérivation, integration	22
1. Sommes et produits	22
2. Derivation	24
3. Intégrales indéfinies (ou primitives)	26
4. Intégrales définies	26
IV. Resoudre des équations	28
1. Solutions symboliques	28
2. Solutions numériques	30
3. Equations différentielles	31
4. Suites récurrentes	33
V.Exercices	34
Les structures de données	36
I. Types simples	36
1. Types numériques	36
2. Les chaines de caractères et le type "name"	37
II. Types composés	37
1. Sequences	37
2. Listes	39
3. Ensembles	39
4. Type indexé	40
5. Tables	40
5. Array	42
III. Types expressions. Opérandes	43
1. Arbre d'une expression	43
2. Type et opérandes d'une expression	44

IV. Typage	45
1. Les types prédéfinis	45
2. Le contrôle des types	46
3. Les types définis par l'utilisateur	47
V. L'evaluation	49
Programmer Maple	51
I. Les structures de contrôle	51
1. Structures conditionnelles	51
2. Structure répétitive	51
II. Les procédures	52
1. Les objets procédures	52
2. Paramètres et variables locales	54
3. Nombre de paramètres	55
4. Le passage des paramètres	56
5. Type des paramètres	57
II. Les fonctions opérateurs	57
1. Fonctions flèches et fonctions angles	57
2. Un peu de programmation fonctionnelle	59
3. La définition d'opérateurs infixes	60
4. Exercices	61
V. La récursivité et les options	61
VI. Résumé de la syntaxe et de la sémantique du langage	62
Les graphismes	64
I. Utilisation des procédures graphiques	64
1. La procédure plot (dimension 2)	64
2. Autres procédures graphiques en 2D	66
3. La procédure plot3d (dimension 3)	69
4. Autres procédures 3D	72
5. Animations	73
6. Superposition de tracés	74
II. La programmation des graphiques	74
III. Exercices	77

Note: Le logiciel Maple© ainsi que la marque Maple© sont propriétés de Waterloo Maple Publishing. Les extraits des écrans d'aide de Maple sont uniquement destinés à être utilisés en même temps que le logiciel à titre de référence rapide et d'illustration de la syntaxe. Ils ne peuvent en aucune façon se substituer à l'aide en ligne ainsi qu'aux ouvrages de base publiés chez Springer Verlag:

		Maple V  Library reference manual
		Maple V Language reference manual

Introduction à Maple

I. L'interface utilisateur
	Nous n'évoquerons ici que l'interface utilisateur évoluée que l'on peut trouver sur les versions Windows, MacIntosh ou X-Windows. Elle est composée d'un éditeur pleine page piloté à la souris. Chaque page est divisée en cellules: des cellules d'entrées d'expressions ou d'instructions (type input), des cellules de sorties de résultat (type output ou éventuellement graphiques), des cellules de commentaire (type text) et des cellules graphiques. Vous pouvez introduire vous mêmes des cellules d'entrées ou des cellules de commentaires. Les cellules de sorties sont créées par Maple lorsqu'il renvoye un résultat. Les cellules graphiques sont remplies par un couper-coller à partir d'une fenêtre graphique (et en particulier celles créées par Maple à la suite d'une instruction de dessin).
	Les cellules de commentaire sont à votre entière disposition. Les cellules d'entrées doivent commencer par un prompt (en général • ou  >), une commande de menu permettant d'insérer un prompt. Ces cellules d'entrée ont une taille qui s'adapte à leur contenu. A l'intérieur de ces cellules, la touche Return  provoque un retour à la ligne de l'éditeur (retour chariot), si bien qu'une cellule peut comprendre plusieurs lignes logiques. Par contre, la touche Enter  (ou encore la combinaison Shift-Return  ) provoque l'envoi de la cellule courante à l'évaluateur de Maple.
	Les cellules de sortie de Maple suivent immédiatement les cellules d'entrée. Elles peuvent être au choix formatées en mode texte simulant des formules mathématiques de manière plus ou moins heureuse (veiller à utiliser en style output exclusivement une police non proportionnelle comme Monaco ou Courier, sinon vos exposants de baladeront n'importe où) ou en mode graphique (sorties "à la TeX", assez esthétiques).

II. Les entrées d'expression et d'instructions
	Comme on l'a vu, l'envoi d'une cellule d'entrée à l'évaluateur de Maple se fait par la touche Enter  ou encore par la combinaison Shift-Return  (la touche Return   provoquant un simple passage à la ligne sans changer de cellule d'entrée). Une cellule d'entrée peut contenir une ou plusieurs expressions Maple évaluables. Ces expressions sont alors évaluées si elles sont complêtes et le résultat de chacune d'entre elles est éventuellement affiché dans une cellule de sortie.
	Une expression Maple est complête si elle se termine par un point-virgule (;) ou deux-points (:). Si vous envoyez à l'évaluateur une expression incomplête, Maple se contente de réafficher le prompt et d'attendre la suite de l'expression jusqu'à ce qu'il rencontre le terminateur fatidique. Ce n'est qu'alors qu'il tentera de l'évaluer (si bien qu'une expression Maple peut figurer de manière morcelée dans plusieurs cellules d'entrée). Lorsqu'une expression Maple est évaluée, son résultat (s'il existe) est déposé sur le sommet d'une pile d'évaluation. Cette pile contient trois éléments au maximum, que l'on peut récupérer par trois symboles Maple qui sont  ", ""  et  """. C'est ainsi que " permet de récupérer le résultat de la dernière évaluation. Lorque cette pile déborde, les éléments les plus anciens sont éliminés si bien que l'on ne peut accéder qu'aux résultats des trois dernières évaluations.
Remarque: nous avons essayé de donner une idée succinte mais malheurusement inexacte de la signification des opérateurs  de type ". Les choses sont en fait plus compliquées et on se réfèrera à l'aide en ligne et à la documentation pour connaître la signification exacte de ces opérateurs qui fait intervenir le niveau d'exécution. On peut regretter que les créateurs de Maple aient utilisé des opérateurs dont la sémantique est bien trop floue.
	Une fois le résultat déposé sur cette pile d'évaluation, celui ci est affiché ou non dans une cellule de sortie suivant que le terminateur de l'expression était point-virgule ou deux-points. Le deux-points permet donc de ne pas afficher le résultat de l'évaluation d'une expression, soit que le résultat soit en lui-même sans intérêt, soit qu'il soit extrêmement compliqué et que son affichage entraîne une grosse perte de temps ou d'espace écran (c'est parfois le cas de bien des résultats intermédiaires).
Remarque  : on a vu que seules les trois derniers résultats d'évaluation sont accessibles. Il ne faut donc pas hésiter à effectuer des affectations pour des résultats intermédaires que l'on pourrait vouloir réutiliser; un autre moyen est d'utiliser une fonction de la bibliothèque Maple qui s'appelle history et qui se charge de conserver au fur et à mesure (au prix d'un encombrement de la mémoire) tous les résultats des évaluations.

FUNCTION: history - maintain a history of all values computed
CALLING SEQUENCE:
   history()
SYNOPSIS:   
- The history function is used to maintain a history of all results computed  within a Maple session, beyond what is available with Maple quotes - ", "",  and """.  A separate timing facility is also available.
- After loading the history function, type history(); to initiate the history  mechanism.  The user will be prompted for input by the prompt O1 := and for  successive statements by the prompts O2 :=, O3 :=, and so on.  Any Maple  statement entered is evaluated and displayed normally.  The result is  assigned to the global variables O1, O2, ...  which may be referred to later  by the user thus providing a history mechanism.
- The previous value may be referred to by using " but "" and """ are no longer  available under history.
- By typing off; the history session is terminated, control is passed back to  the normal session.
- By typing timing(f); the time to execute the expression f will be displayed  after the normal output.
- By typing clear; the values of O1, O2, ... are cleared.
- Caveats: history is an ordinary Maple function, programmed in Maple.  As such  it cannot trap interrupts.  Hence, if you interrupt a calculation you will be  thrown back to
- This function should be defined by the command readlib(history) before it is  used.

III. Les fonctions Maple
	L'appel d'une fonction ou instruction Maple se fait comme en Mathématiques, en Pascal ou en C sous la forme  nom_de_fonction  (paramètres_éventuels  ), à l'aide de parenthèses. Maple dispose de quatre types de fonctions:
	- les fonctions de base, toujours disponibles et qui sont chargées en mémoire dès que de besoin
	- les fonctions de la bibliothèque étendue qui doivent être chargées explicitement par l'utilisateur avant leur emploi à l'aide de l'instruction readlib(nom_de_fonction )
FUNCTION: readlib - read a library file to define a specified name
CALLING SEQUENCE:
   readlib(f)
PARAMETERS:
   f          - the name of a procedure to be read
SYNOPSIS:   
- With only one argument, calling readlib(f) causes the following statement to  be executed:
         read  ``.libname.`/`.f.`.m`;
  This causes the .m file for f to be loaded from the standard Maple library.
- The value returned from the readlib function is the value  assigned to the first argument f after executing the read statement(s).
- It is an error if f does not become defined by this action.
- The readlib function has option remember; hence subsequent invocations of  readlib with the same arguments will not cause files to be re-loaded.
- It is often desirable to follow a call to readlib with a colon (:) rather  than a semicolon (;).  Ending a Maple command with a colon causes Maple to  suppress printing the output from that command.  Thus using a colon when calling readlib avoids having the procedure definition output to the screen.

	- les fonctions des différents packages (ensembles de fonctions) de la bibliothèque; on peut soit charger en mémoire tout un package en bloc à l'aide d'un with(nom_du_package ), soit charger une unique fonction du package en mémoire à l'aide d'un with( nom_du_package , nom_de _fonction ) , soit utiliser directement cette fonction en indiquant explicitement son package d'origine sous la forme nom_du_package [nom_de_fonction  ]; imaginons par exemple que vous vouliez utiliser la fonction submatrix du package linalg, qui extrait une sous matrice d'une matrice donnée; si vous ne l'utilisez qu'une seule fois pour extraire une sous matrice 3x3 d'une matrice A vous taperez
• B:=linalg[submatrix](A,1..3,1..3);
si par contre vous comptez l'utiliser plusieurs fois vous taperez
• with(linalg,submatrix):
  B:=submatrix(A,1..3,1..3);
et vous disposerez désormais de la fonction submatrix comme d'une fonction de base. Si par contre vous pensez avoir besoin par la suite d'autres fonctions du package linalg vous taperez
• with(linalg):
  B:=submatrix(A,1..3,1..3);
et vous disposerez désormais de toutes les fonctions du package comme de fonctions de base
	- les fonctions utilisateurs; ces fonctions peuvent être créées de manière interactive au cours de la session Maple par programmation, mais elles peuvent aussi être entrées par l'intermédiaire d'un fichier à l'aide de l'instruction read `nom_du_fichier  ` (attention aux accents graves)  ou de manière interactive à l'aide du menu adéquat; dans ce dernier cas, Maple réagira différemment suivant le suffixe de ce fichier. Si le nom du fichier se termine par '.m', Maple considérera qu'il s'agit d'un fichier compilé; il en exécutera les diverses instructions sans en afficher les résultats. Si par contre le nom du fichier ne se termine pas par '.m', Maple considérera qu'il s'agit d'un fichier texte; il en exécutera les diverses instructions comme si elles avaient été entrées au clavier par l'utilisateur en affichant au fur et à mesure les résultats.

IV. Sauvegarde des sessions
	Vous pouvez sauvegarder une session Maple sous forme de fichier exécutable (en conservant uniquement les cellules d'entrée) ou sous forme de document complet. Pour le premier cas, vous pouvez le faire de manière interactive à l'aide du menu adéquat, ou à l'aide de l'instruction save `nom_du_fichier  ` (attention aux accents graves). Suivant que le nom du fichier se termine par '.m' ou non, Maple le sauvera sous forme compilée ou sous forme de fichier texte.

V. Observation et recherche des erreurs
Contrairement à d'autres environnements de programmation, Maple ne dispose pas de debogueur intégré avec exécution pas à pas, observation des variables, etc. mais il dispose d'un certain nombre de facilités que nous allons examiner dans ce paragraphe.
1. L'instruction trace
Une des facilités est de pouvoir observer certains appels de procédures ou de fonctions à l'aide de l'instruction trace. Si vous demandez la trace de l'une des procédures ou fonctions (qu'elle soit prédéfinie dans Maple ou dans sa bibliothèque ou bien qu'elle ait été définie par vous), à chaque appel de la procédure ou de la fonction, Maple affichera la valeur courante des paramètres à l'entrée et la valeur de retour à la sortie (si celle ci existe). C'est un moyen commode de recherche d'erreurs simples se situant au niveau du passage des paramètres, de valeurs de retour de fonctions ou de boucles sans fin. Ceci permet de suivre facilement les procédures récursives. Vous supprimez cette facilité avec l'instruction untrace.

FUNCTION: trace, untrace -  trace procedures in order to debug them
CALLING SEQUENCE:
   trace(f)
   trace(f,g,h,...)
   untrace(f)
   untrace(f,g,h,...)
PARAMETERS:
   f, g, h, ... - name(s) of procedure(s) to be traced
SYNOPSIS:   
- The trace function is a debugging tool for tracing the execution of the procedure(s) f, g, h, and so forth.
- During execution, the entry points, the statements that are executed, and the  exit points of the traced procedure(s) are printed.  At entry points, the actual parameters are displayed.  At exit points, the returned function value  is displayed.
- The untrace function turns off the tracing of its arguments.
- The trace (untrace) function returns an expression sequence of the names of  the procedures for which tracing was turned on (off).
- Note that it is not possible to trace any function which has special evaluation rules, namely any of: assigned, eval, evalhf, evalf evaln, traperror, seq, userinfo.

• fact:=proc(n) if n=1 then 1 else n*fact(n-1) fi; end:
trace(fact):
fact(5);
untrace(fact):

{--> enter fact, args = 5
{--> enter fact, args = 4
{--> enter fact, args = 3
{--> enter fact, args = 2
{--> enter fact, args = 1
                                    1

<-- exit fact (now in fact) = 1}
                                    2

<-- exit fact (now in fact) = 2}
                                    6

<-- exit fact (now in fact) = 6}
                                    24

<-- exit fact (now in fact) = 24}
                                   120

<-- exit fact (now at top level) = 120}
                                   120
2. La variable printlevel
	L'évaluation d'une expression de Maple est un processus complexe correspondant à l'évaluation d'un arbre. Maple maintient de manière interne une variable disant à quel niveau d'exécution il en est à un instant donné. Sans rentrer dans le détail des structures de contrôle de Maple, disons que Maple augmente ce niveau de 1 chaque fois qu'il entre dans une structure conditionnelle ou itérative, de 5 chaque fois qu'il entre dans une procédure ou une fonction. Il le diminue de 1 à la sortie d'une structure conditionnelle ou itérative, de 5 à la sortie d'une procédure ou d'une fonction.
	La variable interne printlevel de Maple est une variable qui contrôle le niveau des instructions qui sont affichées par Maple. Cette variable vaut initialement 0, c'est à dire que Maple n'affiche que les résultats des instructions se déroulant au niveau le plus bas. Vous avez la possibilité de lui donner une valeur arbitraire, ce qui vous permettra de voir affichés les résultats de toutes les instructions effectuées par Maple jusqu'au niveau choisi.
HELP FOR: printlevel (display of information; debugging procedures)
SYNOPSIS:   
- printlevel := <integer>
- Statements within a particular procedure (or in the main session) are recognized in levels, determined by the nesting of conditional or repetition statements and the nesting of procedures.
- The top (interactive) level is level 0; statements within  conditional/repetition statements are level 1, or level 2 if doubly nested,  etc.  The first procedure is level 5; statements within  conditional/repetition statements within a procedure are level 6, etc.  The  n-th nested procedure is level 5*n.
- The setting of printlevel causes the display of the results of all statements  executed up to the level indicated by printlevel.  Initially, printlevel is  set to 1.
- Higher values of printlevel will cause more information to be displayed;  negative values will cause no information to be displayed.  In particular, many library procedures are programmed to print out explanatory information  if printlevel > 1, with the values 2, 3, and 4 signifying successively more  detailed information.
- For debugging purposes, printlevel := 1000; is not uncommon.

Voici un exemple avec notre procédure de calcul de la factorielle
• fact:=proc(n) if n=1 then 1 else n*fact(n-1) fi; end:
printlevel:=12:
fact(5);
printlevel:=0:

{--> enter fact, args = 5
{--> enter fact, args = 4
                                    24

<-- exit fact (now in fact) = 24}
                                   120

<-- exit fact (now at top level) = 120}
                                   120

Il est facile ici de comprendre ce qui se passe. Au départ le niveau d'exécution est 0. L'entrée dans la procédure fact le fait passer à 5. L'entrée dans la structure de contrôle le fait passer à 6. La nouvelle entrée dans la procédure fact le fait passer à 11, puis dans la structure de contrôle à 12. A partir de là, le niveau d'exécution dépasse le niveau d'impression printlevel et les exécutions d'instructions ne sont plus affichées jusqu'au retour du calcul de fact(3), auquel cas le niveau d'exécution repasse à 12, puis à 11 au sortir du if puis à 6 au retour du calcul de fact(4), puis à 5 au sortir du if correspondant au calcul de fact(5), puis à 0 au sortir du calcul de fact(5).
Attention: ce sont les instructions qui sont affichées; les évaluations d'expressions sont également considérées comme des instructions; par contre les tests conditionnels et le calcul des bornes d'une structure itérative ne sont pas considérés comme des instructions et ne sont pas affichées (ce qui ne facilite pas le debogage).
Exemple:
• printlevel:=1: for i from 1 to 3 do x:=i*i od;
                                  x := 1
                                  x := 4
                                  x := 9

• x:=0: y:=1: printlevel:=1:
if x=y then 0 else 1 fi;
                                    1

3. La variable infolevel et le suivi algorithmique
La variable printlevel permet un suivi de l'exécution pas à pas d'un calcul. La variable infolevel est destinée au contraire à permettre à une procédure donnée (si elle a été prévue pour cela) de donner des renseignements à l'utilisateur sur son déroulement à l'aide d'une instruction userinfo. L'instruction userinfo utilisée dans la procédure a un paramètre n (entier) fixé. Si lors de l'exécution de la procédure, au moment où l'instruction est rencontrée, la variable infolevel a une valeur supérieure à n, l'information en question est affichée, sinon elle ne l'est pas. Chaque procédure ou fonction dispose de sa propre variable infolevel à laquelle on se réfère par infolevel[nom_de_la_fonction ] .
FUNCTION: userinfo - print useful information to the user
CALLING SEQUENCE:
   userinfo(lev, fn, e1, e2 ... )
PARAMETERS:
   lev - a non-negative integer
   fn  - a procedure name or a set of procedure names
   e1  - any expression
   e2  - (optional) any expression
SYNOPSIS:   
- The procedure userinfo is used to print useful information to the user.
- The first argument lev is a non-negative integer which determines the level  at which information will be printed.
- The second argument fn is a procedure name or set of procedure names for  which this information is printed. The information will be printed if the  global assignment infolevel[fn] := Lev; or infolevel[all] := Lev; was entered  before invoking the procedure containing the userinfo statement, and Lev >=  lev.   
- First the name of the invoked procedure is printed using lprint, followed by  a colon and 3 spaces. Then the third and optional other arguments are  evaluated and lprinted together, but separated by 3 spaces.  If one of the  arguments is of the form print(...) then that argument is prettyprinted.  If  one of the arguments is of the form lprint(...) then that argument is printed  on a separate line.
- The user must assign a non-negative integer to some of the entries in the  global table infolevel before invoking the procedure.  If the entry  infolevel[all] is a non-negative integer then every userinfo call will print  if its level is less than or equal to userinfo[all] .
- Throughout the Maple V library userinfo statements have been used with the
  following conventions:   
  Level 1: reserved for information that the user must be told.
  Level 2,3: general information, including technique or algorithm being used.
  Level 4,5: more detailed information about how the problem is being solved

Exemple:
• solve({2*x+3*y=1,3*x+5*y=3},{x,y});
solve/linear:   # equations   2
solve/linear/integer/sparse:   # equations   2
solve/linear/integer/sparse:   x, 2*x+3*y-1, 2
solve/linear/integer/sparse:   # equations   1
solve/linear/integer/sparse:   y, y-3, 1
solve/linear/integer/sparse:   backsubstitution at:   2
solve/linear/integer/sparse:   backsubstitution at:   1
                             {y = 3, x = -4}
• int(1/(x^2+1),x);

int/indef:   first-stage indefinite integration
int/ratpoly:   rational function integration
                                arctan(x)
4. Les instructions print et lprint
Enfin vous disposez à tout instant des instructions print ou lprint qui vous permettent d'afficher des résultats intermédiaires. La procédure print les affiche formatés comme en sortie, l'instruction lprint les affiche non formatées comme en sortie (les amoureux de C pourront également trouver dans la bibliothèque de Maple leur printf préféré avec une syntaxe très proche de C).
Exemple:
• fact:=proc(n) print(`on en est à n=`.n); if n=1 then 1 else n*fact(n-1) fi; end:
fact(5);

                             on en est à n=5
                             on en est à n=4
                             on en est à n=3
                             on en est à n=2
                             on en est à n=1
                                   120

VI. Facilités supplémentaires
Les noms de fonctions de Maple sont parfois compliqués ou troublent des habitudes acquises depuis longtemps. Maple permet de renommer des objets sans les modifier à l'aide de la fonction alias . Contrairement à une macro, il ne s'agit pas d'une abbréviation, mais bien d'un renommage qui fonctionne aussi bien pour les entrées de l'utilisateur que pour les sorties de Maple.

FUNCTION: alias - define an abbreviation or denotation
CALLING SEQUENCE:
   alias(e1, e2, ..., eN)
PARAMETERS:
   e1, e2, ..., eN - zero or more equations
SYNOPSIS:   
- Mathematics is full of special notations and abbreviations.  These notations  are typically encountered in written material as statements like ``let J  denote the Bessel function of the first kind'' or ``let alpha denote a root  of the polynomial x^3-2''.  The purpose of the alias facility is to allow the  user to state such abbreviations for the longer unique names that Maple uses  and, more generally, to give names to arbitrary expressions.
- To define F as an alias for fibonacci, use alias(F=fibonacci).  To redefine F  as an alias for hypergeom simply use alias(F=hypergeom).  To remove this  alias for F use alias(F=F).
- Aliases work as follows. Consider defining alias(J=BesselJ), and then entering J(0,-x).  On input the expression J(0,-x) is transformed to BesselJ(0,-x).  Maple then evaluates and simplifies this expression as usual.  In this  example Maple returns BesselJ(0,x).  Finally, on output, BesselJ(0,x) is  replaced by J(0,x).
- The arguments to alias are equations.  When alias is called, the equations  are evaluated from left to right but are not subjected to any existing  aliases.  This means that you cannot define one alias in terms of another.
  Next, the aliases are defined.  Finally, a sequence of all existing aliases  is returned as the function value.
- The following improvements for Maple V should be noted.  An alias may be  defined for any Maple object except a numerical constant.  You may assign to  a variable by assigning to its alias.  The global symbol I in Maple has been  defined to be an alias for sqrt(-1).  Hence if you want to see the complex  constant displayed as j then you would use alias(I=I,j=sqrt(-1)).  Parameters  and local variables are not affected by aliases.  Thus it is possible to have  a local variable or parameter called I.