summaryrefslogtreecommitdiff
path: root/support/w2latex/EXEMPLES/chap1.rtf
blob: 63117827105f08aaec379fb8729ab0df02cd09c6 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
{\rtf1\mac\deff2 {\fonttbl{\f0\fswiss Chicago;}{\f2\froman New York;}{\f3\fswiss Geneva;}{\f4\fmodern Monaco;}{\f6\fdecor London;}{\f8\fdecor San Francisco;}{\f11\fnil Cairo;}{\f12\fnil Los Angeles;}{\f13\fnil Zapf Dingbats;}{\f14\fnil Bookman;}
{\f16\fnil Palatino;}{\f18\fnil Zapf Chancery;}{\f20\froman Times;}{\f21\fswiss Helvetica;}{\f22\fmodern Courier;}{\f23\ftech Symbol;}{\f24\fnil Mobile;}{\f33\fnil Avant Garde;}{\f34\fnil New Century Schlbk;}{\f101\fnil Wartburg;}{\f118\fnil Warwick S;}
{\f128\fnil Moscow;}{\f129\fnil Russian;}{\f135\fnil MATH-BES;}{\f140\fnil Lovell;}{\f149\fnil Detroit;}{\f171\fnil XB Futura ExtraBold;}{\f176\fnil H Futura Heavy;}{\f201\fnil ¡Math;}{\f512\fnil Alexandrie;}{\f2500\fnil Konstanz;}}
{\colortbl\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;}{\stylesheet{\s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 
\sbasedon0\snext0 toc 3;}{\s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 \sbasedon0\snext0 toc 2;}{\s233\qj\ri850\tqr\tldot\tx8504 \b\f20 \sbasedon0\snext0 toc 1;}{\s243\qj\tqc\tx4320\tqr\tx8640 \f20 \sbasedon0\snext243 footer;}{
\s252\qj\li354\sb40\sa40 \f20\ul \sbasedon0\snext0 heading 4;}{\s253\qj\li354\sb120\sa80 \b\f20 \sbasedon0\snext0 heading 3;}{\s254\qj\sb200\sa140 \b\f20\fs36\ul \sbasedon0\snext0 heading 2;}{\s255\qc\sb240 \b\f20\fs48 \sbasedon0\snext0 heading 1;}{\qj 
\f20 \sbasedon222\snext0 Normal;}{\s2\sb120\keep\keepn \b\f22 \sbasedon0\snext2 input;}{\s3 \f22\fs20 \sbasedon0\snext3 output;}{\s4\qj\li1120 \f20\fs20 \sbasedon0\snext4 commentaire;}}{\info{\title chap1.doc}{\author EBM}}
\paperw11880\paperh16800\margl1701\margr1701\margt1417\margb1417\deftab709\widowctrl\ftnbj {\*\nextfile disque dur:chap2.doc}\sectd \pgnrestart\pgnucrm\linemod0\linex0\cols1\endnhere {\footerl \pard\plain \s243\qc\tqc\tx4320\tqr\tx8640 \f20 {\fs20 
Calcul formel avec Maple   page \chpgn }\par 
}{\footer \pard\plain \s243\qc\tqc\tx4320\tqr\tx8640 \f20 {\fs20 Calcul formel avec Maple   page }{\fs20 \chpgn }{\fs20 \par 
}}\pard\plain \s233\qc\ri850\tqr\tldot\tx8504 \b\f20 Table des mati\'8fres\par 
\pard \s233\qj\ri850\tqr\tldot\tx8504 Introduction \'88 Maple\tab 1\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 I. L'interface utilisateur\tab 1\par 
II. Les entr\'8ees d'expression et d'instructions\tab 1\par 
III. Les fonctions Maple\tab 2\par 
IV. Sauvegarde des sessions\tab 3\par 
V. Observation et recherche des erreurs\tab 3\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. L'instruction trace\tab 3\par 
2. La variable printlevel\tab 4\par 
3. La variable infolevel et le suivi algorithmique\tab 6\par 
4. Les instructions print et lprint\tab 7\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 VI. Facilit\'8es suppl\'8ementaires\tab 7\par 
\pard\plain \s233\qj\ri850\tqr\tldot\tx8504 \b\f20 Calculer sur des nombres\tab 8\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 I. Calculer sur des entiers\tab 8\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1.Fonctions utilis\'8ees\tab 8\par 
2.Exemples d'utilisation\tab 9\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 II. Calculer sur des rationnels\tab 9\par 
III. Calculer sur des nombres alg\'8ebriques\tab 10\par 
IV. Calculer sur des r\'8eels\tab 11\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1.Fonctions classiques\tab 11\par 
2.Evaluation des r\'8eels en virgule flottante\tab 11\par 
3.Evaluations exactes et \'8evaluations en virgules flottantes\tab 12\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 VI.Calculer sur des complexes\tab 12\par 
VII. Exercices\tab 13\par 
\pard\plain \s233\qj\ri850\tqr\tldot\tx8504 \b\f20 Calculer avec des symboles\tab 14\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 I.Expressions alg\'8ebriques\tab 14\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1.Transformations d'expressions alg\'8ebriques\tab 14\par 
2.Calculs modulo un nombre premier\tab 18\par 
3.Racines communes, racines multiples\tab 18\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 II.Substitutions, affectations\tab 19\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1.Substitutions\tab 19\par 
2.Affectation imm\'8ediate, affectation diff\'8er\'8ee\tab 21\par 
3. Suppression d'une affectation\tab 22\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 III. Sommation, d\'8erivation, integration\tab 22\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Sommes et produits\tab 22\par 
2. Derivation\tab 24\par 
3. Int\'8egrales ind\'8efinies (ou primitives)\tab 26\par 
4. Int\'8egrales d\'8efinies\tab 26\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 IV. Resoudre des \'8equations\tab 28\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Solutions symboliques\tab 28\par 
2. Solutions num\'8eriques\tab 30\par 
3. Equations diff\'8erentielles\tab 31\par 
4. Suites r\'8ecurrentes\tab 33\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 V.Exercices\tab 34\par 
\pard\plain \s233\qj\ri850\tqr\tldot\tx8504 \b\f20 Les structures de donn\'8ees\tab 36\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 I. Types simples\tab 36\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Types num\'8eriques\tab 36\par 
2. Les chaines de caract\'8fres et le type "name"\tab 37\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 II. Types compos\'8es\tab 37\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Sequences\tab 37\par 
2. Listes\tab 39\par 
3. Ensembles\tab 39\par 
4. Type index\'8e\tab 40\par 
5. Tables\tab 40\par 
5. Array\tab 42\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 III. Types expressions. Op\'8erandes\tab 43\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Arbre d'une expression\tab 43\par 
2. Type et op\'8erandes d'une expression\tab 44\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 \page IV. Typage\tab 45\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Les types pr\'8ed\'8efinis\tab 45\par 
2. Le contr\'99le des types\tab 46\par 
3. Les types d\'8efinis par l'utilisateur\tab 47\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 V. L'evaluation\tab 49\par 
\pard\plain \s233\qj\ri850\tqr\tldot\tx8504 \b\f20 Programmer Maple\tab 51\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 I. Les structures de contr\'99le\tab 51\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Structures conditionnelles\tab 51\par 
2. Structure r\'8ep\'8etitive\tab 51\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 II. Les proc\'8edures\tab 52\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Les objets proc\'8edures\tab 52\par 
2. Param\'8ftres et variables locales\tab 54\par 
3. Nombre de param\'8ftres\tab 55\par 
4. Le passage des param\'8ftres\tab 56\par 
5. Type des param\'8ftres\tab 57\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 II. Les fonctions op\'8erateurs\tab 57\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. Fonctions fl\'8fches et fonctions angles\tab 57\par 
2. Un peu de programmation fonctionnelle\tab 59\par 
3. La d\'8efinition d'op\'8erateurs infixes\tab 60\par 
4. Exercices\tab 61\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 V. La r\'8ecursivit\'8e et les options\tab 61\par 
VI. R\'8esum\'8e de la syntaxe et de la s\'8emantique du langage\tab 62\par 
\pard\plain \s233\qj\ri850\tqr\tldot\tx8504 \b\f20 Les graphismes\tab 64\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 I. Utilisation des proc\'8edures graphiques\tab 64\par 
\pard\plain \s231\qj\li1440\ri720\tldot\tx8280\tqr\tx8640 \f20 1. La proc\'8edure plot (dimension 2)\tab 64\par 
2. Autres proc\'8edures graphiques en 2D\tab 66\par 
3. La proc\'8edure plot3d (dimension 3)\tab 69\par 
4. Autres proc\'8edures 3D\tab 72\par 
5. Animations\tab 73\par 
6. Superposition de trac\'8es\tab 74\par 
\pard\plain \s232\qj\li720\ri720\tldot\tx8280\tqr\tx8640 \f20 II. La programmation des graphiques\tab 74\par 
III. Exercices\tab 77\par 
\pard\plain \qj \f20 \par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\par 
\pard \qj Note: Le logiciel Maple{\up6 \'a9} ainsi que la marque Maple{\up6 \'a9} sont propri\'8et\'8es de Waterloo Maple Publishing. Les extraits des \'8ecrans d'aide de Maple sont uniquement destin\'8es \'88 \'90tre utilis\'8es en m\'90
me temps que le logiciel \'88 titre de r\'8ef\'8erence rapide et d'illustration de la syntaxe. Ils ne peuvent en aucune fa\'8don se substituer \'88 l'aide en ligne ainsi qu'aux ouvrages de base publi\'8es chez Springer Verlag:\par 
\pard \qj {\fs14 \par 
}\pard \qj \tab \tab Maple V  Library reference manual\par 
\pard \qj \tab \tab Maple V Language reference manual\par 
{\b\fs48 \sect }\sectd \pgnrestart\linemod0\linex0\headery1077\footery1077\cols1\colsx709\endnhere {\footer \pard\plain \s243\qc\tqc\tx4320\tqr\tx8640 \f20 {\fs20 \par 
}\pard \s243\qc\tqc\tx4320\tqr\tx8640 {\fs20 Calcul formel avec Maple  page }{\fs20 \chpgn }\par 
}\pard\plain \s255\qc \b\f20\fs48 Introduction \'88 Maple\par 
\pard\plain \qj \f20 \par 
\pard\plain \s254\qj\sb200\sa140 \b\f20\fs36\ul I. L'interface utilisateur\par 
\pard\plain \qj \f20 \tab Nous n'\'8evoquerons ici que l'interface utilisateur \'8evolu\'8ee que l'on peut trouver sur les versions Windows, MacIntosh ou X-Windows. Elle est compos\'8ee d'un \'8editeur pleine page pilot\'8e \'88
 la souris. Chaque page est divis\'8ee en cellules: des cellules d'entr\'8ees d'expressions ou d'instructions (type {\b input}), des cellules de sorties de r\'8esultat (type {\b output} ou \'8eventuellement graphiques), des cellules de commentaire (type {
\b text}) et des cellules graphiques. Vous pouvez introduire vous m\'90mes des cellules d'entr\'8ees ou des cellules de commentaires. Les cellules de sorties sont cr\'8e\'8ees par Maple lorsqu'il renvoye un r\'8e
sultat. Les cellules graphiques sont remplies par un couper-coller \'88 partir d'une fen\'90tre graphique (et en particulier celles cr\'8e\'8ees par Maple \'88 la suite d'une instruction de dessin).\par 
\pard \qj \tab Les cellules de commentaire sont \'88 votre enti\'8fre disposition. Les cellules d'entr\'8ees doivent commencer par un prompt (en g\'8en\'8eral {\fs28 \bullet } ou  {\b\fs36 >}), une commande de menu permettant d'ins\'8e
rer un prompt. Ces cellules d'entr\'8ee ont une taille qui s'adapte \'88 leur contenu. A l'int\'8erieur de ces cellules, la touche {\i Return}  provoque un retour \'88 la ligne de l'\'8e
diteur (retour chariot), si bien qu'une cellule peut comprendre plusieurs lignes logiques. Par contre, la touche {\i Enter}  (ou encore la combinaison {\i Shift-Return}  ) provoque l'envoi de la cellule courante \'88 l'\'8evaluateur de Maple.\par 
\pard \qj \tab Les cellules de sortie de Maple suivent imm\'8ediatement les cellules d'entr\'8ee. Elles peuvent \'90tre au choix format\'8ees en mode texte simulant des formules math\'8ematiques de mani\'8fre plus ou moins heureuse (veiller \'88
 utiliser en style {\b output }exclusivement une police non proportionnelle comme Monaco ou Courier, sinon vos exposants de baladeront n'importe o\'9d) ou en mode graphique (sorties "\'88 la TeX", assez esth\'8etiques).\par 
\pard \qj \par 
\pard\plain \s254\qj\sb200\sa140 \b\f20\fs36\ul II. Les entr\'8ees d'expression et d'instructions\par 
\pard\plain \qj \f20 \tab Comme on l'a vu, l'envoi d'une cellule d'entr\'8ee \'88 l'\'8evaluateur de Maple se fait par la touche {\i Enter}  ou encore par la combinaison {\i Shift-Return}  (la touche {\i Return}   provoquant un simple passage \'88
 la ligne sans changer de cellule d'entr\'8ee). Une cellule d'entr\'8ee peut contenir une ou plusieurs expressions Maple \'8evaluables. Ces expressions sont alors \'8evalu\'8ees si elles sont compl\'90tes et le r\'8esultat de chacune d'entre elles est 
\'8eventuellement affich\'8e dans une cellule de sortie.\par 
\pard \qj \tab Une expression Maple est compl\'90te si elle se termine par un point-virgule ({\b ;}) ou deux-points ({\b :}). Si vous envoyez \'88 l'\'8evaluateur une expression incompl\'90te, Maple se contente de r\'8e
afficher le prompt et d'attendre la suite de l'expression jusqu'\'88 ce qu'il rencontre le terminateur fatidique. Ce n'est qu'alors qu'il tentera de l'\'8evaluer (si bien qu'une expression Maple peut figurer de mani\'8fre morcel\'8e
e dans plusieurs cellules d'entr\'8ee). Lorsqu'une expression Maple est \'8evalu\'8ee, son r\'8esultat (s'il existe) est d\'8epos\'8e sur le sommet d'une pile d'\'8evaluation. Cette pile contient trois \'8el\'8ements au maximum, que l'on peut r\'8ecup\'8e
rer par trois symboles Maple qui sont  ", ""  et  """. C'est ainsi que " permet de r\'8ecup\'8erer le r\'8esultat de la derni\'8fre \'8evaluation. Lorque cette pile d\'8eborde, les \'8el\'8ements les plus anciens sont \'8elimin\'8e
s si bien que l'on ne peut acc\'8eder qu'aux r\'8esultats des trois derni\'8fres \'8evaluations.\par 
\pard \qj Remarque: nous avons essay\'8e de donner une id\'8ee succinte mais malheurusement inexacte de la signification des op\'8erateurs  de type ". Les choses sont en fait plus compliqu\'8ees et on se r\'8ef\'8frera \'88 l'aide en ligne et \'88
 la documentation pour conna\'94tre la signification exacte de ces op\'8erateurs qui fait intervenir le niveau d'ex\'8ecution. On peut regretter que les cr\'8eateurs de Maple aient utilis\'8e des op\'8erateurs dont la s\'8emantique est bien trop floue.
\par 
\pard \qj \tab Une fois le r\'8esultat d\'8epos\'8e sur cette pile d'\'8evaluation, celui ci est affich\'8e ou non dans une cellule de sortie suivant que le terminateur de l'expression \'8e
tait point-virgule ou deux-points. Le deux-points permet donc de ne pas afficher le r\'8esultat de l'\'8evaluation d'une expression, soit que le r\'8esultat soit en lui-m\'90me sans int\'8er\'90t, soit qu'il soit extr\'90mement compliqu\'8e
 et que son affichage entra\'94ne une grosse perte de temps ou d'espace \'8ecran (c'est parfois le cas de bien des r\'8esultats interm\'8ediaires).\par 
\pard \qj {\i Remarque}  : on a vu que seules les trois derniers r\'8esultats d'\'8evaluation sont accessibles. Il ne faut donc pas h\'8esiter \'88 effectuer des affectations pour des r\'8esultats interm\'8edaires que l'on pourrait vouloir r\'8e
utiliser; un autre moyen est d'utiliser une fonction de la biblioth\'8fque Maple qui s'appelle {\b history} et qui se charge de conserver au fur et \'88 mesure (au prix d'un encombrement de la m\'8emoire) tous les r\'8esultats des \'8evaluations.\par 
\pard \qj \par 
\pard\plain \s4\qj\li1120 \f20\fs20 FUNCTION: history - maintain a history of all values computed\par 
CALLING SEQUENCE:\par 
   history()\par 
SYNOPSIS:   \par 
\pard \s4\qj\li1120 - 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.\par 
\pard \s4\qj\li1120 - 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.\par 
\pard \s4\qj\li1120 - The previous value may be referred to by using " but "" and """ are no longer  available under history.\par 
- By typing off; the history session is terminated, control is passed back to  the normal session.\par 
- By typing timing(f); the time to execute the expression f will be displayed  after the normal output.\par 
\pard \s4\qj\li1120 - By typing clear; the values of O1, O2, ... are cleared.\par 
\pard \s4\qj\li1120 - 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\par 
\pard \s4\qj\li1120 - This function should be defined by the command readlib(history) before it is  used.\par 
\pard\plain \qj \f20 \par 
\pard\plain \s254\qj\sb200\sa140 \b\f20\fs36\ul III. Les fonctions Maple\par 
\pard\plain \qj \f20 \tab L'appel d'une fonction ou instruction Maple se fait comme en Math\'8ematiques, en Pascal ou en C sous la forme  {\i nom_de_fonction  (param\'8ftres_\'8eventuels}  ), \'88 l'aide de parenth\'8f
ses. Maple dispose de quatre types de fonctions:\par 
\pard \qj \tab - les fonctions de base, toujours disponibles et qui sont charg\'8ees en m\'8emoire d\'8fs que de besoin\par 
\tab - les fonctions de la biblioth\'8fque \'8etendue qui doivent \'90tre charg\'8ees explicitement par l'utilisateur avant leur emploi \'88 l'aide de l'instruction {\b readlib(}{\i nom_de_fonction} {\b )\par 
}\pard\plain \s4\qj\li1120 \f20\fs20 FUNCTION: readlib - read a library file to define a specified name\par 
CALLING SEQUENCE:\par 
   readlib(f)\par 
PARAMETERS:\par 
   f          - the name of a procedure to be read\par 
SYNOPSIS:   \par 
- With only one argument, calling readlib(f) causes the following statement to  be executed:\par 
\pard \s4\qj\li1120          read  ``.libname.`/`.f.`.m`;\par 
  This causes the .m file for f to be loaded from the standard Maple library.\par 
- The value returned from the readlib function is the value  assigned to the first argument f after executing the read statement(s).\par 
- It is an error if f does not become defined by this action.\par 
- The readlib function has option remember; hence subsequent invocations of  readlib with the same arguments will not cause files to be re-loaded.\par 

- 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.\par 
\pard\plain \qj \f20 \par 
\tab - les fonctions des diff\'8erents packages (ensembles de fonctions) de la biblioth\'8fque; on peut soit charger en m\'8emoire tout un package en bloc \'88 l'aide d'un {\b with}({\i nom_du_package} ), soit charger une unique fonction du package en m
\'8emoire \'88 l'aide d'un {\b with}( {\i nom_du_package} , {\i nom_de _fonction} ) , soit utiliser directement cette fonction en indiquant explicitement son package d'origine sous la forme {\i nom_du_package }{\b [}{\i nom_de_fonction}  {\b ]}
; imaginons par exemple que vous vouliez utiliser la fonction {\b submatrix} du package {\b linalg, }qui extrait une sous matrice d'une matrice donn\'8e
e; si vous ne l'utilisez qu'une seule fois pour extraire une sous matrice 3x3 d'une matrice A vous taperez\par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  B:=linalg[submatrix](A,1..3,1..3);\par 
\pard\plain \qj \f20 si par contre vous comptez l'utiliser plusieurs fois vous taperez\par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  with(linalg,submatrix):\line   B:=submatrix(A,1..3,1..3);\par 
\pard\plain \qj \f20 et vous disposerez d\'8esormais de la fonction {\b submatrix} comme d'une fonction de base. Si par contre vous pensez avoir besoin par la suite d'autres fonctions du package {\b linalg} vous taperez\par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  with(linalg):\line   B:=submatrix(A,1..3,1..3);\par 
\pard\plain \qj \f20 et vous disposerez d\'8esormais de toutes les fonctions du package comme de fonctions de base\par 
\tab - les fonctions utilisateurs; ces fonctions peuvent \'90tre cr\'8e\'8ees de mani\'8fre interactive au cours de la session Maple par programmation, mais elles peuvent aussi \'90tre entr\'8ees par l'interm\'8ediaire d'un fichier \'88
 l'aide de l'instruction {\b read} `{\i nom_du_fichier\~ }` (attention aux accents graves)  ou de mani\'8fre interactive \'88 l'aide du menu ad\'8equat; dans ce dernier cas, Maple r\'8eagira diff\'8e
remment suivant le suffixe de ce fichier. Si le nom du fichier se termine par '{\b .m}', Maple consid\'8erera qu'il s'agit d'un fichier compil\'8e; il en ex\'8ecutera les diverses instructions sans en afficher les r\'8e
sultats. Si par contre le nom du fichier ne se termine pas par '{\b .m}', Maple consid\'8erera qu'il s'agit d'un fichier texte; il en ex\'8ecutera les diverses instructions comme si elles avaient \'8et\'8e entr\'8e
es au clavier par l'utilisateur en affichant au fur et \'88 mesure les r\'8esultats.\par 
\par 
\pard\plain \s254\qj\sb200\sa140 \b\f20\fs36\ul IV. Sauvegarde des sessions\par 
\pard\plain \qj \f20 \tab Vous pouvez sauvegarder une session Maple sous forme de fichier ex\'8ecutable (en conservant uniquement les cellules d'entr\'8ee) ou sous forme de document complet. Pour le premier cas, vous pouvez le faire de mani\'8f
re interactive \'88 l'aide du menu ad\'8equat, ou \'88 l'aide de l'instruction {\b save }`{\i nom_du_fichier\~ }` (attention aux accents graves). Suivant que le nom du fichier se termine par '{\b .m}' ou non, Maple le sauvera sous forme compil\'8e
e ou sous forme de fichier texte.\par 
\par 
\pard\plain \s254\qj\sb200\sa140 \b\f20\fs36\ul V. Observation et recherche des erreurs\par 
\pard\plain \qj \f20 Contrairement \'88 d'autres environnements de programmation, Maple ne dispose pas de debogueur int\'8egr\'8e avec ex\'8ecution pas \'88 pas, observation des variables, etc. mais il dispose d'un certain nombre de facilit\'8e
s que nous allons examiner dans ce paragraphe.\par 
\pard\plain \s253\qj\li354\sb120\sa80 \b\f20 1. L'instruction trace\par 
\pard\plain \qj \f20 Une des facilit\'8es est de pouvoir observer certains appels de proc\'8edures ou de fonctions \'88 l'aide de l'instruction {\b trace}. Si vous demandez la trace de l'une des proc\'8edures ou fonctions (qu'elle soit pr\'8ed\'8e
finie dans Maple ou dans sa biblioth\'8fque ou bien qu'elle ait \'8et\'8e d\'8efinie par vous), \'88 chaque appel de la proc\'8edure ou de la fonction, Maple affichera la valeur courante des param\'8ftres \'88 l'entr\'8ee et la valeur de retour \'88
 la sortie (si celle ci existe). C'est un moyen commode de recherche d'erreurs simples se situant au niveau du passage des param\'8ftres, de valeurs de retour de fonctions ou de boucles sans fin. Ceci permet de suivre facilement les proc\'8edures r\'8e
cursives. Vous supprimez cette facilit\'8e avec l'instruction {\b untrace}.\par 
\par 
\pard\plain \s4\qj\li1120 \f20\fs20 FUNCTION: trace, untrace -  trace procedures in order to debug them\par 
CALLING SEQUENCE:\par 
   trace(f)\par 
   trace(f,g,h,...)\par 
   untrace(f)\par 
   untrace(f,g,h,...)\par 
PARAMETERS:\par 
   f, g, h, ... - name(s) of procedure(s) to be traced\par 
SYNOPSIS:   \par 
- The trace function is a debugging tool for tracing the execution of the procedure(s) f, g, h, and so forth.\par 
- 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.\par 
- The untrace function turns off the tracing of its arguments.\par 
- The trace (untrace) function returns an expression sequence of the names of  the procedures for which tracing was turned on (off).\par 
- 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.\par 
\pard\plain \qj \f20 \par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  fact:=proc(n) if n=1 then 1 else n*fact(n-1) fi; end:\line trace(fact):\line fact(5);\line untrace(fact):\par 
\pard\plain \qj \f20 \par 
\pard\plain \s3 \f22\fs20 \{--> enter fact, args = 5\par 
\{--> enter fact, args = 4\par 
\{--> enter fact, args = 3\par 
\{--> enter fact, args = 2\par 
\{--> enter fact, args = 1\par 
                                    1\par 
\par 
<-- exit fact (now in fact) = 1\}\par 
                                    2\par 
\par 
<-- exit fact (now in fact) = 2\}\par 
                                    6\par 
\par 
<-- exit fact (now in fact) = 6\}\par 
                                    24\par 
\par 
<-- exit fact (now in fact) = 24\}\par 
                                   120\par 
\par 
<-- exit fact (now at top level) = 120\}\par 
                                   120\par 
\pard\plain \s253\qj\li354\sb120\sa80 \b\f20 2. La variable printlevel\par 
\pard\plain \qj \f20 \tab L'\'8evaluation d'une expression de Maple est un processus complexe correspondant \'88 l'\'8evaluation d'un arbre. Maple maintient de mani\'8fre interne une variable disant \'88 quel niveau d'ex\'8ecution il en est \'88
 un instant donn\'8e. Sans rentrer dans le d\'8etail des structures de contr\'99le de Maple, disons que Maple augmente ce niveau de 1 chaque fois qu'il entre dans une structure conditionnelle ou it\'8erative, de 5 chaque fois qu'il entre dans une proc\'8e
dure ou une fonction. Il le diminue de 1 \'88 la sortie d'une structure conditionnelle ou it\'8erative, de 5 \'88 la sortie d'une proc\'8edure ou d'une fonction.\par 
\tab La variable interne {\b printlevel} de Maple est une variable qui contr\'99le le niveau des instructions qui sont affich\'8ees par Maple. Cette variable vaut initialement 0, c'est \'88 dire que Maple n'affiche que les r\'8e
sultats des instructions se d\'8eroulant au niveau le plus bas. Vous avez la possibilit\'8e de lui donner une valeur arbitraire, ce qui vous permettra de voir affich\'8es les r\'8esultats de toutes les instructions effectu\'8e
es par Maple jusqu'au niveau choisi.\par 
\pard\plain \s4\qj\li1120 \f20\fs20 HELP FOR: printlevel (display of information; debugging procedures)\par 
SYNOPSIS:   \par 
- printlevel := <integer>\par 
- 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.\par 

- 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 leve
l 6, etc.  The  n-th nested procedure is level 5*n.\par 
- 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.\par 

- 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.\par 
- For debugging purposes, printlevel := 1000; is not uncommon.\par 
\par 
\pard\plain \qj \f20 Voici un exemple avec notre proc\'8edure de calcul de la factorielle\par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  fact:=proc(n) if n=1 then 1 else n*fact(n-1) fi; end:\line printlevel:=12:\line fact(5);\line printlevel:=0:\par 
\pard\plain \qj \f20 \par 
\pard\plain \s3 \f22\fs20 \{--> enter fact, args = 5\par 
\{--> enter fact, args = 4\par 
                                    24\par 
\par 
<-- exit fact (now in fact) = 24\}\par 
                                   120\par 
\par 
<-- exit fact (now at top level) = 120\}\par 
                                   120\par 
\par 
\pard\plain \qj \f20 Il est facile ici de comprendre ce qui se passe. Au d\'8epart le niveau d'ex\'8ecution est 0. L'entr\'8ee dans la proc\'8edure fact le fait passer \'88 5. L'entr\'8ee dans la structure de contr\'99le le fait passer \'88
 6. La nouvelle entr\'8ee dans la proc\'8edure fact le fait passer \'88 11, puis dans la structure de contr\'99le \'88 12. A partir de l\'88, le niveau d'ex\'8ecution d\'8epasse le niveau d'impression {\b printlevel} et les ex\'8e
cutions d'instructions ne sont plus affich\'8ees jusqu'au retour du calcul de fact(3), auquel cas le niveau d'ex\'8ecution repasse \'88 12, puis \'88 11 au sortir du {\b if} puis \'88 6 au retour du calcul de fact(4), puis \'88 5 au sortir du {\b if}
 correspondant au calcul de fact(5), puis \'88 0 au sortir du calcul de fact(5).\par 
Attention: ce sont les instructions qui sont affich\'8ees; les \'8evaluations d'expressions sont \'8egalement consid\'8er\'8ees comme des instructions; par contre les tests conditionnels et le calcul des bornes d'une structure it\'8e
rative ne sont pas consid\'8er\'8es comme des instructions et ne sont pas affich\'8ees (ce qui ne facilite pas le debogage).\par 
Exemple:\par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  printlevel:=1: for i from 1 to 3 do x:=i*i od;\par 
\pard\plain \s3 \f22\fs20                                   x := 1\par 
                                  x := 4\par 
                                  x := 9\par 
\pard\plain \qj \f20 \par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  x:=0: y:=1: printlevel:=1:{\plain \f22 \line }if x=y then 0 else 1 fi;\par 
\pard\plain \s3 \f22\fs20                                     1\par 
\pard\plain \qj \f20 \par 
\pard\plain \s253\qj\li354\sb120\sa80 \b\f20 3. La variable infolevel et le suivi algorithmique\par 
\pard\plain \qj \f20 La variable {\b printlevel} permet un suivi de l'ex\'8ecution pas \'88 pas d'un calcul. La variable {\b infolevel} est destin\'8ee au contraire \'88 permettre \'88 une proc\'8edure donn\'8ee (si elle a \'8et\'8e pr\'8e
vue pour cela) de donner des renseignements \'88 l'utilisateur sur son d\'8eroulement \'88 l'aide d'une instruction {\b userinfo}. L'instruction {\b userinfo} utilis\'8ee dans la proc\'8edure a un param\'8ftre n (entier) fix\'8e. Si lors de l'ex\'8e
cution de la proc\'8edure, au moment o\'9d l'instruction est rencontr\'8ee, la variable {\b infolevel} a une valeur sup\'8erieure \'88 n, l'information en question est affich\'8ee, sinon elle ne l'est pas. Chaque proc\'8e
dure ou fonction dispose de sa propre variable {\b infolevel} \'88 laquelle on se r\'8ef\'8fre par {\b infolevel[}{\i nom_de_la_fonction} {\b ] }.\par 
\pard\plain \s4\qj\li1120 \f20\fs20 FUNCTION: userinfo - print useful information to the user\par 
CALLING SEQUENCE:\par 
   userinfo(lev, fn, e1, e2 ... )\par 
PARAMETERS:\par 
   lev - a non-negative integer\par 
   fn  - a procedure name or a set of procedure names\par 
   e1  - any expression\par 
   e2  - (optional) any expression\par 
SYNOPSIS:   \par 
- The procedure userinfo is used to print useful information to the user.\par 
- The first argument lev is a non-negative integer which determines the level  at which information will be printed.\par 
- The second argument fn is a procedure name or set of procedure names for  which this information is print
ed. 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.   \par 

- 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 prin
t(...) then that argument is prettyprinted.  If  one of the arguments is of the form lprint(...) then that argument is printed  on a separate line.\par 

- 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 equ
al to userinfo[all] .\par 
- Throughout the Maple V library userinfo statements have been used with the\par 
  following conventions:   \par 
  Level 1: reserved for information that the user must be told.\par 
  Level 2,3: general information, including technique or algorithm being used.\par 
  Level 4,5: more detailed information about how the problem is being solved\par 
\pard\plain \qj \f20 \par 
Exemple:\par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  solve(\{2*x+3*y=1,3*x+5*y=3\},\{x,y\});\par 
\pard\plain \s3 \f22\fs20 solve/linear:   # equations   2\par 
solve/linear/integer/sparse:   # equations   2\par 
solve/linear/integer/sparse:   x, 2*x+3*y-1, 2\par 
solve/linear/integer/sparse:   # equations   1\par 
solve/linear/integer/sparse:   y, y-3, 1\par 
solve/linear/integer/sparse:   backsubstitution at:   2\par 
solve/linear/integer/sparse:   backsubstitution at:   1\par 
                             \{y = 3, x = -4\}\par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  int(1/(x^2+1),x);\par 
\pard\plain \qj \f20 \par 
\pard\plain \s3 \f22\fs20 int/indef:   first-stage indefinite integration\par 
int/ratpoly:   rational function integration\par 
                                arctan(x)\par 
\pard\plain \s253\qj\li354\sb120\sa80 \b\f20 4. Les instructions print et lprint\par 
\pard\plain \qj \f20 Enfin vous disposez \'88 tout instant des instructions {\b print} ou {\b lprint} qui vous permettent d'afficher des r\'8esultats interm\'8ediaires. La proc\'8edure {\b print} les affiche format\'8es comme en sortie, l'instruction {\b 
lprint} les affiche non format\'8ees comme en sortie (les amoureux de C pourront \'8egalement trouver dans la biblioth\'8fque de Maple leur {\b printf} pr\'8ef\'8er\'8e avec une syntaxe tr\'8fs proche de C).\par 
Exemple:\par 
\pard\plain \s2\sb120\keep\keepn \b\f22 \bullet  fact:=proc(n) print(`on en est \'88 n=`.n); if n=1 then 1 else n*fact(n-1) fi; end:\par 
fact(5);\par 
\pard\plain \qj \f20 \par 
\pard\plain \s3 \f22\fs20                              on en est \'88 n=5\par 
                             on en est \'88 n=4\par 
                             on en est \'88 n=3\par 
                             on en est \'88 n=2\par 
                             on en est \'88 n=1\par 
                                   120\par 
\par 
\pard\plain \s254\qj\sb200\sa140 \b\f20\fs36\ul VI. Facilit\'8es suppl\'8ementaires\par 
\pard\plain \qj \f20 Les noms de fonctions de Maple sont parfois compliqu\'8es ou troublent des habitudes acquises depuis longtemps. Maple permet de renommer des objets sans les modifier \'88 l'aide de la fonction {\b alias} . Contrairement \'88
 une macro, il ne s'agit pas d'une abbr\'8eviation, mais bien d'un renommage qui fonctionne aussi bien pour les entr\'8ees de l'utilisateur que pour les sorties de Maple.\par 
\par 
\pard\plain \s4\qj\li1120 \f20\fs20 FUNCTION: alias - define an abbreviation or denotation\par 
CALLING SEQUENCE:\par 
   alias(e1, e2, ..., eN)\par 
PARAMETERS:\par 
   e1, e2, ..., eN - zero or more equations\par 
SYNOPSIS:   \par 

- 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.\par 
- 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).\par 

- 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 Besse
lJ(0,x).  Finally, on output, BesselJ(0,x) is  replaced by J(0,x).\par 
- 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.\par 
  Next, the aliases are defined.  Finally, a sequence of all existing aliases  is returned as the function value.\par 
- 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 b
y 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 affecte
d by aliases.  Thus it is possible to have  a local variable or parameter called I.\par 
}