intro maple

Introduction a` Maple

UE4 Master Recherche Mathematiques

Jean-Pol Guillement

Departement de Mathematiques

Nantes 2009/2010

Table des matie`res

Introduction 5

1 Prise de contact 7

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

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

2 Environnement : relation avec le syste`me dexploitation 21

2.1 Personnalisation du syste`me . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.2 Chargement dun fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2.3 Commandes syste`me . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

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

2.5 Chargement des bibliothe`ques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

2.6 Visualisation du code dune 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 delements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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

4 TABLE DES MATIE`RES

6 Les evaluations 37

6.1 Re`gles devaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376.2 Illustration des re`gles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

6.2.1 Niveau devaluation 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 parame`tres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437.8 Passage des parame`tres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437.9 Fonctions locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

8 Les modules 47

9 Les entrees-sorties 49

9.1 Les fonctions dentree-sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499.1.1 Fonctions de lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499.1.2 Analyse dune chane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499.1.3 Fonctions decriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 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

Introduction

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

- Matlab pour le numerique,

- pari, (Mathematica ?), ... pour lalge`bre.

Cest de tre`s 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 decrire dun logiciel qui puisse tourner sur des machines plus modestes (anticipation delemergence 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 dutilisation de Maple :

- Le mode commande reduit aux fonctions les plus basiques comme

- plot,

- int,

- diff ...

Ce type dutilisation 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

- dequations generales,

- de syste`mes lineaires,

- dequations differentielles.

Ce niveau dutilisation necessite de connatre les structures de base de Maple.

- Le mode de programmation qui permet par exemple la resolution de proble`mes du genre Terminale-Deug. Il faut savoir enchaner les calculs, faire passer les resultats dune commande a` une autre,utiliser des fonctions.

6 Introduction

- La programmation de methodes de calcul formel, cest-a`-dire lenrichissement du syste`me.

Avant detudier 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). Cest lart de reduire les calculs a` un nombre fini doperationsarithmetiques elementaires portant sur des nombres representes par un ensemble fini de sym-boles (les chiffres). Le calcul numerique fait necessairement apparatre deux types dapproxima-tion et derreur : lapproximation des nombres par les flottants, (Pi, 1/10 en base 2, ...) et ladiscretisation incontournable. On met en uvre les calculs numeriques a` laide des langages deprogrammation comme le Fortran, le C, le Pascal, ... et aussi a` laide de logiciels numeriquescomme Matlab.

- Le calcul formel qui ope`re sur les expressions mathematiques, mecaniquement, automatiquement,par programmation. Par exemple le calcul de lintegrale de exp(x2) sur ],[ peut se realiserde facon formelle (=

pi) 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` laide dune fonctionspeciale cest-a`-dire en retournant la question posee.

- Le calcul analogique comme par exemple celui que lon peut faire avec une re`gle a` calcul.

Comme nous lavons deja` note, Maple est concu pour le calcul formel, meme sil inte`gre de plus enplus, (pour des necessites commerciales sans doutes), de bons outils permettant le calcul numerique.Pour ma part, je constate quil nest pas du tout approprie aux calculs volumineux qui caracterisent laplupart des calculs scientifiques. Par ailleurs il nest pas tre`s facile de savoir lui imposer une demarchecomple`tement numerique et il nest pas facile de savoir quand il travaille en formel et quand il aban-donne le formel pour sorienter vers le numerique.

Chapitre 1

Prise de contact

1.1 Generalites

Maple est un interpre`te en attente dune expression a` evaluer (ou dune instruction a` executer). Lat-tente est signalee par un prompt, >. On appelle Toplevel cet etat.Le ; et le : marquent la fin de lexpression a` evaluer. (Le Return est ignore, ce nest pas unemarque de fin dexpression).Les expressions a` evaluer sont des symboles, des expressions mathematiques correctement parenthe`ses.(Une definition precise ne peut etre donnee sans recours a` la grammaire sous-jacente a` Maple).Si lexpression est terminee par ;, Maple affiche a` lecran la representation de la valeur du dernierresultat. Ce nest pas le cas quand lexpression 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 cest la version 11 qui est commercialisee. Engros, les versions 2 et 3 assez semblables diffe`rent de la version 4. Les versions 6 . . . 11 respectent lameme syntaxe, tre`s 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

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 laide sur laide taper "??"

# pour avoir de laide 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"

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 := false


V6 := false


V7 := false

> V5:= V5 or V6 or V7;

V5 := false

> if (V3) then

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

> elif (V5) then

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 # lordre 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;


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 laffectation 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)]):

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);


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);

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

>


> 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 lordre 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

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);


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

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

>

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


> 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]);

>

20 Prise de contact

Chapitre 2

Environnement : relation avec lesyste`me dexploitation

Lutilisation de Maple depend de 3 choses :

- De linterface choisie, Texte ou Graphique,

- Du syste`me dexploitation, 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 lusage de Maple en mode Graphique et la creationde ce que Maple appelle feuilles de calcul. Il nest pas question ici de regarder ces fonctionnalites. Onsinteresse principalement au mode Texte, plus rustique, qui presente par ailleurs le grand avantagedetre beaucoup plus portable.Bien que generales, les explications qui suivent concernent le mode Texte sous Unix.

2.1 Personnalisation du syste`me

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

2.2 Chargement dun fichier

Il est fondamental de passer par lintermediaire de fichiers pour solliciter Maple. En mode Texte cesfichiers sont des fichiers ordinaires (Texte, Ascii) que lon ecrit avec nimporte quel traitement detexte (qui ne doit rien ajouter dautre que ce que lon a ecrit). Ils contiennent des requetes Maple,comple`tement identiques a` celles que lon tape au Toplevel. Pour faire connatre leur contenu il faututiliser la commande read(). (Les copies-colles ne peuvent etre utilises que pour quelques lignes).La syntaxe dutilisation de read est

read(nom_de_fichier);

nom de fichier est une chane de caracte`re qui doit designer correctement le fichier a` solliciter, avecchemin dacce`s si necessaire. En principe (version 4) les chanes de caracte`res 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 douvrir le fichier /tmp/prog1.txt et dexecuter toutes les requetes qui sy 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 dutiliser read ou le menu Fichier-Ouvrir.

22 Environnement : relation avec le syste`me dexploitation

2.3 Commandes syste`me

Comme avec tous les langages et tous les interpre`tes, Maple offre la possibilite de lancer des commandessyste`mes depuis linterieur dune session. Il y a pour cela la fonction system() et le macro caracte`re !.

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 fle`ches et .Cest tre`s 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 bibliothe`ques

Afin que le syste`me demarre rapidement et noccupe que peu de memoire, Maple ne charge en debutde session, que le minimum, le noyau. De ce fait cest a` lutilisateur de reclamer le chargement desbibliothe`ques necessaires. Il na pas a` connatre leur localisation. Il y a deux fonctions de chargement,with() et readlib().

with(linalg); # charge toutes les fonctions

# de la bibliothe`que dalge`bre

# lineaire linalg

readlib(ancienne_bibliotheque);

2.6 Visualisation du code dune fonction

On dispose du code de toutes les fonctions des bibliothe`ques ecrites en Maple. Ce nest pas tre`s facile,mais cest 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 syste`me dexploitation, il est possible de lancer Maple pour lexecutiondun 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 nest gue`re 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 dinformation sur les calculseffectues et sur les parame`tres passes aux differentes fonctions. Il y a aussi les fonctions trace() etstopat() qui permettent le pas a` pas. (Consulter laide en ligne).

2.9 Aide en ligne 23

2.9 Aide en ligne

Laide en ligne est tre`s comple`te et plutot bien faite. La consultation est beaucoup plus commodeen mode Graphique grace au syste`me hypertexte. En mode Texte, on utilise le macro-caracte`re ?ou la fonction help(). Laide est retournee par un affichage page par page (programme more tre`sarchaque). Return fait avancer dune ligne, espace dune page, q fait sortir.

24 Environnement : relation avec le syste`me dexploitation

Chapitre 3

Elements complementaires desyntaxe

Les requetes Maple sont realisees par lintermediaire dun langage de programmation qui est unmelange de langage fonctionnel et de langage procedural (imperatif). Les requetes sont aussi biendes demandes devaluation de fonction (comme en Lisp) que des demandes dexecution dinstruction.

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 :

linstruction if

Voici un exemple dutilisation qui presente un certain melange :

x:=1;

if (x=7) then

5;

else

print(10*x);

fi;

Executee au Toplevel, cette requete provoque laffichage de 10, et retourne ce que la fonction printretourne, cest-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)

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 dune suite dindices

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 dune 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 larbre syntaxique

# de lexpression q

Note : il ny a pas de forme fonctionnelle pour for.

3.2.2 La boucle tant que

while seul

i:=1;

while (i

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

28 Elements complementaires de syntaxe

Chapitre 4

Les structures de base

4.1 Les objets Maple

Cest un peu confus (pour moi). Dune certaine manie`re lutilisateur 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 chanes de caracte`res (ex "toto").

Le codage de ces types et leur etendu ne sont pas (ou sont peu) documentes.Les fonctions whattype() ; et type() ; permettent dobtenir de linformation. 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 caracte`re $ 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.

30 Les structures de base

4.1.3 Les structures composites

Ces structures, plus riches et plus comple`tes que les structures de base, ne se comportent pas commeles premie`res. 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 suti-lisent de facon plus intuitive. Ces exemples montrent aussi quil vaut mieux eviter de creer implicite-ment, sans les controler, des objets composites. On reviendra plus comple`tement 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 dune table

a; # -> a, pas devaluation

# 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 dune 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 dune fonction

f; # -> f

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

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 dune 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 dune 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 bibliothe`que 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]


compatibilite entre les tableaux et les matrices

Il y a compatiblite si les intervalles des indices sont de la forme [1..n]. On sy 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 dune expression ou dune structure. Il retourne une suite.

op([1,4,2]); # -> 1,4,2 (cest 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 dextraire 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 delements

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 parame`trespasses 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];

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

Chapitre 5

Les expressions booleennes

Il y a trois booleens, true, false, FAIL.Par FAIL Maple signifie quil ne sait pas. FAIL se comporte comme false dans les tests.La fonction evalb() est dediee a` levaluation 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 lexpression

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 sappliquer 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

36 Les expressions booleennes

if (x < 3) then ... # -> erreur quand x na 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 proble`me de la comparaison impossible lors dun 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)) thenif (x < 0) then 0 else 1; fi;

else

f(x);

fi;

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

Note : Ce proble`me ne se produit ni avec la fonction piecewise() ni avec la fonction if().

f:=x->piecewise(xif(x -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");

else print("x 0");

else print("x 0"

Chapitre 6

Les evaluations

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

6.1 Re`gles devaluation

1. Au Toplevel, Maple evalue au plus profond niveau et retourne le resultat de la dernie`re evaluation.Sauf pour les objets composites (table, array, vector, matrix, function . . .) quil evaluejusquau dernier nom. (last name evaluation, cf exemples ci-dessous).

2. A linterieur des fonctions (ou procedures), Maple nevalue quau premier niveau.

3. On dispose de fonctions specifiques pour forcer levaluation :

fonctions type dutilisation syntaxeeval universel eval(x), eval(x,n), eval(sin(x),x=0)evalf, evalhf flottants,evalb booleens,evalm alge`bre 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 levaluation.

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 re`gles

6.2.1 Niveau devaluation 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

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, cest-a-dire 4.

# t na 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 nest pas

# tre`s normal puisque z vient

# dune 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

6.2 Illustration des re`gles 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 nest pas vu de la me^me

# 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 ny 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 levaluation.

y:=y:

x:=y;

y:=1;

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 dindice des fonctions seq, add, sum, int ,... nont 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 dune 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

Chapitre 7

Les fonctions

7.1 Definition des fonctions

On peut definir les fonctions avec loperateur 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 quil convient de

# suivre. (laborieux)

7.3 Fonctions anonymes

Il est possible dutiliser 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 nexistent 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;

42 Les fonctions

x:=-100;

y:=y;

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

# nont dexistence que lors de

# lexecution de f(). Par

# contre, le statut de a et b est

# modifie apre`s lexecution.

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

7.5 Valeur retournee

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

f:=proc(n) # fonction n!

if (n 10

# pas daffichage

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 laide sur options). Loption remember estinteressante quand une fonction doit etre evaluee plusieurs fois sur les memes parame`tres. Cest no-tamment le cas pour les fonctions recursives dordre superieur a` 1. Quand une fonction est definie avec

7.7 Controle des parame`tres 43

loption remember, Maple attache une table a` cette fonction, la table de remember. Lors de chaqueevaluation, la table est consultee. Si levaluation a deja` ete faite, le resultat y est puise. Sinon lescalculs sont realises et la table est enrichie. (Laide en ligne sur ce sujet est bien faite).

f:=proc(n)

option remember;

if (n 2

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

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

f(5); # -> erreur

f(); # -> erreur

7.8 Passage des parame`tres

Les parame`tres sont passes aux fonctions par valeur. Cela veut dire que si x est une variable dontla valeur est 5, lappel f(x) envoie 5 a` la fonction f et non la variable x. Si l est une liste de valeur[1, 2, 3], lappel g(l) envoie a` g une copie de la liste [1, 2, 3].Par contre si v est le vecteur [1, 2, 3], lappel h(v) envoie a` h la valeur de v telle quelle apparat lors delevaluation de v, cest-a`-dire, comme on la vu au chapitre 6 Les evaluations, la variable elle-meme,et non une copie.Ce mode de passage a deux consequences :

- Les parame`tres de type scalaire ou objet de base, ne peuvent etre modifies a` linterieur desfonctions.

f:=proc(x)

x:=x+1;

end;

y:=5;

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

- Pour obtenir une modification dune variable passee en parame`tre, cest-a`-dire pour effectuer unpassage par reference, il y a au moins deux solutions :

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 ny 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 dunsyste`me lineaire resolu par une methode qui transforme le syste`me), il peut saverer necessaire denpasser 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.

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 tre`s difficile de faire passer a` une fonction locale un parame`tre de lafonction principale. Cest maintenant aise.

g:=proc(x,n)

local f;

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

RETURN(f(x));

end;

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

46 Les fonctions

Chapitre 8

Les modules

Depuis la version 6, Maple offre la possibilite dutiliser 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 dattacher aux objets a` la foisdes structures de donnees et des fonctions (les methodes), permettant lheritage : on peut definirun type particulier dans un type deja` defini (classe) et profiter pour ce type particulier de toutce qui existe pour le type pe`re. On peut enrichir les methodes.

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

48 Les modules

Chapitre 9

Les entrees-sorties

Indiquons quelques fonctions impliquees dans la communication entre Maple et lexterieur, cest-a`-direlecran, le clavier, les fichiers sur disque.

9.1 Les fonctions dentree-sortie

9.1.1 Fonctions de lecture

Le peripherique dentree par defaut est le clavier.

- readstat() est la fonction que linterpre`te utilise pour acquerir les commandes. Elle est utilisablepar les programmeurs. Elle proce`de a` la saisie et a` linterpretation de la chane lue. Elle retourneun objet Maple. (Les saisies sont terminees avec ;).

- readline() retourne une chane de caracte`res.

- scanf() permet la lecture formatee.

9.1.2 Analyse dune chane

Les fonctions suivantes peuvent etre utilisees pour analyser ou fouiller une chane.

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

9.1.3 Fonctions decriture

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

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

- printf() est une fonction daffichage formate. Exemple de syntaxe :

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

la chane contient des caracte`res 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 letre avec 5 chiffres apre`s la virgule, \n est un ordre de retour a` la ligne. Voir laideen ligne sur printf() pour les differents formats (reels, chanes, caracte`res, ...).

9.2 Les redirections

Il est possible dannuler laffichage a` lecran et dordonner que les sorties se fassent dans un fichier.

writeto(nom_de_fichier);

# ou

append(nom_de_fichier);

Pour revenir a` laffichage initial a` lecran utiliser

writeto(terminal);

50 Les entrees-sorties

Cest la fonction read() deja` indiquee qui permet de rediriger les entrees.

On peut executer les calculs en mode batch . Cela veut dire, quetant sous le syste`me dexploita-tion, en lacant la commande

maple [options] fichier_source > fichier_resultat

on ouvre une session Maple non interactive, qui cesse de`s que les calculs presents dans fichier sourcesont 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 dune fonction realisant la lecture dune image en nuances de gris au format PGM (sanscommentaire). Les images PGM sont constituees de deux types de donnees : Dabord quelques lignescodees en caracte`res Ascii (mode texte) indiquant le type du fichier (P5 par exemple), contenanteventuellement des commentaires (# CREATOR ... par exemple), indiquant les dimensions de limage(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 limage 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 lecriture formatee et la fonction writebytes() lecriture en binaire.

Exemple dune fonction realisant lecriture dune 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));

9.4 Ecriture de donnees dans un fichier 51

od;

fclose(canal);

end;

52 Les entrees-sorties

Chapitre 10

Manipulation des expressions

10.1 Diverses fonctions de manipulation

10.1.1 Assign

Cette fonction permet laffectation des membres gauches des equations resultant de lutilisation defonctions comme solve() ou dsolve(). Elle doit etre utilisee moderement. Il est souvent preferabledutiliser 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)

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 dune 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 dobjets. 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;

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 tre`s 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 danalyse et dinterpre`tation des chanes de caracte`res. 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 dequations 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


> 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 solutionsdune equation. Mais elle est trop dependante de la version Maple. Il est necessaire de consulter laideen ligne de la version utilisee.

10.1.8 Value

Cette fonction permet levaluation 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

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 deffectuer 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))

Lutilisation de factor() permet parfois des simplifications difficiles : Soit a` calculer la transformeede Hilbert de f0 :=

1 t2[1,1]. La transformation de Hilbert est loperateur qui a` une fonction f

fait correspondre la fonction

H(p) =1

pi

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, lintegrale 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 )


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

{ 0 t 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 nest pas facile de mettre h2 sous la forme simplifiee attendue. Lutilisation de factor() nest pasla seule possibilite de simplification, mais ici elle est tre`s 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

10.2 Reecriture 59

> collect(simplify(fc),x);

(a + 3 b) x + 2

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

(4 c + 3) x + 6

10.2.5 Combine

Cest 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 me^me ordre didees

> 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


> rationalize(f);

1/2

2 + 2

10.2.8 Convert

Cette fonction a un champ dutilisation tre`s 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);

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 dobtenir 0 partir de lexpression 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

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 demploi. 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. Syste`mes 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.

64 BIBLIOGRAPHIE

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, 56interpre`te, 7intersect, 29iquo, 44

kernelopts, 21

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

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

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

66 INDEX

normal, 59NULL, 32numeric, 36

op, 32options, 42

par reference, 43par valeur, 43parame`tres, 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

intro maple

Documents

fonctions locales

fonctions de lecture

fonctions dentree

contenu des fonctions

fonctions anonymes

fonctions decriture

structures de base

structures composites304