Notes de cours maple

Alain JEAN-MARIE Annie HOFSTETTERy

Juin 2002


LIRMM Montpellier
y INRA LAMETA Montpellier
Table des matières
1 Introduction 3
1.1 Dénition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Accès sur le campus . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Accès à l'aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Prise en main 4
2.1 Notation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 La feuille de calcul . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.4 Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
3 Ce que peut faire Maple 5
4 Ce que Maple ne peut pas faire 6
5 Problème de l'évaluation des symboles 7
6 Structures de données 9
6.1 Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
6.2 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
6.3 Les tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
6.4 Les "table-array" . . . . . . . . . . . . . . . . . . . . . . . . . . 11
6.5 Les matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
6.6 Passage entre les structures de données . . . . . . . . . . . . . . 14
7 Manipulations sur les fonctions 15
7.1 Manipulations simples . . . . . . . . . . . . . . . . . . . . . . . 15
7.2 Coecients des polynômes . . . . . . . . . . . . . . . . . . . . . 16
7.3 Intégration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
7.4 Factorisation et décomposition de fractions . . . . . . . . . . . 19
7.5 Développements . . . . . . . . . . . . . . . . . . . . . . . . . . 20
8 Algèbre linéaire 22
8.1 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
8.2 Résolution de systèmes linéaires . . . . . . . . . . . . . . . . . . 24
8.3 Vecteurs propres . . . . . . . . . . . . . . . . . . . . . . . . . . 25
8.4 Systèmes d'équations généraux . . . . . . . . . . . . . . . . . . 27
8.5 Equations diérentielles . . . . . . . . . . . . . . . . . . . . . . 30
8.6 Développements en série . . . . . . . . . . . . . . . . . . . . . . 31
8.7 Système d'équations . . . . . . . . . . . . . . . . . . . . . . . . 34

1
9 Graphiques 36
10 Programmation 39
10.1 Tests et conditions . . . . . . . . . . . . . . . . . . . . . . . . . 39
10.2 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
10.3 Procédures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
11 Fichiers, entrées/sorties, sauvegardes 43
11.1 Sauvegarde des instructions . . . . . . . . . . . . . . . . . . . . 43
11.2 Utilisation des procédures dans un chier externe . . . . . . . . 43
11.3 Communication . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.3.1 Fichier texte . . . . . . . . . . . . . . . . . . . . . . . . 45
11.3.2 Sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
11.3.3 Feuille de calcul . . . . . . . . . . . . . . . . . . . . . . 45
11.3.4 Format HTML . . . . . . . . . . . . . . . . . . . . . . . 45
11.3.5 Graphiques . . . . . . . . . . . . . . . . . . . . . . . . . 46
11.3.6 Postscript . . . . . . . . . . . . . . . . . . . . . . . . . . 46
11.4 Fonctions d'édition de la feuille de calcul . . . . . . . . . . . . . 46

2
1 Introduction
1.1 Dénition
maple7 est un logiciel de calcul formel ou symbolique comme Mathematica,
Axiom ; tandis que des langages tels que Pascal, C, C++, Java, Matlab, sont
destinés à manipuler des nombres.
1.2 Accès sur le campus
L'acquisition a été faite pour utiliser 6 licences simultanées au maximum.
C'est le gestionnaire de licence qui empêche le 7e appel au programme. A
termes, l'installation sous la forme de licences ottantes devrait permettre
aux utilisateurs de lancer l'application depuis n'importe quelle plateforme (pc
ou tx, depuis windows ou unix).
Sur les pc avec un système d'exploitation windows*, ce type d'accès nécessite
d'installer l'application cliente sur les postes de travail. Ensuite l'accès se fait
par Démarrer > Programmes > Maple7 > Maple7
Dans le cas d'utilisation sous unix, l'accès pourrait se faire depuis une session
telnet soit depuis un pc soit depuis un terminal.
L'interface graphique se présente sous la forme d'une fenêtre avec un menu,
des barres d'outils et un espace de travail. La fenêtre principale est l'espace
de travail où le signe ">" représente le prompt c'est à dire que maple est
prêt à travailler et attend qu'une instruction soit entrée à ce niveau an de
l'exécuter. L'interface laisse la possibilité d'avoir plusieurs feuilles de travail
ouvertes dans la même application. La navigation se fait alors de page en page.
1.3 Accès à l'aide
Documentation : Les livres pédagogiques sont sans doute nombreux. Des sup-
ports de cours existent sur le net (Mourrain & Papegay inria, Salvy).
Aide en ligne : Le menu help introduction assure une navigation de rubrique
en rubrique. L'accès direct peut se faire à partir de la ligne de commande :
>? solve accès à la fenêtre d'aide relative à la commande solve
> ? sol accès à la liste des commandes dont le nom commence par sol
> ?solve

3
2 Prise en main
2.1 Notation
Une instruction est saisie au clavier derrière le prompt ">". Le point virgule
représente la n de l'instruction.
> f : = x^2 + x + 1 ; # commentaire
L'expression x^2 + x + 1 est une formule avec le symbole x , un symbole non
évalué, une variable libre.
: = symbolise l'aectation.
f représente le nom de la variable qui devient ici une fonction de x.
# est un commentaire.
Le point virgule à la n d'une instruction demande son exécution et l'achage
du résultat
> f: = x^2 + x + 1 :
tandis que les deux points à la place du point virgule n'achent pas le résultat.
Ce qui peut être utile en cas de résultat intermédiaire, bien qu'il y ait une
aectation par derrière.
Une formule longue ou une indentation est appliquée grâce à shift return qui
permet de poursuivre une ligne sans demander la n de l'instruction par une
validation avec return. Il n'y a donc pas de message d'invitation à donner une
suite à l'instruction. On peut ainsi mettre plusieurs instructions sur une même
ligne.
> a : = 2 : b : = 3 ; n'ache que la variable b et son aectation.
> a : = 'a' ; b : = unassign('b') ; ces deux commandes permettent de remettre
à zéro l'initialisation.
2.2 La feuille de calcul
Nous avons vu qu'une feuille est une interface entre l'utilisateur et le moteur de
Maple (dénommé server 1 sur le nom de la feuille), qui reçoit des instructions et
les exécute séquentiellement. Attention toutefois, car l'ordre d'exécution n'est
pas forcément l'ordre visuel. De plus, cela signie qu'il n'y a rien en mémoire
dans une feuille Maple : charger la feuille ne sut pas à refaire les instructions.
Pour réexécuter les instructions : Menu Edit > Execute > Worksheet
2.3 Conventions
Pour les noms de variables, toutes les lettres sont autorisées. La casse a de
l'importance.

4
Les chires sont autorisés à condition que le nom ne commence pas par un
chire. De même, le caractères surligné "_" est utilisable.
2.4 Opérateurs
Les opérateurs arithmétiques : + * - / ^
Les opérateurs logiques : < <= > >= <> and or not
> f := x^2 + x + 1 ;
f := x2 + x + 1
> xx=2 ; yy:=3 ; # égalité et affectation
xx := 2
yy := 3
Notons au passage la notation des deux lignes d'instructions suivantes.
> u:=1/(x-1)*(x+2) ;

u := xx ;
+2
1
> u:=1/(x-1)/(x+2) ;

u := (x ; 1)1(x + 2)

3 Ce que peut faire Maple

 Maple sait faire des manipulations algébriques sur les formules composées
de variables, de symboles.
> f: = x + 2 ; Maple n'a pas besoin de savoir ce qu'est x, on suppose
que x supporte l'addition, etc.
 Il sait faire des dérivées, intégrales, factorisations ou résoudre des sys-
tèmes d'équations.
 Il sait faire des manipulations numériques, calculer des nombres, faire
des graphiques.
 Il fait du calcul arbitraire sur les nombres entiers, rationnels, les poly-
nômes. Maple essaie de faire du calcul exact autant que possible.
> f:= a*x+b : solve(f,x) ;

; ab
> (3/2)^100;
515377520732011331036461129765621272702107522001
1267650600228229401496703205376
5
 > 1.5^100;
:4065611775 1018
> r:=(3/2)^100 : evalf(r) ;
:4065611775 1018

4 Ce que Maple ne peut pas faire

 Pour des raisons théoriques, on ne peut pas tester l'égalité à zéro. Si
une expression est trop compliquée (sin, lg) alors il n'est pas possible
d'armer si elle vaut 0 ou non. Par contre si cette expression est un
polynôme, alors c'est possible ; le polynôme nul vaut 0 tout le temps.
Notons que si la formule utilise des sin, log, etc., on peut aboutir à des
formules qui ne se simplieront jamais. Maple ne simplie pas sponta-
nément les expressions. On le lui demande par l'appel de la fonction
simplify().
> f := (x+1)^2 - 2*x - x^2 - 1 ;
f := (x + 1)2 ; 2 x ; x2 ; 1
> f:= simplify(f) ;
f := 0
 Maple fait de son mieux pour résoudre des équations ou factoriser des
formules. S'il ne trouve pas de solution (pour solve par exemple), il ren-
voie un résultat vide. Dans le cas d'un polynôme de degré supérieur ou
égal à 5, il n'existe pas de formule de calcul des racines. L'expression
retournée de type RootOf(...) est toutefois exploitable par Maple.
> solve(f);

 Si la taille du symbole est trop grande ou si l'algoritme est trop long, alors
c'est un échec. Il existe un bouton stop permettant d'interrompre un cal-
cul trop long. Parfois ce bouton ne sut pas et il faut tuer l'application.
Penser à sauvegarder son travail ! !
 Il peut y avoir un problème de précision numérique classique. La valeur
par défaut du nombre de chires signicatifs est Digits: =10. Il faut
donc faire attention aux manipulations de formules et autres inversions
de matrices !
> v:=(log(640320^3+744)/Pi)^2;
2
v := ln(262537412640768744)
2
> Digits := 20 ; evalf(v) ;

6
 Digits := 20
162:99999999999999999
> Digits := 40 ; evalf(v) ;
Digits := 40
163:0000000000000000000000000000232167780

5 Problème de l'évaluation des symboles

Maple évalue les formules le plus loin possible, c'est à dire tant qu'il peut
remplacer les symboles qui ont une valeur.
> f:=x^2 ;
f := x2
> x:=y ;
x := y
> f ;
y2
> g:=x^2 ;
g := y2
> x:=12 ;
x := 12
> f; # f n'a pas changé
144
> g; # g non plus !
y2
Il faut donc faire attention à l'ordre d'aectation des symboles : le résultat
semble le même, bien qu'en mémoire ce soit diérent !
> a:=val ; b:=a ; c:=b ; a; b; c;
a := val
b := val
c := val
val
val
val
> val:=10 ; a; b; c;
val := 10
10
10

7
 10
> val:=c ;
val := 10
> b:='b' ; a; b; c; val ;
b := b
10
b
10
10
> val:=20 ; a; b; c; val ;
val := 20
20
b
20
20
> z:=t ; t:=z^2 ; # récursif !
z := t
Error, recursive assignment
> t:=10 ; z:=t ; t:=z^2 ;

l'initialisation est une solution !

t := 10
z := 10
t := 100
Pour éviter ces problèmes d'évaluation, il vaut mieux ne jamais donner de
valeurs numériques aux variables et utiliser la fonction de substitution.
> f:=x^2+x+1 ;
f := x2 + x + 1
> subs(x=3,f) ;
13
> f ;

f n'a pas changé de nature !

x2 + x + 1
Il est possible d'eectuer plusieurs substitutions avec de nombreuses variables
en même temps.

8
 > f:=x^2 + 3*a*x +1 ;
f := x2 + 3 a x + 1
> subs({x=3,a=2},f) ;
28
Attention aux substitutions récursives...
> subs({x=a^2,a=2},f) ;
a4 + 6 a2 + 1
Il faut procéder en deux temps :
> subs(a=2,subs(x=a^2,f)) ;
41
Information utile :
> anames() permet de savoir quelles sont les variables utilisées, y compris
celles du système parfois nombreuses !
> anames() :

6 Structures de données
6.1 Les ensembles
Un ensemble de symboles est toujours évalué si les valeurs sont assignées. Un
ensemble n'est pas ordonné ; Maple peut donc à tout moment changer l'ordre
des éléments.
> A:={a,b,x^2+1} ;
A := fa; b; x2 + 1g
> B:={A,C} ;
B := fC; fa; b; x2 + 1gg
On peut appliquer les opérations classiques sur les ensembles.
> A union B ;
fa; b; C; x2 + 1; fa; b; x2 + 1gg
> A intersect B ;
fg
6.2 Les listes
Une liste est un ensemble ordonné dont les éléments sont numérotés à partir
de 1.
> l:=[a,b,d];
l := [a; b; d]

9
 > l[1] ; # 1er élément de la liste
a
> a:=[10,11] ; # un élément peut être une liste également
a := [10; 11]
> l;
[[10; 11]; b; d]
> l[1][2] ; #le 2nd membre du 1er élément de l
11
> l[4] ; # le 4ème élément n'existe pas

Error, invalid subscript selector

Ajout d'un élément à une liste
> l:= [op(l),e5] ;
l := [[10; 11]; b; d; e5 ]
Concaténation de deux listes, par exemple une liste avec elle-même : dans une
liste on peut avoir 2 fois le même élément, contrairement aux ensembles.
> l:= [op(l),op(l)] ;
l := [[10; 11]; b; d; e5 ; [10; 11]; b; d; e5 ]
Une façon de fabriquer une "liste" est d'utiliser la fonction seq (séquence) qui
produit une suite que l'on peut mettre dans une liste.
> st:=seq(n*n,n=1..10) ; # création de la séquence d'éléments
st := 1; 4; 9; 16; 25; 36; 49; 64; 81; 100
La séquence est constituée des carrés des nombres allant de 1 à 10.
> l:=[st] ; # affectation à une liste
l := [1; 4; 9; 16; 25; 36; 49; 64; 81; 100]
6.3 Les tables
Les tables sont des objets généraux qui assurent la correspondance entre deux
valeurs (tableau indicé).
> t[1]:=3;
t1 := 3
L'instruction précédente vient de créer implicitement le tableau t et d'assigner
la valeur 3 dans le 3e élément de ce tableau.
> t[12]:=8 ;
t12 := 8
> op(t) ;
table([1 = 3; 12 = 8])

10
 > t[6] ;
t6
> t[1/2]:=7 ;
t1 2 := 7
=

> t[(a,b,c)]:=x ; # table d'une suite

t[10 11]
; := x ; b; c

Une table représente un espace de stockage ou encore une manière d'associer

une valeur à une famille d'objets. C'est un tableau associatif où à un indice
correspond une valeur.
La fonction op() permet d'obtenir une représentation de ce qu'il y a à l'intérieur
d'un tableau, mais elle n'est pas très pratique. La fonction indices retourne la
liste des valeurs des indices et non pas le contenu.
> tbl[[a,b,c]]:=x ; tbl[1/2]:=7 ; indices(tbl) ;
tbl [ ] := x
a; b; c

tbl 1 2 := 7 =

[[a; b; c]]; [ 21 ]
La fonction entries permet d'obtenir la liste des valeurs contenues dans le
tableau.
> entries(tbl) ;
[x]; [7]
Les deux instructions suivantes sont diérentes. La première fait référence à
un élément d'un tableau à 2 dimensions. Tandis que la seconde représente le
3ème élément de l'objet tab[1] qui est un tableau à une dimension.
> tab[1,3]:=y ;
tab 1 3 := y
;

> tab[1][3]:=y ;
tab 13 := y
Le tableau est une structure puissante mais elle n'est pas forcément la plus
ecace.
6.4 Les "table-array"
Il s'agit d'une table avec des indices numériques dans un certain intervalle,
que l'on appelle "array" sous Maple. L'instruction suivante dénit un array
dont les indices vont de 1 à 10.
> a:=array(1..10) ;
a := array(1::10; [])

11
 > a[3] ;
a3
> a[13] ; # en dehors de l'intervalle

Error, 1st index, 13, larger than upper array bound 10

> a[0] ; # l'intervalle commence à 1

Error, 1st index, 0, smaller than lower array bound 1

> b:=array(0..2,[x,y,z]) ;

b := array(0::2; [
(0) = x
(1) = y
(2) = z
])
Si la liste est trop courte, tous les éléments ne sont pas initialisés.
Si la liste est trop longue, Maple refuse de le faire.
> b:=array(0..2,[x,y]);

b := array(0::2; [
(0) = x
(1) = y
(2) = b2
])
> b:=array(0..2,[x,y,z,t]);

Error, (in index/fill) a list with 4 entries cannot be used to

initialize the range 0 .. 2
Par exemple nous proposons de déclarer un tableau puis de le remplir de zéros.
> n:= 10 ; # taille du tableau
n := 10
> b:=array(1..n,[0$n]);# $ est l'opérateur de répétition
b := [0; 0; 0; 0; 0; 0; 0; 0; 0; 0]
Dans l'exemple suivant, la boucle qui remplit le tableau est cachée à l'intérieur
de la fonction de création du tableau. On obtient la liste des valeurs i répétées
pour la valeur d'une variable allant de 1 à n (n=10).
> c:=array(1..n,[i$i=1..n]) ;
c := [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
Tableaux à plusieurs dimensions :
> d2:=array(1..3,1..4) ;

12
 d2 := array(1::3; 1::4; [])
> d2[0,0] ; # en dehors des bornes

Error, 1st index, 0, smaller than lower array bound 1

> d2[1,3]:=3 ;
d2 1 3 := 3
;

> d2[2] ; # le tableau est à deux dimensions

Error, array defined with 2 indices, used with 1 indices

> b2:=array(1..3,1..4,[0$12]) ; # non autorisé

Error, (in index/fill) a list with 12 entries cannot be used to

initialize the range 1 .. 3
Cet exemple nécessite une liste de 3 éléments, chacun étant une liste de 4
autres éléments.
b2:=array(1..3,1..4,[[0$4]$3]);
2 3
>

0 0 0 0
b2 := 64 0 0 0 0 75
0 0 0 0
b2:=array(1..4,1..3,[[0$3]$4]);
2 3
>

0 0 0
6 7
b2 := 664 00 00 00 775
0 0 0
6.5 Les matrices
Il existe peu de diérence entre les structures array et matrice. Dans une
matrice les indices sont toujours dénis à partir de 1.
La matrice est un objet algébrique ce qui nécessite de charger la bibliothèque
spécique aux traitements d'algébre linéaire.
> with(linalg) : # ":" est moins bavard que ";"
M := matrix(4,4,[0$16]);
2 3
>

0 0 0 0
6 7
M := 664 00 00 00 00 775
0 0 0 0
> p:=charpoly(M,Z) ; # renvoie le déterminant (M-ZI)
p := Z 4

13
6.6 Passage entre les structures de données
Lorsqu'il est possible, le passage d'une structure de données à une autre se fait
grâce à l'instruction convert.
convert(M,array) ;
2 3
>

0 0 0 0
66 0 0 0 0 77
64 0 0 0 0 75
0 0 0 0
> whattype(M) ;
symbol
> whattype(op(M)) ; # renvoie le type de M
array
> type(M,matrix) ;
true
> type(M,array) ; # une matrice est un array
true
Convert calcule un objet de type array à partir de la matrice M. L'objet M
ne change pas de type. M peut recevoir le résultat de la conversion (ce qui est
rare), mais cela détruira le contenu antérieur de M.
> matrix(m,n,[]) ;
est équivalent à :
> array(1..m,1..n,[]) ;
On peut fabriquer une array monodimensionnelle ou bidimensionnelle. Ces
objets ne sont pas des matrices.
> array(1..3,[a,aa,aaa]) ;
[a; aa ; aaa ]
b:=array(1..2,1..3,[[0$3] $2]) ;
" #
>

b := 00 00 00
convert(b,matrix) ;
" #
>

0 0 0
0 0 0
> convert(b,list) ; # impossible

Error, (in convert/list) can't convert array of dimension > 1

14
 b:=matrix(3,3,[i$i=1..9]) ;
2 3
>

1 2 3
b := 64 4 5 6 75
7 8 9
> convert(b,listlist) ; # liste de listes
[[1; 2; 3]; [4; 5; 6]; [7; 8; 9]]
> convert(tbl,list) ;
[x; 7]
> convert(tbl,array) ; # impossible

Error, (in index/FillInitVals) unevaluated array index in assignment

Il faut veiller à ne pas perdre le contenu d'un tableau ou les autres données
telles que les symboles importants !
> c:=x ; # le contenu de c est perdu !
c := x

7 Manipulations sur les fonctions

7.1 Manipulations simples
f est une fonction de x.
> f:=x^2 + a*x +1 ;
f := x2 + a x + 1
> df:= diff(f,x) ;
df := 2 x + a
> dfa:=diff(f,a) ;
dfa := x
> dfg:=diff(f,g) ;# f ne dépend pas de
> g
dfg := 0
> df2:=diff(f,x,x) ;
df2 := 2
> df2:=diff(f,x$2) ; # x$2 vaut x,x
df2 := 2
> res:=diff(f,x,a)-diff(f,a,x) ;
res := 0
> f4:=f**4 ;
f4 := (x2 + a x + 1)4

15
 > f4:=expand(f4) ; # pas de hiérarchisation des puissances

f4 := 1 + 4 a3 x3 + 4 x6 + 12 x5 a + 12 x4 a2 + x8 + 6 x4 + 12 x3 a + 6 a2 x2 + 4 a x + 6 x6 a2
+ 4 x5 a3 + a4 x4 + 4 x7 a + 4 x2
> sort(f4,x) ; # puissances décroissantes par défaut

x8 + 4 a x7 + 4 x6 + 6 a2 x6 + 12 a x5 + 4 a3 x5 + 12 a2 x4 + a4 x4 + 6 x4 + 4 a3 x3 + 12 a x3
+ 6 a2 x2 + 4 x2 + 4 a x + 1
> sort(f4,[x,a],plex) ; # tri en x et a, puiss. lexicographiques

x8 + 4 x7 a + 6 x6 a2 + 4 x6 + 4 x5 a3 + 12 x5 a + x4 a4 + 12 x4 a2 + 6 x4 + 4 x3 a3 + 12 x3 a
+ 6 x2 a2 + 4 x2 + 4 x a + 1
> collect(f4,x) ; # rassemble les coeff par puissances de x

x8 + 4 x7 a + (6 a2 + 4) x6 + (12 a + 4 a3) x5 + (a4 + 12 a2 + 6) x4 + (12 a + 4 a3) x3

+ (6 a2 + 4) x2 + 4 x a + 1
> collect(f4,x,sort) ;

x8 + 4 x7 a + (6 a2 + 4) x6 + (4 a3 + 12 a) x5 + (a4 + 12 a2 + 6) x4 + (4 a3 + 12 a) x3
+ (6 a2 + 4) x2 + 4 x a + 1
> collect(f4,[x,a]) ;

x8 + 4 x7 a + (6 a2 + 4) x6 + (4 a3 + 12 a) x5 + (a4 + 12 a2 + 6) x4 + (4 a3 + 12 a) x3
+ (6 a2 + 4) x2 + 4 x a + 1
7.2 Coecients des polynômes
> coeff(f4,x,6) ;
6 a2 + 4
> coeffs(f4,x) ; # liste de tous les coeffs
1; 4 a; 6 a2 + 4; a4 + 12 a2 + 6; 6 a2 + 4; 1; 12 a + 4 a3; 12 a + 4 a3 ; 4 a
> coeffs(expand((x^2+1)^3),x) ; # non ordonné incomplet
1; 1; 3; 3
> degree(expand((x^2+1)^3),x) ;
6
> seq(coeff(x^6+3*x^4+3*x^2+1,x,i),i=0..degree(x^6+3*x^4+3*x^2+1,x))
> ; # ordonné et complet
1; 0; 3; 0; 3; 0; 1
> [seq(coeff(x^6+3*x^4+3*x^2+1,x,i),i=0..degree(x^6+3*x^4+3*x^2+1,x))]
> ; # liste
[1; 0; 3; 0; 3; 0; 1]

16
 7.3 Intégration
> int(f4,x) ; # polynôme résultant de l'intégration

1 x9 + 1 x8 a + 6 x7 a2 + 4 x7 + 2 x6 a3 + 2 x6 a + 1 x5 a4 + 12 x5 a2 + 6 x5 + x4 a3 + 3 x4 a
9 2 7 7 3 5 5 5
4
+ 2 x3 a2 + 3 x3 + 2 x2 a + x
> int(f4,x=1..y) ;

1 y 9 ; 10 + 1 a (y 8 ; 1) + 1 (6 a2 + 4) (y 7 ; 1) + 1 (4 a3 + 12 a) (y 6 ; 1)
9 9 2 7 6
1
+ 5 (a4 + 12 a2 + 6) (y 5 ; 1) + 4 (4 a3 + 12 a) (y 4 ; 1) + 13 (6 a2 + 4) (y 3 ; 1)
1
+ 2 a (y 2 ; 1) + y
> ig:=int(f4,x=1..y) ;

1 10 1 1 1
ig := y 9 ; + a (y 8 ; 1) + (6 a2 + 4) (y 7 ; 1) + (4 a3 + 12 a) (y 6 ; 1)
9 9 2 7 6
+ (a + 12 a + 6) (y ; 1) + (4 a + 12 a) (y ; 1) + 1 (6 a2 + 4) (y 3 ; 1)
1 4 2 5 1 3 4
5 4 3
2
+ 2 a (y ; 1) + y
> simplify(ig) ; # formule magique

; 15 1 4 5 12 2 5 3 4 4 2 3 2 5 3 1 4
2 a+y + 5 a y + 5 a y +a y + 3ay + 2a y + 2ay ; 3 a ; 5 a + 2ay
6

+ 23 a3 y 6 + 91 y 9 + 56 y 5 + 43 y 3 + 74 y 7 ; 184
35 a 2 ; 1328 + 1 a y 8 + 6 a2 y 7
315 2 7
> expand(ig) ; # expand préférée à
> simplify pour les produits (id dans ce cas)

; 152 a + y + 15 a4 y5 + 12
5 a 2 y 5 + a3 y 4 + 3 a y 4 + 2 a2 y 3 + 2 a y 2 ; 5 a3 ; 1 a4 + 2 a y 6
3 5
+ 23 a3 y 6 + 91 y 9 + 56 y 5 + 43 y 3 + 74 y 7 ; 184 2 1328 1 8 6 2 7
35 a ; 315 + 2 a y + 7 a y
> int(1/f4,x) ;

17
1 2x+ a
3 (4 ; a ) (x2 + x a + 1)3
2
0 0 2 x + a )11
BB B 4 arctanh( p CC
BB 3B 2x+ a ; p ;4 + a2 C
C
@(4 ; a2) (x2 + x a + 1) (4 ; a2) ;4 + a2 ACC
10 B1B 2x+a CC
3 B B + CC
BB2 (4 ; a2) (x2 + x a + 1)2 4 ; a2 CC
B@ CA
+
4 ; a2
> int(sqrt(1/f4),x) ; # Maple réussit souvent !

p p
(;2 ;4 + a2 x ; ;4 + a2 a + 4 arctanh( p2 x + a 2 ) x2 + 4 arctanh( p2 x + a 2 ) x a
;4 + a ;4 + a
.
+ 4 arctanh( p2 x + a 2 ))(x2 + x a + 1)(1 (x8 + 4 x7 a + 6 x6 a2 + 4 x6 + 4 x5 a3
;4 + a
+ 12 x5 a + x4 a4 + 12 x4 a2 + 6 x4 + 4 x3 a3 + 12 x3 a + 6 x2 a2 + 4 x2 + 4 x a + 1))
=
.
(1 2) (;4 + a2 )(3 2)
=

int(1/f^(1/3),x) ; # Maple essaie quand même !

Z
>

1 dx
(x2 + x a + 1)(1 3)
=

Il existe une diérence entre évaluation numérique et évaluation formelle

> int(1/f4,x=1..2) ;
Z2 .
1 (x8 + 4 x7 a + 6 x6 a2 + 4 x6 + 4 x5 a3 + 12 x5 a + x4 a4 + 12 x4 a2 + 6 x4 + 4 x3 a3
1
+ 12 x3 a + 6 x2 a2 + 4 x2 + 4 x a + 1)dx
> int(1/f4,x);

1 2x+ a
3 (4 ; a ) (x2 + x a + 1)3
2
0 0 2 x + a 11
BB BB 2x+ a 4 arctanh( p 2 )CC
; a
@(4 ; a2) (x2 + x a + 1) (4 ; a2) ;4 + a2 CACCC
BB 3 ; p 4 +
10 B BB1 2x+a CC
3 B + CC
BB2 (4 ; a2) (x2 + x a + 1)2 4 ; a2 CC
B@ CA
+ 4 ; a2
18
 > fa:=subs(a=3,f4) ; # évacue le pb du paramètre a
fa := x8 + 12 x7 + 58 x6 + 144 x5 + 195 x4 + 144 x3 + 58 x2 + 12 x + 1
> v:=int(1/fa,x=1..2) ; # résultat avec partie réelle
10946 + 8 p5 <(arctanh( 7 p5)) ; 8 p5 <(arctanh(p5))
v := 499125 125 5 125
evalc(v) ; # évaluation/simplification d'un nombre complexe
0 7p 1
>

10946 + 2 p5 ln B ( 5 + 1) C 2 p (p5 + 1)2

2
B@ 75 p CA ; p
499125 125 ( 5 5 ; 1) 2 125 5 ln( ( 5 ; 1)2 )
> evalf(v) ;
:00043687913
Seconde solution : Maple fait de l'intégration numérique et passe par un al-
gorithme pour trouver une approximation de l'intégration.
> evalf(Int(1/fa,x=1..2)) ;
:0004368791081
L'intégration symbolique est exacte mais il arrive parfois qu'elle soit longue et
qu'elle ne marche pas toujours.
L'intégration numérique est approchée, en général plus rapide, et marche tou-
jours en principe.
Sur l'exemple précédent, les deux résultats sont diérents ; donc il y en a au
moins un qui est faux.
Si on demande à Maple > evalf(int(...,x=1..2)), on s'attend à un résultat nu-
mérique. Maple essaie de trouver une primitive : s'il échoue alors il utilise la
méthode numérique. Si on demande evalf(Int(...)) alors la méthode numérique
est appliquée directement.
En conclusion, il faut donc trouver un bon compromis entre le temps et ce que
l'on attend.
7.4 Factorisation et décomposition de fractions
> factor(f4) ;
(x2 + x a + 1)4
> h:=diff(1/f4,x) ;

19
h := ;(8 x7 + 28 x6 a + 36 x5 a2 + 24 x5 + .20 x4 a3 + 60 x4 a + 4 x3 a4 + 48 x3 a2 + 24 x3
+ 12 x2 a3 + 36 x2 a + 12 x a2 + 8 x + 4 a) (x8 + 4 x7 a + 6 x6 a2 + 4 x6 + 4 x5 a3
+ 12 x5 a + x4 a4 + 12 x4 a2 + 6 x4 + 4 x3 a3 + 12 x3 a + 6 x2 a2 + 4 x2 + 4 x a + 1)2
> h:=factor(h);

h := ;4 (x2 +2 xx+a +a 1)5

> numer(h) ;
;8 x ; 4 a
> denom(h) ;
(x2 + x a + 1)5
Il n'y a pas de règles quant à l'écriture : Maple limite l'expression ; ne pas
toujours faire conance à Maple, ne pas s'attendre à ce que le dénominateur
soit toujours positif par exemple.
7.5 Développements
> ty:=taylor(h,x=1,8) : # à tester sur son poste...
renvoie le développement de Taylor de h au voisinage de 1 à l'ordre 8.
> simplify(ty) ;

2
;4 (2 +1 a)4 + 4 (28 ++ 5a)a5 (x ; 1) ; 60 (21++aa)5 (x ; 1)2 + 20 6 +(216+a a+)67 a (x ; 1)3;
21 a + 14 a2 (x ; 1)4 + 12 ;24 + 49 a + 112 a2 + 42 a3 (x ; 1)5;
20 1 + (2 + a)6 (2 + a)7
2 3 3 33 a4 + 36 a2
28 ;19 ; 4 a(2++54a)a7 + 30 a (x ; 1)6 + 40 ;25 ; 64 a +(296+a a+ )8
(x ; 1)7 + O((x ; 1)8)
> convert(ty,polynom) : id sans "O" à tester
Parfois Maple donne un développement à un ordre inférieur à cause de ses
calculs intermédiaires. La solution est de demander un développement à un
ordre supérieur.
> qw:= subs(a=-2,h) ;

qw := ;4 2
2x;2
(x ; 2 x + 1)5
> simplify(qw) ;

;8 (x ; 1) (x21; 2 x + 1)4
> factor(qw) ;

20
 ;8 (x ;1 1)9
> taylor(qw,x=1) ; # par défaut ordre 6
on obtient une erreur mais Maple propose la fonction series
Error, does not have a taylor expansion, try series()
> series(qw,x=1) ;
;8 (x ; 1);9
> series(u,x=1) ;

1 (x ; 1);1 ; 1 + 1 (x ; 1) ; 1 (x ; 1)2 + 1 (x ; 1)3 ; 1 (x ; 1)4 + 1 (x ; 1)5+

3 9 27 81 243 729 2187
O((x ; 1)6)
Quelques compléments sur les développements de Taylor, limité, de Laurent
(extensions de dérivées limites).
> u2 := u*(exp(x-1)-1) ;

u2 :=
e( ;1) ; 1
x

(x ; 1) (x + 2)
> subs(x=1,u2) ;

Error, numeric exception: division by zero

> limit(u2,x=1) ;
1
3
> limit(u2,x=1.0) ;
:3333333333
> subs(x=1.0,u2) ;
Float(1) e0 ; Float(1)
:

Remarquons que l'écriture des paramètres est inversée entre subs et limit.
Maple fait le développement limité pour calculer la singularité.
Par ailleurs, il existe un paradoxe. En eet on demande le développement
limité. Puis on remplace le paramètre a. Le retour ne se fait pas forcément car
les calculs intermédiaires le bloquent peut-être.
> pty:=convert(ty,polynom) : # à tester
> ptz:=subs(x-1=z,pty) :
> st:=seq(coeff(ptz,z,1),i=0..degree(ptz,z));

21
 st := %1; %1; %1; %1; %1; %1; %1; %1
%1 := ;8 (2 +1 a)5 + (2 +20a)4
> map(factor,st);

Error, (in factor) wrong number of arguments

On observe que les coecients ne sont pas dénis si a=0. Maple trouve les
formules génériques sans hypothèses particulières.

8 Algèbre linéaire
8.1 Matrices
Initialisation d'une matrice avec une fonction où le coe i,j est i^j :
M:=matrix(3,3,(i,j)->x[i]^j) ;
2 2 x1 3 3
>

x 1 x1
M := 64 x2 x22 x23 75
x3 x32 x33
Il faut songer à charger le package linalg !
> with(linalg) :
> det(M) ;
x1 x22 x33 ; x1 x23 x32 ; x2 x12 x33 + x2 x13 x32 + x3 x12 x23 ; x3 x13 x22
> factor(det(M)) ;
;x3 x2 x1 (;x2 + x1) (;x1 + x3) (x3 ; x2)
multiply(M,M) ;
2 2 2 3
>

3 3 2 2 3 2 4 2 3 3 3
64 xx12 x+1 +x1x2x32++xx213 xx33 xx112+x2x+1 xx224 ++xx213 xx332 xx12 x+13x+1 xx225 ++xx213 xx333 75
x3 x1 + x32 x2 + x34 x3 x12 + x32 x22 + x35 x13 x3 + x23 x32 + x36
evalm(M &* M) ; # équivalent à multiply(M,M)
2 2 2 3
>

3 3 2 2 3 2 4 2 3 3 3
64 xx12 x+1 +x1x2x32++xx213 xx33 xx112+x2x+1 xx224 ++xx213 xx332 xx12 x+13x+1 xx225 ++xx213 xx333 75
x3 x1 + x32 x2 + x34 x3 x12 + x32 x22 + x35 x13 x3 + x23 x32 + x36
> evalm permet d'évaluer la matrice avec des opérations sur les matrices.
L'opérateur &* est la multiplication de matrices.
> evalm(M**2) ;

22
 2 2 2 3
x1 + x1 x2 + x13 x3 x1 3 + x1 2 x2 2 + x1 3 x3 2 x14 + x12 x23 + x13 x33
64 x2 x1 + x23 + x23 x3 x12 x2 + x24 + x23 x32 x2 x13 + x25 + x23 x33 75
2
x3 x1 + x3 x2 + x3 4 2 2 2
x3 x1 + x3 x2 + x3 5 3 3 2
x1 x3 + x2 x3 + x3 6
> Minv:=evalm(M^(-1)) ;
2 x3 x2 x1 x3 x1 x2 3
66 ; %3 x1 %2 x2 %1 x3 77
6 x3 + x2 x3 + x1 x1 + x2
Minv := 66 %3 x ; %2 x ; %1 x
77
64 1 2 3 77
1 1 1 5
; %3 x %2 x2 %1 x3
1
2
%1 := ;x3 x1 + x2 x1 + x3 ; x2 x3
%2 := ;x2 x3 + x3 x1 + x2 2 ; x2 x1
%3 := ;x2 x3 + x3 x1 + x2 x1 ; x1 2
> simplify(%) ; # % dernier résultat %% avant dernier
2 x3 x2 x1 x3 x1 x2 3
;
66 %3 x1 %2 x2 %1 x3 7
66 x3 + x2 ; x3 + x1 ; x1 + x2 777
66 %3 x1 %2 x2 %1 x3 77
4 1 1 1 5
; %3 x %2 x2 %1 x3
1
%1 := ;x3 x1 + x2 x1 + x3 2 ; x2 x3
%2 := ;x2 x3 + x3 x1 + x2 2 ; x2 x1
%3 := ;x2 x3 + x3 x1 + x2 x1 ; x12
Dans l'exemple qui suit, la fonction map applique la fonction factor à tous les
éléments de la matrice.
map(factor,Minv) ;
2 3
>

x2 x3 x3 x1 x2 x1
66 ; (;x2 + x1) (;x1 + x3) x1 (;x2 + x1) (x3 ; x2) x2 (;x1 + x3) (x3 ; x2) x3 77
66 x +x x +x x +x 77
66 (;x2 + x1)3 (;x21 + x3) x1 ; (;x2 + x13) (x31; x2) x2 ; (;x1 + x31) (x32; x2) x3 77
64 75
; (;x + x ) (1;x + x ) x (;x + x )1(x ; x ) x 1
(;x1 + x3 ) (x3 ; x2 ) x3
2 1 1 3 1 2 1 3 2 2
> evalm(M &* Minv) : # à tester
map(factor,evalm(M &* Minv)) ;
2 3
>

1 0 0
64 0 1 0 75
0 0 1
Les vecteurs sont des matrices !

23
 b:=matrix(3,1,[1,2,0]) ;
2 3
>

1
b := 64 2 75
0
evalm(M &* b) ;
2 3
>

x 1 + 2 x12
64 x2 + 2 x22 75
x3 + 2 x32
transpose(b) ;
h i
>

1 2 0
val:=evalm(transpose(b) &* M &* b) ;
h i
>

val := x1 + 2 x2 + 2 x12 + 4 x22

> val[1,1] ; # scalaire
x1 + 2 x2 + 2 x12 + 4 x22
> val[1] ;

Error, array defined with 2 indices, used with 1 indices

8.2 Résolution de systèmes linéaires

> xs:=linsolve(M,b);
2 x (;2 x x 2 + x 2 x + 2 x 3 ; x 3) 3
66 ; 3 3 1 2 3 1 2
77
66 ;2 x x 2 + xx2xx12%1 77
xs := 66 1 3 2 3 + 2 x13 ; x2 3 77
66 x2 x1 %1 77
4 2 2 5
; 2 x1 ; 2 x1 x3 ; x2 + x2 x3
x1 %1 x2
%1 := ;x3 x1 2 + x2 x12 ; x2 x3 2 + x1 x3 2 + x2 2 x3 ; x2 2 x1
Ce sont les solutions de Mx=b en x : la même chose que x=M(-1)b, ce qui
n'est pas faux !
> xs2:=evalm(M^(-1) &* b);

24
 2 x2 x3 ; 2 x1 x3 3
66 %2 x1 %1 x2 7
66 x2 + x3 2 (x1 + x3) 777
xs2 := 66 ; + 7
64 %2 x1 %1 x2 77
1 ; 2 5
%2 x1 %1 x2
%1 := ;x1 x3 + x2 x1 ; x2 2 + x2 x3
%2 := x2 x3 ; x2 x1 ; x1 x3 + x12
map(simplify,evalm(xs-xs2)); # pour voir que c'est identique
2 3
>

64 00 75
0
Calcule aussi x mais c'est plus long, d'autant plus long que les symboles restent
dans la matrice !
Le calcul symbolique a ses limites : il est exact mais prend du temps.
8.3 Vecteurs propres
> z:='z' : cp:=charpoly(M,z) ;

cp := z 3 ; z 2 x3 3 ; x2 2 z 2 + z x22 x33 ; z x2 3 x3 2 ; x1 z 2 + x1 z x3 3 + x1 x2 2 z ; x1 x2 2 x3 3
+ x1 x2 3 x3 2 ; x2 x1 2 z + x2 x1 2 x3 3 ; x2 x13 x32 ; x3 x1 2 x2 3 ; x3 x1 3 z + x3 x1 3 x2 2
> factor(cp) ;

z3 ; z2 x33 ; x22 z2 + z x22 x33 ; z x23 x32 ; x1 z2 + x1 z x33 + x1 x22 z ; x1 x22 x33 + x1 x23 x32
; x2 x12 z + x2 x12 x33 ; x2 x13 x32 ; x3 x12 x23 ; x3 x13 z + x3 x13 x22
M2:=subs({x[1]=0,x[2]=1,x[3]=t},op(M)) ;
2 3
>

0 0 0
M2 := 64 1 1 1 75
t t2 t3
eigenvals(M2) ; # valeurs propres
p p
>

0; 1 + 1 t3 + 1 1 ; 2 t3 + t6 + 4 t2 ; 1 + 1 t3 ; 1 1 ; 2 t3 + t6 + 4 t2
2 2 2 2 2 2
>

1 1 
eigenvects(M2) ; # vecteurs propres
1 1 1 1 
3 3
[ 2 + 2 t + 2 %1; 1; f 0; 1; ; 2 + 2 t + 2 %1 g];
   
[ 21 + 12 t3 ; 21 %1; 1; f 0; 1; ; 21 + 12 t3 ; 21 %1 g]; [0; 1; f ; t +t 1 ; 1; ; t +1 1 g]
p
%1 := 1 ; 2 t3 + t6 + 4 t2
Renvoie une séquence avec la valeur propre, la dimension de l'espace et l'ensemble
des vecteurs propre, soit autant de descripteurs qu'il y a de valeurs propres.

25
 > eigenvects(diag(1,1,2)) ;
[1; 2; f[1; 0; 0]; [0; 1; 0]g]; [2; 1; f[0; 0; 1]g]
Par exemple, pour chercher si le système est stable, on cherche si les valeurs
propres sont inférieures à 1 en valeur absolue.
> linsolve(M2,b) ; # pas de message = pas de solution
> evalm(inverse(M2) &* b);

Error, (in inverse) singular matrix

Renvoie une erreur car il n'y a pas de solution à ce système : il n'existe pas
de x tel que M2x=b, mais M2 est singulière.
zoro:=matrix(3,1,[0,0,0]) ;
2 3
>

0
zoro := 64 0 75
0
linsolve(M2,zoro) ;
2 3
>

t 11 t
64 ; t 11 (t + 1) 75
t 11
Ce résultat peut paraître étrange mais il est correct ! Il existe une innité
de solutions proportionnelles à un vecteur que Maple a choisi de noter d'une
certaine façon.
Le problème est de trouver x tel que M2x=0 et la somme des x = 1 pour i
i

dimensions du vecteur.
res:=linsolve(M2,zoro) ;
2 3
>

t 11 t
res := 64 ; t 11 (t + 1) 75
t 11
> total:=sum(res[i,1],i=1..3);
t t t
total := ; 11 + t 11 ; 11
t+1 t+1
> simplify(total);
0
On ne peut pas trouver de solution telle que x1 + 2x2 + 3x3 = 1 car toute
solution est telle que x1 + 2x2 + 3x3 = 0. On essaie donc de trouver x avec
M2x=0 et x1 + 2x2 + 3x3 = 1.
> total:=res[1,1]+2*res[2,1]+3*res[3,1];
t t 3t
total := ; 11 + 2 t 11 ; 11
t+1 t+1

26
 > solu:=evalm(res/total);
2 t 11 t 3
66 ; %1 (t + 1) 77
6 t 11 77
solu := 666 %1 77
64 75
; %1 (tt11+ 1)
%1 := ; tt+111t + 2 t 11 ; 3t +t 111
avec x tel que x1 + 2x2 + 3x3 = 1 soit 1 tel que 1 + 2 2 + 3 3 = 1.
x x
s
x
s
x
s

map(simplify,solu) ;
2 t 3
>

66 ; t ; 1 77
66 t + 1 77
66 t ; 1 77
64 1 75
;t ; 1
map(factor,solu) ;
2 t 3
>

66 ; t ; 1 77
66 t + 1 77
66 t ; 1 77
64 1 75
;t ; 1
Quelques manipulations sur les matrices :
> coldim(b) ;
1
> rowdim(b) ;
3
8.4 Systèmes d'équations généraux
> p:=product(z-i,i=1..4) ;
p := (z ; 1) (z ; 2) (z ; 3) (z ; 4)
seq et sum sont des fonctions permettant d'obtenir en une seule ligne des
résultats parfois compliqués.
> solve(p,z) ; # sous entendu p=0
1; 2; 3; 4
> solve(p=1,z) ;

27
 5 ; 1 q5 + 4 p2; 5 + 1 q5 + 4 p2; 5 ; 1 q5 ; 4 p2; 5 + 1 q5 ; 4 p2
2 2 2 2 2 2 2 2
> solve(p=-10,z) ;
1 + I; 1 ; I; 4 + I; 4 ; I
Renvoie des nombres imaginaires.
> sol:=[solve(p=-10,z)] ;
sol := [1 + I; 1 ; I; 4 + I; 4 ; I ]
> sol[2] ;
1;I
> p:=product(z-i,i=1..5) ;
p := (z ; 1) (z ; 2) (z ; 3) (z ; 4) (z ; 5)
> sol:=[solve(p=-10,z)] ;

sol := [RootOf(%1; index = 1); RootOf(%1; index = 2); RootOf(%1; index = 3);
RootOf(%1; index = 4); RootOf(%1; index = 5)]
%1 := Z 5 ; 15 Z 4 + 85 Z 3 ; 225 Z 2 + 274 Z ; 110
Maple n'ayant pas réussi, on peut lui demander de faire la résolution avec des
ottants.
> fsolve(p=-10,z) ;
:7449115882443210833027883655874290900097
Maple a trouvé une racine qui est réelle. On lui demande alors de savoir où
sont toutes les racines.
> Digits:=10 : fsolve(p=-10,z,complex) ;

:7449115882; 2:349739682 ; :9370699874 I; 2:349739682 + :9370699874 I;

4:777804524 ; :4980352577 I; 4:777804524 + :4980352577 I
Il renvoie des valeurs complexes mais numériques que l'ont peut vérier gra-
phiquement.
> plot(p+10,z=0..2); # cf. Figure 1
> fsolve(p=sin(z)) ;
1:038994656
On trouve une solution mais la question est de savoir s'il existe une autre
racine, soit par la réalisation de graphes, soit en s'aidant de l'analyse mathé-
matique, soit en trouvant (ou excluant) des intervalles contenant les racines.
Soit une fonction d'utilité que l'on cherche à maximiser.
> ut:=-(x+2*y+2)^4-(3*x+y-2)^2 ;
ut := ;(x + 2 y + 2)4 ; (3 x + y ; 2)2
> maximize(ut,x,y) ;

28
 Figure 1: Plot z

z
0.2 0.4 0.6 0.8 1 1.2 1.4 1.6 1.8 2
0

–20

–40

–60

–80

–100

0
> maximize(ut,location) ;

0; f[fy = ;58 ; x = 56 g; 0]g

Maple écrit les équations du 1er ordre et les résoud. Faisons le étape par étape.
gr:=grad(ut,[x,y]) ; # calcul du gradient
 
>

gr := ;4 (x + 2 y + 2)3 ; 18 x ; 6 y + 12; ;8 (x + 2 y + 2)3 ; 6 x ; 2 y + 4

> sys:={gr[1]=0,gr[2]=0} ;
sys := f;8 (x + 2 y + 2)3 ; 6 x ; 2 y + 4 = 0; ;4 (x + 2 y + 2)3 ; 18 x ; 6 y + 12 = 0g
Il s'agit d'un système d'équations de deux éléments : on prend le 1er élément
de gradient=0 et le second de gradient=0.
> so:=solve(sys) ;

29
 so := fy = ;8 ; x = 6 g
5 5
> so[1] ;

y = ;58
> subs(so[1],ut) ;

;(x ; 65 )4 ; (3 x ; 18
5)
2
On peut récupérer la valeur du 2nd élément de la première solution, mais selon
les cas ce n'est pas toujours dans le même ordre.
> a:=op(2,so[1]) ;

a := ;58
Pour illustrer le propos de la conance limitée à accorder à Maple quant aux
résultats, il sut de faire l'exercice avec la fonction d'utilité suivante :
> ut:=-(x^2+2*y+2)^4-(3*x+y-2)^2 ;
ut := ;(x2 + 2 y + 2)4 ; (3 x + y ; 2)2
8.5 Equations diérentielles
dsolve concerne équations diérentielles ordinaires.
pdesolve (ou pdsolve) est utilisé pour les dérivées partielles.
> ode1:=diff(y(x),x) ;
ode1 := @
@x
y(x)
ode1 reçoit ensuite toute l'équation.
> ode1:=diff(y(x),x)=k*y(x)*(1-y(x)) ;
ode1 := @x
@
y(x) = k y(x) (1 ; y(x))
> dsolve(ode1,{y(x)}) ;

y(x) = 1
1 + e ) C1
( ; kx

Cette solution est générique, C1 étant la constante d'intégration.

Pour avoir une solution particulière, il faut mentionner que y(0) a une certaine
valeur et extraire la constante de l'équation. Le premier membre de la fonction
dsolve représente le système d'équations à résoudre et le second concerne les
fonctions recherchées.
> dsolve({ode1,y(0)=y0},{y(x)}) ;

y(x) = 1
1; e(; ) (;1 + C1 )
k x

C1
30
 > dsolve({ode1,y(0)=0},{y(x)}) ;
y(x) = 0
8.6 Développements en série
Si l'on veut obtenir la série de y(x) à l'ordre 6 :
> dsolve(ode1,{y(x)},type=series) ;

y(x) = y(0) + k y(0) (1 ; y(0)) x + (; 3 k2 y(0)2 + k2 y(0)3 + 1 k2 y(0)) x2 + (

2 2
1 k y(0) ( 3 k2 y(0)2 ; k2 y(0)3 ; 1 k2 y(0)) ; 1 k3 y(0)2 (1 ; y(0))2
3 2 2 3
1 3 2 2 2 3 1
+ 3 k (; 2 k y(0) + k y(0) + 2 k y(0)) (1 ; y(0)))x3+
2
25 k4 y(0)3 ; 5 k4 y(0)4 ; 5 k4 y(0)2 + k4 y(0)5 + 1 k4 y(0)) x4+
( 12 2 8 24
3 13 31
( 2 k5 y(0)3 ; 4 k5 y(0)4 ; 120 k5 y(0)2 + 3 k5 y(0)5 + 120 1 k5 y(0) ; k5 y(0)6) x5+
O(x6)
> Order:=10 ; # à l'odre 10 ! avec majuscule
Order := 10
> dsolve(ode1,{y(x)},type=series) :# à tester
> dsolve({ode1,y(0)=1/2},{y(x)},type=series) ;

y(x) = 21 + 14 k x ; 48
1 k3 x3 + 1 k5 x5 ; 17 k7 x7 + 31 k9 x9 + O(x10 )
480 80640 1451520
> ode2:=diff(y(x),x,x)-k*y(x)*(1-y(x)):
> dsolve({ode2,y(0)=1/2},{y(x)},type=series) ;

y(x) = 21 + D(y )(0) x + 18 k x2 ; 12

1 k D(y )(0)2 x4 ; 1 k2 D(y )(0) x5 ; 1 k3 x6 +
80 1920
1 k2 D(y )(0)3 x7 + 11 k3 D(y )(0)2 x8 + 1 k4 D(y )(0) x9 + O(x10)
252 13440 17280
> D(y)(0) ; # dérivée de y évaluée en 0
D(y )(0)
Récupération de la partie polynomiale du développement limité :
> solu:=dsolve({ode2,y(0)=1/2,D(y)(0)=1},{y(x)},type=series) ;

solu := y(x) = 1 + x + 1 k x2 ; 1 k x4 ; 1 k2 x5 ; 1 k3 x6 + 1 k2 x7 + 11 k3 x8 +
2 8 12 80 1920 252 13440
1 k4 x9 + O(x10 )
17280
> toto:=subs(solu,y(x)) ;

31
toto := 1 + x + 1 k x2 ; 1 k x4 ; 1 k2 x5 ; 1 k3 x6 + 1 k2 x7 + 11 k3 x8 + 1 k4
2 8 12 80 1920 252 13440 17280
x9 + O(x10)
> toto:=convert(toto,polynom) ;

toto := 1 + x + 1 k x2 ; 1 k x4 ; 1 k2 x5 ; 1 k3 x6 + 1 k2 x7 + 11 k3 x8
2 8 12 80 1920 252 13440
1
+ 17280 k4 x9
> subs(x=4,toto) ;
9 ; 58 k + 16448 k2 + 5408 k3 + 2048 k4
2 3 315 105 135
Ces deux méthodes -solution générique et développement limité- sont des mé-
thodes formelles.
Passons maintenant à la méthode numérique :
> k:=0.1 ;
> lo:=dsolve({ode1,y(0)=1/2},{y(x)},type=numeric) ;
k := :1
lo := proc(rkf45 x ) : : : end proc
Le résultat de cet appel est une procédure.
> lo(1) ;
[x = 1:; y(x) = :524979187477936592]
> lo(2) ;
[x = 2:; y(x) = :549833997184993926]
> lo(0) ;
[x = 0:; y(x) = :50000000000000]
> Digits:=20 ;
Digits := 20
> lo(1.0) ;
[x = 1:0; y(x) = :524979195325058768]
> lo1:=subs(k=2,lo) ; # ne marche pas
lo1 := lo
> k:=0.1 ; lo(1.0) ; # marche... mais...
k := :1
[x = 1:0; y(x) = :524979195325058768]
> logode:=subs(k=0.1,ode1) ;
logode := @
@x
y(x) = :1 y(x) (1 ; y(x))

32
 > lo:=dsolve({subs(k=0.1,ode1),y(0)=1/2},{y(x)},type=numeric)
;
lo := proc(rkf45 x ) : : : end proc
> with(plots) : # bibliothèque des fonctions graphiques évoluées
> curvs:=seq(dsolve({logode,y(0)=i/10},
> {y(x)},type=numeric),i=1..9) ;

curvs := proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc;

proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc;
proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc;
proc(rkf45 x ) : : : end proc; proc(rkf45 x ) : : : end proc;
proc(rkf45 x ) : : : end proc
> odeplot n'accepte pas une liste de courbes, il faut extraire la 1ière :
> odeplot(curvs[1],x=0..100) ; # cf. Figure 2

Figure 2: Plot 1 seule courbe

0.8

0.6
y

0.4

0.2

0 20 40 60 80 100
x

33
 > listgr:=[seq(odeplot(curvs[i],x=0..100),i=1..9)]:
> display (listgr) ; # cf. Figure 3

Figure 3: Plot plusieurs courbes

0.8

0.6
y

0.4

0.2

0 20 40 60 80 100
x

8.7 Système d'équations

Méthode formelle :
> t:='t' : a:='a' : b:='b' : c:='c' :
> eq1:=diff(x(t),t)=a*x(t)+b*y(t) ;
eq1 := @
@t
x(t) = a x(t) + b y(t)
> eq2:=diff(y(t),t)=c*x(t)+d*y(t) ;
eq2 := @
@t
y(t) = c x(t) + d y(t)
> dsolve({eq1,eq2},{x(t),y(t)}) ;

34
 fy(t) = ; 12 C1 %3 a ; C1 %3 d ; C1 %3 %1 +b C2 %2 a ; C2 %2 d + C2 %2 %1 ;
x(t) = C1 %3 + C2 %2g
p
%1 := a2 ; 2 a d + d2 + 4 c b
%2 := e(1 2( + ;%1) )
= a d t

%3 := e((1 2 +1 2 +1 2 %1) )
= a = d = t

> dsolve({eq1,eq2,x(0)=1,y(0)=0},{x(t),y(t)}) ;
8 0 p p
< 1 1 ( a ; d + %1) %3 a 1 ( a ; d + %1) %3 d ; 1 (a ; d + p%1) %3
: y( t ) = ; @ p ; p
2 2 %1 2 %1 2
p 1 (a ; d ; p%1) %2 d 1
p .
; 12 (a ; d ;p %1) %2 a + 2 p ; 12 (a ; d ; %1) %2A b;
%1 %1
p p 9
1 ( a ; d + %1) %3 1 ( a ; d ; %1) %2 =
x(t) = 2 p ;2 p ;
%1 %1
%1 := a2 ; 2 a d +p d2 + 4 c b
%2 := e(1 2( + ; %1) )p
= a d t

%3 := e((1 2 +1 2 +1 2 %1) )
= a = d = t

Méthode série :
> Order:=4; dsolve({eq1,eq2},{x(t),y(t)}, type=series) ;
Order := 4
fx(t) = x(0) + (a x(0) + b y(0)) t + ( 12 a2 x(0) + 12 a b y(0) + 21 b c x(0) + 12 b d y(0)) t2 + (
1 a3 x(0) + 1 a2 b y(0) + 1 a b c x(0) + 1 a b d y(0) + 1 c b2 y(0) + 1 b d c x(0)
6 6 3 6 6 6
1
+ 6 b d2 y(0))t3 + O(t4 ); y(t) = y(0) + (c x(0) + d y(0)) t+
( 12 c a x(0) + 21 c b y(0) + 12 d c x(0) + 12 d2 y(0)) t2 + ( 16 c a2 x(0) + 61 c a b y(0)
+ 16 b c2 x(0) + 13 c b d y(0) + 61 d c a x(0) + 16 d2 c x(0) + 16 d3 y(0))t3 + O(t4 )g
Equations non linéaires :
> eq3:=diff(x(t),t)=x(t)^2+2*y(t) ;
eq3 := @
@t
x(t) = x(t)2 + 2 y(t)
> eq4:=diff(y(t),t)=x(t)*y(t) ;
eq4 := @
@t
y(t) = x(t) y(t)

35
 > dsolve({eq3,eq4},{x(t),y(t)}) ;

[fx(t) = ;2 t + C2 1 12
; C1 + t2 + 2 t C2 + C2 2 g; fy(t) = 2 ( x(t)) ; 2 x(t) g]
@
@t

> eq5:=diff(y(t),t)=x(t)*y(t)^2 ;
eq5 := @
@t
y(t) = x(t) y(t)2
> dsolve({eq3,eq5},{x(t),y(t)}) ;
2( Z Z RootOf(;e Z a 2 ; 4 C1 + 4 Ei(1; ; Z )) !)
4 x(t) = RootOf ; d a + t + C2 ;
4 + RootOf(;e Z a 2 ; 4 C1 + 4 Ei(1; ; Z )) a 2
3
1 1
fy(t) = 2 ( x(t)) ; 2 x(t)2g5
@
@t

En rajoutant des conditions initiales et la liste des procédures, on obtient :

> ff:=dsolve({eq3,eq5,x(0)=1,y(0)=1},{x(t),y(t)},
> type=numeric,output=listprocedure) ;

 := [t = (proc(t) : : : end proc); x(t) = (proc(t) : : : end proc );

y(t) = (proc(t) : : : end proc)]
> fx:=subs(ff,x(t)) ;
fx := proc(t) : : : end proc
> fy:=subs(ff,y(t)) ;
fy := proc(t) : : : end proc
> fx(0.0) ; fy(0.0) ;
> fx(1.0) ; fy(1.0) ;
1:
1:
Error, (in fx) cannot evaluate the solution further right of
.43053336, probably a singularity

Error, (in fy) cannot evaluate the solution further right of .43053336
> odeplot(ff,t=0..0.5) ; # cf. Figure 4
Warning, cannot compute solution further right of
.43053336275796050028
Le graphique apparaît dans la feuille de calcul, pour le faire apparaître dans
une fenêtre, il faut passer par la commande interface (sur unix mettre plot-
device=X11). Tous les graphiques sont mis dans une fenêtre à part, chaque
graphique étant dans sa propre fenêtre.

9 Graphiques
> f:=-(x+2*y+1)^4-(x+3*y-3)^2 ;

36
 Figure 4: Plot t

12

10

8
x
6

0 0.1 0.2 0.3 0.4

t

f := ;(x + 2 y + 1)4 ; (x + 3 y ; 3)2

> plot3d(f,x=-2..2,y=-2..2,axes=boxed) ; # cf. Figure 5
Dans une fenêtre graphique le menu contextuel du bouton droit de la sou-
ris est utilisable. Par exemple, une option des styles patches et contours fait
apparaître les lignes de niveaux.
> ?plot[options] : # accès aux options
La commande suivante permet de dessiner le gradient de la fonction.
> animate propose de superposer les graphiques sous la forme d'une animation.
> gradplot(f,x=-2..2,y=-2..2,grid=[10,10],arrows=SLIM) ;

gradplot(;(x + 2 y + 1)4 ; (x + 3 y ; 3)2; x = ;2::2; y = ;2::2; grid = [10; 10];

arrows = SLIM )
> implicitplot(f=-10,x=-2..2,y=-2..2,grid=[50,50]) ;

37
 Figure 5: Plot 3d

0
–500
–1000
–1500
–2000

–2 –2
–1 –1
0 0
y 1 1 x
2 2

implicitplot(;(x + 2 y + 1)4 ; (x + 3 y ; 3)2 = ;10; x = ;2::2; y = ;2::2; grid = [50; 50])

Par défaut la précision de lissage est donnée par le paramètre grid=[25,25].
Il faut veiller à choisir les bonnes dimensions du graphique.
> f:=x*x+cos(x)-x*y^3 ;
f := x2 + cos(x) ; x y3
> plot(f,x=-1..1,y=-10..10) ; # utiliser plot3d

Plotting error, empty plot

38
10 Programmation
10.1 Tests et conditions
> if a=1 then
> a*a
> else
> a-1
> fi ;
a;1
> if a=1 then
> b:=a*a
> elif a=2 then
> b:=a
> else
> b:= a-1
> fi ;
b := a ; 1
> if a=1 then
> a*a
> else
> if b=1 then
> b:=0
> fi
> fi ;
10.2 Boucles
> s:='s' : n:=10 ; s:=0 ;
> for i from 1 to n
> do s:= s+ i*i
> od:
n := 10
s := 0
> s;
385
> s:='s' : # récursif
> for i from 1 to n
> do s:= s+ i*i
> od ;
s := s + 4
Error, too many levels of recursion
Construction d'une récurrence :
> for i from 1 to n
> do v[i]:=v[i-1]+ i*i
> od ;
v1 := v0 + 1

39
 v2 := v0 + 5
v3 := v0 + 14
v4 := v0 + 30
v5 := v0 + 55
v6 := v0 + 91
v7 := v0 + 140
v8 := v0 + 204
v9 := v0 + 285
v10 := v0 + 385
> op(v) ;

table([1 = v0 + 1; 2 = v0 + 5; 3 = v0 + 14; 4 = v0 + 30; 5 = v0 + 55; 6 = v0 + 91; 7 = v0 + 140;

8 = v0 + 204; 9 = v0 + 285;
10 = v0 + 385
])
> sum(j*j,j=1..N) ;
1 (N + 1)3 ; 1 (N + 1)2 + 1 N + 1
3 2 6 6
> factor(sum(j*j,j=1..N)) ;
1 N (N + 1) (2 N + 1)
6
La boucle descendante présentera un incrément négatif. Une boucle s'incrémente
tant que c'est inférieur à la borne (ou supérieur si c'est une boucle descen-
dante).
> for i from 1 to 9 by 2
> do v[i]:=v[i-1]+i^3;
> od ;
v1 := v0 + 1
v3 := v0 + 32
v5 := v0 + 155
v7 := v0 + 434
v9 := v0 + 933
> for i in [4, 7, 12] do toto[i]:=i*i od ;
toto 4 := 16
toto 7 := 49
toto 12 := 144
> a:='a' : b:='b' : # réinitialisation
> l:=[a,b,c] ;# quelle que soit la liste, ensemble, etc.
> for i in l do l2:=[op(l2),i*i] od ; # initialisation d'une liste
vide
l := [a; b; c]

40
 l2 := []
l2 := [a2]
l2 := [a2 ; b2]
l2 := [a2; b2; c2]
> [seq(l[i]^2,i=1..nops(l))] ;
[a2; b2; c2]
La fonction nops correspond au nombre d'éléments de la liste.
> for i in l
> do l2:=[op(l2),i^2] # concaténation par ajout à l'existant
> od ;
l2 := [a2; b2; c2 ; a2 ]
l2 := [a2; b2; c2; a2 ; b2 ]
l2 := [a2; b2; c2 ; a2 ; b2; c2]
Boucle tant que :
> s:=1 ;
> while s<2000
> do s:=2*s
> od ;
s := 1
s := 2
s := 4
s := 8
s := 16
s := 32
s := 64
s := 128
s := 256
s := 512
s := 1024
s := 2048
10.3 Procédures
Une procédure est une suite d'instructions partagées que l'on peut appeler
ensuite.

41
> # la fonction carre calcule le carre d'un nb
> carre:=proc(x)
> local x2; # variable locale
> x2:=x*x;
> RETURN(x2); # par défaut retourne le dernier résultat
> end;
carre := proc(x) local x2 ; x2 := x2 ; RETURN(x2 ) end proc
> carre(3) ;
9
> carre(3,4) ; # prend le 1er argument
9
> carre(truc) ;
truc 2
> racine:=proc(x)
> if (x>=0) then
> RETURN(sqrt(x)) ;
> else
> RETURN(Impossible !) ;
> fi;
> end ;

racine := proc(x)
if 0  x then RETURN(sqrt(x)) else RETURN(Impossible!) end if
end proc
> racine(4) ;
2
> racine(-3) ;
Impossible!
> racine(sophie) ; # ne sait pas évaluer sophie

Error, (in racine) cannot evaluate boolean: -sophie <= 0

sqrt(-3) ;
p
>

I 3
> racine:=proc(x::numeric) # paramètre
> de type connu par maple
> if (x>=0) then
> RETURN(sqrt(x))
> else
> RETURN("Impossible!")
> fi;
> end ;

42
 racine := proc(x: : numeric )
if 0  x then RETURN(sqrt(x)) else RETURN( Impossible! ) end if
end proc
> racine(ab) ;

Error, invalid input: racine expects its 1st argument, x, to be of

type numeric, but received ab
> racine(carre(4,6)) ; # prend le 1er argument
4

11 Fichiers, entrées/sorties, sauvegardes

11.1 Sauvegarde des instructions
La sauvegarde d'une session correspond à la sauvegarde des instructions. La
feuille de calcul Maple est sauvegardée avec les instructions et leurs résultats.
La fonction save permet de sauvegarder des instructions telles on les taperait
en tant qu'instructions Maple. Le chier est éditable dans un éditeur (Notepad,
Emacs) et chargeable dans Maple par le menu File> Open.
> M:=matrix(2,2,[0$4]) :
> save M,"C:toto.dat" ;
read "c:toto.dat" ; # rapelle et exécute les instructions
" #
>

M := 00 00
toto.dat contient les informations suivantes :

M : = array(1.. 2, 1 .. 2,[(1, 1)=0,(1, 2)=0,(2, 1)=0,(2, 2)=0]);

11.2 Utilisation des procédures dans un chier externe

Le chier ascii peut contenir la procédure maxvp qui recherche le maximum
des valeurs propres d'une matrice.

43
 maxvp : =proc(M: : matrix)
local ev, mx ;
ev : = eigenvals(M) ;
mx : = max(ev) ;
RETURN(ev,mx);
end;
> read "C:toto.dat" :
> debug(maxvp) ; #mode debugage d'une procédure
Le principe est de mettre les procédures dans un chier. Le restart réinitialise
et se débarasse du contexte précédent.
> restart ; # remise à zéro
On peut sauvegarder une procédure comme tout autre objet dans un chier,
sans mise en forme.
> save carre, "carre.txt" ;

carre : = proc (x, y) local x2, y2; x2: =x^2; y2 : = y^3; RETURN(x2,"et",y2)
end proc;

Un chier de commandes peut contenir de nombreuses instructions :

44
 # mon chier de commandes progmp.txt with(linalg);
# proc carre
carre: =proc(x,y)
local x2,y2;
x2: =x*x;
y2: =y*y*y;
RETURN(x2,"et",y2)
end;
# proc calcul...
maxvp: =proc(M: : matrix)
local ev, mx, vabs ;
ev : = eigenvals(M) ;
vabs : = seq(abs(vabs[i]),i=1..nops(vabs));
mx : = max(ev) ;
RETURN(mx);
end;

11.3 Communication
11.3.1 Fichier texte
Menu File> Save as Text
Ensuite on peut copier depuis un éditeur puis coller dans Maple as Maple Text
11.3.2 Sélection
Menu Exporter pose le problème de tout exporter : il faut faire le ménage
ensuite.
11.3.3 Feuille de calcul
L'exportation au format TeX de la feuille de calcul produit un chier TeX
autonome très utile pour retravailler le texte. Il est nécessaire d'avoir récupéré
le package maple2e.
11.3.4 Format HTML
Il est possible de fabriquer du HTML standard avec des chiers GIF intégrés.
A l'avenir, mathML permettra de représenter des formules.

45
11.3.5 Graphiques
Il est préférable de passer par le menu contextuel car le menu Export ne
s'applique pas toujours à l'ensemble souhaité.
> interface(plotdevice=inline) ; # retour à la feuille
Les exportations de graphiques peuvent se faire aux diérents formats reconnus
(GIF, JPG, EPS, WMF).
11.3.6 Postscript
Pour exporter la feuille en postscript, Maple ne le fait pas tout seul, il faut
passer par l'impression dans un chier à l'aide d'un driver d'imprimante Post-
script (rappelons que lorsqu'on imprime, on peut imprimer sur une feuille ou
dans un chier ! ), puis éditer avec un éditeur de chiers postscript, tel que
GhostView et sélectionner les pages intéressantes.
Entre collaborateurs, la communication peut se faire à l'aide de chiers post-
script.
11.4 Fonctions d'édition de la feuille de calcul
Nous mentionnons ici les principales fonctionnalités.
Menu > Insert > Execution Group > Before ou After
permet de créer un groupe de commandes. Le système présente une barre de
modication avec validation par exemple.
Les fenêtres d'aide ont été faites avec des instructions et des commentaires.
Menu > Insert > Section ou Subsection.
Le bloc peut être indenté ou outdenté par Menu > Format.
Les blocs d'exécution peuvent être fusionnés ou cassés par Menu > Edit >
Split ou Join.

46
Index
:,4 exp, 21
: =, 4 expand, 16
;,4 exporter, 45
>, 3
?,3 factor, 19
#, 4 chiers, 43
$, 12 for, 39
&*, 22 formats, 46
fsolve, 28
aide, 3
anames, 9 gif, 45
array, 11 html, 45
boucle, 39, 41 if, 39
charpoly, 13, 25 implicitplot, 37
coe, 16 indices, 11
coes, 16 int, 17
coldim, 27 intersect, 9
collect, 16 limit, 21
convert, 14 linalg, 13, 22
debug, 44 linsolve, 24
degree, 16 liste, 9, 41
denom, 20 listlist, 15
det, 22 listprocedure, 36
diag, 26 map, 23
di, 15 maple2e, 45
Digits, 6 matrice, 13
display, 34 maximize, 28
dsolve, 30 multiply, 22
édition, 46 nops, 41
eigenvals, 25 numer, 20
eigenvects, 25
ensemble, 9 odeplot, 36
entries, 11 op, 10, 11
evalc, 19 opérateurs arithmétiques, 5
evalf, 6 opérateurs logiques, 5
evalm, 22 order, 35

47
Order, 31
pdesolve, 30
pdsolve, 30
plot, 28
plot3d, 37
plots, 33
postscript, 46
procedure, 41
product, 27
prompt, 3
read, 43
restart, 44
return, 42
rowdim, 27
sauvegarde, 43, 45
save, 43
seq, 10
series, 21
simplify, 6
solve, 6
sort, 16
sqrt, 18
subs, 8
sum, 26, 40
table, 10
tableau indicé, 10
taylor, 20
test, 39
transpose, 24
type, 14
type numeric, 42
unassign, 4
union, 9
variable locale, 42
whattype, 14
while, 41
with, 13, 33

48
Liste des gures
1 Plot z . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
2 Plot 1 seule courbe . . . . . . . . . . . . . . . . . . . . . . . . . 33
3 Plot plusieurs courbes . . . . . . . . . . . . . . . . . . . . . . . 34
4 Plot t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5 Plot 3d . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Références
[1] C. Gomez. Notes de cours Maple. Institut National de la Recherche en
Informatique et Automatique, 2001.
[2] Y. Mourrain, B. Papegay. Notes de cours Maple. Institut National de la
Recherche en Informatique et Automatique, 2001.
[3] Waterloo. Maple 7. Waterloo Maple, 2002.

49