Introduction `a Maple - Des Mathématiques à Nantes

Introduction à Maple
UE4 Master Recherche Mathématiques
Jean-Pol Guillement
Département de Mathématiques
Nantes 2009/2010
2
Table des matières
Introduction
5
1 Prise de contact
1.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2 Exemples de commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
7
7
7
2 Environnement : relation avec le système
2.1 Personnalisation du système . . . . . . . .
2.2 Chargement d’un fichier . . . . . . . . . .
2.3 Commandes système . . . . . . . . . . . .
2.4 Historique des commandes . . . . . . . . .
2.5 Chargement des bibliothèques . . . . . . .
2.6 Visualisation du code d’une fonction . . .
2.7 Exécution en mode batch . . . . . . . . .
2.8 Débugage . . . . . . . . . . . . . . . . . .
2.9 Aide en ligne . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
21
21
21
22
22
22
22
22
22
23
.
.
.
.
.
.
25
25
25
26
26
26
26
.
.
.
.
.
.
.
.
.
.
.
.
29
29
29
29
30
31
32
32
32
32
32
33
33
expressions booléennes
Le symbole ”=” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le prédicat ”=” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Le prédicat ”<” . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
35
35
35
35
3 Éléments complémentaires de syntaxe
3.1 Les branchements conditionnels . . . .
3.1.1 Le si . . . . . . . . . . . . . . .
3.1.2 Le choix multiple . . . . . . . .
3.2 Les répétitions . . . . . . . . . . . . .
3.2.1 La boucle pour . . . . . . . . .
3.2.2 La boucle tant que . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
d’exploitation
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
. . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
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éation explicite de structures composites
4.2 Manipulations des objets de base . . . . . . . . . .
4.2.1 Extraction . . . . . . . . . . . . . . . . . . .
4.2.2 Sélection . . . . . . . . . . . . . . . . . . .
4.2.3 Nombre d’éléments . . . . . . . . . . . . . .
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
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
TABLE DES MATIÈRES
6 Les évaluations
6.1 Règles d’évaluation . . . . . . . . . . . . . . . . . .
6.2 Illustration des règles . . . . . . . . . . . . . . . . .
6.2.1 Niveau d’évaluation et affectations . . . . .
6.2.2 Affectations . . . . . . . . . . . . . . . . . .
6.2.3 Quotage . . . . . . . . . . . . . . . . . . . .
6.2.4 Quelques différences difficilement prévisibles
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
37
37
37
37
39
39
40
7 Les
7.1
7.2
7.3
7.4
7.5
7.6
7.7
7.8
7.9
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
41
41
41
41
41
42
42
43
43
44
fonctions
Définition des fonctions . . . . . . . .
Comment voir le contenu des fonctions
Fonctions anonymes . . . . . . . . . .
Variables locales, variables globales . .
Valeur retournée . . . . . . . . . . . .
Options . . . . . . . . . . . . . . . . .
Contrôle des paramètres . . . . . . . .
Passage des paramètres . . . . . . . .
Fonctions locales . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
8 Les modules
47
9 Les entrées-sorties
9.1 Les fonctions d’entrée-sortie . . . .
9.1.1 Fonctions de lecture . . . .
9.1.2 Analyse d’une chaı̂ne . . . .
9.1.3 Fonctions d’écriture . . . .
9.2 Les redirections . . . . . . . . . . .
9.3 Lecture de données dans un fichier
9.4 Écriture de données dans un fichier
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
49
49
49
49
49
49
50
50
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éécriture . . . . . . . . . . . . . .
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 . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
53
53
53
54
54
55
55
55
56
56
57
57
57
57
58
59
59
59
60
Bibliographie
61
Index
65
Introduction
Maple est avant tout un logiciel de calcul formel, symbolique, c’est-à-dire qui travaille sur les expressions à la différence du calcul numérique qui calcule sur les nombres. Il intègre des possibilités de
calcul numérique qui sont au fil des nouvelles versions de plus en plus performantes. Mais le calcul
numérique n’est pas son objectif.
Maple est un logiciel généraliste qui convient très bien par exemple pour les calculs usuels genre
Terminale-Deug. Il touche à toutes les branches des mathématiques sur lesquelles on peut calculer. Il
n’est pas spécialisé et de ce fait, ne prétend pas rivaliser avec les logiciels spécifiques comme :
- Matlab pour le numérique,
- pari, (Mathematica ?), ... pour l’algèbre.
C’est de très loin le logiciel le plus utilisé (5 millions de licences en 2003). Il est commercialisé par la
société Maplesoft qui a pratiqué une politique commerciale astucieuse.
Quelques dates :
1960 Les premiers logiciels de calcul formel, Macsyma, Reduce, à base de Lisp, nécessitent de gros
ordinateurs et offrent des possibilités limitées.
1980 Projet d’écrire d’un logiciel qui puisse tourner sur des machines plus modestes (anticipation de
l’émergence des ordinateurs individuels) : petit programme, efficace, noyau réduit, écrit en C.
1983 1er cours avec Maple, 1ers articles, 50 installations dans le monde.
1984 Contrat avec la société Watcom pour la commercialisation.
1985 Début de la commercialisation.
1987 300 installations.
1987 Contrat avec la société Waterloo Maple Software (Université de Waterloo).
1988 2000 installations.
2003 Société Maplesoft, 5 millions de licences.
Il y a différents niveaux d’utilisation de Maple :
- Le mode commande réduit aux fonctions les plus basiques comme
- plot,
- int,
- diff ...
Ce type d’utilisation ne nécessite pas de suivre un cours. Il y a de nombreux tutoriels bien faits
sur le Web. Par exemple [13].
- Le mode commande avec résolution
- d’équations générales,
- de systèmes linéaires,
- d’équations différentielles.
Ce niveau d’utilisation nécessite de connaı̂tre les structures de base de Maple.
- Le mode de programmation qui permet par exemple la résolution de problèmes du genre TerminaleDeug. Il faut savoir enchaı̂ner les calculs, faire passer les résultats d’une commande à une autre,
utiliser des fonctions.
6
Introduction
- La programmation de méthodes de calcul formel, c’est-à-dire l’enrichissement du système.
Avant d’étudier Maple il est nécessaire de bien faire la distinction entre les 4 types de calcul mathématique :
- Le calcul mathématique habituel, sur feuille de papier, celui auquel on est le plus habitué, difficile
à définir, tout le monde voit de quoi on parle.
- Le calcul numérique (scientifique). C’est l’art de réduire les calculs à un nombre fini d’opérations
arithmétiques élémentaires portant sur des nombres représentés par un ensemble fini de symboles (les chiffres). Le calcul numérique fait nécessairement apparaı̂tre deux types d’approximation et d’erreur : l’approximation des nombres par les flottants, (Pi, 1/10 en base 2, ...) et la
discrétisation incontournable. On met en œuvre les calculs numériques à l’aide des langages de
programmation comme le Fortran, le C, le Pascal, ... et aussi à l’aide de logiciels numériques
comme Matlab.
- Le calcul formel qui opère sur les expressions mathématiques, mécaniquement, automatiquement,
par programmation. √
Par exemple le calcul de l’intégrale de exp(−x2 ) sur ]−∞, ∞[ peut se réaliser
de façon formelle (= π) et de façon numérique, approchée, (≈ 1.772453851). La même intégrale,
mais sur [0..1] ne peut se calculer de façon formelle, sauf en répondant à l’aide d’une fonction
spéciale c’est-à-dire en retournant la question posée.
- Le calcul analogique comme par exemple celui que l’on peut faire avec une règle à calcul.
Comme nous l’avons déjà noté, Maple est conçu pour le calcul formel, même s’il intègre de plus en
plus, (pour des nécessités commerciales sans doutes), de bons outils permettant le calcul numérique.
Pour ma part, je constate qu’il n’est pas du tout approprié aux calculs volumineux qui caractérisent la
plupart des calculs scientifiques. Par ailleurs il n’est pas très facile de savoir lui imposer une démarche
complètement numérique et il n’est pas facile de savoir quand il travaille en formel et quand il abandonne le formel pour s’orienter vers le numérique.
Chapitre 1
Prise de contact
1.1
Généralités
Maple est un interprète en attente d’une expression à évaluer (ou d’une instruction à exécuter). L’attente est signalée par un prompt, ”>”. On appelle Toplevel cet état.
Le ” ;” et le ” :” marquent la fin de l’expression à évaluer. (Le ”Return” est ignoré, ce n’est pas une
marque de fin d’expression).
Les expressions à évaluer sont des symboles, des expressions mathématiques ”correctement parenthèses”.
(Une définition précise ne peut être donnée sans recours à la grammaire sous-jacente à Maple).
Si l’expression est terminée par ” ;”, Maple affiche à l’écran la représentation de la valeur du dernier
résultat. Ce n’est pas le cas quand l’expression est terminée par ” :”.
On ferme le logiciel avec ”quit”.
On peut travailler en mode Texte interactif ou batch, et en mode Graphique interactif (sous Unix
commande maple -x ou xmaple).
Note : Il y a des différences entre les versions. En 2007 c’est la version 11 qui est commercialisée. En
gros, les versions 2 et 3 assez semblables diffèrent de la version 4. Les versions 6 . . . 11 respectent la
même syntaxe, très voisine de celle de la version 5.
1.2
Exemples de commandes
|\^/|
._|\|
|/|_.
\ MAPLE /
<____ ____>
|
Maple 9 (IBM INTEL LINUX)
Copyright (c) Maplesoft, a division of Waterloo Maple Inc. 2003
All rights reserved. Maple is a trademark of
Waterloo Maple Inc.
Type ? for help.
true
# Debut avec maple
# Sept 2000, J-P Guillement
>
> printf("\tExecute sur %s\tle %s\n",ssystem("hostname")[2],ssystem("date")[2]);
Execute sur Quad
le Wed Sep 12 09:58:55 CEST 2007
>
#
#
#
>
#
#
#
pour demarrer maple en mode texte interactif sur unix
taper "maple" sur la ligne de commande.
pour quitter maple taper "quit"
pour evaluer entierement ce texte en mode interactif taper (sous maple)
read("nomdufichier");
et taper RETURN apres chaque message RETURN
8
Prise de contact
>
# pour evaluer la totalite du fichier en mode batch sous Unix
#
maple [-exec] nomdufichier
# ou
maple [-exec] nomdufichier > resultats
# ou
maple < nomdufichier > resultats
# (sous Windows, utiliser la comande "cmaple").
>
# pour avoir de l’aide sur l’aide taper "??"
# pour avoir de l’aide sur la commande solve par exemple
# en Version 3 et Version 6 taper "?so". En Version 4 taper "?solve"
# En Version 4, pour avoir la liste des fonctions disponibles
# taper "?index[function]"
#
>
# Pour reprendre des calculs, utiliser parfois x:=’x’:
# ou evaln(x) ou unassign(’x’) pour faire un nettoyage
>
#################################################
#
Prise de contact avec Maple
#
#################################################
> 5;
5
> 2+5*3;
17
> sin(0);
0
> print(x);
x
> x:=2;
x := 2
> x;
2
> print(x);
2
> y:=x;
y := 2
> y;
2
> toto;
toto
> toto:=y;
toto := 2
> toto;
2
> y:="bonjour";
y := "bonjour"
1.2 Exemples de commandes
9
> toto;
2
>
> sin(1);
sin(1)
> evalf(sin(1));
0.8414709848
> evalf(sin(1),30);
0.841470984807896506652502321630
> sin(1.0);
0.8414709848
> evalf(sin(1.0));
0.8414709848
> evalhf(sin(1.0));
0.841470984807896505
> evalhf(sin(1));
0.841470984807896505
> tmp:=Digits;
tmp := 10
> Digits:=50;
Digits := 50
> evalf(4*arctan(1));
3.1415926535897932384626433832795028841971693993751
> Digits:=tmp;
Digits := 10
>
# petite programmation de fonction
# selon version,
V3 = true or false
> V3:=evalb(SearchText("3",interface(version),15..20) > 0);
V3 := true
# ou V3:= evalb(evalf(E-exp(1)) =0);
> V5:=evalb(SearchText("5",interface(version),15..20) > 0);
V5 := false
> V6:=evalb(SearchText("6",interface(version),15..20) > 0);
V6 := false
> V7:=evalb(SearchText("7",interface(version),15..20) > 0);
V7 := false
> V5:= V5 or V6 or V7;
V5 := false
> if (V3) then
>
ret := ()-> readline(terminal):
>
elif (V5) then
10
Prise de contact
>
ret:=proc() printf("\n");readline(default):end;
>
else
>
ret := readline:
>
fi:
>
# Mathematiques
> printf("Maintenant Arithmetique et Calcul polynomial, RETURN ");
Maintenant Arithmetique et Calcul polynomial, RETURN > ret():
> ifactor(100);
2
(2)
2
(5)
> isprime(101);
true
> 1/3 mod 7;
5
>
> factor(x^5+1);
33
> x:=’x’;
x := x
> factor(x^5+1);
4
3
2
(x + 1) (x - x + x - x + 1)
> p:=1+expand((x-1)*(x-3)*(x-5));
3
2
p := -14 + x - 9 x + 23 x
> s:=solve(p=1,x);
s := 1, 3, 5
#
s := 1, 3, 5
> s[2];
# l’ordre peut varier
3
> y:=’y’;
y := y
> solve({x+y=2,x-y=1});
{y = 1/2, x = 3/2}
> x;
x
> assign(%%);
> x;
3/2
# trigonometrie
> printf("Maintenant trigonometrie, RETURN ");
Maintenant trigonometrie, RETURN > ret():
> x:=’x’;
1.2 Exemples de commandes
11
x := x
> cos(x)^2+sin(x)^2;
2
cos(x)
2
+ sin(x)
> simplify(cos(x)^2+sin(x)^2);
1
> combine(cos(x)^2+sin(x)^2,trig);
1
> e:=expand(cos(5*x));
5
e := 16 cos(x)
3
- 20 cos(x)
+ 5 cos(x)
> combine(e,trig);
cos(5 x)
> sin(n*Pi);
sin(n Pi)
> assume(n,integer); sin(n*Pi);
0
#
0 en version 4 et sin(n~ Pi) en version 3
#
> solve(sin(x),x);
0
> _EnvAllSolutions := true: solve(sin(x));
Pi _Z1~
# attention retourne 0 en version 3 si la requete solve(sin(x));
# a ete faite prealablement a l’affectation de _EnvAllSolutions !
>
# algebre lineaire
> with(linalg):
# noter le : pour discretion
Warning, the protected names norm and trace have been redefined and unprotected
> printf("Maintenant algebre lineaire, RETURN ");
Maintenant algebre lineaire, RETURN > ret():
# petit calculs sur les matrices de Hilbert
> h4:=matrix(4,4,[seq(seq(1/(i+j),i=1..4),j=1..4)]);
[1/2
1/3
1/4
1/5]
[
]
[1/3
1/4
1/5
1/6]
h4 := [
]
[1/4
1/5
1/6
1/7]
[
]
[1/5
1/6
1/7
1/8]
> det(h4); evalf(%);
1/423360000
-8
0.2362055933 10
> h:=n->matrix(n,n,[seq(seq(1/(i+j),i=1..n),j=1..n)]):
12
Prise de contact
> deth:=n->det(h(n));
deth := n -> det(h(n))
> d6:=deth(6);
d6 := 1/172153600393420800000
> h6:=h(6):
> norm(h6);
223
--140
> n2:=norm(h6,2);
1/2
6
5
n2 := 1/210 5
RootOf(62953620111360000 _Z - 700749536346021888000 _Z
4
+ 62512217960687222169600 _Z
3
- 14491862768764210106880 _Z
2
1/2
+ 3301345200565172560 _Z - 236492379085 _Z + 1, index = 6)
> n2f:=evalf(n2);
n2f := 1.118858688
> p:=charpoly(h6 &* h6,x):
> p:=p/subs(x=0,p);
6
p := 29636862128417614224539925872640000000000 x
5
- 37402940357699778471770869963161600000000 x
4
+ 378302532523400164964886734340096000000 x
3
2
- 9943286845929810115968744099840000 x + 256819566380446129856544000 x
- 2085862783529700 x + 1
> vph6h6:=eigenvals(h6 &* h6);
vph6h6 := 1/8820 RootOf(%1, index = 1), 1/8820 RootOf(%1, index = 2),
1/8820 RootOf(%1, index = 3), 1/8820 RootOf(%1, index = 4),
1/8820 RootOf(%1, index = 5), 1/8820 RootOf(%1, index = 6)
6
%1 := 62953620111360000 _Z
5
- 700749536346021888000 _Z
4
+ 62512217960687222169600 _Z
3
- 14491862768764210106880 _Z
2
+ 3301345200565172560 _Z - 236492379085 _Z + 1
>
> norm(h6,infinity);
1.2 Exemples de commandes
13
223
--140
> cond(h6);
91073646
> vp:=evalf(Eigenvals(h6));
[
-7
-5
vp := [0.2203114976 10 , 0.2850438197 10 , 0.0001607660527, 0.005130954614,
]
0.1008467195, 1.118858688]
> printf("det h%a = %a, prod vp = %a\n",6,evalf(d6),‘*‘(op(convert(vp,list))));
det h6 = .5808766112e-20, prod vp = .5844916720e-20
> printf("norme2 h%a = %a, plus gde vp = %a\n\n\n",6,n2f,max(op(convert(vp,list))));
norme2 h6 = 1.118858688, plus gde vp = 1.118858688
#
# calcul diff et integral
> printf("Maintenant calcul diff, RETURN ");
Maintenant calcul diff, RETURN > ret():
> diff(exp(cos(x)),x);
-sin(x) exp(cos(x))
> subs(x=0,%); simplify(%);
-sin(0) exp(cos(0))
0
> diff(sin(x),x,x); diff(sin(x),x$2);D(sin);(D@@3)(sin);
-sin(x)
-sin(x)
cos
-cos
> taylor(exp(cos(x)), x=0, 4 );
2
4
exp(1) - 1/2 exp(1) x + O(x )
> int(x^2,x=0..1);
1/3
> int(x*exp(x),x);
x exp(x) - exp(x)
> fx:=sin(x)/x;
sin(x)
fx := -----x
>
> int(fx,x=0..infinity);
14
Prise de contact
Pi
---2
> y:=’y’;
y := y
> int(int(exp(-x^2-2*y^2-3*y),x=-infinity..infinity),y=-infinity..infinity);
1/2
1/2 exp(9/8) Pi 2
#
> n:=’n’: e2:=sum(k^2,k=1..n);
3
2
(n + 1)
(n + 1)
e2 := -------- - -------- + n/6 + 1/6
3
2
> factor(e2);
n (n + 1) (2 n + 1)
------------------6
> s:=Sum(a(n)*sin(n*x),n=0..infinity);
infinity
----\
s :=
)
a(n) sin(n x)
/
----n = 0
> s0:=subs(x=0,s);
infinity
----\
s0 :=
)
a(n) sin(0)
/
----n = 0
> simplify(s0);
0
# avec versions précédentes simplify(s0); ->
#
infinity
#
----#
\
#
)
0
#
/
#
----#
n = 0
> evalf(s0);
0.
> value(s0);
0
>
1.2 Exemples de commandes
15
> pi2s6:=sum(1/k^2,k=1..infinity);
2
Pi
pi2s6 := --6
> k:=’k’:sn2:=sum(1/k^2,k=1..n);
2
Pi
sn2 := -Psi(1, n + 1) + --6
> asympt(sn2,n);
2
Pi
1
1
1
1
--- - 1/n + ---- - ---- + ----- + O(----)
6
2
3
5
6
2 n
6 n
30 n
n
>
> y:=’y’:
> s:=dsolve(diff(y(x),x$2) + y(x), y(x));
s := y(x) = _C1 sin(x) + _C2 cos(x)
# attention l’ordre de sin(x) et de cos(x) peut changer
#
> y(x);
y(x)
> assign(s);
> y(x);
_C1 sin(x) + _C2 cos(x)
> y(0);
y(0)
> simplify(y(0));
y(0)
> subs(x=0,y(x));
_C1 sin(0) + _C2 cos(0)
> simplify(%);
_C2
> coeff(y(x),sin(x));
_C1
> print(y);
proc() option remember; ’procname(args)’ end proc
> print(y(x));
_C1 sin(x) + _C2 cos(x)
> print(y(t));
y(t)
> whattype(y);
symbol
16
Prise de contact
> whattype(y(x));
+
> whattype(y(t));
function
> has(y(x),sin(x));
true
> select(has,y(x),sin(x));
_C1 sin(x)
>
>
>
>
# suites recurrentes
> printf("Maintenant suites recurrentes, RETURN ");
Maintenant suites recurrentes, RETURN > ret():
n:=’n’: p:=’p’: up:=rsolve(u(n+2)=u(n+1)+u(n),u(p));
> restart:
# rsolve est tres capricieux
> V3:= evalb(evalf(E-exp(1)) =0);
V3 := false
> n:=’n’: p:=’p’: up:=rsolve(u(n+2)=u(n+1)+u(n),u(p));
/
1/2
\p
1/2
1/2 | 5
|
up := (1/2 u(0) + 1/10 u(0) 5
- 1/5 u(1) 5
) |- ---- + 1/2|
\
2
/
/ 1/2
\p
1/2
1/2 |5
|
+ (1/2 u(0) - 1/10 u(0) 5
+ 1/5 u(1) 5
) |---- + 1/2|
\ 2
/
> u(0):=1: u(1):=1:
> u5:=subs(p=5,up);
/
1/2\
|
5
|
u5 := |1/2 - ----|
\
10 /
/
1/2
\5
/
1/2\
| 5
|
|
5
|
|- ---- + 1/2| + |1/2 + ----|
\
2
/
\
10 /
> evalf(u5);
7.999999983
> if (V3) then readlib(rationalize): fi:
> rationalize(u5);
8
>
> u:=n->u(n-1)+u(n-2):
# u(5);
#
Error, (in u) too many levels of recursion
> u(0):=1:u(1):=1: u(5);
8
>
> n:=’n’:u:=evaln(u);
/ 1/2
\5
|5
|
|---- + 1/2|
\ 2
/
1.2 Exemples de commandes
17
u := u
# pb avec version 7, reponse correcte apres restart ???
>
> rsolve(u(n)=2*u(n/2)+n,u(n));
n (u(1) ln(2) + ln(n))
---------------------ln(2)
>
# calcul sur les groupes
> printf("Maintenant calcul sur les groupes, RETURN ");
Maintenant calcul sur les groupes, RETURN > ret():
>
> with(group):
> g:=permgroup(5,{[[1,2]],[[1,2,3,4,5]]});
g := permgroup(5, {[[1, 2]], [[1, 2, 3, 4, 5]]})
> grouporder(g);
120
> isabelian(g);
false
>
>
>
# Transformation de Fourier
> printf("Maintenant transformation de Fourier, RETURN ");
Maintenant transformation de Fourier, RETURN > ret():
>
> if (V3) then readlib(fourier): else with(inttrans) fi:
>
> y:=’y’: fo:=fourier(exp(-Pi*t^2/2),t,y);
2
y
1/2
fo := exp(- ----) 2
2 Pi
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
18
Prise de contact
>
# plots
> printf("Maintenant dessins, RETURN ");
Maintenant dessins, RETURN > ret():
>
> plot(sin(x),x=-10..10);
AAA
1+
AAAA
AAA
A AA
+
AA A
AA AA
AA
A
+
A
A
AA
AA
A
A
+ AA
AA
A
A
A
A
+ A
A
AA
A
A
A
A
0.5+ AA
A
A
A
A
A
A
+ A
A
A
A
A
A
AA
+AA
A
A
A
A
A
A
+A
A
A
A
A
A
A
+A
A
AA
AA
++*++-++-++-++*++-++-++-++*++-++-++-+**+-++-++-++*++-++-++-++*++-++-++-++*++
AA
AA
A
*
A
A
A
-10 A -8
A-6
-4
A -2
*
2
A 4
6
8
10
A
A
A
A+
A
A
A
A
A
A
A+
A
AA
A
A
A
A
-0.5+
A
A
A
AA
AA
A
A +
A
A
A
A
AA
AA +
A
A
AA
AA
A
A +
A
AA
AA AA
A AA +
AA A
AAA
AAAA -1+
AAA
>
> plot(sin(x)+0.08*cos(40*x),x=-10..10);
AA
+
AAA
AAA
AAAA
1+
AAAA
AAAAA
AAA AA
+
AAAAAA
AA AA
AA
AA
+ AA
AA
AA
AA
AA
AA
+ AA
AA
AA
AA
A
A
AA
0.5+ A
AA
AA
AA
AA
AA
AA
+ A
AA
AA
AA
A
A
AA
+ A
A
AA
AA
AA
AA
A
+A
AA
A
A
A
AA
AA
*A
A
AA
A
++*++-++-++-++*++-++-++-+**++-++-++-+**+-++-++-++*++-++-++-++*++-++-++-++*++
AA
AA
A
*
AA
AA
A
-10AA -8
A-6
-4
A -2
A*
2
A 4
6A
8
10
A
A
A
A*
AA
AA
AA
A
AA
A
A+
A
A
AA
AA
A
A
-0.5+
AA
A
A
AA
A
AA
A +
AA
AA
AA
AA
A
AA +
AA
AA
AAA AA
AA AAA +
AAAAAAA
AAAAA
AAAAA-1+
AAAAA
AAA
AA
+
AAA
>
>
>
> with(plots):
Warning, the name changecoords has been redefined
1.2 Exemples de commandes
> plotsetup(ps,plotoutput=‘tore.ps‘):
> n:=10;
n := 10
> tubeplot({[10*cos(t),10*sin(t),0,
>
t=0..2*Pi,radius=2,numpoints=10*n,tubepoints=2*n],
>
[cos(t)*(10+4*sin(9*t)),sin(t)*(10+4*sin(9*t)),4*cos(9*t),
>
t=0..2*Pi,radius=1,numpoints=trunc(37.5*n),tubepoints=n]},
>
scaling = CONSTRAINED , orientation = [76,40]);
>
19
20
Prise de contact
Chapitre 2
Environnement : relation avec le
système d’exploitation
L’utilisation de Maple dépend de 3 choses :
- De l’interface choisie, Texte ou Graphique,
- Du système d’exploitation, Unix, Windows, Macintosh,
- De la version utilisée.
Les nouvelles versions de Maple offrent des possibilités importantes pour exporter les calculs, en
documents latex, html ...Ces possibilités nécessitent l’usage de Maple en mode Graphique et la création
de ce que Maple appelle feuilles de calcul. Il n’est pas question ici de regarder ces fonctionnalités. On
s’intéresse principalement au mode Texte, plus rustique, qui présente par ailleurs le grand avantage
d’être beaucoup plus portable.
Bien que générales, les explications qui suivent concernent le mode Texte sous Unix.
2.1
Personnalisation du système
Le fichier .mapleinit, s’il existe dans le répertoire personnel (home directory) est exécuté en début
de toute session Maple. On peut donc y mettre les instructions dont on souhaite systématiquement
l’exécution. Par exemple plotsetup(X11) ; kernelopts(printbytes=false) ;
2.2
Chargement d’un fichier
Il est fondamental de passer par l’intermédiaire de fichiers pour solliciter Maple. En mode Texte ces
fichiers sont des fichiers ordinaires (Texte, Ascii) que l’on écrit avec n’importe quel traitement de
texte (qui ne doit rien ajouter d’autre que ce que l’on a écrit). Ils contiennent des requêtes Maple,
complètement identiques à celles que l’on tape au Toplevel. Pour faire connaı̂tre leur contenu il faut
utiliser la commande read(). (Les copiés-collés ne peuvent être utilisés que pour quelques lignes).
La syntaxe d’utilisation de read est
read(nom_de_fichier);
nom de fichier est une chaı̂ne de caractère qui doit désigner correctement le fichier à solliciter, avec
chemin d’accès si nécessaire. En principe (version ≥ 4) les chaı̂nes de caractères sont à mettre entre
guillemets (”). Si nom de fichier ne contient pas de signe Maple (−, /, \, ..) les guillemets peuvent
être omis. On reviendra plus loin sur la façon dont Maple évalue les objets. Par exemple la commande
read("/tmp/prog1.txt");
demande à Maple d’ouvrir le fichier /tmp/prog1.txt et d’exécuter toutes les requêtes qui s’y trouvent,
exactement comme si elles étaient tapées au Toplevel.
Note : Les fichiers provenant des feuilles de calcul, (extension ”.mws”) ne peuvent pas être lues en mode
Texte. Il est nécessaire de passer en mode Graphique, et d’utiliser read ou le menu Fichier-Ouvrir.
22
Environnement : relation avec le système d’exploitation
2.3
Commandes système
Comme avec tous les langages et tous les interprètes, Maple offre la possibilité de lancer des commandes
systèmes depuis l’intérieur d’une session. Il y a pour cela la fonction system() et le macro caractère
” !”.
system("ls")
system("pwd")
!ne prog1.txt
2.4
# liste le répertoire courant
# affiche le nom du répertoire courant
# édite (si éditeur ne existe) prog1.txt
Historique des commandes
En mode Texte (pas en mode Graphique), on peut rééditer les commandes avec les flèches ↑ et ↓.
C’est très commode.
On peut aussi afficher les 3 derniers résultats avec
%;
%%;
%%%;
# dernier résultat
# avant dernier
# avant avant dernier
On peut aussi indexer les résultats en utilisant au préalable la fonction history() ;
2.5
Chargement des bibliothèques
Afin que le système démarre rapidement et n’occupe que peu de mémoire, Maple ne charge en début
de session, que le minimum, le noyau. De ce fait c’est à l’utilisateur de réclamer le chargement des
bibliothèques nécessaires. Il n’a pas à connaı̂tre leur localisation. Il y a deux fonctions de chargement,
with() et readlib().
with(linalg);
# charge toutes les fonctions
# de la bibliothèque d’algèbre
# linéaire linalg
readlib(ancienne_bibliotheque);
2.6
Visualisation du code d’une fonction
On dispose du code de toutes les fonctions des bibliothèques écrites en Maple. Ce n’est pas très facile,
mais c’est instructif de pouvoir les regarder.
interface(verboseproc=2);
print(sin);
# affiche le code de la fonction
# sinus
# ou
showstat(sin);
2.7
Exécution en mode batch
En dehors de Maple, sous le système d’exploitation, il est possible de lancer Maple pour l’exécution
d’un unique fichier. Et éventuellement de récupérer les résultats dans un autre fichier.
maple nom_de_fichier > fichier_resultats
2.8
Débugage
Rechercher les erreurs dans un programme est une chose courante. Ce n’est guère possible de programmer juste du premier coup. En général on ajoute des affichages supplémentaires pour contrôler les
calculs. Maple fournit diverses possibilités supplémentaires. La valeur de la variable printlevel peut
être modifiée. Plus la valeur est grande (7,15,255,..), plus Maple donne d’information sur les calculs
effectués et sur les paramètres passés aux différentes fonctions. Il y a aussi les fonctions trace() et
stopat() qui permettent le pas à pas. (Consulter l’aide en ligne).
2.9 Aide en ligne
2.9
Aide en ligne
L’aide en ligne est très complète et plutôt bien faite. La consultation est beaucoup plus commode
en mode Graphique grâce au système hypertexte. En mode Texte, on utilise le macro-caractère ” ?”
ou la fonction help(). L’aide est retournée par un affichage page par page (programme more très
archaı̈que). ”Return” fait avancer d’une ligne, ”espace” d’une page, ”q” fait sortir.
23
24
Environnement : relation avec le système d’exploitation
Chapitre 3
Éléments complémentaires de
syntaxe
Les requêtes Maple sont réalisées par l’intermédiaire d’un langage de programmation qui est un
mélange de langage fonctionnel et de langage procédural (impératif). Les requêtes sont aussi bien
des demandes d’évaluation de fonction (comme en Lisp) que des demandes d’exécution d’instruction.
On a déjà vu dans les chapitres précédents certain éléments de la syntaxe. Complétons par
3.1
3.1.1
Les branchements conditionnels
Le si
Le si peut être utilisé sous deux formes, instruction et fonction :
l’instruction if
Voici un exemple d’utilisation qui présente un certain mélange :
x:=1;
if (x=7) then
5;
else
print(10*x);
fi;
Exécutée au Toplevel, cette requête provoque l’affichage de ”10”, et retourne ce que la fonction print
retourne, c’est-à-dire NULL.
x:=7;
if (x=7) then
5;
else
print(5*x);
fi;
# -> 5
la fonction if
x:=1;
x:=7;
%;
x:=1;
y;
x:=9;
y;
‘if‘(x=7,5,55);
‘if‘(x=7,5,55);
# -> 55
# -> 5
# -> 5
y:=‘if‘(x=7,5,55);
y:=‘if‘(x=7,5,print(10*x));
# -> 55
# affiche 90
# -> suite vide (NULL)
26
Éléments complémentaires de syntaxe
3.1.2
Le choix multiple
x:=1;
if (x=7) then 100;
elif (x=8) then 200;
else 300;
fi;
3.2
Les répétitions
3.2.1
La boucle pour
# -> 300
Il y a plusieurs façon de faire circuler les indices :
la forme courante
for i from 1 to 10 do
print(10*i);
od;
%;
s:=0;
for i from 1 to 3 do
s:=s+i^2;
od;
# parcours d’une suite d’indices
# affiche les nombres 10,20,..
# -> true (résultat déroutant)
%,s,i;
# au Toplevel affiche les valeurs
# intermédiaires de s
# -> 14,14,4
# calcul équivalent
s:=add(i^2,i=1..3);s;
# -> 14
parcours des éléments d’une structure
l:=[3,2,1];
s:=0;
for i in l do
s:=s+i^2;
od;
%,s,i;
q:=sin(x)+2*x*y*ln(x+y);
for u in q do
print(u);
od;
# -> 14,14,1
#
#
#
#
affiche sin(x) et 2 x y ln(x + y)
qui correspondent aux fils de
niveau 1 de l’arbre syntaxique
de l’expression q
Note : il n’y a pas de forme fonctionnelle pour for.
3.2.2
La boucle tant que
while seul
i:=1;
while (i<10) do
print(i);
i:=i+1;
od;
# affiche 1,2,..
3.2 Les répétitions
27
en association avec for
l:=[3,2,1,100];
for i in l while (i^2 > 1) do
print(i);
od;
# affiche 3,2
28
Éléments complémentaires de syntaxe
Chapitre 4
Les structures de base
4.1
Les objets Maple
C’est un peu confus (pour moi). D’une certaine manière l’utilisateur ne voit pas les structures informatiques. Il y a mélange entre structures informatiques et mathématiques.
4.1.1
Les objets atomiques
(ou scalaires). On peut distinguer
- les symboles (ex toto),
- les entiers,
- les flottants,
- les nombres en précision arbitraire,
- les booléens (true,false,FAIL),
- les chaı̂nes de caractères (ex "toto").
Le codage de ces types et leur étendu ne sont pas (ou sont peu) documentés.
Les fonctions whattype() ; et type() ; permettent d’obtenir de l’information. Cette information est
principalement de nature mathématique.
4.1.2
x:=5: y:=5/2: y2:=5.0/2: z:=’z’:
u:= 2*z+5*x: t:=’t’:
whattype(x);
whattype(y);
whattype(y2);
whattype(z);
whattype(u);
type(x,rational);
type(y,rational);
type(y2,rational);
type(z,rational);
type(u,rational);
#
#
#
#
#
#
#
#
#
#
assume(t,integer):
type(t,integer);
# -> false, t a pour valeur le symbole t
->
->
->
->
->
->
->
->
->
->
integer
fraction
float
symbol
+
true
true
false
false
false
Les structures de base
Maple manipule efficacement
- les suites. Elles sont représentées extérieurement comme 2,1,0,1,2,
- les listes. Elles sont représentées extérieurement comme [2,1,0,1,2],
- les ensembles. Ils sont représentés extérieurement comme {0,1,2}.
La fonction seq() et le macro caractère $ permettent de définir les suites. Les crochets [] et les
accolades {} permettent de définir les listes (list) et les ensembles (set). Les fonctions union() ,
intersect() , minus() , member() sont associées aux ensembles.
30
Les structures de base
4.1.3
Les structures composites
Ces structures, plus riches et plus complètes que les structures de base, ne se comportent pas comme
les premières. On y reviendra ultérieurement. On distingue les
- les tables (table),
- les tables-procédures,
- les tableaux (array),
- les vecteurs et les matrices (vector, matrix (linalg)),
- les fonctions.
Les exemples qui suivent, un peu laborieux mais incontournables, montrent des différences déroutantes
de comportement entre les structures de base et les structures composites. Les structures de base s’utilisent de façon plus intuitive. Ces exemples montrent aussi qu’il vaut mieux éviter de créer implicitement, sans les contrôler, des objets composites. On reviendra plus complètement sur les évaluations.
# comportement des listes
l:=[1,5,7]
#
#
#
#
#
#
#
#
#
l est un symbole dont
la valeur est une liste
-> [1,5,7]
-> list
-> list
-> 1,5,7
-> 1
-> erreur
-> erreur
#
#
#
#
#
#
#
#
#
#
#
création d’une table
-> a, pas d’évaluation
au plus profond niveau
-> table([2 = 5])
-> 5
-> a[1]
-> symbol
-> table
-> table([2 = 5])
-> [2 = 5]
-> list
op(eval(g));
whattype(op(eval(g)));
#
#
#
#
#
#
#
#
#
#
#
#
création d’une table-procédure
-> g
-> proc() option remember;
’procname(args)’ end proc
-> 5
-> g(1)
-> symbol
-> procedure
-> proc() option remember;
’procname(args)’ end proc
-> remember, table([2 = 5])
-> exprseq
# les fonctions
f:= n -> n^2;
f;
eval(f);
# création d’une fonction
# -> f
# -> n -> n^2
l;
whattype(l);
whattype(eval(l));
op(l);
l[1];
l[4];
l[4]:=8;
# comportement des tables
a:=’a’:
a[2]:=5;
a;
eval(a);
a[2];
a[1];
whattype(a);
whattype(eval(a));
op(a);
op(eval(a));
whattype(op(eval(a)));
# les tables-procédures
g:=’g’:
g(2):=5;
g;
eval(g);
g(2);
g(1);
whattype(g);
whattype(eval(g));
op(g);
4.1 Les objets Maple
f(toto);
whattype(f);
whattype(eval(f));
op(f);
op(eval(f));
#
#
#
#
#
->
->
->
->
->
h:= proc(n) n^2; end;
#
#
#
#
#
#
#
création d’une fonction
petite différence avec f
-> proc(n) n^2 end
-> symbol
-> procedure
-> proc(n) n^2 end
-> n
eval(h);
whattype(h);
whattype(eval(h));
op(h);
op(eval(h));
4.1.4
31
toto^2
symbol
procedure
n -> n^2
n, operator, arrow
Création explicite de structures composites
tables
d:=table();
d[titi];
d[titi]:=cos(xx);
d[titi];
# création d’une table sans instanciation
# -> d[titi]
# -> cos(xx)
# création explicite
dd:=table([(2) = 100, (toto) = 3*xx^2]);
dd[toto];
# -> 3 * xx^2
dd[tata] := 24;
dd[tata];
# -> 24
tableaux
v:=array(-2..2,[4,1,0,1,4]);
v;
eval(v);
print(v);
lv:=convert(v,list);
lv;
v[-2];
lv[1];
v[3];
v[3]:=1000;
#
#
#
#
intervalle des indices = -2 .. 2
-> v
-> array(-2..2, [(-2)=4, ...])
-> array(-2..2, [(-2)=4, ...])
#
#
#
#
#
->
->
->
->
->
[4,1,0,1,4]
4
4
erreur
erreur
vecteurs et matrices
Les types vector et matrix font en principe partie de la bibliothèque linalg. Mais ils sont visibles
sans son chargement.
l:=[1$4];
v:=vector(4,l);
v;
eval(v);
print(v);
evalb(l=v);
evalb(l=eval(v));
evalb(l=convert(v,list));
m:=matrix(2,4,[l,2*l]);
#
#
#
#
#
#
#
#
#
#
->
->
->
->
->
->
->
[1
[
[2
v
[1,1,1,1] vu comme la liste sous-jacente
[1,1,1,1]
false
false
true
1
1
2
2
1]
]
2]
32
Les structures de base
compatibilité entre les tableaux et les matrices
Il y a compatiblité si les intervalles des indices sont de la forme [1..n]. On s’y perd un peu.
l:=[1$4];
b:=array(1..2,[l,2*l]);
c:=array(1..2,1..4,[l,2*l]);
m:=matrix(2,4,[l,2*l]);
evalb(b=m);
evalb(c=m);
type(b,matrix);
type(c,matrix);
eval(b);
eval(c);
4.2
4.2.1
#
#
#
#
#
#
#
#
#
->
->
->
->
->
->
[1
[
[2
false
false
false
true
[[1, 1, 1, 1], [2, 2, 2, 2]]
1
1
2
2
1]
]
2]
Manipulations des objets de base
Extraction
op extrait les composantes d’une expression ou d’une structure. Il retourne une suite.
op([1,4,2]);
op(1,4,2);
op({1,4,2,1});
op(1+2+3);
op(x+y-z);
op(x/y/z);
4.2.2
#
#
#
#
#
#
->
->
->
->
->
->
1,4,2 (c’est une suite)
erreur
1,2,4
6
x,y,-z
x,1/y,1/z
Sélection
op permet également d’extraire un seul élément.
op(2,[x,y,z]);
l:=[4,5,6,7,8]:
l[2];
l[1..3];
l[2..-1];
l[2..-2];
op(2,x+y*z-8);
4.2.3
#
#
#
#
#
->
->
->
->
->
5
[4,5,6]
[5,6,7,8]
[5,6,7]
y*z
Nombre d’éléments
l:=[4,5,6,7,8]:
nops(l);
4.2.4
# -> y
# -> 5
Constitution de suites et de listes
Les listes sont plus faciles à manipuler que les suites qui se confondent souvent avec les paramètres
passés aux fonctions.
s:=NULL;
l:=[NULL];
ll:=[];
evalb(l=ll);
l:=[4,5,6];
l:=[seq(i^2,i=2..6)];
l:=[2$4];
m:=[x,y,z];
#
#
#
#
suite vide
liste vide
liste vide
-> true
4.2 Manipulations des objets de base
33
n:=[100,op(l)];
o:=[op(l),op(m)];
4.2.5
# -> [100,2,2,2,2]
# -> [2,2,2,2,x,y,z]
Test de la suite ou de la liste vide
if (nops(l) = 0) then ...
# ou
if (s = NULL) then ...
# ou
if (l = [NULL]) then ...
# ou
if (op(l) = NULL) then ...
4.2.6
La fonction map
la fonction map prend en entrée une structure et une fonction, elle retourne la structure dont les
éléments sont les images des éléments 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éennes
Il y a trois booléens, true, false, FAIL.
Par FAIL Maple signifie qu’il ne sait pas. FAIL se comporte comme false dans les tests.
La fonction evalb() est dédiée à l’évaluation des expressions booléennes.
5.1
Le symbole ”=”
a deux sens. Dans un test genre
if (x = 8) then ...
il se comporte comme un prédicat. Dans cette construction, (x = 8) est une expression booléenne.
Par contre dans l’expression
e:=(x=y);
il sert à définir un objet de type équation.
e:=((x-1)*(x-2) = (x-1));
e;
whattype(e);
solve(e);
evalb(e);
evalb(subs(x=3,e));
5.2
#
#
#
#
#
->
->
->
->
->
(x - 1) (x - 2) = x - 1
=
3,1
false
true
Le prédicat ”=”
est universel. Il peut s’appliquer à tous les objets.
a:={5,4,2,1,0,3};
b:={seq(abs(i),i=-5..5)};
evalb(a=b);
# -> true
Mais attention aux tests du genre
evalb(sin(x)^2 + cos(x)^2 = 1);
# -> false
evalb(simplify(sin(x)^2+cos(x)^2) = 1); # -> true
dont la réponse est imprévisible.
5.3
Le prédicat ”<”
A la différence du prédicat "=" qui est universel, les prédicats "<" et ">" ne s’appliquent qu’aux
nombres. Ceci est la raison de nombreuses erreurs dans l’exécution de fonctions contenant des tests
d’inégalité lorsque les expressions à comparer comportent des variables n’ayant pas de valeur numérique.
36
Les expressions booléennes
if (x < 3) then ...
f:=x-> if (x < 0) then 0 else 1; fi;
f(-2);
plot(f(x),x=-5..5);
# -> erreur quand x n’a pas de
# valeur numérique
# -> 0
# -> erreur cannot ...
Pour contourner le problème de la comparaison impossible lors d’un plot, il y a plusieurs solutions :
1. f:=x-> if (x < 0) then 0 else 1; fi;
plot(f(x),x=-5..5);
plot(’f(x)’,x=-5..5);
# -> erreur cannot ...
# ok
2. f:=x-> if (type(x,numeric)) then
if (x < 0) then 0 else 1; fi;
else
’f(x)’;
fi;
plot(f(x),x=-5..5);
# ok
Note : Ce problème ne se produit ni avec la fonction piecewise() ni avec la fonction ‘if‘().
f:=x->piecewise(x<0,0,1);
plot(f(x),x=-5..5);
# ok
f:=x->‘if‘(x<0,0,1);
plot(f(x),x=-5..5);
# ok
Attention aussi aux tests dont Maple ne connaı̂t pas la réponse :
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 évaluations
Le fonctionnement des évaluations est un peu délicat, car il diffère selon les objets à évaluer (scalaires,
objets basiques, objets composites) et suivant le contexte (Toplevel, intérieur des fonctions). On doit
retenir les règles suivantes :
6.1
Règles d’évaluation
1. Au Toplevel, Maple évalue au plus profond niveau et retourne le résultat de la dernière évaluation.
Sauf pour les objets composites (table, array, vector, matrix, function . . .) qu’il évalue
jusqu’au ”dernier nom”. (last name evaluation, cf exemples ci-dessous).
2. A l’intérieur des fonctions (ou procédures), Maple n’évalue qu’au premier niveau.
3. On dispose de fonctions spécifiques pour forcer l’évaluation :
fonctions
eval
evalf, evalhf
evalb
evalm
evalc
evala
evalr
type d’utilisation
universel
flottants,
booléens,
algèbre linéaire,
nombres complexes,
nombres algébriques,
calcul par intervalles
value
évaluation 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’évaluation.
5. Au Toplevel, lors des affectations (x := y), il y a recopie de la valeur au plus profond niveau
du membre de droite. Sauf lorsque celui-ci est de type composite, auquel cas il y a pointage.
6.2
6.2.1
Illustration des règles
Niveau d’évaluation et affectations
au Toplevel
x:=’x’: y:= ’y’: z:=’z’:
x:=y;
y:=z;
z:=1;
x;
z:=4;
x;
#
#
#
#
-> 1. Evaluation au plus
profond niveau
x pointe sur y qui pointe sur
z dont la valeur est 1
# -> 4
38
Les évaluations
x:=5;
z;
t:=y;
t;
y:=55;
t;
# -> 4, x ne pointe plus sur y
#
#
#
#
t prend la valeur au plus profond
niveau de y, c’est-a-dire 4.
t n’a plus de relation avec y et z
-> 4
# -> 4
dans une fonction
essai:=proc()
local
x,y,z;
x:=y; y:=z; z:=1;
print(x,y,z);
print(eval(x,2));
end;
essai();
# la procédure affiche y,z,1 et z
# elle retourne NULL (print)
essai2:=proc()
local
x,y,z;
x:=y; y:=z; z:=1;
print(x,y,z);
eval(x,2);
end;
essai2();
a:=essai2();
a;
eval(a,1);
# la procédure affiche y,z,1
# et retourne z
#
#
#
#
#
#
#
-> 1
-> z
a a pour valeur z qui a pour
valeur 1 (ce qui n’est pas
très normal puisque z vient
d’une variable locale de
essai2)
#
#
#
#
#
#
-> m
-> [a
b]
[
]
[c
d]
idem avec eval(m), print(m),
eval(m,1)
last name evaluation
m:=matrix(2,2,[a,b,c,d]);
m;
evalm(m);
m1:=m;
m2:=m1;
m3:=m2;
m,m1,m2,m3;
eval(m1,1),eval(m2,1),eval(m3,1);
# -> m,m,m,m
# -> m,m,m
m5:=m4;
m4:=m3;
m4,m5;
eval(m4,1), eval(m5,1);
# -> m,m
# -> m,m4
6.2 Illustration des règles
print(m5);
f:= 2*b+c;
b:= 1;
f;
b:= 10;
f;
eval(m);
map(eval,m);
6.2.2
39
# -> [a
#
[
#
[c
b]
]
d]
# -> 2 + c
#
#
#
#
#
#
-> 20 + c
-> [a
b]
[
]
[c
d]
b n’est pas vu de la m^
eme
façon dans f et dans m
# -> [a
#
[
#
[c
10]
]
d]
Affectations
cas des listes
l1:=[2,3,4];
l2:=l1;
l2[2]:=33;
l1;
l2;
#
#
#
#
#
-> [2,3,4]
-> [2,33,4]
il y a eu recopie de la
valeur de l1 et distinction
totale entre l1 et l2
#
#
#
#
#
#
#
-> v1
[2,333,4]
il n’y a pas eu recopie de
la valeur au plus profond
niveau de v1, v2 pointe sur
v1, une modification de v2
entra^
ıne une modification de v1
cas des tables
Attention danger !
v1:=vector(3,l1);
v2:=v1;
v2[2]:=333;
v1;
eval(v1);
v3:=copy(v1);
v3[3]:=444;
eval(v1);
6.2.3
# recopie
# [2,333,4]
Quotage
La fonction evaln() et le dispositif de quotage retardent l’évaluation.
y:=’y’:
x:=y;
y:=1;
40
Les évaluations
x;
eval(x,1);
eval(’x’,1);
eval(’x’,2);
eval(’x’,3);
eval(’’x’’,3);
eval(’2*x’,1);
eval(’x+5’,2);
x:=evaln(x);
x;
6.2.4
#
#
#
#
#
#
#
#
#
#
-> 1
-> y
-> x
-> y
-> 1
-> y, (deux fois signe quote)
-> 2 x
-> y+5
meme effet que ’x’
-> x
Quelques différences difficilement prévisibles
Les variables d’indice des fonctions seq, add, sum, int ,... n’ont pas le même comportement
selon les versions de Maple et selon que les fonctions font partie du noyau (built-in functions, codées
en binaire) ou au contraire font partie des fonctions écrites en Maple.
Voici quelques exemples, tous provenant d’une exécution en version 7.
i:=’i’; sum(i,i=1..3);
i;
i:=5; sum(i,i=1..3);
i:=5; add(i,i=1..3);
i:=5; seq(i,i=1..3);
i;
i:=5; sum(i,’i’=1..3);
i:=5; sum(’i’,’i’=1..3);
i;
#
#
#
#
#
#
#
#
#
#
#
#
-> 6
-> i
erreur
-> 6
-> 1,2,3
-> 5
add et seq sont des fonctions
de bas niveau contrairement à
sum
-> 15 (3x5)
-> 6
-> 5
Chapitre 7
Les fonctions
7.1
Définition des fonctions
On peut définir les fonctions avec l’opérateur → ou en utilisant proc(). Voir les exemples dans les
chapitres précédents.
7.2
Comment voir le contenu des fonctions
showstat(sum);
# ou
interface(verboseproc=2); print(sum);
#
#
#
#
#
7.3
affiche le programme de la
fonction sum. Cette fonction
comporte de nombreuses
méthodes qu’il convient de
suivre. (laborieux)
Fonctions anonymes
Il est possible d’utiliser des fonctions sans leur donner de nom.
((x,y) -> x * y) (2,20);
map(t->t^2, [1,2,3]);
7.4
# -> 40
# -> [1,4,9]
Variables locales, variables globales
On peut choisir le statut des variables utilisées dans la définition des fonctions avec les déclarations
local ou global. Par défaut Maple émet un avertissement et déclare local les variables qui ne sont
pas déclarées et qui n’existent pas par ailleurs.
Mais je déconseille de profiter de cette disposition, je recommande de procéder systématiquement aux
déclarations.
f:=proc()
global a,b;
local
x,y;
a:=1;
b:=10;
x:=100;
y:=1000;
end;
a:=-1;
b:=’b’;
42
Les fonctions
x:=-100;
y:=’y’;
f();
a,b,x,y;
7.5
#
#
#
#
#
#
-> 1000. Les variables x et y
n’ont d’existence que lors de
l’exécution de f(). Par
contre, le statut de a et b est
modifié après l’exécution.
-> 1, 10, -100, y
Valeur retournée
La valeur retournée par une fonction est celle de la dernière évaluation ou la valeur explicitement
spécifiée par RETURN. Il me semble plus clair d’utiliser systématiquement RETURN(). On peut cependant
utiliser les deux formes de retour dans la même fonction.
f:=proc(n)
if (n<2) then RETURN(1);fi;
n*f(n-1);
end;
# fonction n!
Attention à la commande plot dans une fonction : il faut savoir que la commande plot n’est pas une
instruction d’affichage. Elle retourne en fait une structure informatique. Cette structure, exactement
comme toutes les autres, n’est affichée à l’écran (ou imprimée, ou mise en fichier) que
- si elle est soumise à la commande print,
- ou si son évaluation s’est réalisée en dernier et si une demande implicite d’affichage (” ;” en fin
d’expression) a été faite.
On est toujours très surpris de ne pas voir les requêtes plot apparaı̂tre à l’écran.
f1:=proc(a,b)
local x;
plot(sin(x),x=a..b);
end;
f1(0,10);
# sortie écran ok
f2:=proc(a,b)
local x;
plot(sin(x),x=a..b);
b-a;
end;
f2(0,10);
# -> 10
# pas d’affichage
f3:=proc(a,b)
local x;
print(plot(sin(x),x=a..b));
b-a;
end;
f3(0,10);
7.6
# -> 10
# dessin ok
Options
On peut attacher aux fonctions plusieurs options. (Voir l’aide sur options). L’option remember est
intéressante quand une fonction doit être évaluée plusieurs fois sur les mêmes paramètres. C’est notamment le cas pour les fonctions récursives d’ordre supérieur à 1. Quand une fonction est définie avec
7.7 Contrôle des paramètres
43
l’option remember, Maple attache une table à cette fonction, la table de remember. Lors de chaque
évaluation, la table est consultée. Si l’évaluation a déjà été faite, le résultat y est puisé. Sinon les
calculs sont réalisés et la table est enrichie. (L’aide en ligne sur ce sujet est bien faite).
f:=proc(n)
option remember;
if (n<2) then RETURN(1);fi;
n*f(n-1);
end;
f(5);
f(7);
7.7
# 5 appels de la fonction
# 2 appels seulement, f(5) pris dans la table
Contrôle des paramètres
On nomme paramètres formels les paramètres qui figurent dans la définition des fonctions, et paramètres effectifs ceux qui sont passés lors d’un appel. Le programmeur dispose des variables prédéfinies
suivantes :
- nargs contient le nombre des paramètres effectifs. Ce nombre peut être différent de celui des
paramètres formels.
- args est une variable qui contient la suite des paramètres effectifs.
- procname est une variable qui contient le nom de la fonction.
typage : Il est possible de ”typer” certains paramètres. Quand un paramètre est typé, Maple ajoute
automatiquement au code de la fonction un test du paramètre effectif et retourne éventuellement un
message d’erreur approprié.
f:=proc(l::list)
l[1];
end;
f([2,3]);
f([2,3],5);
f(5,[2,3]);
f(5);
f();
7.8
#
#
#
#
#
->
->
->
->
->
2
2
erreur
erreur
erreur
Passage des paramètres
Les paramètres sont passés aux fonctions par valeur. Cela veut dire que si x est une variable dont
la valeur est 5, l’appel f (x) envoie 5 à la fonction f et non la variable x. Si l est une liste de valeur
[1, 2, 3], l’appel g(l) envoie à g une copie de la liste [1, 2, 3].
Par contre si v est le vecteur [1, 2, 3], l’appel h(v) envoie à h la valeur de v telle qu’elle apparaı̂t lors de
l’évaluation de v, c’est-à-dire, comme on l’a vu au chapitre 6 Les évaluations, la variable elle-même,
et non une copie.
Ce mode de passage a deux conséquences :
- Les paramètres de type scalaire ou objet de base, ne peuvent être modifiés à l’intérieur des
fonctions.
f:=proc(x)
x:=x+1;
end;
y:=5;
f(y);
# -> erreur,
5 := 6 impossible
- Pour obtenir une modification d’une variable passée en paramètre, c’est-à-dire pour effectuer un
passage par référence, il y a au moins deux solutions :
44
Les fonctions
f1:=proc(x)
x:=eval(x)+1;
10;
end;
y:=5;
f(’y’);
y;
f2:=proc(x::evaln)
x:=eval(x)+1;
10;
end;
y:=5;
f(y);
y;
# -> 10, passage de y
# -> 6
# déclaration de passage par référence
# -> 10, passage de y
# -> 6
Pour les objets composites, il n’y a rien à prévoir pour effectuer un passage par référence. Au contraire,
si la fonction modifie un objet dont on désire conserver la valeur initiale (par exemple la matrice d’un
système linéaire résolu par une méthode qui transforme le système), il peut s’avérer nécessaire d’en
passer une copie avec la fonction copy().
f:=proc(x)
x[1]:=x[1]+1000;
end;
v:=vector(3,[1$3]);
f(v);
v;
eval(v);
l:=[1$3];
f(l);
f(’l’);
l;
# -> 1001
# -> v
# -> [1001,1,1]
# -> erreur
# -> 1001
# -> [1001,1,1]
Exemple
Soit à programmer la fonction deuclide() qui retourne quotient et reste de la division euclidienne.
On souhaite que deuclide(7,2) retourne 3, et que deuclide(7,2,r) retourne 3 et affecte r par le
reste 1. (Comme la fonction Maple iquo()).
deuclide:=proc(a,b,r::evaln)
local q;
q:=trunc(a/b);
if (nargs > 2) then
r:=a-b*q;
fi;
q;
end;
deuclide(7,2);
z:=sin(x);
deuclide(7,2,z);
z;
7.9
# -> 3
# -> 3
# -> 1
Fonctions locales
Il est possible de définir des fonctions locales à une fonction donnée.
7.9 Fonctions locales
p4:=proc(x)
local f;
45
# fonction x -> x^4
f:=proc(x) x^2; end;
RETURN(f(f(x)));
end;
p4(2);
# -> 16
Note : Avant la version 5, il était très difficile de faire passer à une fonction locale un paramètre de la
fonction principale. C’est maintenant aisé.
g:=proc(x,n)
local f;
f:= t->sin(n*t);
RETURN(f(x));
end;
g(Pi/2,3);
# -> -1
46
Les fonctions
Chapitre 8
Les modules
Depuis la version 6, Maple offre la possibilité d’utiliser des modules. Les modules permettent
- de créer des objets complexes, comme les enregistrements du Pascal (RECORD) et les structures
du C (struct), avec la notion de champs associés aux objets.
- de faire de la programmation orientée objet, offrant la possibilité d’attacher aux objets à la fois
des structures de données et des fonctions (les méthodes), permettant l’héritage : on peut définir
un type particulier dans un type déjà défini (classe) et profiter pour ce type particulier de tout
ce qui existe pour le type père. On peut enrichir les méthodes.
Consulter l’aide en ligne sur module, use ou help(" :-") ; (Version 7).
48
Les modules
Chapitre 9
Les entrées-sorties
Indiquons quelques fonctions impliquées dans la communication entre Maple et l’extérieur, c’est-à-dire
l’écran, le clavier, les fichiers sur disque.
9.1
Les fonctions d’entrée-sortie
9.1.1
Fonctions de lecture
Le périphérique d’entrée par défaut est le clavier.
- readstat() est la fonction que l’interprète utilise pour acquérir les commandes. Elle est utilisable
par les programmeurs. Elle procède à la saisie et à l’interprétation de la chaı̂ne lue. Elle retourne
un objet Maple. (Les saisies sont terminées avec ” ;”).
- readline() retourne une chaı̂ne de caractères.
- scanf() permet la lecture formatée.
9.1.2
Analyse d’une chaı̂ne
Les fonctions suivantes peuvent être utilisées pour analyser ou fouiller une chaı̂ne.
parse(), sscanf(), substring(), convert(.,byte)
9.1.3
Fonctions d’écriture
- print() est la fonction d’affichage de haut niveau. La syntaxe print("x" = x) est parfois
intéressante.
- lprint() permet un affichage basique, non centré.
- printf() est une fonction d’affichage formaté. Exemple de syntaxe :
printf("f(%3a) = %.5a\n",i,f(i));
la chaı̂ne contient des caractères qui sont affichés (f,(,), ,=), et des directives de formatage :
%3a indique que la valeur de i doit être affichée sur 3 colonnes, %.5a indique que la valeur de
f(i) doit l’être avec 5 chiffres après la virgule, \n est un ordre de retour à la ligne. Voir l’aide
en ligne sur printf() pour les différents formats (réels, chaı̂nes, caractères, ...).
9.2
Les redirections
Il est possible d’annuler l’affichage à l’écran et d’ordonner que les sorties se fassent dans un fichier.
writeto(nom_de_fichier);
# ou
append(nom_de_fichier);
Pour revenir à l’affichage initial à l’écran utiliser
writeto(terminal);
50
Les entrées-sorties
C’est la fonction read() déjà indiquée qui permet de rediriger les entrées.
On peut exécuter les calculs en mode batch . Cela veut dire, qu’étant sous le système d’exploitation, en laçant la commande
maple [options] fichier_source > fichier_resultat
on ouvre une session Maple non interactive, qui cesse dès que les calculs présents dans fichier source
sont achevés. Les résultats se trouvant dans fichier resultat.
9.3
Lecture de données dans un fichier
Pour la lecture de données numériques écrites ”en clair” dans un fichier Texte (Ascii), la fonction
readdata() convient bien.
Si le fichier contient du texte et des valeurs numériques, readline() et parse() peuvent être intéressantes.
Le fonction fscanf() permet de réaliser des lectures formatées et la fonction readbytes() permet de
lire des données binaires.
Exemple d’une fonction réalisant la lecture d’une image en nuances de gris au format PGM (sans
commentaire). Les images PGM sont constituées de deux types de données : D’abord quelques lignes
codées en caractères Ascii (mode texte) indiquant le type du fichier (P5 par exemple), contenant
éventuellement des commentaires (# CREATOR ... par exemple), indiquant les dimensions de l’image
(900 600 par ex) et le nombre de nuances de gris (255). Ensuite figurent les pixels (les 900 x 600 pixels)
codés en binaire sur 1 octet.
# la fonction loadpgm prend en entrée un nom de fichier f et retourne
# une liste formée des dimensions de l’image et de la matrice des pixels.
loadpgm:=proc(f)
# f = nom_de_fichier
local lg,haut,larg,dims,l;
lg:=readline(f);
#
lg:=readline(f);
while (substring(lg,1..1) = "#") do # les
lg:=readline(f);
od;
dims:=sscanf(lg,"%d %d");
#
haut:=dims[2]; larg:=dims[1];
lg:=readline(f);
#
l:=readbytes(f,infinity);
#
RETURN([haut,larg,matrix(haut,larg,l)]);
end;
9.4
marque P5
commentaires
les dimensions
le nombre de nuances
les pixels
Écriture de données dans un fichier
La fonction fprintf() permet l’écriture formatée et la fonction writebytes() l’écriture en binaire.
Exemple d’une fonction réalisant l’écriture d’une image au format PGM :
# la fonction sauvegm prend en entrée une image im (cf ci-dessus) et un
# nom de fichier f. Elle écrit 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 Écriture de données dans un fichier
od;
fclose(canal);
end;
51
52
Les entrées-sorties
Chapitre 10
Manipulation des expressions
10.1
Diverses fonctions de manipulation
10.1.1
Assign
Cette fonction permet l’affectation des membres gauches des équations résultant de l’utilisation de
fonctions comme solve() ou dsolve(). Elle doit être utilisée modérément. Il est souvent préférable
d’utiliser la fonction rhs() ou la fonction select/has() pour récupérer 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éer une fonction à partir d’une variable dont la valeur est une expression, ce qui
ne peut se faire directement.
> q := x^2 + y^3 + 1;
2
3
q := x + y + 1
> g:=x->q;
g := x -> q
> g(0);
2
3
x + y + 1
> f := unapply(q,x);
2
3
f := x -> x + y + 1
> f(0);
3
1 + y
> diff(f(t),t);
2 t
10.1.3
Sort
La fonction sort() permet de trier différents types d’objets. Elle a pour particularité de modifier les
expressions passées en argument (ne modifie ni les suites ni les listes).
> p:=x+5*x^2+8*x+1+x;
2
p := 10 x + 5 x
+ 1
> sort(p);
2
5 x + 10 x + 1
> p;
10.1 Diverses fonctions de manipulation
55
2
5 x + 10 x + 1
> l:=[5,4,15];
l := [5, 4, 15]
> sort(l);
[4, 5, 15]
> l;
[5, 4, 15]
10.1.4
Subsop
Cette fonction permet de changer un opérande dans une expression. Elle permet des combinaisons
sophistiquées, pas très aisées, par exemple dans les intégrales.
> p := x^7+8*x^6+x^2-9;
7
6
2
p := x + 8 x + x - 9
> op(2,p);
6
8 x
> y:=’y’:
> subsop( 2=y^55, p );
7
55
2
x + y
+ x - 9
> sort(%);
7
2
x + x + y - 9
10.1.5
Parse
Parse est la fonction d’analyse et d’interprètation des chaı̂nes de caractères. 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éthode identity attachée à la fonction solve() permet la résolution d’équations selon la
méthode des coefficients indéterminés.
> x:=’x’: a:=’a’: b:=’b’:
> p:=a*x^3+(a+b+1)*x+(a-b-1);
3
p := a x + (a + b + 1) x + a - b - 1
56
Manipulation des expressions
> solve(identity(p,x),{a,b});
{a = 0, b = -1}
> p:=a*sin(2*x)+(a+b+1)*sin(x)+(a-b-1)*cos(x);
p := a sin(2 x) + (a + b + 1) sin(x) + (a - b - 1) cos(x)
> solve(identity(p,x),{a,b});
{a = 0, b = -1}
10.1.7
Allvalues
Cette fonction travaille en association avec la fonction RootOf() pour obtenir toutes les solutions
d’une équation. Mais elle est trop dépendante de la version Maple. Il est nécessaire de consulter l’aide
en ligne de la version utilisée.
10.1.8
Value
Cette fonction permet l’évaluation des expressions contenant des fonctions inertes.
> F := Int(x, x);
/
|
| x dx
|
F :=
/
> F - 1/2 * x^2;
/
|
2
| x dx - 1/2 x
|
/
> diff(F,x);
x
> value(F - 1/2 * x^2);
0
> i:=Int(1/x,x=1..infinity);
infinity
/
|
i := |
1/x dx
|
/
1
> j:=Int(1/(1+x),x=1..infinity);
infinity
/
|
1
j := |
----- dx
|
1 + x
/
1
10.2 Réécriture
57
> d:=combine(i-j);
infinity
/
|
d := |
|
/
1
1
1/x - ----- dx
1 + x
> value(d);
ln(2)
10.2
Réécriture
Voici quelques exemples de commandes permettant d’effectuer diverses transformations sur les expressions.
10.2.1
Expand
> expand(tan(a+b));
tan(a) + tan(b)
----------------1 - tan(a) tan(b)
10.2.2
Simplify
> subs(x=0,ln(exp(x)));
ln(exp(0))
> simplify(%);
0
10.2.3
Factor
> p:=cos(t)*sin(3*x) + ln(y)*sin(3*x);
p := cos(t) sin(3 x) + ln(y) sin(3 x)
> factor(p);
sin(3 x) (cos(t) + ln(y))
L’utilisation de factor()
permet parfois des simplifications difficiles : Soit à calculer la transformée
√
de Hilbert de f 0 := 1 − t2 χ[−1,1] . La transformation de Hilbert est l’opérateur qui à une fonction f
fait correspondre la fonction
Z
1 ∞ f (t)
H(p) =
dt.
π −∞ p − t
La fonction Maple hilbert() du package inttrans est capable de faire ce calcul, mais elle échoue
pour f 0 (version 7). Cependant le calcul est faisable directement.
p Le résultat à trouver estpp pour
−1 < p < 1, l’intégrale étant 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 )
t <= -1
1 <= t
otherwise
> hilbert(f0,t,p);
# echec
t <= -1
{
0
{
hilbert({
0
{
{
2 1/2
{ (1 - t )
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 n’est pas facile de mettre h2 sous la forme simplifiée attendue. L’utilisation de factor() n’est pas
la seule possibilité de simplification, mais ici elle est très pratique.
> factor(h2,denom(h2));
2
p~ - (p~
10.2.4
1/2
- 1)
Collect
> p:=cos(t)*sin(3*x) + ln(y)*sin(3*x) + 5;
p := cos(t) sin(3 x) + ln(y) sin(3 x) + 5
> collect(p,sin(3*x));
(cos(t) + ln(y)) sin(3 x) + 5
> f:=(2*a*x+4+6*b*x)/(8+8*c*x+4+6*x);
2 a x + 4 + 6 b x
f := ----------------12 + 8 c x + 6 x
> fc:=collect(f,x);
(2 a + 6 b) x + 4
fc := ----------------(8 c + 6) x + 12
> simplify(fc);
a x + 2 + 3 b x
--------------6 + 4 c x + 3 x
10.2 Réécriture
59
> collect(simplify(fc),x);
(a + 3 b) x + 2
--------------(4 c + 3) x + 6
10.2.5
Combine
C’est souvent difficile de trouver les bonnes combinaisons à appliquer.
> combine(4*sin(x)^3,trig);
-sin(3 x) + 3 sin(x)
> combine(Int(x,x=a..b)-Int(x^2,x=a..b));
b
/
|
2
|
x - x dx
|
/
a
> combine(exp(x)^2*exp(y),exp);
exp(2 x + y)
> combine(ln(x+1)+ln(x-1));
ln(x + 1) + ln(x - 1)
> combine(ln(x+1)+ln(x-1),ln);
ln(x + 1) + ln(x - 1)
> combine(ln(x+1)+ln(x-1),ln,symbolic);
ln((x + 1) (x - 1))
# dans le m^
eme ordre d’idées
> simplify(sqrt((x*y)^2,assume = positive);
x y
10.2.6
Normal
> p:=(x^2 - y^2)/(x-y) - (x+y);
2
2
x - y
p := ------- - x - y
x - y
> normal(p);
0
10.2.7
Rationalize
> f:=2/(2-sqrt(2));
2
f := -------1/2
2 - 2
60
Manipulation des expressions
> rationalize(f);
1/2
2 + 2
10.2.8
Convert
Cette fonction a un champ d’utilisation très vaste. Voici quelques exemples :
> t:=taylor(sin(x),x=0,4);
3
4
t := x - 1/6 x + O(x )
> convert(t,polynom);
3
x - 1/6 x
> convert(exp(I*3*x),trig);
cos(3 x) + I sin(3 x)
> r:=(x^2+x+1)/(x^2+1);
2
x + x + 1
r := ---------2
x + 1
> rf:=convert(r,parfrac,x);
x
rf := 1 + -----2
x + 1
> rr:=(x^3+x+1)/expand((x+I)*(x-I));
3
x + x + 1
rr := ---------2
x + 1
> convert(rr,parfrac,x,complex);
# (Maple 7)
.5000000000 I
.5000000000 I
x + ----------------- - ------------x + 1.000000000 I
x - 1. I
> convert(rr,fullparfrac,x);
/
----\
|
\
/
_alpha \|
x + |
)
|- 1/2 ----------||
|
/
\
x - _alpha/|
|
----|
\_alpha = %1
/
2
%1 := RootOf(_Z
# Ecriture en base autre que 10
> c:=convert(10,base,2);
+ 1)
10.2 Réécriture
61
c := [0, 1, 0, 1]
# Ecriture en base 12
> b:=12: chiffres:=convert([$48..48+9,$65..65+max(0,b-1-10)],bytes);
chiffres := "0123456789AB"
> x:=23: StringTools[Reverse](cat(op(map(t->substring(chiffres,t+1),convert(x,base,b)))));
"1B"
> # ou
> envers:=proc(l) local i; [seq(l[-i],i=1..nops(l))];end:
> x:=23: cat(op(map(t->substring(chiffres,t+1),envers(convert(x,base,b)))));
"1B"
# Pas facile d’obtenir 0 partir de l’expression suivante (version >= 4)
> s:=sum(exp(2*I*Pi*k/7),k=0..6);
s := 1 + exp(2/7 I Pi) + exp(4/7 I Pi) + exp(6/7 I Pi) + exp(-6/7 I Pi)
+ exp(-4/7 I Pi) + exp(-2/7 I Pi)
> convert(s,polar);
polar(0, 1/2 Pi)
> evalc(convert(s,polar));
0
> u:=sin(Pi/10);
u := sin(1/10 Pi)
> convert(u,radical);
1/2
1/4 5
- 1/4
62
Manipulation des expressions
Bibliographie
[1] Waterloo Maple. Maple V, Learning Guide (fourni avec le logiciel). Springer.
[2] Waterloo Maple. Maple V, Programming Guide (fourni avec le logiciel). Springer.
[3] P. Dumas, X. Gourdon. Maple. Son bon usage en mathématiques. Springer, 1997.
[4] C.Gomez B.Salvy, P.Zimmermann. Calcul formel. Mode d’emploi. Exemples en Maple. Masson,
1995.
[5] A. Heck. - Introduction to Maple. Springer Verlag New York 1993.
[6] P. Saux Picart. - Cours de calcul formel. Ellipses fr Paris 1999.
[7] P. Douillet. - Maths avec Maple t1 et t2. Ellipses fr Paris 1995.
[8] W. Gander, J. Hrbicek. - Solving problems in scientific computing using Maple and Matlab.
Springer Berlin Heidelberg 1994.
[9] J.Davenport, Y. Siret, E. Tournier. - Calcul formel. Systèmes et algorithmes de manipulations
algébriques. Masson, 1987.
[10] G. Articolo. - Partial differential equations and boundary value problems with Maple V. Academic
Press us San Diego, CA 1998.
[11] Zimmermann. Bibliographie en ligne. http ://www.loria.fr/%7Ezimmerma/maple/.
[12] Université de Lille. Bibliographie en ligne. http ://www.grappa.univ-lille3.fr/polys/maple1999/index34.html.
[13] Université 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éens, 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ébugage, 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ète, 7
intersect, 29
iquo, 44
kernelopts, 21
last, 38
liste, 29
local, 41
lprint, 49
map, 33
maple -x, 7
mapleinit, 21
matrix, 30
member, 29
minus, 29
modules, 47
name, 38
nargs, 43
nombre, 32
nops, 32
66
INDEX
normal, 59
NULL, 32
numeric, 36
typage, 43
type, 29
numeric, 36
op, 32
options, 42
unapply, 54
union, 29
use, 47
par référence, 43
par valeur, 43
paramètres, 43
parfrac, 60
parse, 49, 50, 55
pgm, 50
piecewise, 36
plot, 36, 42
plotsetup, 21
polar, 60
prédicat, 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édure, 30
tableaux, 30
toplevel, 37
trace, 22
true, 35
value, 37, 56
vector, 30
verboseproc, 22, 41
vide, 32
whattype, 29
while, 26
with, 22
writebytes, 50
writeto, 49
xmaple, 7