Introduction `a Maple

Introduction ` a Maple UE4 Master Recherche Math´ematiques

Jean-Pol Guillement D´ epartement de Math´ ematiques Nantes 2009/2010

2

Table des mati` eres Introduction

5

1 Prise de contact 1.1 G´en´eralit´es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Exemples de commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

7 7 7

2 Environnement : relation avec le syst` eme 2.1 Personnalisation du syst`eme . . . . . . . . 2.2 Chargement d’un fichier . . . . . . . . . . 2.3 Commandes syst`eme . . . . . . . . . . . . 2.4 Historique des commandes . . . . . . . . . 2.5 Chargement des biblioth`eques . . . . . . . 2.6 Visualisation du code d’une fonction . . . 2.7 Ex´ecution en mode batch . . . . . . . . . 2.8 D´ebugage . . . . . . . . . . . . . . . . . . 2.9 Aide en ligne . . . . . . . . . . . . . . . .

. . . . . . . . .

21 21 21 22 22 22 22 22 22 23

. . . . . .

25 25 25 26 26 26 26

. . . . . . . . . . . .

29 29 29 29 30 31 32 32 32 32 32 33 33

expressions bool´ eennes Le symbole ”=” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le pr´edicat ”=” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le pr´edicat ””. On appelle Toplevel cet ´etat. Le ” ;” et le ” :” marquent la fin de l’expression `a ´evaluer. (Le ”Return” est ignor´e, ce n’est pas une marque de fin d’expression). Les expressions `a ´evaluer sont des symboles, des expressions math´ematiques ”correctement parenth`eses”. (Une d´efinition pr´ecise ne peut ˆetre donn´ee sans recours `a la grammaire sous-jacente `a Maple). Si l’expression est termin´ee par ” ;”, Maple affiche `a l’´ecran la repr´esentation de la valeur du dernier r´esultat. Ce n’est pas le cas quand l’expression est termin´ee par ” :”. On ferme le logiciel avec ”quit”. On peut travailler en mode Texte interactif ou batch, et en mode Graphique interactif (sous Unix commande maple -x ou xmaple). Note : Il y a des diff´erences entre les versions. En 2007 c’est la version 11 qui est commercialis´ee. En gros, les versions 2 et 3 assez semblables diff`erent de la version 4. Les versions 6 . . . 11 respectent la mˆeme syntaxe, tr`es voisine de celle de la version 5.

1.2

Exemples de commandes

|\^/| ._|\| |/|_. \ MAPLE / |

Maple 9 (IBM INTEL LINUX) Copyright (c) Maplesoft, a division of Waterloo Maple Inc. 2003 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 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"

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

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 > s[2];

# l’ordre peut varier 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’;

1.2 Exemples de commandes

11 x := x

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

2 + 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 e := 16 cos(x)

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

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 + 62512217960687222169600 _Z

3 - 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 %1 := 62953620111360000 _Z

5 - 700749536346021888000 _Z 4

+ 62512217960687222169600 _Z

3 - 14491862768764210106880 _Z

2 + 3301345200565172560 _Z - 236492379085 _Z + 1 > > norm(h6,infinity);

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

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 pr´ ec´ edentes simplify(s0); -> # infinity # ----# \ # ) 0 # / # ----# n = 0 > evalf(s0); 0. > value(s0); 0 >

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

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\ | 5 | u5 := |1/2 - ----| \ 10 /

/ 1/2 \5 / 1/2\ | 5 | | 5 | |- ---- + 1/2| + |1/2 + ----| \ 2 / \ 10 /

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

/ 1/2 \5 |5 | |---- + 1/2| \ 2 /

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

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

1.2 Exemples de commandes > 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]); >

19

20

Prise de contact

Chapitre 2

Environnement : relation avec le syst` eme d’exploitation L’utilisation de Maple d´epend de 3 choses : - De l’interface choisie, Texte ou Graphique, - Du syst`eme d’exploitation, Unix, Windows, Macintosh, - De la version utilis´ee. Les nouvelles versions de Maple offrent des possibilit´es importantes pour exporter les calculs, en documents latex, html ...Ces possibilit´es n´ecessitent l’usage de Maple en mode Graphique et la cr´eation de ce que Maple appelle feuilles de calcul. Il n’est pas question ici de regarder ces fonctionnalit´es. On s’int´eresse principalement au mode Texte, plus rustique, qui pr´esente par ailleurs le grand avantage d’ˆetre beaucoup plus portable. Bien que g´en´erales, les explications qui suivent concernent le mode Texte sous Unix.

2.1

Personnalisation du syst` eme

Le fichier .mapleinit, s’il existe dans le r´epertoire personnel (home directory) est ex´ecut´e en d´ebut de toute session Maple. On peut donc y mettre les instructions dont on souhaite syst´ematiquement l’ex´ecution. Par exemple plotsetup(X11) ; kernelopts(printbytes=false) ;

2.2

Chargement d’un fichier

Il est fondamental de passer par l’interm´ediaire de fichiers pour solliciter Maple. En mode Texte ces fichiers sont des fichiers ordinaires (Texte, Ascii) que l’on ´ecrit avec n’importe quel traitement de texte (qui ne doit rien ajouter d’autre que ce que l’on a ´ecrit). Ils contiennent des requˆetes Maple, compl`etement identiques `a celles que l’on tape au Toplevel. Pour faire connaˆıtre leur contenu il faut utiliser la commande read(). (Les copi´es-coll´es ne peuvent ˆetre utilis´es que pour quelques lignes). La syntaxe d’utilisation de read est read(nom_de_fichier); nom de fichier est une chaˆıne de caract`ere qui doit d´esigner correctement le fichier `a solliciter, avec chemin d’acc`es si n´ecessaire. En principe (version ≥ 4) les chaˆınes de caract`eres sont `a mettre entre guillemets (”). Si nom de fichier ne contient pas de signe Maple (−, /, \, ..) les guillemets peuvent ˆetre omis. On reviendra plus loin sur la fa¸con 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’ex´ecuter toutes les requˆetes qui s’y trouvent, exactement comme si elles ´etaient tap´ees au Toplevel. Note : Les fichiers provenant des feuilles de calcul, (extension ”.mws”) ne peuvent pas ˆetre lues en mode Texte. Il est n´ecessaire de passer en mode Graphique, et d’utiliser read ou le menu Fichier-Ouvrir.

22

Environnement : relation avec le syst` eme d’exploitation

2.3

Commandes syst` eme

Comme avec tous les langages et tous les interpr`etes, Maple offre la possibilit´e de lancer des commandes syst`emes depuis l’int´erieur d’une session. Il y a pour cela la fonction system() et le macro caract`ere ” !”. system("ls") system("pwd") !ne prog1.txt

2.4

# liste le r´ epertoire courant # affiche le nom du r´ epertoire courant # ´ edite (si ´ editeur ne existe) prog1.txt

Historique des commandes

En mode Texte (pas en mode Graphique), on peut r´e´editer les commandes avec les fl`eches ↑ et ↓. C’est tr`es commode. On peut aussi afficher les 3 derniers r´esultats avec %; %%; %%%;

# dernier r´ esultat # avant dernier # avant avant dernier

On peut aussi indexer les r´esultats en utilisant au pr´ealable la fonction history() ;

2.5

Chargement des biblioth` eques

Afin que le syst`eme d´emarre rapidement et n’occupe que peu de m´emoire, Maple ne charge en d´ebut de session, que le minimum, le noyau. De ce fait c’est `a l’utilisateur de r´eclamer le chargement des biblioth`eques n´ecessaires. 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 biblioth` eque d’alg` ebre # lin´ eaire linalg

readlib(ancienne_bibliotheque);

2.6

Visualisation du code d’une fonction

On dispose du code de toutes les fonctions des biblioth`eques ´ecrites en Maple. Ce n’est pas tr`es 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

Ex´ ecution en mode batch

En dehors de Maple, sous le syst`eme d’exploitation, il est possible de lancer Maple pour l’ex´ecution d’un unique fichier. Et ´eventuellement de r´ecup´erer les r´esultats dans un autre fichier. maple nom_de_fichier > fichier_resultats

2.8

D´ ebugage

Rechercher les erreurs dans un programme est une chose courante. Ce n’est gu`ere possible de programmer juste du premier coup. En g´en´eral on ajoute des affichages suppl´ementaires pour contrˆoler les calculs. Maple fournit diverses possibilit´es suppl´ementaires. La valeur de la variable printlevel peut ˆetre modifi´ee. Plus la valeur est grande (7,15,255,..), plus Maple donne d’information sur les calculs effectu´es et sur les param`etres pass´es aux diff´erentes fonctions. Il y a aussi les fonctions trace() et stopat() qui permettent le pas `a pas. (Consulter l’aide en ligne).

2.9 Aide en ligne

2.9

Aide en ligne

L’aide en ligne est tr`es compl`ete et plutˆot bien faite. La consultation est beaucoup plus commode en mode Graphique grˆ ace au syst`eme hypertexte. En mode Texte, on utilise le macro-caract`ere ” ?” ou la fonction help(). L’aide est retourn´ee par un affichage page par page (programme more tr`es archa¨ıque). ”Return” fait avancer d’une ligne, ”espace” d’une page, ”q” fait sortir.

23

24

Environnement : relation avec le syst` eme d’exploitation

Chapitre 3

´ ements compl´ El´ ementaires de syntaxe Les requˆetes Maple sont r´ealis´ees par l’interm´ediaire d’un langage de programmation qui est un m´elange de langage fonctionnel et de langage proc´edural (imp´eratif). Les requˆetes sont aussi bien des demandes d’´evaluation de fonction (comme en Lisp) que des demandes d’ex´ecution d’instruction. On a d´ej`a vu dans les chapitres pr´ec´edents certain ´el´ements de la syntaxe. Compl´etons par

3.1 3.1.1

Les branchements conditionnels Le si

Le si peut ˆetre utilis´e sous deux formes, instruction et fonction : l’instruction if Voici un exemple d’utilisation qui pr´esente un certain m´elange : x:=1; if (x=7) then 5; else print(10*x); fi; Ex´ecut´ee au Toplevel, cette requˆete 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; x:=7; %; x:=1; y; x:=9; y;

‘if‘(x=7,5,55); ‘if‘(x=7,5,55);

# -> 55 # -> 5 # -> 5

y:=‘if‘(x=7,5,55); y:=‘if‘(x=7,5,print(10*x));

# -> 55 # affiche 90 # -> suite vide (NULL)

´ ements compl´ El´ ementaires de syntaxe

26

3.1.2

Le choix multiple x:=1; if (x=7) then 100; elif (x=8) then 200; else 300; fi;

3.2

Les r´ ep´ etitions

3.2.1

La boucle pour

# -> 300

Il y a plusieurs fa¸con de faire circuler les indices : la forme courante for i from 1 to 10 do print(10*i); od; %; s:=0; for i from 1 to 3 do s:=s+i^2; od;

# parcours d’une suite d’indices # affiche les nombres 10,20,.. # -> true (r´ esultat d´ eroutant)

%,s,i;

# au Toplevel affiche les valeurs # interm´ ediaires de s # -> 14,14,4

# calcul ´ equivalent s:=add(i^2,i=1..3);s;

# -> 14

parcours des ´ el´ ements d’une structure l:=[3,2,1]; s:=0; for i in l do s:=s+i^2; od; %,s,i; q:=sin(x)+2*x*y*ln(x+y); for u in q do print(u); od;

# -> 14,14,1

# # # #

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 1) do print(i); od;

# affiche 3,2

28

´ ements compl´ El´ ementaires de syntaxe

Chapitre 4

Les structures de base 4.1

Les objets Maple

C’est un peu confus (pour moi). D’une certaine mani`ere l’utilisateur ne voit pas les structures informatiques. Il y a m´elange entre structures informatiques et math´ematiques.

4.1.1

Les objets atomiques

(ou scalaires). On peut distinguer - les symboles (ex toto), - les entiers, - les flottants, - les nombres en pr´ecision arbitraire, - les bool´eens (true,false,FAIL), - les chaˆınes de caract`eres (ex "toto"). Le codage de ces types et leur ´etendu ne sont pas (ou sont peu) document´es. Les fonctions whattype() ; et type() ; permettent d’obtenir de l’information. Cette information est principalement de nature math´ematique.

4.1.2

x:=5: y:=5/2: y2:=5.0/2: z:=’z’: u:= 2*z+5*x: t:=’t’: whattype(x); whattype(y); whattype(y2); whattype(z); whattype(u); type(x,rational); type(y,rational); type(y2,rational); type(z,rational); type(u,rational);

# # # # # # # # # #

assume(t,integer): type(t,integer);

# -> false, t a pour valeur le symbole t

-> -> -> -> -> -> -> -> -> ->

integer fraction float symbol + true true false false false

Les structures de base

Maple manipule efficacement - les suites. Elles sont repr´esent´ees ext´erieurement comme 2,1,0,1,2, - les listes. Elles sont repr´esent´ees ext´erieurement comme [2,1,0,1,2], - les ensembles. Ils sont repr´esent´es ext´erieurement comme {0,1,2}. La fonction seq() et le macro caract`ere $ permettent de d´efinir les suites. Les crochets [] et les accolades {} permettent de d´efinir les listes (list) et les ensembles (set). Les fonctions union() , intersect() , minus() , member() sont associ´ees aux ensembles.

30

Les structures de base

4.1.3

Les structures composites

Ces structures, plus riches et plus compl`etes que les structures de base, ne se comportent pas comme les premi`eres. On y reviendra ult´erieurement. On distingue les - les tables (table), - les tables-proc´edures, - les tableaux (array), - les vecteurs et les matrices (vector, matrix (linalg)), - les fonctions. Les exemples qui suivent, un peu laborieux mais incontournables, montrent des diff´erences d´eroutantes de comportement entre les structures de base et les structures composites. Les structures de base s’utilisent de fa¸con plus intuitive. Ces exemples montrent aussi qu’il vaut mieux ´eviter de cr´eer implicitement, sans les contrˆoler, des objets composites. On reviendra plus compl`etement sur les ´evaluations. # comportement des listes l:=[1,5,7]

# # # # # # # # #

l est un symbole dont la valeur est une liste -> [1,5,7] -> list -> list -> 1,5,7 -> 1 -> erreur -> erreur

# # # # # # # # # # #

cr´ eation d’une table -> a, pas d’´ evaluation au plus profond niveau -> table([2 = 5]) -> 5 -> a[1] -> symbol -> table -> table([2 = 5]) -> [2 = 5] -> list

op(eval(g)); whattype(op(eval(g)));

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

cr´ eation d’une table-proc´ edure -> g -> proc() option remember; ’procname(args)’ end proc -> 5 -> g(1) -> symbol -> procedure -> proc() option remember; ’procname(args)’ end proc -> remember, table([2 = 5]) -> exprseq

# les fonctions f:= n -> n^2; f; eval(f);

# cr´ eation d’une fonction # -> f # -> n -> n^2

l; whattype(l); whattype(eval(l)); op(l); l[1]; l[4]; l[4]:=8; # comportement des tables a:=’a’: a[2]:=5; a; eval(a); a[2]; a[1]; whattype(a); whattype(eval(a)); op(a); op(eval(a)); whattype(op(eval(a))); # les tables-proc´ edures g:=’g’: g(2):=5; g; eval(g); g(2); g(1); whattype(g); whattype(eval(g)); op(g);

4.1 Les objets Maple f(toto); whattype(f); whattype(eval(f)); op(f); op(eval(f));

# # # # #

-> -> -> -> ->

h:= proc(n) n^2; end;

# # # # # # #

cr´ eation d’une fonction petite diff´ erence avec f -> proc(n) n^2 end -> symbol -> procedure -> proc(n) n^2 end -> n

eval(h); whattype(h); whattype(eval(h)); op(h); op(eval(h));

4.1.4

31 toto^2 symbol procedure n -> n^2 n, operator, arrow

Cr´ eation explicite de structures composites

tables d:=table(); d[titi]; d[titi]:=cos(xx); d[titi];

# cr´ eation d’une table sans instanciation # -> d[titi] # -> cos(xx) # cr´ eation 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]); v; eval(v); print(v); lv:=convert(v,list); lv; v[-2]; lv[1]; v[3]; v[3]:=1000;

# # # #

intervalle des indices = -2 .. 2 -> v -> array(-2..2, [(-2)=4, ...]) -> array(-2..2, [(-2)=4, ...])

# # # # #

-> -> -> -> ->

[4,1,0,1,4] 4 4 erreur erreur

vecteurs et matrices Les types vector et matrix font en principe partie de la biblioth`eque linalg. Mais ils sont visibles sans son chargement. l:=[1$4]; v:=vector(4,l); v; eval(v); print(v); evalb(l=v); evalb(l=eval(v)); evalb(l=convert(v,list)); m:=matrix(2,4,[l,2*l]);

# # # # # # # # # #

-> -> -> -> -> -> -> [1 [ [2

v [1,1,1,1] vu comme la liste sous-jacente [1,1,1,1] false false true 1

1

2

2

1] ] 2]

32

Les structures de base compatibilit´ e entre les tableaux et les matrices Il y a compatiblit´e 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); evalb(c=m); type(b,matrix); type(c,matrix); eval(b); eval(c);

4.2 4.2.1

# # # # # # # # #

-> -> -> -> -> -> [1 [ [2

false false false true [[1, 1, 1, 1], [2, 2, 2, 2]] 1

1

2

2

1] ] 2]

Manipulations des objets de base Extraction

op extrait les composantes d’une expression ou d’une structure. Il retourne une suite. op([1,4,2]); op(1,4,2); op({1,4,2,1}); op(1+2+3); op(x+y-z); op(x/y/z);

4.2.2

# # # # # #

-> -> -> -> -> ->

1,4,2 (c’est une suite) erreur 1,2,4 6 x,y,-z x,1/y,1/z

S´ election

op permet ´egalement d’extraire un seul ´el´ement. op(2,[x,y,z]); l:=[4,5,6,7,8]: l[2]; l[1..3]; l[2..-1]; l[2..-2]; op(2,x+y*z-8);

4.2.3

# # # # #

-> -> -> -> ->

5 [4,5,6] [5,6,7,8] [5,6,7] y*z

Nombre d’´ el´ ements l:=[4,5,6,7,8]: nops(l);

4.2.4

# -> y

# -> 5

Constitution de suites et de listes

Les listes sont plus faciles `a manipuler que les suites qui se confondent souvent avec les param`etres pass´es aux fonctions. s:=NULL; l:=[NULL]; ll:=[]; evalb(l=ll); l:=[4,5,6]; l:=[seq(i^2,i=2..6)]; l:=[2$4]; m:=[x,y,z];

# # # #

suite vide liste vide liste vide -> true

4.2 Manipulations des objets de base

33

n:=[100,op(l)]; o:=[op(l),op(m)];

4.2.5

# -> [100,2,2,2,2] # -> [2,2,2,2,x,y,z]

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 entr´ee une structure et une fonction, elle retourne la structure dont les ´el´ements sont les images des ´el´ements de la structure source. l:=[1,2,3]; map(t->t^2,l); e:=x^2+25*y+Pi/2; map(sin,e);

# -> [1,4,9] 2 # -> sin(x ) + sin(25 y) + 1

34

Les structures de base

Chapitre 5

Les expressions bool´ eennes Il y a trois bool´eens, true, false, FAIL. Par FAIL Maple signifie qu’il ne sait pas. FAIL se comporte comme false dans les tests. La fonction evalb() est d´edi´ee `a l’´evaluation des expressions bool´eennes.

5.1

Le symbole ”=”

a deux sens. Dans un test genre if (x = 8) then ... il se comporte comme un pr´edicat. Dans cette construction, (x = 8) est une expression bool´eenne. Par contre dans l’expression e:=(x=y); il sert `a d´efinir un objet de type ´ equation. e:=((x-1)*(x-2) = (x-1)); e; whattype(e); solve(e); evalb(e); evalb(subs(x=3,e));

5.2

# # # # #

-> -> -> -> ->

(x - 1) (x - 2) = x - 1 = 3,1 false true

Le pr´ edicat ”=”

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 r´eponse est impr´evisible.

5.3

Le pr´ edicat ” if (x < 0) then 0 else 1; fi; f(-2); plot(f(x),x=-5..5);

# -> erreur quand x n’a pas de # valeur num´ erique # -> 0 # -> erreur cannot ...

Pour contourner le probl`eme 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); plot(’f(x)’,x=-5..5);

# -> erreur cannot ... # 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 probl`eme ne se produit ni avec la fonction piecewise() ni avec la fonction ‘if‘(). f:=x->piecewise(x‘if‘(x0); evalb(x>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 d´elicat, car il diff`ere selon les objets `a ´evaluer (scalaires, objets basiques, objets composites) et suivant le contexte (Toplevel, int´erieur des fonctions). On doit retenir les r`egles suivantes :

6.1

R` egles d’´ evaluation

1. Au Toplevel, Maple ´evalue au plus profond niveau et retourne le r´esultat de la derni`ere ´evaluation. Sauf pour les objets composites (table, array, vector, matrix, function . . .) qu’il ´evalue jusqu’au ”dernier nom”. (last name evaluation, cf exemples ci-dessous). 2. A l’int´erieur des fonctions (ou proc´edures), Maple n’´evalue qu’au premier niveau. 3. On dispose de fonctions sp´ecifiques pour forcer l’´evaluation : fonctions eval evalf, evalhf evalb evalm evalc evala evalr

type d’utilisation universel flottants, bool´eens, alg`ebre lin´eaire, nombres complexes, nombres alg´ebriques, calcul par intervalles

value

´evaluation des fonctions inertes.

syntaxe eval(x), eval(x,n), eval(sin(x),x=0)

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 niveau du membre de droite. Sauf lorsque celui-ci est de type composite, auquel cas il y a pointage.

6.2 6.2.1

Illustration des r` egles Niveau d’´ evaluation et affectations

au Toplevel x:=’x’: y:= ’y’: z:=’z’: x:=y; y:=z; z:=1; x;

z:=4; x;

# # # #

-> 1. Evaluation au plus profond niveau x pointe sur y qui pointe sur z dont la valeur est 1

# -> 4

38

Les ´ evaluations x:=5; z; t:=y;

t; y:=55; t;

# -> 4, x ne pointe plus sur 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 -> 4

# -> 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 proc´ edure 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(); a:=essai2(); a; eval(a,1);

# la proc´ edure affiche y,z,1 # et retourne z # # # # # # #

-> 1 -> z a a pour valeur z qui a pour valeur 1 (ce qui n’est pas tr` es normal puisque z vient d’une variable locale de essai2)

# # # # # #

-> m -> [a b] [ ] [c d] idem avec eval(m), print(m), eval(m,1)

last name evaluation m:=matrix(2,2,[a,b,c,d]); m; evalm(m);

m1:=m; m2:=m1; m3:=m2; m,m1,m2,m3; eval(m1,1),eval(m2,1),eval(m3,1);

# -> m,m,m,m # -> m,m,m

m5:=m4; m4:=m3; m4,m5; eval(m4,1), eval(m5,1);

# -> m,m # -> m,m4

6.2 Illustration des r` egles

print(m5);

f:= 2*b+c; b:= 1; f; b:= 10; f; eval(m);

map(eval,m);

6.2.2

39

# -> [a # [ # [c

b] ] d]

# -> 2 + c # # # # # #

-> 20 + c -> [a b] [ ] [c d] b n’est pas vu de la m^ eme fa¸ con dans f et dans m

# -> [a # [ # [c

10] ] d]

Affectations

cas des listes l1:=[2,3,4]; l2:=l1; l2[2]:=33; l1; l2;

# # # # #

-> [2,3,4] -> [2,33,4] il y a eu recopie de la valeur de l1 et distinction totale entre l1 et l2

# # # # # # #

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

cas des tables Attention danger ! v1:=vector(3,l1); v2:=v1; v2[2]:=333; v1; eval(v1);

v3:=copy(v1); v3[3]:=444; eval(v1);

6.2.3

# recopie # [2,333,4]

Quotage

La fonction evaln() et le dispositif de quotage retardent l’´evaluation. y:=’y’: x:=y; y:=1;

40

Les ´ evaluations x; eval(x,1); eval(’x’,1); eval(’x’,2); eval(’x’,3); eval(’’x’’,3); eval(’2*x’,1); eval(’x+5’,2); x:=evaln(x); x;

6.2.4

# # # # # # # # # #

-> 1 -> y -> x -> y -> 1 -> y, (deux fois signe quote) -> 2 x -> y+5 meme effet que ’x’ -> x

Quelques diff´ erences difficilement pr´ evisibles

Les variables d’indice des fonctions seq, add, sum, int ,... n’ont pas le mˆeme comportement selon les versions de Maple et selon que les fonctions font partie du noyau (built-in functions, cod´ees en binaire) ou au contraire font partie des fonctions ´ecrites en Maple. Voici quelques exemples, tous provenant d’une ex´ecution en version 7. i:=’i’; sum(i,i=1..3); i; i:=5; sum(i,i=1..3); i:=5; add(i,i=1..3); i:=5; seq(i,i=1..3); i;

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

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

-> 6 -> i erreur -> 6 -> 1,2,3 -> 5 add et seq sont des fonctions de bas niveau contrairement ` a sum -> 15 (3x5) -> 6 -> 5

Chapitre 7

Les fonctions 7.1

D´ efinition des fonctions

On peut d´efinir les fonctions avec l’op´erateur → ou en utilisant proc(). Voir les exemples dans les chapitres pr´ec´edents.

7.2

Comment voir le contenu des fonctions showstat(sum); # ou interface(verboseproc=2); print(sum); # # # # #

7.3

affiche le programme de la fonction sum. Cette fonction comporte de nombreuses m´ ethodes qu’il convient de suivre. (laborieux)

Fonctions anonymes

Il est possible d’utiliser des fonctions sans leur donner de nom. ((x,y) -> x * y) (2,20); map(t->t^2, [1,2,3]);

7.4

# -> 40 # -> [1,4,9]

Variables locales, variables globales

On peut choisir le statut des variables utilis´ees dans la d´efinition des fonctions avec les d´eclarations local ou global. Par d´efaut Maple ´emet un avertissement et d´eclare local les variables qui ne sont pas d´eclar´ees et qui n’existent pas par ailleurs. Mais je d´econseille de profiter de cette disposition, je recommande de proc´eder syst´ematiquement aux d´eclarations. 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();

a,b,x,y;

7.5

# # # # # #

-> 1000. Les variables x et y n’ont d’existence que lors de l’ex´ ecution de f(). Par contre, le statut de a et b est modifi´ e apr` es l’ex´ ecution. -> 1, 10, -100, y

Valeur retourn´ ee

La valeur retourn´ee par une fonction est celle de la derni`ere ´evaluation ou la valeur explicitement sp´ecifi´ee par RETURN. Il me semble plus clair d’utiliser syst´ematiquement RETURN(). On peut cependant utiliser les deux formes de retour dans la mˆeme fonction. f:=proc(n) if (n 10 # pas d’affichage

f3:=proc(a,b) local x; print(plot(sin(x),x=a..b)); b-a; end; f3(0,10);

7.6

# -> 10 # dessin ok

Options

On peut attacher aux fonctions plusieurs options. (Voir l’aide sur options). L’option remember est int´eressante quand une fonction doit ˆetre ´evalu´ee plusieurs fois sur les mˆemes param`etres. C’est notamment le cas pour les fonctions r´ecursives d’ordre sup´erieur `a 1. Quand une fonction est d´efinie avec

7.7 Contrˆ ole des param` etres

43

l’option remember, Maple attache une table `a cette fonction, la table de remember. Lors de chaque ´evaluation, la table est consult´ee. Si l’´evaluation a d´ej`a ´et´e faite, le r´esultat y est puis´e. Sinon les calculs sont r´ealis´es et la table est enrichie. (L’aide en ligne sur ce sujet est bien faite). f:=proc(n) option remember; if (n -> -> -> ->

2 2 erreur erreur erreur

Passage des param` etres

Les param`etres sont pass´es aux fonctions par valeur. Cela veut dire que si x est une variable dont la 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 de l’´evaluation de v, c’est-`a-dire, comme on l’a vu au chapitre 6 Les ´evaluations, la variable elle-mˆeme, et non une copie. Ce mode de passage a deux cons´equences : - Les param`etres de type scalaire ou objet de base, ne peuvent ˆetre modifi´es `a l’int´erieur des fonctions. f:=proc(x) x:=x+1; end; y:=5; f(y);

# -> erreur,

5 := 6 impossible

- Pour obtenir une modification d’une variable pass´ee en param`etre, c’est-`a-dire pour effectuer un passage par r´ef´erence, il y a au moins deux solutions :

44

Les fonctions f1:=proc(x) x:=eval(x)+1; 10; end; y:=5; f(’y’); y; f2:=proc(x::evaln) x:=eval(x)+1; 10; end; y:=5; f(y); y;

# -> 10, passage de y # -> 6 # d´ eclaration de passage par r´ ef´ erence

# -> 10, passage de y # -> 6

Pour les objets composites, il n’y a rien `a pr´evoir pour effectuer un passage par r´ef´erence. Au contraire, si la fonction modifie un objet dont on d´esire conserver la valeur initiale (par exemple la matrice d’un syst`eme lin´eaire r´esolu par une m´ethode qui transforme le syst`eme), il peut s’av´erer n´ecessaire d’en passer une copie avec la fonction copy(). f:=proc(x) x[1]:=x[1]+1000; end; v:=vector(3,[1$3]); f(v); v; eval(v); l:=[1$3]; f(l); f(’l’); l;

# -> 1001 # -> v # -> [1001,1,1] # -> erreur # -> 1001 # -> [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 le reste 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); z:=sin(x); deuclide(7,2,z); z;

7.9

# -> 3 # -> 3 # -> 1

Fonctions locales

Il est possible de d´efinir des fonctions locales `a une fonction donn´ee.

7.9 Fonctions locales p4:=proc(x) local f;

45 # fonction x -> x^4

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

# -> 16

Note : Avant la version 5, il ´etait tr`es difficile de faire passer `a une fonction locale un param`etre de la fonction principale. C’est maintenant ais´e. 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 possibilit´e d’utiliser des modules. Les modules permettent - de cr´eer des objets complexes, comme les enregistrements du Pascal (RECORD) et les structures du C (struct), avec la notion de champs associ´es aux objets. - de faire de la programmation orient´ee objet, offrant la possibilit´e d’attacher aux objets `a la fois des structures de donn´ees et des fonctions (les m´ethodes), permettant l’h´eritage : on peut d´efinir un type particulier dans un type d´ej`a d´efini (classe) et profiter pour ce type particulier de tout ce qui existe pour le type p`ere. On peut enrichir les m´ethodes. Consulter l’aide en ligne sur module, use ou help(" :-") ; (Version 7).

48

Les modules

Chapitre 9

Les entr´ ees-sorties Indiquons quelques fonctions impliqu´ees dans la communication entre Maple et l’ext´erieur, c’est-`a-dire l’´ecran, le clavier, les fichiers sur disque.

9.1

Les fonctions d’entr´ ee-sortie

9.1.1

Fonctions de lecture

Le p´eriph´erique d’entr´ee par d´efaut est le clavier. - readstat() est la fonction que l’interpr`ete utilise pour acqu´erir les commandes. Elle est utilisable par les programmeurs. Elle proc`ede `a la saisie et `a l’interpr´etation de la chaˆıne lue. Elle retourne un objet Maple. (Les saisies sont termin´ees avec ” ;”). - readline() retourne une chaˆıne de caract`eres. - scanf() permet la lecture format´ee.

9.1.2

Analyse d’une chaˆıne

Les fonctions suivantes peuvent ˆetre utilis´ees 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 parfois int´eressante. - lprint() permet un affichage basique, non centr´e. - printf() est une fonction d’affichage format´e. Exemple de syntaxe : printf("f(%3a) = %.5a\n",i,f(i)); la chaˆıne contient des caract`eres qui sont affich´es (f,(,), ,=), et des directives de formatage : %3a indique que la valeur de i doit ˆetre affich´ee sur 3 colonnes, %.5a indique que la valeur de f(i) doit l’ˆetre avec 5 chiffres apr`es la virgule, \n est un ordre de retour `a la ligne. Voir l’aide en ligne sur printf() pour les diff´erents formats (r´eels, chaˆınes, caract`eres, ...).

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

50

Les entr´ ees-sorties C’est la fonction read() d´ej`a indiqu´ee qui permet de rediriger les entr´ees. On peut ex´ecuter les calculs en mode batch . Cela veut dire, qu’´etant sous le syst`eme d’exploitation, en la¸cant la commande maple [options] fichier_source > fichier_resultat on ouvre une session Maple non interactive, qui cesse d`es que les calculs pr´esents dans fichier source sont achev´es. Les r´esultats se trouvant dans fichier resultat.

9.3

Lecture de donn´ ees dans un fichier

Pour la lecture de donn´ees num´eriques ´ecrites ”en clair” dans un fichier Texte (Ascii), la fonction readdata() convient bien. Si le fichier contient du texte et des valeurs num´eriques, readline() et parse() peuvent ˆetre int´eressantes. Le fonction fscanf() permet de r´ealiser des lectures format´ees et la fonction readbytes() permet de lire des donn´ees binaires. Exemple d’une fonction r´ealisant la lecture d’une image en nuances de gris au format PGM (sans commentaire). Les images PGM sont constitu´ees de deux types de donn´ees : D’abord quelques lignes cod´ees en caract`eres Ascii (mode texte) indiquant le type du fichier (P5 par exemple), contenant ´eventuellement 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) cod´es en binaire sur 1 octet. # la fonction loadpgm prend en entr´ ee un nom de fichier f et retourne # une liste form´ ee 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); # lg:=readline(f); while (substring(lg,1..1) = "#") do # les lg:=readline(f); od; dims:=sscanf(lg,"%d %d"); # haut:=dims[2]; larg:=dims[1]; lg:=readline(f); # l:=readbytes(f,infinity); # RETURN([haut,larg,matrix(haut,larg,l)]); end;

9.4

marque P5 commentaires

les dimensions le nombre de nuances les pixels

´ Ecriture de donn´ ees dans un fichier

La fonction fprintf() permet l’´ecriture format´ee et la fonction writebytes() l’´ecriture en binaire. Exemple d’une fonction r´ealisant l’´ecriture d’une image au format PGM : # la fonction sauvegm prend en entr´ ee 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 donn´ ees dans un fichier od; fclose(canal); end;

51

52

Les entr´ ees-sorties

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 r´esultant de l’utilisation de fonctions comme solve() ou dsolve(). Elle doit ˆetre utilis´ee mod´er´ement. Il est souvent pr´ef´erable d’utiliser la fonction rhs() ou la fonction select/has() pour r´ecup´erer les expressions apparaissant dans 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 cr´eer une fonction `a partir d’une variable dont la valeur est une expression, ce qui ne 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 diff´erents types d’objets. Elle a pour particularit´e de modifier les expressions pass´ees 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 op´erande dans une expression. Elle permet des combinaisons sophistiqu´ees, pas tr`es ais´ees, par exemple dans les int´egrales. > 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’interpr`etation des chaˆınes de caract`eres. Elle retourne un objet Maple. > x:=1: > "x+2"; "x+2" > parse("x+2"); x + 2 > eval(parse("x+2")); 3

10.1.6

Solve/identity

La m´ethode identity attach´ee `a la fonction solve() permet la r´esolution d’´equations selon la m´ethode des coefficients ind´etermin´es. > 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

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 solutions d’une ´equation. Mais elle est trop d´ependante de la version Maple. Il est n´ecessaire de consulter l’aide en ligne de la version utilis´ee.

10.1.8

Value

Cette fonction permet l’´evaluation des expressions contenant des fonctions inertes. > F := Int(x, x); / | | x dx |

F := / > 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 R´ e´ ecriture

57

> d:=combine(i-j); infinity / | d := | | / 1

1 1/x - ----- dx 1 + x

> value(d); ln(2)

10.2

R´ e´ ecriture

Voici quelques exemples de commandes permettant d’effectuer diverses transformations sur les expressions.

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 transform´ee √ de Hilbert de f 0 := 1 − t2 χ[−1,1] . La transformation de Hilbert est l’op´erateur qui `a une fonction f fait correspondre la fonction Z 1 ∞ f (t) H(p) = dt. π −∞ p − t La fonction Maple hilbert() du package inttrans est capable de faire ce calcul, mais elle ´echoue pour f 0 (version 7). Cependant le calcul est faisable directement. p Le r´esultat `a trouver estpp pour −1 < p < 1, l’int´egrale ´etant une valeur principale de Cauchy, p − p2 − 1 pour p > 1, et p + p2 − 1 pour p < 1. > with(inttrans): > f :=sqrt(1-t^2); 2 1/2 f := (1 - t )

58

Manipulation des expressions

> f0:=piecewise(t=1,0,f); { 0 { f0 := { 0 { { 2 1/2 { (1 - t )

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 n’est pas facile de mettre h2 sous la forme simplifi´ee attendue. L’utilisation de factor() n’est pas la seule possibilit´e de simplification, mais ici elle est tr`es pratique. > factor(h2,denom(h2)); 2 p~ - (p~

10.2.4

1/2 - 1)

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 R´ e´ ecriture

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 m^ eme ordre d’id´ ees > 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

60

Manipulation des expressions > rationalize(f); 1/2 2 + 2

10.2.8

Convert

Cette fonction a un champ d’utilisation tr`es 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

# Ecriture en base autre que 10 > c:=convert(10,base,2);

+ 1)

10.2 R´ e´ ecriture

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

62

Manipulation des expressions

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 math´ematiques. 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. Syst`emes et algorithmes de manipulations alg´ebriques. Masson, 1987. [10] G. Articolo. - Partial differential equations and boundary value problems with Maple V. Academic Press us San Diego, CA 1998. [11] Zimmermann. Bibliographie en ligne. http ://www.loria.fr/%7Ezimmerma/maple/. [12] Universit´e de Lille. Bibliographie en ligne. http ://www.grappa.univ-lille3.fr/polys/maple1999/index34.html. [13] Universit´e 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, 40 aide, 23 allvalues, 56 anonyme, 41 append, 49 args, 43 array, 30 assign, 53 base, 60 batch, 22, 50 binaire, 50 bool´eens, 35 bytes, 60 collect, 58 combine, 59 exp, 59 ln, 59 symbolic, 59 trig, 59 convert, 49, 60 base, 60 bytes, 60 fullparfrac, 60 parfrac, 60 polar, 60 polynom, 60 radical, 60 trig, 60 copy, 44 d´ebugage, 22 dsolve, 53 ensemble, 29 eval, 37 evala, 37 evalb, 37 evalc, 37, 60

evalf, 37 evalhf, 37 evalm, 37 evaln, 37, 39, 43 evalr, 37 expand, 57 factor, 57 FAIL, 35, 36 fclose, 50 fopen, 50 for, 26 in, 26 while, 26 fprintf, 50 fscanf, 50 fullparfrac, 60 global, 41 help, 23 history, 22 if, 25, 36 fonction, 25 instruction, 25 in, 26 inerte, 56 Int, 56 interpr`ete, 7 intersect, 29 iquo, 44 kernelopts, 21 last, 38 liste, 29 local, 41 lprint, 49 map, 33 maple -x, 7 mapleinit, 21 matrix, 30 member, 29 minus, 29 modules, 47 name, 38 nargs, 43 nombre, 32 nops, 32

66

INDEX normal, 59 NULL, 32 numeric, 36

typage, 43 type, 29 numeric, 36

op, 32 options, 42

unapply, 54 union, 29 use, 47

par r´ef´erence, 43 par valeur, 43 param`etres, 43 parfrac, 60 parse, 49, 50, 55 pgm, 50 piecewise, 36 plot, 36, 42 plotsetup, 21 polar, 60 pr´edicat, 35 print, 42, 49 printbytes, 21 printf, 49 printlevel, 22 procname, 43 quit, 7 quotage, 39 rationalize, 59 read, 21 readbytes, 50 readdata, 50 readlib, 22 readline, 49, 50 readstat, 49 remember, 42 RETURN, 42 rhs, 53 scanf, 49 select/has, 53 seq, 29, 40 showstat, 22, 41 simplify, 57 solve, 53 solve/identity, 55 sort, 54 sscanf, 49 stopat, 22 subsop, 55 substring, 49, 50 suite, 29 sum, 40, 60 system, 22 table, 30 table-proc´edure, 30 tableaux, 30 toplevel, 37 trace, 22 true, 35

value, 37, 56 vector, 30 verboseproc, 22, 41 vide, 32 whattype, 29 while, 26 with, 22 writebytes, 50 writeto, 49 xmaple, 7