66
Introduction ` a Maple UE4 Master Recherche Math´ ematiques Jean-Pol Guillement epartement de Math´ ematiques Nantes 2009/2010

Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

  • Upload
    others

  • View
    1

  • Download
    0

Embed Size (px)

Citation preview

Page 1: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Introduction a Maple

UE4 Master Recherche Mathematiques

Jean-Pol Guillement

Departement de Mathematiques

Nantes 2009/2010

Page 2: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

2

Page 3: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Table des matieres

Introduction 5

1 Prise de contact 7

1.1 Generalites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.2 Exemples de commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

2 Environnement : relation avec le systeme d’exploitation 21

2.1 Personnalisation du systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.2 Chargement d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.3 Commandes systeme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.4 Historique des commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.5 Chargement des bibliotheques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.6 Visualisation du code d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.7 Execution en mode batch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.8 Debugage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.9 Aide en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3 Elements complementaires de syntaxe 25

3.1 Les branchements conditionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.1.1 Le si . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3.1.2 Le choix multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.2 Les repetitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.2.1 La boucle pour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

3.2.2 La boucle tant que . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

4 Les structures de base 29

4.1 Les objets Maple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.1.1 Les objets atomiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.1.2 Les structures de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4.1.3 Les structures composites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

4.1.4 Creation explicite de structures composites . . . . . . . . . . . . . . . . . . . . 31

4.2 Manipulations des objets de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2.1 Extraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2.2 Selection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2.3 Nombre d’elements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2.4 Constitution de suites et de listes . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.2.5 Test de la suite ou de la liste vide . . . . . . . . . . . . . . . . . . . . . . . . . 33

4.2.6 La fonction map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

5 Les expressions booleennes 35

5.1 Le symbole ”=” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5.2 Le predicat ”=” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

5.3 Le predicat ”<” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

Page 4: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

4 TABLE DES MATIERES

6 Les evaluations 37

6.1 Regles d’evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376.2 Illustration des regles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

6.2.1 Niveau d’evaluation et affectations . . . . . . . . . . . . . . . . . . . . . . . . . 376.2.2 Affectations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396.2.3 Quotage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396.2.4 Quelques differences difficilement previsibles . . . . . . . . . . . . . . . . . . . . 40

7 Les fonctions 41

7.1 Definition des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417.2 Comment voir le contenu des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . 417.3 Fonctions anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417.4 Variables locales, variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417.5 Valeur retournee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427.6 Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427.7 Controle des parametres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437.8 Passage des parametres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437.9 Fonctions locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

8 Les modules 47

9 Les entrees-sorties 49

9.1 Les fonctions d’entree-sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499.1.1 Fonctions de lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499.1.2 Analyse d’une chaıne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499.1.3 Fonctions d’ecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49

9.2 Les redirections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499.3 Lecture de donnees dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509.4 Ecriture de donnees dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

10 Manipulation des expressions 53

10.1 Diverses fonctions de manipulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5310.1.1 Assign . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5310.1.2 Unapply . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5410.1.3 Sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5410.1.4 Subsop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5510.1.5 Parse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5510.1.6 Solve/identity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5510.1.7 Allvalues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5610.1.8 Value . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

10.2 Reecriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5710.2.1 Expand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5710.2.2 Simplify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5710.2.3 Factor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5710.2.4 Collect . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5810.2.5 Combine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5910.2.6 Normal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5910.2.7 Rationalize . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5910.2.8 Convert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

Bibliographie 61

Index 65

Page 5: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Introduction

Maple est avant tout un logiciel de calcul formel, symbolique, c’est-a-dire qui travaille sur les expres-sions a la difference du calcul numerique qui calcule sur les nombres. Il integre des possibilites decalcul numerique qui sont au fil des nouvelles versions de plus en plus performantes. Mais le calculnumerique n’est pas son objectif.Maple est un logiciel generaliste qui convient tres bien par exemple pour les calculs usuels genreTerminale-Deug. Il touche a toutes les branches des mathematiques sur lesquelles on peut calculer. Iln’est pas specialise et de ce fait, ne pretend pas rivaliser avec les logiciels specifiques comme :

- Matlab pour le numerique,

- pari, (Mathematica ?), ... pour l’algebre.

C’est de tres loin le logiciel le plus utilise (5 millions de licences en 2003). Il est commercialise par lasociete Maplesoft qui a pratique une politique commerciale astucieuse.

Quelques dates :

1960 Les premiers logiciels de calcul formel, Macsyma, Reduce, a base de Lisp, necessitent de grosordinateurs et offrent des possibilites limitees.

1980 Projet d’ecrire d’un logiciel qui puisse tourner sur des machines plus modestes (anticipation del’emergence des ordinateurs individuels) : petit programme, efficace, noyau reduit, ecrit en C.

1983 1er cours avec Maple, 1ers articles, 50 installations dans le monde.

1984 Contrat avec la societe Watcom pour la commercialisation.

1985 Debut de la commercialisation.

1987 300 installations.

1987 Contrat avec la societe Waterloo Maple Software (Universite de Waterloo).

1988 2000 installations.

2003 Societe Maplesoft, 5 millions de licences.

Il y a differents niveaux d’utilisation de Maple :

- Le mode commande reduit aux fonctions les plus basiques comme

- plot,

- int,

- diff ...

Ce type d’utilisation ne necessite pas de suivre un cours. Il y a de nombreux tutoriels bien faitssur le Web. Par exemple [13].

- Le mode commande avec resolution

- d’equations generales,

- de systemes lineaires,

- d’equations differentielles.

Ce niveau d’utilisation necessite de connaıtre les structures de base de Maple.

- Le mode de programmation qui permet par exemple la resolution de problemes du genre Terminale-Deug. Il faut savoir enchaıner les calculs, faire passer les resultats d’une commande a une autre,utiliser des fonctions.

Page 6: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

6 Introduction

- La programmation de methodes de calcul formel, c’est-a-dire l’enrichissement du systeme.

Avant d’etudier Maple il est necessaire de bien faire la distinction entre les 4 types de calcul mathematique :

- Le calcul mathematique habituel, sur feuille de papier, celui auquel on est le plus habitue, difficilea definir, tout le monde voit de quoi on parle.

- Le calcul numerique (scientifique). C’est l’art de reduire les calculs a un nombre fini d’operationsarithmetiques elementaires portant sur des nombres representes par un ensemble fini de sym-boles (les chiffres). Le calcul numerique fait necessairement apparaıtre deux types d’approxima-tion et d’erreur : l’approximation des nombres par les flottants, (Pi, 1/10 en base 2, ...) et ladiscretisation incontournable. On met en œuvre les calculs numeriques a l’aide des langages deprogrammation comme le Fortran, le C, le Pascal, ... et aussi a l’aide de logiciels numeriquescomme Matlab.

- Le calcul formel qui opere sur les expressions mathematiques, mecaniquement, automatiquement,par programmation. Par exemple le calcul de l’integrale de exp(−x2) sur ]−∞,∞[ peut se realiserde facon formelle (=

√π) et de facon numerique, approchee, (≈ 1.772453851). La meme integrale,

mais sur [0..1] ne peut se calculer de facon formelle, sauf en repondant a l’aide d’une fonctionspeciale c’est-a-dire en retournant la question posee.

- Le calcul analogique comme par exemple celui que l’on peut faire avec une regle a calcul.

Comme nous l’avons deja note, Maple est concu pour le calcul formel, meme s’il integre de plus enplus, (pour des necessites commerciales sans doutes), de bons outils permettant le calcul numerique.Pour ma part, je constate qu’il n’est pas du tout approprie aux calculs volumineux qui caracterisent laplupart des calculs scientifiques. Par ailleurs il n’est pas tres facile de savoir lui imposer une demarchecompletement numerique et il n’est pas facile de savoir quand il travaille en formel et quand il aban-donne le formel pour s’orienter vers le numerique.

Page 7: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 1

Prise de contact

1.1 Generalites

Maple est un interprete en attente d’une expression a evaluer (ou d’une instruction a executer). L’at-tente est signalee par un prompt, ”>”. On appelle Toplevel cet etat.Le ” ;” et le ” :” marquent la fin de l’expression a evaluer. (Le ”Return” est ignore, ce n’est pas unemarque de fin d’expression).Les expressions a evaluer sont des symboles, des expressions mathematiques ”correctement parentheses”.(Une definition precise ne peut etre donnee sans recours a la grammaire sous-jacente a Maple).Si l’expression est terminee par ” ;”, Maple affiche a l’ecran la representation de la valeur du dernierresultat. Ce n’est pas le cas quand l’expression est terminee par ” :”.On ferme le logiciel avec ”quit”.

On peut travailler en mode Texte interactif ou batch, et en mode Graphique interactif (sous Unixcommande maple -x ou xmaple).

Note : Il y a des differences entre les versions. En 2007 c’est la version 11 qui est commercialisee. Engros, les versions 2 et 3 assez semblables different de la version 4. Les versions 6 . . . 11 respectent lameme syntaxe, tres voisine de celle de la version 5.

1.2 Exemples de commandes

|\^/| Maple 9 (IBM INTEL LINUX)

._|\| |/|_. Copyright (c) Maplesoft, a division of Waterloo Maple Inc. 2003

\ MAPLE / All rights reserved. Maple is a trademark of

<____ ____> Waterloo Maple Inc.

| Type ? for help.

true

# Debut avec maple

# Sept 2000, J-P Guillement

>

> printf("\tExecute sur %s\tle %s\n",ssystem("hostname")[2],ssystem("date")[2]);

Execute sur Quad

le Wed Sep 12 09:58:55 CEST 2007

>

# pour demarrer maple en mode texte interactif sur unix

# taper "maple" sur la ligne de commande.

# pour quitter maple taper "quit"

>

# pour evaluer entierement ce texte en mode interactif taper (sous maple)

# read("nomdufichier");

# et taper RETURN apres chaque message RETURN

Page 8: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

8 Prise de contact

>

# pour evaluer la totalite du fichier en mode batch sous Unix

# maple [-exec] nomdufichier

# ou maple [-exec] nomdufichier > resultats

# ou maple < nomdufichier > resultats

# (sous Windows, utiliser la comande "cmaple").

>

# pour avoir de l’aide sur l’aide taper "??"

# pour avoir de l’aide sur la commande solve par exemple

# en Version 3 et Version 6 taper "?so". En Version 4 taper "?solve"

# En Version 4, pour avoir la liste des fonctions disponibles

# taper "?index[function]"

#

>

# Pour reprendre des calculs, utiliser parfois x:=’x’:

# ou evaln(x) ou unassign(’x’) pour faire un nettoyage

>

#################################################

# Prise de contact avec Maple #

#################################################

> 5;

5

> 2+5*3;

17

> sin(0);

0

> print(x);

x

> x:=2;

x := 2

> x;

2

> print(x);

2

> y:=x;

y := 2

> y;

2

> toto;

toto

> toto:=y;

toto := 2

> toto;

2

> y:="bonjour";

y := "bonjour"

Page 9: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

1.2 Exemples de commandes 9

> toto;

2

>

> sin(1);

sin(1)

> evalf(sin(1));

0.8414709848

> evalf(sin(1),30);

0.841470984807896506652502321630

> sin(1.0);

0.8414709848

> evalf(sin(1.0));

0.8414709848

> evalhf(sin(1.0));

0.841470984807896505

> evalhf(sin(1));

0.841470984807896505

> tmp:=Digits;

tmp := 10

> Digits:=50;

Digits := 50

> evalf(4*arctan(1));

3.1415926535897932384626433832795028841971693993751

> Digits:=tmp;

Digits := 10

>

# petite programmation de fonction

# selon version, V3 = true or false

> V3:=evalb(SearchText("3",interface(version),15..20) > 0);

V3 := true

# ou V3:= evalb(evalf(E-exp(1)) =0);

> V5:=evalb(SearchText("5",interface(version),15..20) > 0);

V5 := false

> V6:=evalb(SearchText("6",interface(version),15..20) > 0);

V6 := false

> V7:=evalb(SearchText("7",interface(version),15..20) > 0);

V7 := false

> V5:= V5 or V6 or V7;

V5 := false

> if (V3) then

> ret := ()-> readline(terminal):

> elif (V5) then

Page 10: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

10 Prise de contact

> ret:=proc() printf("\n");readline(default):end;

> else

> ret := readline:

> fi:

>

# Mathematiques

> printf("Maintenant Arithmetique et Calcul polynomial, RETURN ");

Maintenant Arithmetique et Calcul polynomial, RETURN > ret():

> ifactor(100);

2 2

(2) (5)

> isprime(101);

true

> 1/3 mod 7;

5

>

> factor(x^5+1);

33

> x:=’x’;

x := x

> factor(x^5+1);

4 3 2

(x + 1) (x - x + x - x + 1)

> p:=1+expand((x-1)*(x-3)*(x-5));

3 2

p := -14 + x - 9 x + 23 x

> s:=solve(p=1,x);

s := 1, 3, 5

# s := 1, 3, 5 # l’ordre peut varier

> s[2];

3

> y:=’y’;

y := y

> solve({x+y=2,x-y=1});

{y = 1/2, x = 3/2}

> x;

x

> assign(%%);

> x;

3/2

# trigonometrie

> printf("Maintenant trigonometrie, RETURN ");

Maintenant trigonometrie, RETURN > ret():

> x:=’x’;

Page 11: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

1.2 Exemples de commandes 11

x := x

> cos(x)^2+sin(x)^2;

2 2

cos(x) + sin(x)

> simplify(cos(x)^2+sin(x)^2);

1

> combine(cos(x)^2+sin(x)^2,trig);

1

> e:=expand(cos(5*x));

5 3

e := 16 cos(x) - 20 cos(x) + 5 cos(x)

> combine(e,trig);

cos(5 x)

> sin(n*Pi);

sin(n Pi)

> assume(n,integer); sin(n*Pi);

0

# 0 en version 4 et sin(n~ Pi) en version 3

#

> solve(sin(x),x);

0

> _EnvAllSolutions := true: solve(sin(x));

Pi _Z1~

# attention retourne 0 en version 3 si la requete solve(sin(x));

# a ete faite prealablement a l’affectation de _EnvAllSolutions !

>

# algebre lineaire

> with(linalg): # noter le : pour discretion

Warning, the protected names norm and trace have been redefined and unprotected

> printf("Maintenant algebre lineaire, RETURN ");

Maintenant algebre lineaire, RETURN > ret():

# petit calculs sur les matrices de Hilbert

> h4:=matrix(4,4,[seq(seq(1/(i+j),i=1..4),j=1..4)]);

[1/2 1/3 1/4 1/5]

[ ]

[1/3 1/4 1/5 1/6]

h4 := [ ]

[1/4 1/5 1/6 1/7]

[ ]

[1/5 1/6 1/7 1/8]

> det(h4); evalf(%);

1/423360000

-8

0.2362055933 10

> h:=n->matrix(n,n,[seq(seq(1/(i+j),i=1..n),j=1..n)]):

Page 12: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

12 Prise de contact

> deth:=n->det(h(n));

deth := n -> det(h(n))

> d6:=deth(6);

d6 := 1/172153600393420800000

> h6:=h(6):

> norm(h6);

223

---

140

> n2:=norm(h6,2);

1/2 6 5

n2 := 1/210 5 RootOf(62953620111360000 _Z - 700749536346021888000 _Z

4 3

+ 62512217960687222169600 _Z - 14491862768764210106880 _Z

2 1/2

+ 3301345200565172560 _Z - 236492379085 _Z + 1, index = 6)

> n2f:=evalf(n2);

n2f := 1.118858688

> p:=charpoly(h6 &* h6,x):

> p:=p/subs(x=0,p);

6

p := 29636862128417614224539925872640000000000 x

5

- 37402940357699778471770869963161600000000 x

4

+ 378302532523400164964886734340096000000 x

3 2

- 9943286845929810115968744099840000 x + 256819566380446129856544000 x

- 2085862783529700 x + 1

> vph6h6:=eigenvals(h6 &* h6);

vph6h6 := 1/8820 RootOf(%1, index = 1), 1/8820 RootOf(%1, index = 2),

1/8820 RootOf(%1, index = 3), 1/8820 RootOf(%1, index = 4),

1/8820 RootOf(%1, index = 5), 1/8820 RootOf(%1, index = 6)

6 5

%1 := 62953620111360000 _Z - 700749536346021888000 _Z

4 3

+ 62512217960687222169600 _Z - 14491862768764210106880 _Z

2

+ 3301345200565172560 _Z - 236492379085 _Z + 1

>

> norm(h6,infinity);

Page 13: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

1.2 Exemples de commandes 13

223

---

140

> cond(h6);

91073646

> vp:=evalf(Eigenvals(h6));

[ -7 -5

vp := [0.2203114976 10 , 0.2850438197 10 , 0.0001607660527, 0.005130954614,

]

0.1008467195, 1.118858688]

> printf("det h%a = %a, prod vp = %a\n",6,evalf(d6),‘*‘(op(convert(vp,list))));

det h6 = .5808766112e-20, prod vp = .5844916720e-20

> printf("norme2 h%a = %a, plus gde vp = %a\n\n\n",6,n2f,max(op(convert(vp,list))));

norme2 h6 = 1.118858688, plus gde vp = 1.118858688

#

# calcul diff et integral

> printf("Maintenant calcul diff, RETURN ");

Maintenant calcul diff, RETURN > ret():

> diff(exp(cos(x)),x);

-sin(x) exp(cos(x))

> subs(x=0,%); simplify(%);

-sin(0) exp(cos(0))

0

> diff(sin(x),x,x); diff(sin(x),x$2);D(sin);(D@@3)(sin);

-sin(x)

-sin(x)

cos

-cos

> taylor(exp(cos(x)), x=0, 4 );

2 4

exp(1) - 1/2 exp(1) x + O(x )

> int(x^2,x=0..1);

1/3

> int(x*exp(x),x);

x exp(x) - exp(x)

> fx:=sin(x)/x;

sin(x)

fx := ------

x

>

> int(fx,x=0..infinity);

Page 14: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

14 Prise de contact

Pi

----

2

> y:=’y’;

y := y

> int(int(exp(-x^2-2*y^2-3*y),x=-infinity..infinity),y=-infinity..infinity);

1/2

1/2 exp(9/8) Pi 2

#

> n:=’n’: e2:=sum(k^2,k=1..n);

3 2

(n + 1) (n + 1)

e2 := -------- - -------- + n/6 + 1/6

3 2

> factor(e2);

n (n + 1) (2 n + 1)

-------------------

6

> s:=Sum(a(n)*sin(n*x),n=0..infinity);

infinity

-----

\

s := ) a(n) sin(n x)

/

-----

n = 0

> s0:=subs(x=0,s);

infinity

-----

\

s0 := ) a(n) sin(0)

/

-----

n = 0

> simplify(s0);

0

# avec versions precedentes simplify(s0); ->

# infinity

# -----

# \

# ) 0

# /

# -----

# n = 0

> evalf(s0);

0.

> value(s0);

0

>

Page 15: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

1.2 Exemples de commandes 15

> pi2s6:=sum(1/k^2,k=1..infinity);

2

Pi

pi2s6 := ---

6

> k:=’k’:sn2:=sum(1/k^2,k=1..n);

2

Pi

sn2 := -Psi(1, n + 1) + ---

6

> asympt(sn2,n);

2

Pi 1 1 1 1

--- - 1/n + ---- - ---- + ----- + O(----)

6 2 3 5 6

2 n 6 n 30 n n

>

> y:=’y’:

> s:=dsolve(diff(y(x),x$2) + y(x), y(x));

s := y(x) = _C1 sin(x) + _C2 cos(x)

# attention l’ordre de sin(x) et de cos(x) peut changer

#

> y(x);

y(x)

> assign(s);

> y(x);

_C1 sin(x) + _C2 cos(x)

> y(0);

y(0)

> simplify(y(0));

y(0)

> subs(x=0,y(x));

_C1 sin(0) + _C2 cos(0)

> simplify(%);

_C2

> coeff(y(x),sin(x));

_C1

> print(y);

proc() option remember; ’procname(args)’ end proc

> print(y(x));

_C1 sin(x) + _C2 cos(x)

> print(y(t));

y(t)

> whattype(y);

symbol

Page 16: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

16 Prise de contact

> whattype(y(x));

+

> whattype(y(t));

function

> has(y(x),sin(x));

true

> select(has,y(x),sin(x));

_C1 sin(x)

>

>

>

>

# suites recurrentes

> printf("Maintenant suites recurrentes, RETURN ");

Maintenant suites recurrentes, RETURN > ret():

n:=’n’: p:=’p’: up:=rsolve(u(n+2)=u(n+1)+u(n),u(p));

> restart: # rsolve est tres capricieux

> V3:= evalb(evalf(E-exp(1)) =0);

V3 := false

> n:=’n’: p:=’p’: up:=rsolve(u(n+2)=u(n+1)+u(n),u(p));

/ 1/2 \p

1/2 1/2 | 5 |

up := (1/2 u(0) + 1/10 u(0) 5 - 1/5 u(1) 5 ) |- ---- + 1/2|

\ 2 /

/ 1/2 \p

1/2 1/2 |5 |

+ (1/2 u(0) - 1/10 u(0) 5 + 1/5 u(1) 5 ) |---- + 1/2|

\ 2 /

> u(0):=1: u(1):=1:

> u5:=subs(p=5,up);

/ 1/2\ / 1/2 \5 / 1/2\ / 1/2 \5

| 5 | | 5 | | 5 | |5 |

u5 := |1/2 - ----| |- ---- + 1/2| + |1/2 + ----| |---- + 1/2|

\ 10 / \ 2 / \ 10 / \ 2 /

> evalf(u5);

7.999999983

> if (V3) then readlib(rationalize): fi:

> rationalize(u5);

8

>

> u:=n->u(n-1)+u(n-2):

# u(5);

# Error, (in u) too many levels of recursion

> u(0):=1:u(1):=1: u(5);

8

>

> n:=’n’:u:=evaln(u);

Page 17: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

1.2 Exemples de commandes 17

u := u

# pb avec version 7, reponse correcte apres restart ???

>

> rsolve(u(n)=2*u(n/2)+n,u(n));

n (u(1) ln(2) + ln(n))

----------------------

ln(2)

>

# calcul sur les groupes

> printf("Maintenant calcul sur les groupes, RETURN ");

Maintenant calcul sur les groupes, RETURN > ret():

>

> with(group):

> g:=permgroup(5,{[[1,2]],[[1,2,3,4,5]]});

g := permgroup(5, {[[1, 2]], [[1, 2, 3, 4, 5]]})

> grouporder(g);

120

> isabelian(g);

false

>

>

>

# Transformation de Fourier

> printf("Maintenant transformation de Fourier, RETURN ");

Maintenant transformation de Fourier, RETURN > ret():

>

> if (V3) then readlib(fourier): else with(inttrans) fi:

>

> y:=’y’: fo:=fourier(exp(-Pi*t^2/2),t,y);

2

y 1/2

fo := exp(- ----) 2

2 Pi

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

Page 18: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

18 Prise de contact

>

# plots

> printf("Maintenant dessins, RETURN ");

Maintenant dessins, RETURN > ret():

>

> plot(sin(x),x=-10..10);

AAA 1+ AAAA AAA

A AA + AA A AA AA

AA A + A A AA AA

A A + AA AA A A

A A + A A AA A

A A A 0.5+ AA A A A

A A A + A A A A

A A AA +AA A A A

A A A +A A A A

A A A +A A AA AA

++*++-++-++-++*++-++-++-++*++-++-++-+**+-++-++-++*++-++-++-++*++-++-++-++*++

AA AA A * A A A

-10 A -8 A-6 -4 A -2 * 2 A 4 6 8 10

A A A A+ A A A

A A A A+ A AA A

A A A -0.5+ A A A

AA AA A A + A A

A A AA AA + A A

AA AA A A + A AA

AA AA A AA + AA A

AAA AAAA -1+ AAA

>

> plot(sin(x)+0.08*cos(40*x),x=-10..10);

AA + AAA AAA

AAAA 1+ AAAA AAAAA

AAA AA + AAAAAA AA AA

AA AA + AA AA AA AA

AA AA + AA AA AA AA

A A AA 0.5+ A AA AA AA

AA AA AA + A AA AA AA

A A AA + A A AA AA

AA AA A +A AA A A

A AA AA *A A AA A

++*++-++-++-++*++-++-++-+**++-++-++-+**+-++-++-++*++-++-++-++*++-++-++-++*++

AA AA A * AA AA A

-10AA -8 A-6 -4 A -2 A* 2 A 4 6A 8 10

A A A A* AA AA AA

A AA A A+ A A AA

AA A A -0.5+ AA A A

AA A AA A + AA AA

AA AA A AA + AA AA

AAA AA AA AAA + AAAAAAA

AAAAA AAAAA-1+ AAAAA

AAA AA + AAA

>

>

>

> with(plots):

Warning, the name changecoords has been redefined

Page 19: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

1.2 Exemples de commandes 19

> plotsetup(ps,plotoutput=‘tore.ps‘):

> n:=10;

n := 10

> tubeplot({[10*cos(t),10*sin(t),0,

> t=0..2*Pi,radius=2,numpoints=10*n,tubepoints=2*n],

> [cos(t)*(10+4*sin(9*t)),sin(t)*(10+4*sin(9*t)),4*cos(9*t),

> t=0..2*Pi,radius=1,numpoints=trunc(37.5*n),tubepoints=n]},

> scaling = CONSTRAINED , orientation = [76,40]);

>

Page 20: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

20 Prise de contact

Page 21: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 2

Environnement : relation avec lesysteme d’exploitation

L’utilisation de Maple depend de 3 choses :

- De l’interface choisie, Texte ou Graphique,

- Du systeme d’exploitation, Unix, Windows, Macintosh,

- De la version utilisee.

Les nouvelles versions de Maple offrent des possibilites importantes pour exporter les calculs, endocuments latex, html ...Ces possibilites necessitent l’usage de Maple en mode Graphique et la creationde ce que Maple appelle feuilles de calcul. Il n’est pas question ici de regarder ces fonctionnalites. Ons’interesse principalement au mode Texte, plus rustique, qui presente par ailleurs le grand avantaged’etre beaucoup plus portable.Bien que generales, les explications qui suivent concernent le mode Texte sous Unix.

2.1 Personnalisation du systeme

Le fichier .mapleinit, s’il existe dans le repertoire personnel (home directory) est execute en debutde toute session Maple. On peut donc y mettre les instructions dont on souhaite systematiquementl’execution. Par exemple plotsetup(X11) ; kernelopts(printbytes=false) ;

2.2 Chargement d’un fichier

Il est fondamental de passer par l’intermediaire de fichiers pour solliciter Maple. En mode Texte cesfichiers sont des fichiers ordinaires (Texte, Ascii) que l’on ecrit avec n’importe quel traitement detexte (qui ne doit rien ajouter d’autre que ce que l’on a ecrit). Ils contiennent des requetes Maple,completement identiques a celles que l’on tape au Toplevel. Pour faire connaıtre leur contenu il faututiliser la commande read(). (Les copies-colles ne peuvent etre utilises que pour quelques lignes).La syntaxe d’utilisation de read est

read(nom_de_fichier);

nom de fichier est une chaıne de caractere qui doit designer correctement le fichier a solliciter, avecchemin d’acces si necessaire. En principe (version ≥ 4) les chaınes de caracteres sont a mettre entreguillemets (”). Si nom de fichier ne contient pas de signe Maple (−, /, \, ..) les guillemets peuventetre omis. On reviendra plus loin sur la facon dont Maple evalue les objets. Par exemple la commande

read("/tmp/prog1.txt");

demande a Maple d’ouvrir le fichier /tmp/prog1.txt et d’executer toutes les requetes qui s’y trouvent,exactement comme si elles etaient tapees au Toplevel.

Note : Les fichiers provenant des feuilles de calcul, (extension ”.mws”) ne peuvent pas etre lues en modeTexte. Il est necessaire de passer en mode Graphique, et d’utiliser read ou le menu Fichier-Ouvrir.

Page 22: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

22 Environnement : relation avec le systeme d’exploitation

2.3 Commandes systeme

Comme avec tous les langages et tous les interpretes, Maple offre la possibilite de lancer des commandessystemes depuis l’interieur d’une session. Il y a pour cela la fonction system() et le macro caractere” !”.

system("ls") # liste le repertoire courant

system("pwd") # affiche le nom du repertoire courant

!ne prog1.txt # edite (si editeur ne existe) prog1.txt

2.4 Historique des commandes

En mode Texte (pas en mode Graphique), on peut reediter les commandes avec les fleches ↑ et ↓.C’est tres commode.On peut aussi afficher les 3 derniers resultats avec

%; # dernier resultat

%%; # avant dernier

%%%; # avant avant dernier

On peut aussi indexer les resultats en utilisant au prealable la fonction history() ;

2.5 Chargement des bibliotheques

Afin que le systeme demarre rapidement et n’occupe que peu de memoire, Maple ne charge en debutde session, que le minimum, le noyau. De ce fait c’est a l’utilisateur de reclamer le chargement desbibliotheques necessaires. Il n’a pas a connaıtre leur localisation. Il y a deux fonctions de chargement,with() et readlib().

with(linalg); # charge toutes les fonctions

# de la bibliotheque d’algebre

# lineaire linalg

readlib(ancienne_bibliotheque);

2.6 Visualisation du code d’une fonction

On dispose du code de toutes les fonctions des bibliotheques ecrites en Maple. Ce n’est pas tres facile,mais c’est instructif de pouvoir les regarder.

interface(verboseproc=2);

print(sin); # affiche le code de la fonction

# sinus

# ou

showstat(sin);

2.7 Execution en mode batch

En dehors de Maple, sous le systeme d’exploitation, il est possible de lancer Maple pour l’executiond’un unique fichier. Et eventuellement de recuperer les resultats dans un autre fichier.

maple nom_de_fichier > fichier_resultats

2.8 Debugage

Rechercher les erreurs dans un programme est une chose courante. Ce n’est guere possible de pro-grammer juste du premier coup. En general on ajoute des affichages supplementaires pour controler lescalculs. Maple fournit diverses possibilites supplementaires. La valeur de la variable printlevel peutetre modifiee. Plus la valeur est grande (7,15,255,..), plus Maple donne d’information sur les calculseffectues et sur les parametres passes aux differentes fonctions. Il y a aussi les fonctions trace() etstopat() qui permettent le pas a pas. (Consulter l’aide en ligne).

Page 23: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

2.9 Aide en ligne 23

2.9 Aide en ligne

L’aide en ligne est tres complete et plutot bien faite. La consultation est beaucoup plus commodeen mode Graphique grace au systeme hypertexte. En mode Texte, on utilise le macro-caractere ” ?”ou la fonction help(). L’aide est retournee par un affichage page par page (programme more tresarchaıque). ”Return” fait avancer d’une ligne, ”espace” d’une page, ”q” fait sortir.

Page 24: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

24 Environnement : relation avec le systeme d’exploitation

Page 25: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 3

Elements complementaires desyntaxe

Les requetes Maple sont realisees par l’intermediaire d’un langage de programmation qui est unmelange de langage fonctionnel et de langage procedural (imperatif). Les requetes sont aussi biendes demandes d’evaluation de fonction (comme en Lisp) que des demandes d’execution d’instruction.

On a deja vu dans les chapitres precedents certain elements de la syntaxe. Completons par

3.1 Les branchements conditionnels

3.1.1 Le si

Le si peut etre utilise sous deux formes, instruction et fonction :

l’instruction if

Voici un exemple d’utilisation qui presente un certain melange :

x:=1;

if (x=7) then

5;

else

print(10*x);

fi;

Executee au Toplevel, cette requete provoque l’affichage de ”10”, et retourne ce que la fonction print

retourne, c’est-a-dire NULL.

x:=7;

if (x=7) then

5;

else

print(5*x);

fi; # -> 5

la fonction if

x:=1; ‘if‘(x=7,5,55); # -> 55

x:=7; ‘if‘(x=7,5,55); # -> 5

%; # -> 5

x:=1; y:=‘if‘(x=7,5,55);

y; # -> 55

x:=9; y:=‘if‘(x=7,5,print(10*x)); # affiche 90

y; # -> suite vide (NULL)

Page 26: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

26 Elements complementaires de syntaxe

3.1.2 Le choix multiple

x:=1;

if (x=7) then 100;

elif (x=8) then 200;

else 300;

fi; # -> 300

3.2 Les repetitions

3.2.1 La boucle pour

Il y a plusieurs facon de faire circuler les indices :

la forme courante

for i from 1 to 10 do # parcours d’une suite d’indices

print(10*i);

od; # affiche les nombres 10,20,..

%; # -> true (resultat deroutant)

s:=0;

for i from 1 to 3 do

s:=s+i^2;

od; # au Toplevel affiche les valeurs

# intermediaires de s

%,s,i; # -> 14,14,4

# calcul equivalent

s:=add(i^2,i=1..3);s; # -> 14

parcours des elements d’une structure

l:=[3,2,1];

s:=0;

for i in l do

s:=s+i^2;

od;

%,s,i; # -> 14,14,1

q:=sin(x)+2*x*y*ln(x+y);

for u in q do

print(u);

od; # affiche sin(x) et 2 x y ln(x + y)

# qui correspondent aux fils de

# niveau 1 de l’arbre syntaxique

# de l’expression q

Note : il n’y a pas de forme fonctionnelle pour for.

3.2.2 La boucle tant que

while seul

i:=1;

while (i<10) do

print(i);

i:=i+1;

od; # affiche 1,2,..

Page 27: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

3.2 Les repetitions 27

en association avec for

l:=[3,2,1,100];

for i in l while (i^2 > 1) do

print(i);

od; # affiche 3,2

Page 28: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

28 Elements complementaires de syntaxe

Page 29: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 4

Les structures de base

4.1 Les objets Maple

C’est un peu confus (pour moi). D’une certaine maniere l’utilisateur ne voit pas les structures infor-matiques. Il y a melange entre structures informatiques et mathematiques.

4.1.1 Les objets atomiques

(ou scalaires). On peut distinguer

- les symboles (ex toto),

- les entiers,

- les flottants,

- les nombres en precision arbitraire,

- les booleens (true,false,FAIL),

- les chaınes de caracteres (ex "toto").

Le codage de ces types et leur etendu ne sont pas (ou sont peu) documentes.Les fonctions whattype() ; et type() ; permettent d’obtenir de l’information. Cette information estprincipalement de nature mathematique.

x:=5: y:=5/2: y2:=5.0/2: z:=’z’:

u:= 2*z+5*x: t:=’t’:

whattype(x); # -> integer

whattype(y); # -> fraction

whattype(y2); # -> float

whattype(z); # -> symbol

whattype(u); # -> +

type(x,rational); # -> true

type(y,rational); # -> true

type(y2,rational); # -> false

type(z,rational); # -> false

type(u,rational); # -> false

assume(t,integer):

type(t,integer); # -> false, t a pour valeur le symbole t

4.1.2 Les structures de base

Maple manipule efficacement

- les suites. Elles sont representees exterieurement comme 2,1,0,1,2,

- les listes. Elles sont representees exterieurement comme [2,1,0,1,2],

- les ensembles. Ils sont representes exterieurement comme {0,1,2}.La fonction seq() et le macro caractere $ permettent de definir les suites. Les crochets [] et lesaccolades {} permettent de definir les listes (list) et les ensembles (set). Les fonctions union() ,intersect() , minus() , member() sont associees aux ensembles.

Page 30: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

30 Les structures de base

4.1.3 Les structures composites

Ces structures, plus riches et plus completes que les structures de base, ne se comportent pas commeles premieres. On y reviendra ulterieurement. On distingue les

- les tables (table),

- les tables-procedures,

- les tableaux (array),

- les vecteurs et les matrices (vector, matrix (linalg)),

- les fonctions.

Les exemples qui suivent, un peu laborieux mais incontournables, montrent des differences deroutantesde comportement entre les structures de base et les structures composites. Les structures de base s’uti-lisent de facon plus intuitive. Ces exemples montrent aussi qu’il vaut mieux eviter de creer implicite-ment, sans les controler, des objets composites. On reviendra plus completement sur les evaluations.

# comportement des listes

l:=[1,5,7] # l est un symbole dont

# la valeur est une liste

l; # -> [1,5,7]

whattype(l); # -> list

whattype(eval(l)); # -> list

op(l); # -> 1,5,7

l[1]; # -> 1

l[4]; # -> erreur

l[4]:=8; # -> erreur

# comportement des tables

a:=’a’:

a[2]:=5; # creation d’une table

a; # -> a, pas d’evaluation

# au plus profond niveau

eval(a); # -> table([2 = 5])

a[2]; # -> 5

a[1]; # -> a[1]

whattype(a); # -> symbol

whattype(eval(a)); # -> table

op(a); # -> table([2 = 5])

op(eval(a)); # -> [2 = 5]

whattype(op(eval(a))); # -> list

# les tables-procedures

g:=’g’:

g(2):=5; # creation d’une table-procedure

g; # -> g

eval(g); # -> proc() option remember;

# ’procname(args)’ end proc

g(2); # -> 5

g(1); # -> g(1)

whattype(g); # -> symbol

whattype(eval(g)); # -> procedure

op(g); # -> proc() option remember;

# ’procname(args)’ end proc

op(eval(g)); # -> remember, table([2 = 5])

whattype(op(eval(g))); # -> exprseq

# les fonctions

f:= n -> n^2; # creation d’une fonction

f; # -> f

eval(f); # -> n -> n^2

Page 31: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

4.1 Les objets Maple 31

f(toto); # -> toto^2

whattype(f); # -> symbol

whattype(eval(f)); # -> procedure

op(f); # -> n -> n^2

op(eval(f)); # -> n, operator, arrow

h:= proc(n) n^2; end; # creation d’une fonction

# petite difference avec f

eval(h); # -> proc(n) n^2 end

whattype(h); # -> symbol

whattype(eval(h)); # -> procedure

op(h); # -> proc(n) n^2 end

op(eval(h)); # -> n

4.1.4 Creation explicite de structures composites

tables

d:=table(); # creation d’une table sans instanciation

d[titi]; # -> d[titi]

d[titi]:=cos(xx);

d[titi]; # -> cos(xx)

# creation explicite

dd:=table([(2) = 100, (toto) = 3*xx^2]);

dd[toto]; # -> 3 * xx^2

dd[tata] := 24;

dd[tata]; # -> 24

tableaux

v:=array(-2..2,[4,1,0,1,4]); # intervalle des indices = -2 .. 2

v; # -> v

eval(v); # -> array(-2..2, [(-2)=4, ...])

print(v); # -> array(-2..2, [(-2)=4, ...])

lv:=convert(v,list);

lv; # -> [4,1,0,1,4]

v[-2]; # -> 4

lv[1]; # -> 4

v[3]; # -> erreur

v[3]:=1000; # -> erreur

vecteurs et matrices

Les types vector et matrix font en principe partie de la bibliotheque linalg. Mais ils sont visiblessans son chargement.

l:=[1$4];

v:=vector(4,l);

v; # -> v

eval(v); # -> [1,1,1,1] vu comme la liste sous-jacente

print(v); # -> [1,1,1,1]

evalb(l=v); # -> false

evalb(l=eval(v)); # -> false

evalb(l=convert(v,list)); # -> true

m:=matrix(2,4,[l,2*l]); # ->

# [1 1 1 1]

# [ ]

# [2 2 2 2]

Page 32: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

32 Les structures de base

compatibilite entre les tableaux et les matrices

Il y a compatiblite si les intervalles des indices sont de la forme [1..n]. On s’y perd un peu.

l:=[1$4];

b:=array(1..2,[l,2*l]);

c:=array(1..2,1..4,[l,2*l]);

m:=matrix(2,4,[l,2*l]);

evalb(b=m); # -> false

evalb(c=m); # -> false

type(b,matrix); # -> false

type(c,matrix); # -> true

eval(b); # -> [[1, 1, 1, 1], [2, 2, 2, 2]]

eval(c); # ->

# [1 1 1 1]

# [ ]

# [2 2 2 2]

4.2 Manipulations des objets de base

4.2.1 Extraction

op extrait les composantes d’une expression ou d’une structure. Il retourne une suite.

op([1,4,2]); # -> 1,4,2 (c’est une suite)

op(1,4,2); # -> erreur

op({1,4,2,1}); # -> 1,2,4

op(1+2+3); # -> 6

op(x+y-z); # -> x,y,-z

op(x/y/z); # -> x,1/y,1/z

4.2.2 Selection

op permet egalement d’extraire un seul element.

op(2,[x,y,z]); # -> y

l:=[4,5,6,7,8]:

l[2]; # -> 5

l[1..3]; # -> [4,5,6]

l[2..-1]; # -> [5,6,7,8]

l[2..-2]; # -> [5,6,7]

op(2,x+y*z-8); # -> y*z

4.2.3 Nombre d’elements

l:=[4,5,6,7,8]:

nops(l); # -> 5

4.2.4 Constitution de suites et de listes

Les listes sont plus faciles a manipuler que les suites qui se confondent souvent avec les parametrespasses aux fonctions.

s:=NULL; # suite vide

l:=[NULL]; # liste vide

ll:=[]; # liste vide

evalb(l=ll); # -> true

l:=[4,5,6];

l:=[seq(i^2,i=2..6)];

l:=[2$4];

m:=[x,y,z];

Page 33: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

4.2 Manipulations des objets de base 33

n:=[100,op(l)]; # -> [100,2,2,2,2]

o:=[op(l),op(m)]; # -> [2,2,2,2,x,y,z]

4.2.5 Test de la suite ou de la liste vide

if (nops(l) = 0) then ...

# ou

if (s = NULL) then ...

# ou

if (l = [NULL]) then ...

# ou

if (op(l) = NULL) then ...

4.2.6 La fonction map

la fonction map prend en entree une structure et une fonction, elle retourne la structure dont leselements sont les images des elements de la structure source.

l:=[1,2,3];

map(t->t^2,l); # -> [1,4,9]

e:=x^2+25*y+Pi/2; 2

map(sin,e); # -> sin(x ) + sin(25 y) + 1

Page 34: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

34 Les structures de base

Page 35: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 5

Les expressions booleennes

Il y a trois booleens, true, false, FAIL.Par FAIL Maple signifie qu’il ne sait pas. FAIL se comporte comme false dans les tests.La fonction evalb() est dediee a l’evaluation des expressions booleennes.

5.1 Le symbole ”=”

a deux sens. Dans un test genre

if (x = 8) then ...

il se comporte comme un predicat. Dans cette construction, (x = 8) est une expression booleenne.Par contre dans l’expression

e:=(x=y);

il sert a definir un objet de type equation.

e:=((x-1)*(x-2) = (x-1));

e; # -> (x - 1) (x - 2) = x - 1

whattype(e); # -> =

solve(e); # -> 3,1

evalb(e); # -> false

evalb(subs(x=3,e)); # -> true

5.2 Le predicat ”=”

est universel. Il peut s’appliquer a tous les objets.

a:={5,4,2,1,0,3};

b:={seq(abs(i),i=-5..5)};

evalb(a=b); # -> true

Mais attention aux tests du genre

evalb(sin(x)^2 + cos(x)^2 = 1); # -> false

evalb(simplify(sin(x)^2+cos(x)^2) = 1); # -> true

dont la reponse est imprevisible.

5.3 Le predicat ”<”

A la difference du predicat "=" qui est universel, les predicats "<" et ">" ne s’appliquent qu’auxnombres. Ceci est la raison de nombreuses erreurs dans l’execution de fonctions contenant des testsd’inegalite lorsque les expressions a comparer comportent des variables n’ayant pas de valeur numerique.

Page 36: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

36 Les expressions booleennes

if (x < 3) then ... # -> erreur quand x n’a pas de

# valeur numerique

f:=x-> if (x < 0) then 0 else 1; fi;

f(-2); # -> 0

plot(f(x),x=-5..5); # -> erreur cannot ...

Pour contourner le probleme de la comparaison impossible lors d’un plot, il y a plusieurs solutions :

1. f:=x-> if (x < 0) then 0 else 1; fi;

plot(f(x),x=-5..5); # -> erreur cannot ...

plot(’f(x)’,x=-5..5); # ok

2. f:=x-> if (type(x,numeric)) then

if (x < 0) then 0 else 1; fi;

else

’f(x)’;

fi;

plot(f(x),x=-5..5); # ok

Note : Ce probleme ne se produit ni avec la fonction piecewise() ni avec la fonction ‘if‘().

f:=x->piecewise(x<0,0,1);

plot(f(x),x=-5..5); # ok

f:=x->‘if‘(x<0,0,1);

plot(f(x),x=-5..5); # ok

Attention aussi aux tests dont Maple ne connaıt pas la reponse :

x := -int(t*cos(exp(t)),t=0..1); # -> -int(...)

evalf(x); # -> 0.1897747668

is(x>0); # -> FAIL

evalb(x>0); # -> int(...) < 0

if (x>0) then

print("x > 0");

else print("x <= 0");

fi; # -> error ...

if (is(x>0)) then

print("x > 0");

else print("x <= 0");

fi; # -> "x <= 0"

if (evalf(x) > 0) then

print("x > 0");

else print("x <= 0");

fi; # -> "x > 0"

Page 37: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 6

Les evaluations

Le fonctionnement des evaluations est un peu delicat, car il differe selon les objets a evaluer (scalaires,objets basiques, objets composites) et suivant le contexte (Toplevel, interieur des fonctions). On doitretenir les regles suivantes :

6.1 Regles d’evaluation

1. Au Toplevel, Maple evalue au plus profond niveau et retourne le resultat de la derniere evaluation.Sauf pour les objets composites (table, array, vector, matrix, function . . .) qu’il evaluejusqu’au ”dernier nom”. (last name evaluation, cf exemples ci-dessous).

2. A l’interieur des fonctions (ou procedures), Maple n’evalue qu’au premier niveau.

3. On dispose de fonctions specifiques pour forcer l’evaluation :

fonctions type d’utilisation syntaxeeval universel eval(x), eval(x,n), eval(sin(x),x=0)

evalf, evalhf flottants,evalb booleens,evalm algebre lineaire,evalc nombres complexes,evala nombres algebriques,evalr calcul par intervalles

value evaluation des fonctions inertes.

4. La fonction evaln() et le dispositif de quotage ’x’ permettent de retarder l’evaluation.

5. Au Toplevel, lors des affectations (x := y), il y a recopie de la valeur au plus profond niveaudu membre de droite. Sauf lorsque celui-ci est de type composite, auquel cas il y a pointage.

6.2 Illustration des regles

6.2.1 Niveau d’evaluation et affectations

au Toplevel

x:=’x’: y:= ’y’: z:=’z’:

x:=y;

y:=z;

z:=1;

x; # -> 1. Evaluation au plus

# profond niveau

# x pointe sur y qui pointe sur

# z dont la valeur est 1

z:=4;

x; # -> 4

Page 38: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

38 Les evaluations

x:=5;

z; # -> 4, x ne pointe plus sur y

t:=y; # t prend la valeur au plus profond

# niveau de y, c’est-a-dire 4.

# t n’a plus de relation avec y et z

t; # -> 4

y:=55;

t; # -> 4

dans une fonction

essai:=proc()

local x,y,z;

x:=y; y:=z; z:=1;

print(x,y,z);

print(eval(x,2));

end;

essai(); # la procedure affiche y,z,1 et z

# elle retourne NULL (print)

essai2:=proc()

local x,y,z;

x:=y; y:=z; z:=1;

print(x,y,z);

eval(x,2);

end;

essai2(); # la procedure affiche y,z,1

# et retourne z

a:=essai2();

a; # -> 1

eval(a,1); # -> z

# a a pour valeur z qui a pour

# valeur 1 (ce qui n’est pas

# tres normal puisque z vient

# d’une variable locale de

# essai2)

last name evaluation

m:=matrix(2,2,[a,b,c,d]);

m; # -> m

evalm(m); # -> [a b]

# [ ]

# [c d]

# idem avec eval(m), print(m),

# eval(m,1)

m1:=m;

m2:=m1;

m3:=m2;

m,m1,m2,m3; # -> m,m,m,m

eval(m1,1),eval(m2,1),eval(m3,1); # -> m,m,m

m5:=m4;

m4:=m3;

m4,m5; # -> m,m

eval(m4,1), eval(m5,1); # -> m,m4

Page 39: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

6.2 Illustration des regles 39

print(m5); # -> [a b]

# [ ]

# [c d]

f:= 2*b+c;

b:= 1;

f; # -> 2 + c

b:= 10;

f; # -> 20 + c

eval(m); # -> [a b]

# [ ]

# [c d]

# b n’est pas vu de la meme

# facon dans f et dans m

map(eval,m); # -> [a 10]

# [ ]

# [c d]

6.2.2 Affectations

cas des listes

l1:=[2,3,4];

l2:=l1;

l2[2]:=33;

l1; # -> [2,3,4]

l2; # -> [2,33,4]

# il y a eu recopie de la

# valeur de l1 et distinction

# totale entre l1 et l2

cas des tables

Attention danger !

v1:=vector(3,l1);

v2:=v1;

v2[2]:=333;

v1; # -> v1

eval(v1); # [2,333,4]

# il n’y a pas eu recopie de

# la valeur au plus profond

# niveau de v1, v2 pointe sur

# v1, une modification de v2

# entraıne une modification de v1

v3:=copy(v1); # recopie

v3[3]:=444;

eval(v1); # [2,333,4]

6.2.3 Quotage

La fonction evaln() et le dispositif de quotage retardent l’evaluation.

y:=’y’:

x:=y;

y:=1;

Page 40: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

40 Les evaluations

x; # -> 1

eval(x,1); # -> y

eval(’x’,1); # -> x

eval(’x’,2); # -> y

eval(’x’,3); # -> 1

eval(’’x’’,3); # -> y, (deux fois signe quote)

eval(’2*x’,1); # -> 2 x

eval(’x+5’,2); # -> y+5

x:=evaln(x); # meme effet que ’x’

x; # -> x

6.2.4 Quelques differences difficilement previsibles

Les variables d’indice des fonctions seq, add, sum, int ,... n’ont pas le meme comportementselon les versions de Maple et selon que les fonctions font partie du noyau (built-in functions, codeesen binaire) ou au contraire font partie des fonctions ecrites en Maple.Voici quelques exemples, tous provenant d’une execution en version 7.

i:=’i’; sum(i,i=1..3); # -> 6

i; # -> i

i:=5; sum(i,i=1..3); # erreur

i:=5; add(i,i=1..3); # -> 6

i:=5; seq(i,i=1..3); # -> 1,2,3

i; # -> 5

# add et seq sont des fonctions

# de bas niveau contrairement a

# sum

i:=5; sum(i,’i’=1..3); # -> 15 (3x5)

i:=5; sum(’i’,’i’=1..3); # -> 6

i; # -> 5

Page 41: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 7

Les fonctions

7.1 Definition des fonctions

On peut definir les fonctions avec l’operateur → ou en utilisant proc(). Voir les exemples dans leschapitres precedents.

7.2 Comment voir le contenu des fonctions

showstat(sum);

# ou

interface(verboseproc=2); print(sum);

# affiche le programme de la

# fonction sum. Cette fonction

# comporte de nombreuses

# methodes qu’il convient de

# suivre. (laborieux)

7.3 Fonctions anonymes

Il est possible d’utiliser des fonctions sans leur donner de nom.

((x,y) -> x * y) (2,20); # -> 40

map(t->t^2, [1,2,3]); # -> [1,4,9]

7.4 Variables locales, variables globales

On peut choisir le statut des variables utilisees dans la definition des fonctions avec les declarationslocal ou global. Par defaut Maple emet un avertissement et declare local les variables qui ne sontpas declarees et qui n’existent pas par ailleurs.Mais je deconseille de profiter de cette disposition, je recommande de proceder systematiquement auxdeclarations.

f:=proc()

global a,b;

local x,y;

a:=1;

b:=10;

x:=100;

y:=1000;

end;

a:=-1;

b:=’b’;

Page 42: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

42 Les fonctions

x:=-100;

y:=’y’;

f(); # -> 1000. Les variables x et y

# n’ont d’existence que lors de

# l’execution de f(). Par

# contre, le statut de a et b est

# modifie apres l’execution.

a,b,x,y; # -> 1, 10, -100, y

7.5 Valeur retournee

La valeur retournee par une fonction est celle de la derniere evaluation ou la valeur explicitementspecifiee par RETURN. Il me semble plus clair d’utiliser systematiquement RETURN(). On peut cependantutiliser les deux formes de retour dans la meme fonction.

f:=proc(n) # fonction n!

if (n<2) then RETURN(1);fi;

n*f(n-1);

end;

Attention a la commande plot dans une fonction : il faut savoir que la commande plot n’est pas uneinstruction d’affichage. Elle retourne en fait une structure informatique. Cette structure, exactementcomme toutes les autres, n’est affichee a l’ecran (ou imprimee, ou mise en fichier) que

- si elle est soumise a la commande print,

- ou si son evaluation s’est realisee en dernier et si une demande implicite d’affichage (” ;” en find’expression) a ete faite.

On est toujours tres surpris de ne pas voir les requetes plot apparaıtre a l’ecran.

f1:=proc(a,b)

local x;

plot(sin(x),x=a..b);

end;

f1(0,10); # sortie ecran ok

f2:=proc(a,b)

local x;

plot(sin(x),x=a..b);

b-a;

end;

f2(0,10); # -> 10

# pas d’affichage

f3:=proc(a,b)

local x;

print(plot(sin(x),x=a..b));

b-a;

end;

f3(0,10); # -> 10

# dessin ok

7.6 Options

On peut attacher aux fonctions plusieurs options. (Voir l’aide sur options). L’option remember estinteressante quand une fonction doit etre evaluee plusieurs fois sur les memes parametres. C’est no-tamment le cas pour les fonctions recursives d’ordre superieur a 1. Quand une fonction est definie avec

Page 43: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

7.7 Controle des parametres 43

l’option remember, Maple attache une table a cette fonction, la table de remember. Lors de chaqueevaluation, la table est consultee. Si l’evaluation a deja ete faite, le resultat y est puise. Sinon lescalculs sont realises et la table est enrichie. (L’aide en ligne sur ce sujet est bien faite).

f:=proc(n)

option remember;

if (n<2) then RETURN(1);fi;

n*f(n-1);

end;

f(5); # 5 appels de la fonction

f(7); # 2 appels seulement, f(5) pris dans la table

7.7 Controle des parametres

On nomme parametres formels les parametres qui figurent dans la definition des fonctions, et pa-rametres effectifs ceux qui sont passes lors d’un appel. Le programmeur dispose des variables predefiniessuivantes :

- nargs contient le nombre des parametres effectifs. Ce nombre peut etre different de celui desparametres formels.

- args est une variable qui contient la suite des parametres effectifs.

- procname est une variable qui contient le nom de la fonction.

typage : Il est possible de ”typer” certains parametres. Quand un parametre est type, Maple ajouteautomatiquement au code de la fonction un test du parametre effectif et retourne eventuellement unmessage d’erreur approprie.

f:=proc(l::list)

l[1];

end;

f([2,3]); # -> 2

f([2,3],5); # -> 2

f(5,[2,3]); # -> erreur

f(5); # -> erreur

f(); # -> erreur

7.8 Passage des parametres

Les parametres sont passes aux fonctions par valeur. Cela veut dire que si x est une variable dontla valeur est 5, l’appel f(x) envoie 5 a la fonction f et non la variable x. Si l est une liste de valeur[1, 2, 3], l’appel g(l) envoie a g une copie de la liste [1, 2, 3].Par contre si v est le vecteur [1, 2, 3], l’appel h(v) envoie a h la valeur de v telle qu’elle apparaıt lors del’evaluation de v, c’est-a-dire, comme on l’a vu au chapitre 6 Les evaluations, la variable elle-meme,et non une copie.Ce mode de passage a deux consequences :

- Les parametres de type scalaire ou objet de base, ne peuvent etre modifies a l’interieur desfonctions.

f:=proc(x)

x:=x+1;

end;

y:=5;

f(y); # -> erreur, 5 := 6 impossible

- Pour obtenir une modification d’une variable passee en parametre, c’est-a-dire pour effectuer unpassage par reference, il y a au moins deux solutions :

Page 44: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

44 Les fonctions

f1:=proc(x)

x:=eval(x)+1;

10;

end;

y:=5;

f(’y’); # -> 10, passage de y

y; # -> 6

f2:=proc(x::evaln) # declaration de passage par reference

x:=eval(x)+1;

10;

end;

y:=5;

f(y); # -> 10, passage de y

y; # -> 6

Pour les objets composites, il n’y a rien a prevoir pour effectuer un passage par reference. Au contraire,si la fonction modifie un objet dont on desire conserver la valeur initiale (par exemple la matrice d’unsysteme lineaire resolu par une methode qui transforme le systeme), il peut s’averer necessaire d’enpasser une copie avec la fonction copy().

f:=proc(x)

x[1]:=x[1]+1000;

end;

v:=vector(3,[1$3]);

f(v); # -> 1001

v; # -> v

eval(v); # -> [1001,1,1]

l:=[1$3];

f(l); # -> erreur

f(’l’); # -> 1001

l; # -> [1001,1,1]

Exemple

Soit a programmer la fonction deuclide() qui retourne quotient et reste de la division euclidienne.On souhaite que deuclide(7,2) retourne 3, et que deuclide(7,2,r) retourne 3 et affecte r par lereste 1. (Comme la fonction Maple iquo()).

deuclide:=proc(a,b,r::evaln)

local q;

q:=trunc(a/b);

if (nargs > 2) then

r:=a-b*q;

fi;

q;

end;

deuclide(7,2); # -> 3

z:=sin(x);

deuclide(7,2,z); # -> 3

z; # -> 1

7.9 Fonctions locales

Il est possible de definir des fonctions locales a une fonction donnee.

Page 45: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

7.9 Fonctions locales 45

p4:=proc(x) # fonction x -> x^4

local f;

f:=proc(x) x^2; end;

RETURN(f(f(x)));

end;

p4(2); # -> 16

Note : Avant la version 5, il etait tres difficile de faire passer a une fonction locale un parametre de lafonction principale. C’est maintenant aise.

g:=proc(x,n)

local f;

f:= t->sin(n*t);

RETURN(f(x));

end;

g(Pi/2,3); # -> -1

Page 46: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

46 Les fonctions

Page 47: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 8

Les modules

Depuis la version 6, Maple offre la possibilite d’utiliser des modules. Les modules permettent

- de creer des objets complexes, comme les enregistrements du Pascal (RECORD) et les structuresdu C (struct), avec la notion de champs associes aux objets.

- de faire de la programmation orientee objet, offrant la possibilite d’attacher aux objets a la foisdes structures de donnees et des fonctions (les methodes), permettant l’heritage : on peut definirun type particulier dans un type deja defini (classe) et profiter pour ce type particulier de toutce qui existe pour le type pere. On peut enrichir les methodes.

Consulter l’aide en ligne sur module, use ou help(" :-") ; (Version 7).

Page 48: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

48 Les modules

Page 49: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 9

Les entrees-sorties

Indiquons quelques fonctions impliquees dans la communication entre Maple et l’exterieur, c’est-a-direl’ecran, le clavier, les fichiers sur disque.

9.1 Les fonctions d’entree-sortie

9.1.1 Fonctions de lecture

Le peripherique d’entree par defaut est le clavier.

- readstat() est la fonction que l’interprete utilise pour acquerir les commandes. Elle est utilisablepar les programmeurs. Elle procede a la saisie et a l’interpretation de la chaıne lue. Elle retourneun objet Maple. (Les saisies sont terminees avec ” ;”).

- readline() retourne une chaıne de caracteres.

- scanf() permet la lecture formatee.

9.1.2 Analyse d’une chaıne

Les fonctions suivantes peuvent etre utilisees pour analyser ou fouiller une chaıne.

parse(), sscanf(), substring(), convert(.,byte)

9.1.3 Fonctions d’ecriture

- print() est la fonction d’affichage de haut niveau. La syntaxe print("x" = x) est parfoisinteressante.

- lprint() permet un affichage basique, non centre.

- printf() est une fonction d’affichage formate. Exemple de syntaxe :

printf("f(%3a) = %.5a\n",i,f(i));

la chaıne contient des caracteres qui sont affiches (f,(,), ,=), et des directives de formatage :%3a indique que la valeur de i doit etre affichee sur 3 colonnes, %.5a indique que la valeur def(i) doit l’etre avec 5 chiffres apres la virgule, \n est un ordre de retour a la ligne. Voir l’aideen ligne sur printf() pour les differents formats (reels, chaınes, caracteres, ...).

9.2 Les redirections

Il est possible d’annuler l’affichage a l’ecran et d’ordonner que les sorties se fassent dans un fichier.

writeto(nom_de_fichier);

# ou

append(nom_de_fichier);

Pour revenir a l’affichage initial a l’ecran utiliser

writeto(terminal);

Page 50: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

50 Les entrees-sorties

C’est la fonction read() deja indiquee qui permet de rediriger les entrees.

On peut executer les calculs en mode batch . Cela veut dire, qu’etant sous le systeme d’exploita-tion, en lacant la commande

maple [options] fichier_source > fichier_resultat

on ouvre une session Maple non interactive, qui cesse des que les calculs presents dans fichier source

sont acheves. Les resultats se trouvant dans fichier resultat.

9.3 Lecture de donnees dans un fichier

Pour la lecture de donnees numeriques ecrites ”en clair” dans un fichier Texte (Ascii), la fonctionreaddata() convient bien.Si le fichier contient du texte et des valeurs numeriques, readline() et parse() peuvent etre interessantes.Le fonction fscanf() permet de realiser des lectures formatees et la fonction readbytes() permet delire des donnees binaires.

Exemple d’une fonction realisant la lecture d’une image en nuances de gris au format PGM (sanscommentaire). Les images PGM sont constituees de deux types de donnees : D’abord quelques lignescodees en caracteres Ascii (mode texte) indiquant le type du fichier (P5 par exemple), contenanteventuellement des commentaires (# CREATOR ... par exemple), indiquant les dimensions de l’image(900 600 par ex) et le nombre de nuances de gris (255). Ensuite figurent les pixels (les 900 x 600 pixels)codes en binaire sur 1 octet.

# la fonction loadpgm prend en entree un nom de fichier f et retourne

# une liste formee des dimensions de l’image et de la matrice des pixels.

loadpgm:=proc(f) # f = nom_de_fichier

local lg,haut,larg,dims,l;

lg:=readline(f); # marque P5

lg:=readline(f);

while (substring(lg,1..1) = "#") do # les commentaires

lg:=readline(f);

od;

dims:=sscanf(lg,"%d %d"); # les dimensions

haut:=dims[2]; larg:=dims[1];

lg:=readline(f); # le nombre de nuances

l:=readbytes(f,infinity); # les pixels

RETURN([haut,larg,matrix(haut,larg,l)]);

end;

9.4 Ecriture de donnees dans un fichier

La fonction fprintf() permet l’ecriture formatee et la fonction writebytes() l’ecriture en binaire.

Exemple d’une fonction realisant l’ecriture d’une image au format PGM :

# la fonction sauvegm prend en entree une image im (cf ci-dessus) et un

# nom de fichier f. Elle ecrit cette image au format PGM dans le fichier f

sauvepgm:=proc(im,f)

local canal,haut,m,i;

haut:=im[1];

m:=im[3];

canal:=fopen(f,WRITE);

fprintf(canal,"P5\n%d %d\n255\n",im[2],haut);

for i from 1 to haut do

writebytes(canal,convert(row(eval(m),i),list));

Page 51: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

9.4 Ecriture de donnees dans un fichier 51

od;

fclose(canal);

end;

Page 52: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

52 Les entrees-sorties

Page 53: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Chapitre 10

Manipulation des expressions

10.1 Diverses fonctions de manipulation

10.1.1 Assign

Cette fonction permet l’affectation des membres gauches des equations resultant de l’utilisation defonctions comme solve() ou dsolve(). Elle doit etre utilisee moderement. Il est souvent preferabled’utiliser la fonction rhs() ou la fonction select/has() pour recuperer les expressions apparaissantdans les membres droits.

> s:=solve({2*a+b=4,a+2*b=5},{a,b});

s := {b = 2, a = 1}

> whattype(s);

set

> assign(s);

> a,b;

1, 2

> y:=’y’:

> s:=dsolve(diff(y(t),t) = 2* y(t),y(t));

s := y(t) = _C1 exp(2 t)

> whattype(s);

=

> assign(s);

> y(t);

_C1 exp(2 t)

> equat:=diff(x(t),t$2) - 4*x(t);

/ 2 \

|d |

equat := |--- x(t)| - 4 x(t)

| 2 |

\dt /

> init:={x(0)=1, D(x)(0)=10};

init := {D(x)(0) = 10, x(0) = 1}

> sol:=dsolve({equat,op(init)});

sol := x(t) = 3 exp(2 t) - 2 exp(-2 t)

> xt:=rhs(sol);

xt := 3 exp(2 t) - 2 exp(-2 t)

Page 54: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

54 Manipulation des expressions

> equat:={v(t)=diff(x(t),t),diff(v(t),t) = - 10 - 2*v(t)};

d d

equat := {v(t) = -- x(t), -- v(t) = -10 - 2 v(t)}

dt dt

> inits:={x(0)=20,v(0)=0};

inits := {v(0) = 0, x(0) = 20}

> sol:=dsolve(equat union inits,{x(t),v(t)});

sol := {v(t) = -5 + 5 exp(-2 t), x(t) = -5 t - 5/2 exp(-2 t) +

45/2}

> xt:=rhs(op(select(has,sol,x))); # = rhs(op(select(e->has(e,x),sol)))

xt := -5 t - 5/2 exp(-2 t) + 45/2

10.1.2 Unapply

Unapply permet de creer une fonction a partir d’une variable dont la valeur est une expression, ce quine peut se faire directement.

> q := x^2 + y^3 + 1;

2 3

q := x + y + 1

> g:=x->q;

g := x -> q

> g(0);

2 3

x + y + 1

> f := unapply(q,x);

2 3

f := x -> x + y + 1

> f(0);

3

1 + y

> diff(f(t),t);

2 t

10.1.3 Sort

La fonction sort() permet de trier differents types d’objets. Elle a pour particularite de modifier lesexpressions passees en argument (ne modifie ni les suites ni les listes).

> p:=x+5*x^2+8*x+1+x;

2

p := 10 x + 5 x + 1

> sort(p);

2

5 x + 10 x + 1

> p;

Page 55: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

10.1 Diverses fonctions de manipulation 55

2

5 x + 10 x + 1

> l:=[5,4,15];

l := [5, 4, 15]

> sort(l);

[4, 5, 15]

> l;

[5, 4, 15]

10.1.4 Subsop

Cette fonction permet de changer un operande dans une expression. Elle permet des combinaisonssophistiquees, pas tres aisees, par exemple dans les integrales.

> p := x^7+8*x^6+x^2-9;

7 6 2

p := x + 8 x + x - 9

> op(2,p);

6

8 x

> y:=’y’:

> subsop( 2=y^55, p );

7 55 2

x + y + x - 9

> sort(%);

7 2

x + x + y - 9

10.1.5 Parse

Parse est la fonction d’analyse et d’interpretation des chaınes de caracteres. Elle retourne un objetMaple.

> x:=1:

> "x+2";

"x+2"

> parse("x+2");

x + 2

> eval(parse("x+2"));

3

10.1.6 Solve/identity

La methode identity attachee a la fonction solve() permet la resolution d’equations selon lamethode des coefficients indetermines.

> x:=’x’: a:=’a’: b:=’b’:

> p:=a*x^3+(a+b+1)*x+(a-b-1);

3

p := a x + (a + b + 1) x + a - b - 1

Page 56: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

56 Manipulation des expressions

> solve(identity(p,x),{a,b});

{a = 0, b = -1}

> p:=a*sin(2*x)+(a+b+1)*sin(x)+(a-b-1)*cos(x);

p := a sin(2 x) + (a + b + 1) sin(x) + (a - b - 1) cos(x)

> solve(identity(p,x),{a,b});

{a = 0, b = -1}

10.1.7 Allvalues

Cette fonction travaille en association avec la fonction RootOf() pour obtenir toutes les solutionsd’une equation. Mais elle est trop dependante de la version Maple. Il est necessaire de consulter l’aideen ligne de la version utilisee.

10.1.8 Value

Cette fonction permet l’evaluation des expressions contenant des fonctions inertes.

> F := Int(x, x);

/

|

F := | x dx

|

/

> F - 1/2 * x^2;

/

| 2

| x dx - 1/2 x

|

/

> diff(F,x);

x

> value(F - 1/2 * x^2);

0

> i:=Int(1/x,x=1..infinity);

infinity

/

|

i := | 1/x dx

|

/

1

> j:=Int(1/(1+x),x=1..infinity);

infinity

/

| 1

j := | ----- dx

| 1 + x

/

1

Page 57: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

10.2 Reecriture 57

> d:=combine(i-j);

infinity

/

| 1

d := | 1/x - ----- dx

| 1 + x

/

1

> value(d);

ln(2)

10.2 Reecriture

Voici quelques exemples de commandes permettant d’effectuer diverses transformations sur les expres-sions.

10.2.1 Expand

> expand(tan(a+b));

tan(a) + tan(b)

-----------------

1 - tan(a) tan(b)

10.2.2 Simplify

> subs(x=0,ln(exp(x)));

ln(exp(0))

> simplify(%);

0

10.2.3 Factor

> p:=cos(t)*sin(3*x) + ln(y)*sin(3*x);

p := cos(t) sin(3 x) + ln(y) sin(3 x)

> factor(p);

sin(3 x) (cos(t) + ln(y))

L’utilisation de factor() permet parfois des simplifications difficiles : Soit a calculer la transformeede Hilbert de f0 :=

√1 − t2χ[−1,1]. La transformation de Hilbert est l’operateur qui a une fonction f

fait correspondre la fonction

H(p) =1

π

−∞

f(t)

p − tdt.

La fonction Maple hilbert() du package inttrans est capable de faire ce calcul, mais elle echouepour f0 (version 7). Cependant le calcul est faisable directement. Le resultat a trouver est p pour

−1 < p < 1, l’integrale etant une valeur principale de Cauchy, p−√

p2 − 1 pour p > 1, et p+√

p2 − 1pour p < 1.

> with(inttrans):

> f :=sqrt(1-t^2);

2 1/2

f := (1 - t )

Page 58: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

58 Manipulation des expressions

> f0:=piecewise(t<=-1,0,t>=1,0,f);

{ 0 t <= -1

{

f0 := { 0 1 <= t

{

{ 2 1/2

{ (1 - t ) otherwise

> hilbert(f0,t,p); # echec

{ 0 t <= -1

{

hilbert({ 0 1 <= t , t, p)

{

{ 2 1/2

{ (1 - t ) otherwise

> assume(-1<p,p<1);

> h1:=int(f/(p-t),t=-1..1,’CauchyPrincipalValue’)/Pi;

h1 := p~

> assume(p>1);

> h2:=int(f/(p-t),t=-1..1)/Pi;

2 2 1/2

-p~ + p~ (p~ - 1) + 1

h2 := --------------------------

2 1/2

(p~ - 1)

Ce n’est pas facile de mettre h2 sous la forme simplifiee attendue. L’utilisation de factor() n’est pasla seule possibilite de simplification, mais ici elle est tres pratique.

> factor(h2,denom(h2));

2 1/2

p~ - (p~ - 1)

10.2.4 Collect

> p:=cos(t)*sin(3*x) + ln(y)*sin(3*x) + 5;

p := cos(t) sin(3 x) + ln(y) sin(3 x) + 5

> collect(p,sin(3*x));

(cos(t) + ln(y)) sin(3 x) + 5

> f:=(2*a*x+4+6*b*x)/(8+8*c*x+4+6*x);

2 a x + 4 + 6 b x

f := -----------------

12 + 8 c x + 6 x

> fc:=collect(f,x);

(2 a + 6 b) x + 4

fc := -----------------

(8 c + 6) x + 12

> simplify(fc);

a x + 2 + 3 b x

---------------

6 + 4 c x + 3 x

Page 59: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

10.2 Reecriture 59

> collect(simplify(fc),x);

(a + 3 b) x + 2

---------------

(4 c + 3) x + 6

10.2.5 Combine

C’est souvent difficile de trouver les bonnes combinaisons a appliquer.

> combine(4*sin(x)^3,trig);

-sin(3 x) + 3 sin(x)

> combine(Int(x,x=a..b)-Int(x^2,x=a..b));

b

/

| 2

| x - x dx

|

/

a

> combine(exp(x)^2*exp(y),exp);

exp(2 x + y)

> combine(ln(x+1)+ln(x-1));

ln(x + 1) + ln(x - 1)

> combine(ln(x+1)+ln(x-1),ln);

ln(x + 1) + ln(x - 1)

> combine(ln(x+1)+ln(x-1),ln,symbolic);

ln((x + 1) (x - 1))

# dans le meme ordre d’idees

> simplify(sqrt((x*y)^2,assume = positive);

x y

10.2.6 Normal

> p:=(x^2 - y^2)/(x-y) - (x+y);

2 2

x - y

p := ------- - x - y

x - y

> normal(p);

0

10.2.7 Rationalize

> f:=2/(2-sqrt(2));

2

f := --------

1/2

2 - 2

Page 60: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

60 Manipulation des expressions

> rationalize(f);

1/2

2 + 2

10.2.8 Convert

Cette fonction a un champ d’utilisation tres vaste. Voici quelques exemples :

> t:=taylor(sin(x),x=0,4);

3 4

t := x - 1/6 x + O(x )

> convert(t,polynom);

3

x - 1/6 x

> convert(exp(I*3*x),trig);

cos(3 x) + I sin(3 x)

> r:=(x^2+x+1)/(x^2+1);

2

x + x + 1

r := ----------

2

x + 1

> rf:=convert(r,parfrac,x);

x

rf := 1 + ------

2

x + 1

> rr:=(x^3+x+1)/expand((x+I)*(x-I));

3

x + x + 1

rr := ----------

2

x + 1

> convert(rr,parfrac,x,complex); # (Maple 7)

.5000000000 I .5000000000 I

x + ----------------- - -------------

x + 1.000000000 I x - 1. I

> convert(rr,fullparfrac,x);

/ ----- \

| \ / _alpha \|

x + | ) |- 1/2 ----------||

| / \ x - _alpha/|

| ----- |

\_alpha = %1 /

2

%1 := RootOf(_Z + 1)

# Ecriture en base autre que 10

> c:=convert(10,base,2);

Page 61: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

10.2 Reecriture 61

c := [0, 1, 0, 1]

# Ecriture en base 12

> b:=12: chiffres:=convert([$48..48+9,$65..65+max(0,b-1-10)],bytes);

chiffres := "0123456789AB"

> x:=23: StringTools[Reverse](cat(op(map(t->substring(chiffres,t+1),convert(x,base,b)))));

"1B"

> # ou

> envers:=proc(l) local i; [seq(l[-i],i=1..nops(l))];end:

> x:=23: cat(op(map(t->substring(chiffres,t+1),envers(convert(x,base,b)))));

"1B"

# Pas facile d’obtenir 0 partir de l’expression suivante (version >= 4)

> s:=sum(exp(2*I*Pi*k/7),k=0..6);

s := 1 + exp(2/7 I Pi) + exp(4/7 I Pi) + exp(6/7 I Pi) + exp(-6/7 I Pi)

+ exp(-4/7 I Pi) + exp(-2/7 I Pi)

> convert(s,polar);

polar(0, 1/2 Pi)

> evalc(convert(s,polar));

0

> u:=sin(Pi/10);

u := sin(1/10 Pi)

> convert(u,radical);

1/2

1/4 5 - 1/4

Page 62: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

62 Manipulation des expressions

Page 63: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Bibliographie

[1] Waterloo Maple. Maple V, Learning Guide (fourni avec le logiciel). Springer.

[2] Waterloo Maple. Maple V, Programming Guide (fourni avec le logiciel). Springer.

[3] P. Dumas, X. Gourdon. Maple. Son bon usage en mathematiques. Springer, 1997.

[4] C.Gomez B.Salvy, P.Zimmermann. Calcul formel. Mode d’emploi. Exemples en Maple. Masson,1995.

[5] A. Heck. - Introduction to Maple. Springer Verlag New York 1993.

[6] P. Saux Picart. - Cours de calcul formel. Ellipses fr Paris 1999.

[7] P. Douillet. - Maths avec Maple t1 et t2. Ellipses fr Paris 1995.

[8] W. Gander, J. Hrbicek. - Solving problems in scientific computing using Maple and Matlab.Springer Berlin Heidelberg 1994.

[9] J.Davenport, Y. Siret, E. Tournier. - Calcul formel. Systemes et algorithmes de manipulationsalgebriques. Masson, 1987.

[10] G. Articolo. - Partial differential equations and boundary value problems with Maple V. AcademicPress us San Diego, CA 1998.

[11] Zimmermann. Bibliographie en ligne. http ://www.loria.fr/%7Ezimmerma/maple/.

[12] Universite de Lille. Bibliographie en ligne. http ://www.grappa.univ-lille3.fr/polys/maple-1999/index34.html.

[13] Universite de Laval (Canada). Cours en ligne. http ://www.mat.ulaval.ca/mating/Maple.

Page 64: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

64 BIBLIOGRAPHIE

Page 65: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

Index

’, 39:-, 47: :, 43:=, 37?, 23[], 29%, 22!, 22$, 29, 31{}, 29

add, 40aide, 23allvalues, 56anonyme, 41append, 49args, 43array, 30assign, 53

base, 60batch, 22, 50binaire, 50booleens, 35bytes, 60

collect, 58combine, 59

exp, 59ln, 59symbolic, 59trig, 59

convert, 49, 60base, 60bytes, 60fullparfrac, 60parfrac, 60polar, 60polynom, 60radical, 60trig, 60

copy, 44

debugage, 22dsolve, 53

ensemble, 29eval, 37evala, 37evalb, 37evalc, 37, 60

evalf, 37evalhf, 37evalm, 37evaln, 37, 39, 43evalr, 37expand, 57

factor, 57FAIL, 35, 36fclose, 50fopen, 50for, 26

in, 26while, 26

fprintf, 50fscanf, 50fullparfrac, 60

global, 41

help, 23history, 22

if, 25, 36fonction, 25instruction, 25

in, 26inerte, 56Int, 56interprete, 7intersect, 29iquo, 44

kernelopts, 21

last, 38liste, 29local, 41lprint, 49

map, 33maple -x, 7mapleinit, 21matrix, 30member, 29minus, 29modules, 47

name, 38nargs, 43nombre, 32nops, 32

Page 66: Introduction `a Maple - Des Mathématiques à Nantesguilleme/enseignement/m4/intromaple.pdf · Comme nous l’avons d´ej`a not´e, Maple est con¸cu pour le calcul formel, mˆeme

66 INDEX

normal, 59NULL, 32numeric, 36

op, 32options, 42

par reference, 43par valeur, 43parametres, 43parfrac, 60parse, 49, 50, 55pgm, 50piecewise, 36plot, 36, 42plotsetup, 21polar, 60predicat, 35print, 42, 49printbytes, 21printf, 49printlevel, 22procname, 43

quit, 7quotage, 39

rationalize, 59read, 21readbytes, 50readdata, 50readlib, 22readline, 49, 50readstat, 49remember, 42RETURN, 42rhs, 53

scanf, 49select/has, 53seq, 29, 40showstat, 22, 41simplify, 57solve, 53solve/identity, 55sort, 54sscanf, 49stopat, 22subsop, 55substring, 49, 50suite, 29sum, 40, 60system, 22

table, 30table-procedure, 30tableaux, 30toplevel, 37trace, 22true, 35

typage, 43type, 29

numeric, 36

unapply, 54union, 29use, 47

value, 37, 56vector, 30verboseproc, 22, 41vide, 32

whattype, 29while, 26with, 22writebytes, 50writeto, 49

xmaple, 7