Introduction ` a Maple

UE4 Master Recherche Math ematiques

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

Table des mati` eres

Introduction 1 Prise de contact 1.1 G en eralit es . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1.2 Exemples de commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 Environnement : relation avec le syst` eme 2.1 Personnalisation du syst` eme . . . . . . . . 2.2 Chargement dun chier . . . . . . . . . . 2.3 Commandes syst` eme . . . . . . . . . . . . 2.4 Historique des commandes . . . . . . . . . 2.5 Chargement des biblioth` eques . . . . . . . 2.6 Visualisation du code dune fonction . . . 2.7 Ex ecution en mode batch . . . . . . . . . 2.8 D ebugage . . . . . . . . . . . . . . . . . . 2.9 Aide en ligne . . . . . . . . . . . . . . . . ements compl 3 El ementaires de syntaxe 3.1 Les branchements conditionnels . . . . 3.1.1 Le si . . . . . . . . . . . . . . . 3.1.2 Le choix multiple . . . . . . . . 3.2 Les r ep etitions . . . . . . . . . . . . . 3.2.1 La boucle pour . . . . . . . . . 3.2.2 La boucle tant que . . . . . . . dexploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 7 7 7 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 35 35 35 35

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

. . . . . .

4 Les structures de base 4.1 Les objets Maple . . . . . . . . . . . . . . . . . . . 4.1.1 Les objets atomiques . . . . . . . . . . . . . 4.1.2 Les structures de base . . . . . . . . . . . . 4.1.3 Les structures composites . . . . . . . . . . 4.1.4 Cr eation explicite de structures composites 4.2 Manipulations des objets de base . . . . . . . . . . 4.2.1 Extraction . . . . . . . . . . . . . . . . . . . 4.2.2 S election . . . . . . . . . . . . . . . . . . . 4.2.3 Nombre d el ements . . . . . . . . . . . . . . 4.2.4 Constitution de suites et de listes . . . . . . 4.2.5 Test de la suite ou de la liste vide . . . . . 4.2.6 La fonction map . . . . . . . . . . . . . . . 5 Les 5.1 5.2 5.3

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

expressions bool eennes Le symbole = . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le pr edicat = . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Le pr edicat < . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

4 6 Les evaluations 6.1 R` egles d evaluation . . . . . . . . . . . . . . . . . . 6.2 Illustration des r` egles . . . . . . . . . . . . . . . . . 6.2.1 Niveau d evaluation et aectations . . . . . 6.2.2 Aectations . . . . . . . . . . . . . . . . . . 6.2.3 Quotage . . . . . . . . . . . . . . . . . . . . 6.2.4 Quelques di erences dicilement pr evisibles 7 Les 7.1 7.2 7.3 7.4 7.5 7.6 7.7 7.8 7.9 fonctions D enition des fonctions . . . . . . . . Comment voir le contenu des fonctions Fonctions anonymes . . . . . . . . . . Variables locales, variables globales . . Valeur retourn ee . . . . . . . . . . . . Options . . . . . . . . . . . . . . . . . Contr ole des param` etres . . . . . . . . Passage des param` etres . . . . . . . . Fonctions locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

` TABLE DES MATIERES 37 37 37 37 39 39 40 41 41 41 41 41 42 42 43 43 44 47 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 49 49 49 49 49 50 50 53 53 53 54 54 55 55 55 56 56 57 57 57 57 58 59 59 59 60 61 65

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

8 Les modules 9 Les entr ees-sorties 9.1 Les fonctions dentr ee-sortie . . . . 9.1.1 Fonctions de lecture . . . . 9.1.2 Analyse dune cha ne . . . . 9.1.3 Fonctions d ecriture . . . . 9.2 Les redirections . . . . . . . . . . . 9.3 Lecture de donn ees dans un chier 9.4 Ecriture de donn ees dans un chier 10 Manipulation des expressions 10.1 Diverses fonctions de manipulation 10.1.1 Assign . . . . . . . . . . . . 10.1.2 Unapply . . . . . . . . . . . 10.1.3 Sort . . . . . . . . . . . . . 10.1.4 Subsop . . . . . . . . . . . 10.1.5 Parse . . . . . . . . . . . . 10.1.6 Solve/identity . . . . . . . . 10.1.7 Allvalues . . . . . . . . . . 10.1.8 Value . . . . . . . . . . . . 10.2 R e ecriture . . . . . . . . . . . . . . 10.2.1 Expand . . . . . . . . . . . 10.2.2 Simplify . . . . . . . . . . . 10.2.3 Factor . . . . . . . . . . . . 10.2.4 Collect . . . . . . . . . . . . 10.2.5 Combine . . . . . . . . . . . 10.2.6 Normal . . . . . . . . . . . 10.2.7 Rationalize . . . . . . . . . 10.2.8 Convert . . . . . . . . . . . Bibliographie Index

Introduction
Maple est avant tout un logiciel de calcul formel, symbolique, cest-` a-dire qui travaille sur les expressions ` a la di erence du calcul num erique qui calcule sur les nombres. Il int` egre des possibilit es de calcul num erique qui sont au l des nouvelles versions de plus en plus performantes. Mais le calcul num erique nest pas son objectif. es bien par exemple pour les calculs usuels genre Maple est un logiciel g en eraliste qui convient tr` Terminale-Deug. Il touche ` a toutes les branches des math ematiques sur lesquelles on peut calculer. Il nest pas sp ecialis e et de ce fait, ne pr etend pas rivaliser avec les logiciels sp eciques comme : - Matlab pour le num erique, - pari, (Mathematica ?), ... pour lalg` ebre. Cest de tr` es loin le logiciel le plus utilis e (5 millions de licences en 2003). Il est commercialis e par la soci et e Maplesoft qui a pratiqu e une politique commerciale astucieuse. Quelques dates : 1960 Les premiers logiciels de calcul formel, Macsyma, Reduce, ` a base de Lisp, n ecessitent de gros ordinateurs et orent des possibilit es limit ees. 1980 Projet d ecrire dun logiciel qui puisse tourner sur des machines plus modestes (anticipation de l emergence des ordinateurs individuels) : petit programme, ecace, noyau r eduit, ecrit en C. 1983 1er cours avec Maple, 1ers articles, 50 installations dans le monde. 1984 Contrat avec la soci et e Watcom pour la commercialisation. 1985 D ebut de la commercialisation. 1987 300 installations. 1987 Contrat avec la soci et e Waterloo Maple Software (Universit e de Waterloo). 1988 2000 installations. 2003 Soci et e Maplesoft, 5 millions de licences.

Il y a di erents niveaux dutilisation de Maple : - Le mode commande r eduit aux fonctions les plus basiques comme - plot, - int, - di ... Ce type dutilisation ne n ecessite pas de suivre un cours. Il y a de nombreux tutoriels bien faits sur le Web. Par exemple [13]. - Le mode commande avec r esolution - d equations g en erales, - de syst` emes lin eaires, - d equations di erentielles. Ce niveau dutilisation n ecessite de conna tre les structures de base de Maple. - Le mode de programmation qui permet par exemple la r esolution de probl` emes du genre TerminaleDeug. Il faut savoir encha ner les calculs, faire passer les r esultats dune commande ` a une autre, utiliser des fonctions.

Introduction - La programmation de m ethodes de calcul formel, cest-` a-dire lenrichissement du syst` eme.

Avant d etudier Maple il est n ecessaire de bien faire la distinction entre les 4 types de calcul math ematique : - Le calcul math ematique habituel, sur feuille de papier, celui auquel on est le plus habitu e, dicile ` a d enir, tout le monde voit de quoi on parle. - Le calcul num erique (scientique). Cest lart de r eduire les calculs ` a un nombre ni dop erations arithm etiques el ementaires portant sur des nombres repr esent es par un ensemble ni de symboles (les chires). Le calcul num erique fait n ecessairement appara tre deux types dapproximation et derreur : lapproximation des nombres par les ottants, (Pi, 1/10 en base 2, ...) et la discr etisation incontournable. On met en uvre les calculs num eriques ` a laide des langages de programmation comme le Fortran, le C, le Pascal, ... et aussi ` a laide de logiciels num eriques comme Matlab. - Le calcul formel qui op` ere sur les expressions math ematiques, m ecaniquement, automatiquement, par programmation. Par exemple le calcul de lint egrale de exp(x2 ) sur ], [ peut se r ealiser de fa con formelle (= ) et de fa con num erique, approch ee, ( 1.772453851). La m eme int egrale, mais sur [0..1] ne peut se calculer de fa con formelle, sauf en r epondant ` a laide dune fonction sp eciale cest-` a-dire en retournant la question pos ee. - Le calcul analogique comme par exemple celui que lon peut faire avec une r` egle ` a calcul.

Comme nous lavons d ej` a not e, Maple est con cu pour le calcul formel, m eme sil int` egre de plus en plus, (pour des n ecessit es commerciales sans doutes), de bons outils permettant le calcul num erique. Pour ma part, je constate quil nest pas du tout appropri e aux calculs volumineux qui caract erisent la plupart des calculs scientiques. Par ailleurs il nest pas tr` es facile de savoir lui imposer une d emarche compl` etement num erique et il nest pas facile de savoir quand il travaille en formel et quand il abandonne le formel pour sorienter vers le num erique.

Chapitre 1

Prise de contact
1.1 G en eralit es

Maple est un interpr` ete en attente dune expression ` a evaluer (ou dune instruction ` a ex ecuter). Lattente est signal ee par un prompt, >. On appelle Toplevel cet etat. Le ; et le : marquent la n de lexpression ` a evaluer. (Le Return est ignor e, ce nest pas une marque de n dexpression). Les expressions ` a evaluer sont des symboles, des expressions math ematiques correctement parenth` eses. (Une d enition pr ecise ne peut etre donn ee sans recours ` a la grammaire sous-jacente ` a Maple). Si lexpression est termin ee par ;, Maple ache ` a l ecran la repr esentation de la valeur du dernier r esultat. Ce nest pas le cas quand lexpression 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 di erences entre les versions. En 2007 cest la version 11 qui est commercialis ee. En gros, les versions 2 et 3 assez semblables di` 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 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

|\^/| ._|\| |/|_. \ MAPLE / <____ ____> |

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

Prise de contact

1.2 Exemples de commandes > 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 > 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) > 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]; # lordre 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; 2 (5)

Prise de contact

1.2 Exemples de commandes x := x > cos(x)^2+sin(x)^2; 2 cos(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) > 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)]): - 20 cos(x) 3 + 5 cos(x) + sin(x) 2

11

12 > deth:=n->det(h(n)); deth := n -> det(h(n)) > d6:=deth(6); d6 := 1/172153600393420800000 > h6:=h(6): > norm(h6); 223 --140

Prise de contact

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

13

# # 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 Pi ---2 > y:=y; y := y

Prise de contact

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

15

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 / > 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 / 1/2\ | 5 | | 5 | |- ---- + 1/2| + |1/2 + ----| \ 2 / \ 10 /

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

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

17

18 > # plots > printf("Maintenant dessins, RETURN "); Maintenant dessins, RETURN > ret(): > > plot(sin(x),x=-10..10);

Prise de contact

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 dexploitation

Lutilisation de Maple d epend de 3 choses : - De linterface choisie, Texte ou Graphique, - Du syst` eme dexploitation, Unix, Windows, Macintosh, - De la version utilis ee. Les nouvelles versions de Maple orent des possibilit es importantes pour exporter les calculs, en documents latex, html ...Ces possibilit es n ecessitent lusage de Maple en mode Graphique et la cr eation de ce que Maple appelle feuilles de calcul. Il nest pas question ici de regarder ces fonctionnalit es. On sint 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 chier .mapleinit, sil 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 lex ecution. Par exemple plotsetup(X11) ; kernelopts(printbytes=false) ;

2.2

Chargement dun chier

Il est fondamental de passer par linterm ediaire de chiers pour solliciter Maple. En mode Texte ces chiers sont des chiers ordinaires (Texte, Ascii) que lon ecrit avec nimporte quel traitement de texte (qui ne doit rien ajouter dautre que ce que lon a ecrit). Ils contiennent des requ etes Maple, compl` etement identiques ` a celles que lon 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 dutilisation de read est read(nom_de_fichier); ne de caract` ere qui doit d esigner correctement le chier ` a solliciter, avec nom de fichier est une cha chemin dacc` 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 douvrir le chier /tmp/prog1.txt et dex ecuter toutes les requ etes qui sy trouvent, exactement comme si elles etaient tap ees au Toplevel. Note : Les chiers 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 dutiliser read ou le menu Fichier-Ouvrir.

22

Environnement : relation avec le syst` eme dexploitation

2.3

Commandes syst` eme

Comme avec tous les langages et tous les interpr` etes, Maple ore la possibilit e de lancer des commandes syst` emes depuis lint erieur dune session. Il y a pour cela la fonction system() et le macro caract` ere !. system("ls") system("pwd") !ne prog1.txt # liste le r epertoire courant # affiche le nom du r epertoire courant # edite (si editeur ne existe) prog1.txt

2.4

Historique des commandes

En mode Texte (pas en mode Graphique), on peut r e editer les commandes avec les ` eches et . Cest tr` es commode. On peut aussi acher 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

An que le syst` eme d emarre rapidement et noccupe que peu de m emoire, Maple ne charge en d ebut de session, que le minimum, le noyau. De ce fait cest ` a lutilisateur de r eclamer le chargement des biblioth` eques n ecessaires. Il na 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 dalg` ebre # lin eaire linalg

readlib(ancienne_bibliotheque);

2.6

Visualisation du code dune fonction

On dispose du code de toutes les fonctions des biblioth` eques ecrites en Maple. Ce nest pas tr` es facile, mais cest instructif de pouvoir les regarder. interface(verboseproc=2); print(sin); # ou showstat(sin); # affiche le code de la fonction # sinus

2.7

Ex ecution en mode batch

En dehors de Maple, sous le syst` eme dexploitation, il est possible de lancer Maple pour lex ecution dun unique chier. Et eventuellement de r ecup erer les r esultats dans un autre chier. maple nom_de_fichier > fichier_resultats

2.8

D ebugage

Rechercher les erreurs dans un programme est une chose courante. Ce nest gu` ere possible de programmer juste du premier coup. En g en eral on ajoute des achages suppl ementaires pour contr oler les calculs. Maple fournit diverses possibilit es suppl ementaires. La valeur de la variable printlevel peut etre modi ee. Plus la valeur est grande (7,15,255,..), plus Maple donne dinformation sur les calculs eectu es et sur les param` etres pass es aux di erentes fonctions. Il y a aussi les fonctions trace() et stopat() 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 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(). Laide est retourn ee par un achage page par page (programme more tr` es archa que). Return fait avancer dune ligne, espace dune page, q fait sortir.

24

Environnement : relation avec le syst` eme dexploitation

Chapitre 3

ements compl El ementaires de syntaxe

Les requ etes Maple sont r ealis ees par linterm ediaire dun 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 dex ecution dinstruction. 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 : linstruction if Voici un exemple dutilisation 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 lachage de 10, et retourne ce que la fonction print retourne, cest-` a-dire NULL. x:=7; if (x=7) then 5; else print(5*x); fi; la fonction if x:=1; x:=7; %; x:=1; y; x:=9; y; if(x=7,5,55); if(x=7,5,55); y:=if(x=7,5,55); y:=if(x=7,5,print(10*x)); # -> 55 # affiche 90 # -> suite vide (NULL) # -> 55 # -> 5 # -> 5

# -> 5

26

ements compl El ementaires 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
3.2.1

Les r ep etitions
La boucle pour

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; %,s,i; # calcul equivalent s:=add(i^2,i=1..3);s; parcours des el ements dune 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; # parcours dune suite dindices # affiche les nombres 10,20,.. # -> true (r esultat d eroutant)

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

# -> 14

# -> 14,14,1

# # # #

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

i:=1; while (i<10) do print(i); i:=i+1; od;

while seul

# affiche 1,2,..

3.2 Les r ep etitions en association avec for l:=[3,2,1,100]; for i in l while (i^2 > 1) do print(i); od;

27

# affiche 3,2

28

ements compl El ementaires de syntaxe

Chapitre 4

Les structures de base

4.1 Les objets Maple

Cest un peu confus (pour moi). Dune certaine mani` ere lutilisateur 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 ottants, - 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 dobtenir de linformation. Cette information est principalement de nature math ematique. 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);

# # # # # # # # # #

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

integer fraction float symbol + true true false false false

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

4.1.2

Les structures de base

Maple manipule ecacement - 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 enir les suites. Les crochets [] et les accolades {} permettent de d enir 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 di erences d eroutantes de comportement entre les structures de base et les structures composites. Les structures de base sutilisent de fa con plus intuitive. Ces exemples montrent aussi quil 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; 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); op(eval(g)); whattype(op(eval(g))); # les fonctions f:= n -> n^2; f; eval(f);

# # # # # # # # #

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

# # # # # # # # # # #

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

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

cr eation dune 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

# cr eation dune fonction # -> f # -> n -> n^2

4.1 Les objets Maple f(toto); whattype(f); whattype(eval(f)); op(f); op(eval(f)); h:= proc(n) n^2; end; eval(h); whattype(h); whattype(eval(h)); op(h); op(eval(h)); # # # # # # # # # # # # -> -> -> -> -> toto^2 symbol procedure n -> n^2 n, operator, arrow

31

cr eation dune fonction petite diff erence avec f -> proc(n) n^2 end -> symbol -> procedure -> proc(n) n^2 end -> n

4.1.4
tables

Cr eation explicite de structures composites

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

# cr eation dune 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; 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]); # # # # # # # # # 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

# # # # # # # # # #

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

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

32 compatibilit e entre les tableaux et les matrices

Les structures de base

Il y a compatiblit e 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); evalb(c=m); type(b,matrix); type(c,matrix); eval(b); eval(c);

# # # # # # # # #

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

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

4.2
4.2.1

Manipulations des objets de base

Extraction
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); # # # # # # -> -> -> -> -> -> 1,4,2 (cest une suite) erreur 1,2,4 6 x,y,-z x,1/y,1/z

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

4.2.2

S election
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); # -> y # # # # # -> -> -> -> -> 5 [4,5,6] [5,6,7,8] [5,6,7] y*z

op permet egalement dextraire un seul el ement.

4.2.3

Nombre d el ements
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 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 n:=[100,op(l)]; o:=[op(l),op(m)]; # -> [100,2,2,2,2] # -> [2,2,2,2,x,y,z]

33

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 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 signie quil 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 =
if (x = 8) then ...

a deux sens. Dans un test genre

il se comporte comme un pr edicat. Dans cette construction, (x = 8) est une expression bool eenne. Par contre dans lexpression e:=(x=y); il sert ` a d enir un objet de type equation. e:=((x-1)*(x-2) = (x-1)); e; whattype(e); solve(e); evalb(e); evalb(subs(x=3,e)); # # # # # -> -> -> -> -> (x - 1) (x - 2) = x - 1 = 3,1 false true

5.2

Le pr edicat =
a:={5,4,2,1,0,3}; b:={seq(abs(i),i=-5..5)}; evalb(a=b);

est universel. Il peut sappliquer ` a tous les objets.

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

A la di erence du pr edicat "=" qui est universel, les pr edicats "<" et ">" ne sappliquent quaux nombres. Ceci est la raison de nombreuses erreurs dans lex ecution de fonctions contenant des tests din egalit e lorsque les expressions ` a comparer comportent des variables nayant pas de valeur num erique.

36 if (x < 3) then ... f:=x-> if (x < 0) then 0 else 1; fi; f(-2); plot(f(x),x=-5..5);

Les expressions bool eennes # -> erreur quand x na pas de # valeur num erique # -> 0 # -> erreur cannot ...

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

# ok

Note : Ce probl` eme ne se produit ni avec la fonction piecewise() ni avec la fonction if(). f:=x->piecewise(x<0,0,1); plot(f(x),x=-5..5); f:=x->if(x<0,0,1); plot(f(x),x=-5..5); # ok

# ok

Attention aussi aux tests dont Maple ne conna t pas la r eponse : x := -int(t*cos(exp(t)),t=0..1); evalf(x); is(x>0); evalb(x>0); if (x>0) then print("x > 0"); else print("x <= 0"); fi; if (is(x>0)) then print("x > 0"); else print("x <= 0"); fi; if (evalf(x) > 0) then print("x > 0"); else print("x <= 0"); fi; # # # # -> -> -> -> -int(...) 0.1897747668 FAIL int(...) < 0

# -> error ...

# -> "x <= 0"

# -> "x > 0"

Chapitre 6

Les evaluations
Le fonctionnement des evaluations est un peu d elicat, car il di` 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

evalue au plus profond niveau et retourne le r esultat de la derni` ere evaluation. 1. Au Toplevel, Maple Sauf pour les objets composites (table, array, vector, matrix, function . . .) quil evalue jusquau dernier nom. (last name evaluation, cf exemples ci-dessous). 2. A lint erieur des fonctions (ou proc edures), Maple n evalue quau premier niveau. 3. On dispose de fonctions sp eciques pour forcer l evaluation : fonctions eval evalf, evalhf evalb evalm evalc evala evalr value type dutilisation universel ottants, bool eens, alg` ebre lin eaire, nombres complexes, nombres alg ebriques, calcul par intervalles 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 aectations (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 aectations
x:=x: y:= y: z:=z: x:=y; y:=z; z:=1; x;

au Toplevel

# # # #

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

z:=4; x;

# -> 4

38 x:=5; z; t:=y;

Les evaluations

# -> 4, x ne pointe plus sur y # # # # t prend la valeur au plus profond niveau de y, cest-a-dire 4. t na plus de relation avec y et z -> 4

t; y:=55; t; 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(); 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);

# -> 4

# la proc edure affiche y,z,1 et z # elle retourne NULL (print)

# la proc edure affiche y,z,1 # et retourne z # # # # # # # -> 1 -> z a a pour valeur z qui a pour valeur 1 (ce qui nest pas tr` es normal puisque z vient dune variable locale de essai2)

last name evaluation m:=matrix(2,2,[a,b,c,d]); m; evalm(m); # # # # # # -> m -> [a b] [ ] [c d] idem avec eval(m), print(m), eval(m,1)

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

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

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

6.2 Illustration des r` egles

39

print(m5);

# -> [a # [ # [c

b] ] d]

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

# -> 2 + c # # # # # # -> 20 + c -> [a b] [ ] [c d] b nest pas vu de la m^ eme fa con dans f et dans m 10] ] d]

map(eval,m);

# -> [a # [ # [c

6.2.2

Aectations
l1:=[2,3,4]; l2:=l1; l2[2]:=33; l1; l2;

cas des listes

# # # # #

-> [2,3,4] -> [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; eval(v1);

# # # # # # #

-> 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); v3[3]:=444; eval(v1);

# recopie # [2,333,4]

6.2.3

Quotage
y:=y: x:=y; y:=1;

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

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

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

6.2.4

Quelques di erences dicilement pr evisibles

Les variables dindice des fonctions seq, add, sum, int ,... nont 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 dune 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; # # # # # # # # # # # # -> 6 -> i erreur -> 6 -> 1,2,3 -> 5 add et seq sont des fonctions de bas niveau contrairement ` a sum -> 15 (3x5) -> 6 -> 5

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

Chapitre 7

Les fonctions
7.1 D enition des fonctions

On peut d enir les fonctions avec lop 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); # # # # # affiche le programme de la fonction sum. Cette fonction comporte de nombreuses m ethodes quil convient de suivre. (laborieux)

7.3

Fonctions anonymes
((x,y) -> x * y) (2,20); map(t->t^2, [1,2,3]); # -> 40 # -> [1,4,9]

Il est possible dutiliser des fonctions sans leur donner de nom.

7.4

Variables locales, variables globales

On peut choisir le statut des variables utilis ees dans la d enition 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 nexistent pas par ailleurs. Mais je d econseille de proter 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 x:=-100; y:=y; f();

Les fonctions

a,b,x,y;

# # # # # #

-> 1000. Les variables x et y nont dexistence que lors de lex ecution de f(). Par contre, le statut de a et b est modifi e apr` es lex ecution. -> 1, 10, -100, y

7.5

Valeur retourn ee

La valeur retourn ee par une fonction est celle de la derni` ere evaluation ou la valeur explicitement sp eci ee par RETURN. Il me semble plus clair dutiliser syst ematiquement RETURN(). On peut cependant utiliser les deux formes de retour dans la m eme fonction. f:=proc(n) if (n<2) then RETURN(1);fi; n*f(n-1); end; # fonction n!

Attention ` a la commande plot dans une fonction : il faut savoir que la commande plot nest pas une instruction dachage. Elle retourne en fait une structure informatique. Cette structure, exactement ee ` a l ecran (ou imprim ee, ou mise en chier) que comme toutes les autres, nest ach - si elle est soumise ` a la commande print, - ou si son evaluation sest r ealis ee en dernier et si une demande implicite dachage ( ; en n dexpression) a et e faite. On est toujours tr` es surpris de ne pas voir les requ etes plot appara tre ` a l ecran. f1:=proc(a,b) local x; plot(sin(x),x=a..b); end; f1(0,10); f2:=proc(a,b) local x; plot(sin(x),x=a..b); b-a; end; f2(0,10); # -> 10 # pas daffichage # sortie ecran ok

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 est int eressante quand une fonction doit etre evalu ee plusieurs fois sur les m emes param` etres. Cest notamment le cas pour les fonctions r ecursives dordre sup erieur ` a 1. Quand une fonction est d enie avec

7.7 Contr ole des param` etres loption 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. (Laide en ligne sur ce sujet est bien faite). f:=proc(n) option remember; if (n<2) then RETURN(1);fi; n*f(n-1); end; f(5); f(7);

43

# 5 appels de la fonction # 2 appels seulement, f(5) pris dans la table

7.7

Contr ole des param` etres

etres qui gurent dans la d enition des fonctions, et paOn nomme param` etres formels les param` ram` etres eectifs ceux qui sont pass es lors dun appel. Le programmeur dispose des variables pr ed enies suivantes : - nargs contient le nombre des param` etres eectifs. Ce nombre peut etre di erent de celui des param` etres formels. etres eectifs. - args est une variable qui contient la suite des param` - procname est une variable qui contient le nom de la fonction. typage : Il est possible de typer certains param` etres. Quand un param` etre est typ e, Maple ajoute automatiquement au code de la fonction un test du param` etre eectif et retourne eventuellement un message derreur appropri e. f:=proc(l::list) l[1]; end; f([2,3]); f([2,3],5); f(5,[2,3]); f(5); f(); # # # # # -> -> -> -> -> 2 2 erreur erreur erreur

7.8

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, 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 appara t lors de l evaluation de v, cest-` a-dire, comme on la 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 modi es ` a lint erieur des fonctions. f:=proc(x) x:=x+1; end; y:=5; f(y);

# -> erreur,

5 := 6 impossible

- Pour obtenir une modication dune variable pass ee en param` etre, cest-` a-dire pour eectuer un passage par r ef erence, il y a au moins deux solutions :

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

Les fonctions

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

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

Pour les objets composites, il ny a rien ` a pr evoir pour eectuer un passage par r ef erence. Au contraire, si la fonction modie un objet dont on d esire conserver la valeur initiale (par exemple la matrice dun syst` eme lin eaire r esolu par une m ethode qui transforme le syst` eme), il peut sav erer n ecessaire den 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; 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 aecte 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; # -> 3 # -> 3 # -> 1

# -> 1001 # -> v # -> [1001,1,1] # -> erreur # -> 1001 # -> [1001,1,1]

7.9

Fonctions locales

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

7.9 Fonctions locales p4:=proc(x) local f; f:=proc(x) x^2; end; RETURN(f(f(x))); end; p4(2); # -> 16 # fonction x -> x^4

45

Note : Avant la version 5, il etait tr` es dicile de faire passer ` a une fonction locale un param` etre de la fonction principale. Cest 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 ore la possibilit e dutiliser 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. e dattacher aux objets ` a la fois - de faire de la programmation orient ee objet, orant la possibilit des structures de donn ees et des fonctions (les m ethodes), permettant lh eritage : on peut d enir un type particulier dans un type d ej` a d eni (classe) et proter pour ce type particulier de tout ce qui existe pour le type p` ere. On peut enrichir les m ethodes. Consulter laide 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 lext erieur, cest-` a-dire l ecran, le clavier, les chiers sur disque.

9.1
9.1.1

Les fonctions dentr ee-sortie

Fonctions de lecture

Le p eriph erique dentr ee par d efaut est le clavier. - readstat() est la fonction que linterpr` ete utilise pour acqu erir les commandes. Elle est utilisable par les programmeurs. Elle proc` ede ` a la saisie et ` a linterpr 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 dune 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 dachage de haut niveau. La syntaxe print("x" = x) est parfois int eressante. - lprint() permet un achage basique, non centr e. - printf() est une fonction dachage format e. Exemple de syntaxe : printf("f(%3a) = %.5a\n",i,f(i)); la cha ne contient des caract` eres qui sont ach es (f,(,), ,=), et des directives de formatage : %3a indique que la valeur de i doit etre ach ee sur 3 colonnes, %.5a indique que la valeur de f(i) doit l etre avec 5 chires apr` es la virgule, \n est un ordre de retour ` a la ligne. Voir laide en ligne sur printf() pour les di erents formats (r eels, cha nes, caract` eres, ...).

9.2

Les redirections
writeto(nom_de_fichier); # ou append(nom_de_fichier);

Il est possible dannuler lachage ` a l ecran et dordonner que les sorties se fassent dans un chier.

Pour revenir ` a lachage initial ` a l ecran utiliser writeto(terminal);

50 Cest la fonction read() d ej` a indiqu ee qui permet de rediriger les entr ees.

Les entr ees-sorties

On peut ex ecuter les calculs en mode batch . Cela veut dire, qu etant sous le syst` eme dexploitation, 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 chier

Pour la lecture de donn ees num eriques ecrites en clair dans un chier Texte (Ascii), la fonction readdata() convient bien. Si le chier 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 dune fonction r ealisant la lecture dune image en nuances de gris au format PGM (sans commentaire). Les images PGM sont constitu ees de deux types de donn ees : Dabord quelques lignes cod ees en caract` eres Ascii (mode texte) indiquant le type du chier (P5 par exemple), contenant eventuellement des commentaires (# CREATOR ... par exemple), indiquant les dimensions de limage (900 600 par ex) et le nombre de nuances de gris (255). Ensuite gurent 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 limage 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; marque P5 commentaires

les dimensions le nombre de nuances les pixels

9.4

Ecriture de donn ees dans un chier

La fonction fprintf() permet l ecriture format ee et la fonction writebytes() l ecriture en binaire. Exemple dune fonction r ealisant l ecriture dune 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 chier od; fclose(canal); end;

51

52

Les entr ees-sorties

Chapitre 10

Manipulation des expressions

10.1
10.1.1

Diverses fonctions de manipulation

Assign

Cette fonction permet laectation des membres gauches des equations r esultant de lutilisation de fonctions comme solve() ou dsolve(). Elle doit etre utilis ee mod er ement. Il est souvent pr ef erable dutiliser 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 dune 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 di erents types dobjets. Elle a pour particularit e de modier les expressions pass ees en argument (ne modie ni les suites ni les listes). > p:=x+5*x^2+8*x+1+x; 2 p := 10 x + 5 x > sort(p); 2 5 x + 10 x + 1 > p; + 1

10.1 Diverses fonctions de manipulation 2 5 x + 10 x + 1 > l:=[5,4,15]; l := [5, 4, 15] > sort(l); [4, 5, 15] > l; [5, 4, 15]

55

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 danalyse et dinterpr` 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 coecients 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 dune equation. Mais elle est trop d ependante de la version Maple. Il est n ecessaire de consulter laide 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 - 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

F :=

10.2 R e ecriture

57

> d:=combine(i-j); infinity / | d := | | / 1 > value(d); ln(2) 1 1/x - ----- dx 1 + x

10.2

R e ecriture

Voici quelques exemples de commandes permettant deectuer diverses transformations sur les expressions.

10.2.1

Expand
tan(a) + tan(b) ----------------1 - tan(a) tan(b)

> expand(tan(a+b));

10.2.2

Simplify
ln(exp(0))

> subs(x=0,ln(exp(x))); > 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 simplications diciles : Soit ` a calculer la transform ee de Hilbert de f 0 := 1 t2 [1,1] . La transformation de Hilbert est lop erateur qui ` a une fonction f fait correspondre la fonction 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. Le r esultat ` a trouver est p pour 1 < p < 1, lint 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,t>=1,0,f); { 0 { f0 := { 0 { { 2 1/2 { (1 - t ) > hilbert(f0,t,p); { 0 { hilbert({ 0 { { 2 1/2 { (1 - t )

t <= -1 1 <= t

otherwise # echec t <= -1 1 <= t , t, p)

otherwise

> assume(-1<p,p<1); > h1:=int(f/(p-t),t=-1..1,CauchyPrincipalValue)/Pi; h1 := p~ > assume(p>1); > h2:=int(f/(p-t),t=-1..1)/Pi; 2 2 1/2 -p~ + p~ (p~ - 1) + 1 h2 := -------------------------2 1/2 (p~ - 1) Ce nest pas facile de mettre h2 sous la forme simpli ee attendue. Lutilisation de factor() nest pas la seule possibilit e de simplication, mais ici elle est tr` es pratique. > factor(h2,denom(h2)); 2 p~ - (p~ - 1) 1/2

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 R e ecriture > collect(simplify(fc),x); (a + 3 b) x + 2 --------------(4 c + 3) x + 6

59

10.2.5

Combine

Cest souvent dicile 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 did ees > simplify(sqrt((x*y)^2,assume = positive); x y

10.2.6

Normal
2 2 x - y p := ------- - x - y x - y

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

> normal(p); 0

10.2.7

Rationalize
2 f := -------1/2 2 - 2

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

60 > rationalize(f); 1/2 2 + 2

Manipulation des expressions

10.2.8

Convert

Cette fonction a un champ dutilisation 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 + 1)

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

10.2 R e ecriture c := [0, 1, 0, 1]

61

# 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

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 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 scientic 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 dierential 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 normal, 59 NULL, 32 numeric, 36 op, 32 options, 42 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 typage, 43 type, 29 numeric, 36 unapply, 54 union, 29 use, 47 value, 37, 56 vector, 30 verboseproc, 22, 41 vide, 32 whattype, 29 while, 26 with, 22 writebytes, 50 writeto, 49 xmaple, 7

INDEX