Introduction `a Maple (suite)

Introduction a` Maple (suite)
Rappels
Il est fortement conseill´e d’utiliser la commande restart au d´ebut de chaque exercice pour lib´erer les variables de leur affectation.
Pensez `
a SAUVEGARDER votre travail r´eguli`erement !
Maple est un logiciel relativement instable et votre professeur d´ecline toute responsabilit´e en cas de perte de
votre travail...
Prenez l’habitude de consulter l’aide grˆ
ace au point d’interrogation ”?” suivi de la commande recherch´ee.
1
Listes et s´
equences.
Listes et s´equences sont des outils essentiels `a l’utilisation de Maple, en particulier pour la construction de
proc´
edures o`
u elles sont omnipr´esentes.
Une s´
equence est une collection ordonn´ee d’expressions, s´epar´ees par des virgules. Ces expressions peuvent
ˆetre du mˆeme type (par exemple des nombres entiers) ou de types diff´erents (ex : une fonction suivie d’une
variable, d’un r´eel et d’une matrice).
> S:= x, 2, Pi+1, 3*y+1 ;
S := x, 2, π + 1, 3y + 1
Cette s´equence S comporte 4 objets. Il est possible de cr´eer une s´equence avec 0 objet grˆace `a la commande
NULL. Ceci se r´ev`elera utile dans les proc´edures.
Il est souvent utile d’ajouter des ´el´ements `a une s´equence, ou mˆeme de concat´ener deux s´equences. Pour
cela il suffit de les s´eparer par une virgule :
> S:=NULL ;
S :=
> T:=Pi,9 ;
T := π, 9
> x,S,y,T ;
x, y, π, 9
Lorsque la s´equence est issue d’un terme g´en´erique d´ependant d’un param`etre k, la commande seq permet
de construire cette s´equence de mani`ere automatique.
Notez que l’on peut imbriquer plusieurs seq (et donc plusieurs param`etres).
> seq(2*k,k=1..8) ;
2, 4, 6, 8, 10, 12, 14, 16
> seq(i^2,i=-2..2) ;
4, 1, 0, 1, 4
> seq(seq(i+k,i=0..4),k=0..4) ;
0, 1, 2, 3, 4, 1, 2, 3, 4, 5, 2, 3, 4, 5, 6, 3, 4, 5, 6, 7, 4, 5, 6, 7, 8
Exercice 1 Construire les s´equences suivantes en utilisant la commande seq :
1
√
√
√
v) 0, −1, 2, − 3, 2, − 5
i) 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
ii) π, 2π, 3π, 4π, 5π
vi) 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1
iii) 2, 5, 8, 11, 14, 17, 20
iv) 0,
1 1 3 1
8, 4, 8, 2
vii) a, a + 1, a + 2, a + 3, b, b + 1, b + 2, b + 3
viii) 1, 2, 3, 2, 4, 6, 3, 6, 9, 4, 8, 12, 5, 10, 15
Une liste est une s´equence encadr´ee par des crochets. La diff´erence est essentielle pour Maple qui comprend
la liste comme un objet unique.
> L:= [1,2,3,x,y] ;
L := [1, 2, 3, x, y]
Pour connaˆıtre le nombre d’´el´ements d’une liste on utilise la commande nops. Dans une liste L, les ´el´ements
sont num´erot´es de 1 `
a nops(L).
Pour acc´
eder et modifier les ´el´ements d’une liste, on ´ecrit le nom de la liste suivi, entre crochets, du num´ero
de la position de l’objet `
a extraire.
> L:= [1,2,3,x,y] :
> nops(L) ;
5
> L[1] ;
1
> L[nops(L)] ;
y
> L[2..4] ;
[2, 3, x]
> L[2]:=8 ;
L2 := 8
> L;
[1, 8, 3, x, y]
Pour transformer une s´
equence en liste, il suffit d’encadrer la s´equence par des crochets.
Pour transformer une liste en s´
equence, on utilise la commande op.
Pour supprimer un ´
el´
ement, on utilise la commande subsop.
> S:= x, 2, Pi+1, 3*y+1 ;
S := x, 2, π + 1, 3y + 1
> L:=[S] ;
L := [x, 2, π + 1, 3y + 1]
> op(L) ;
x, 2, π + 1, 3y + 1
> subsop(3=NULL,L) ;
[x, 2, 3y + 1]
2
2
Programmation.
Comme tous les logiciels de programmation, Maple a la capacit´e d’automatiser des tˆaches, notamment grˆ
ace
aux instructions fondamentales if, for, while auxquelles correspond une syntaxe sp´ecifique.
2.1
Proc´
edures.
Un des outils principaux de Maple est la cr´eation de programmes ou proc´
edures utilisant ses instructions.
Une proc´edure permet d’ex´ecuter plusieurs commandes ou instructions `a l’aide d’un seul programme.
Une proc´edure se pr´esente sur le sch´ema suivant :
> nom :=proc(arg1,arg2,...)
local var1,var2,...;
instruction1 ;
instruction2 ;
...
return resultat ;
end proc ;
o`
u
– nom est le nom de la proc´
edure ;
– arg1, arg2, . . . sont les arguments de la proc´edure, dont la proc´edure aura besoin pour fonctionner (ils
ˆtre modifie
´s a
` l’inte
´rieur de la proce
´dure !) ;
ne peuvent pas e
– var1, var2, . . . sont les variables locales que la proc´edure utilise et que l’on doit d´eclarer via la commande local ;
– instruction1, instruction2, . . . sont des instructions que la proc´edure ex´ecute ;
– la commande return permet de renvoyer un r´esultat en fin de proc´edure, en l’occurrence celui que l’on
aura indiqu´e dans la variable resultat ;
– end proc permet de terminer la proc´edure (c’est indispensable !).
Notez que toute la proc´edure s’´ecrit sur la mˆeme ligne de calcul (il n’y a qu’un seul crochet > ). Pour rendre
la proc´edure lisible, on d´esire aller `
a la ligne en restant sur la mˆeme ligne de calcul, pour cela il faut taper
Shift+Entr´ee.
Une fois la proc´edure ´ecrite, on l’utilise en tapant son nom et les arguments dont elle a besoin.
Voici un premier exemple :
> division:=proc(a,b)
local c ;
c:=evalf(a/b) ;
return c ;
end proc ;
> division(10,13) ;
Cet exemple illustre mal tout le potentiel des proc´edures car il est nettement plus rapide d’effectuer directement la division evalf(a/b) ;.
Exercice 2 Recopier la proc´edure division pr´ec´edente en respectant la pr´esentation. Distinguer pr´ecis´ement
le nom, les arguments, les variables locales, les instructions et le r´esultat de sortie.
Exercice 3 Ecrire une proc´edure toto qui prend en argument un entier n et qui renvoie la liste des entiers
de 1 `
a n.
´dure doit e
ˆtre teste
´e sur plusieurs exemples !
Attention ! Toute proce
3
2.2
L’instruction conditionnelle if
Voici la syntaxe `
a respecter :
> if condition
then instruction1
instruction2
...
else instructionA
instructionB
...
fi ;
;
;
;
;
Si la condition est vraie, les instructions (instruction1, instruction2,. . . ) qui suivent then sont ex´ecut´ees,
sinon ce sont les instructions (instructionA, instructionB,. . . ) qui suivent else. La commande fi marque
la fin de l’instruction conditionnelle, l’ex´ecution du programme reprend ensuite normalement.
Voici un exemple qui renvoie le maximum entre deux arguments a et b :
> maximum:=proc(a,b)
local c ;
if a>=b
then c:=a ;
else c:=b ;
fi ;
return c ;
end proc ;
La condition doit obligatoirement ˆetre du type ”bool´een”, c’est-`a-dire une variable qui est vraie ou fausse.
La commande evalb permet de connaˆıtre la valeur du bool´een.
> u:=1 :
> evalb(u>0) ;
true
> evalb(u>2) ;
f alse
Attention ! Ne confondez pas le symbole ”=” qui teste l’´egalit´e entre deux objets et le symbole d’affectation
”:=” !
Exercice 4 Ecrire une proc´edure signe qui prend en argument un nombre a et qui renvoie −1 si ce nombre
est strictement n´egatif et 1 si ce nombre est strictement positif. Que se passe-t-il si a = 0 ?
Lorsque l’on veut tester diff´
erentes conditions bool´
eennes, l’instruction conditionnelle if peut ˆetre
raffin´ee par l’instruction elif qui peut se traduire par ”sinon si”.
Voici un exemple concret :
> if a<0
then b:=-1 ;
elif a=0
then b:=0 ;
else b:=1 ;
fi ;
Exercice 5 A l’aide de la commande elif, ´ecrire une proc´edure signebis qui prend en argument un nombre
a et qui renvoie −1 si ce nombre est strictement n´egatif, 1 s’il est strictement positif et 0 s’il est nul.
4
2.3
La boucle for
La boucle for sert `
a r´ep´eter un paquet de commandes plusieurs fois `a la suite.
` l’avance.
ˆtre connu a
Le nombre de passages dans la boucle doit e
Voici la syntaxe `
a respecter :
> for compteur from d´
ebut to fin by pas
do instruction1 ;
instruction2 ;
...
od ;
Le programme initialise le compteur `
a la valeur d´
ebut puis ex´ecute toutes les instructions (instruction1,
instruction2,. . . ) de la boucle. Ensuite il augmente (il ”incr´emente”) la valeur du compteur en fonction du
pas et r´eex´ecute les instructions de la boucle. Il continue ainsi tant que le compteur a une valeur inf´erieure ou
´egale `
a fin.
Si la valeur du pas n’est pas pr´ecis´ee, elle vaut 1 par d´efaut.
Voici un exemple qui renvoie la factorielle d’un argument entier n :
> fact:=proc(n)
local c,k ;
c:=1 ;
for k from 1 to n
do c:=c*k ;
od ;
return c ;
end proc ;
Exercice 6 Ecrire une proc´edure terme qui prend en argument un entier n et qui renvoie une valeur approch´ee
du terme un de la suite d´efinie par r´ecurrence par
u0 = 1
et
uk+1 = ln(uk + 1)
Ecrire ensuite une proc´edure listetermes qui renvoie la liste des valeurs approch´ees des n premiers termes de
cette suite.
2.4
La boucle while
La boucle while sert `
a r´ep´eter un paquet de commandes plusieurs fois `a la suite ; le nombre de fois d´epend
d’une condition ´enonc´ee en d´ebut de boucle.
` l’avance.
Le nombre de passages dans la boucle n’est pas connu a
Voici la syntaxe `
a respecter :
> while condition
do instruction1 ;
instruction2 ;
...
od ;
Le programme teste si la condition est vraie puis ex´ecute toutes les instructions (instruction1, instruction2,. . . )
de la boucle. Il r´eex´ecute les instructions tant que la condition reste vraie.
Voici un exemple qui renvoie le plus petit cube sup´erieur ou ´egal `a n :
> cube:=proc(n)
local c ;
c:=0 ;
while c^3<n
do c:=c+1 ;
od ;
return c^3 ;
end proc ;
5
Attention ! Une erreur fr´equente est d’´ecrire une condition qui reste toujours vraie. La boucle ne s’arrˆete
donc jamais, ce qui entraine un bug de Maple.
Exercice 7 Ecrire une proc´edure listecubes d´ependant d’un argument entier n qui renvoie la liste des cubes
inf´erieurs ou ´egaux `
a n.
2.5
Remarques importantes
1. Lorsque vous programmez (quel que soit le language utilis´e) il est vital de soigner la lisibilit´
e de votre
programme, en particulier en respectant l’indentation dans les instructions if, for, while.
En effet, Maple se fiche de votre pr´esentation, mais pas vous (ou votre professeur) qui voudrez vous relire
pour chercher vos erreurs ou peaufiner votre programme (surtout pour les longues proc´edures !).
2. Il va de soi que l’on peut imbriquer plusieurs boucles entre elles. C’est une technique `a maitriser si
l’on veut construire des programmes plus complexes (cf. remarque ci-dessus).
3. Il est souvent fort utile de commencer a` r´efl´echir `a une proc´edure avec un crayon et du papier en
´ecrivant dans les grandes lignes ”l’architecture” de la proc´edure `a construire.
On peut ´egalement dessiner la proc´edure sur un ”sch´
ema algorithmique” qui repr´esente clairement les
boucles et les instructions de la proc´edure.
4. Les commandes if, for, while peuvent ˆetre utilis´ees hors des proc´edures.
> for k from 1 to 10
do k! ;
od ;
Dans ce cas, tous les r´esultats interm´ediaires sont affich´es (cela peut ˆetre int´eressant). Si l’on ne d´esire
pas les afficher, on peut remplacer le ”;” par un ”:” dans l’instruction principale.
5. D`es que Maple lit la commande return il quitte imm´
ediatement la proc´
edure et renvoie le r´esultat.
Cette commande peut ˆetre utilis´ee `
a n’importe quel endroit de la proc´edure (mˆeme `a l’int´erieur d’une
boucle). Cela peut, par exemple, ˆetre utile `a l’int´erieur d’un test if.
6. Il est parfois impossible d’exprimer une condition par une seule (in)´egalit´e. Dans ce cas, on peut exprimer
la condition par plusieurs (in)´egalit´es s´epar´ees par les op´erateurs and et or, signifiant respectivement
”et” et ”ou”.
> while a>0 and a<10
do ...
od ;
3
Messages d’erreurs
Lorsque certaines instructions sont erron´ees (cela arrivera, c’est ainsi que l’on progresse), Maple renvoie
d’habitude un message d’erreur ´ecrit en rose. Les messages d’erreurs les plus fr´equents sont parmi les suivants :
1. missing operator or ;
Il s’agit en g´en´eral d’un point-virgule ”;” oubli´e.
2. (in rtble/Sum) invalid arguments
Une commande est mal utilis´ee. Elle ne re¸coit pas le bon nombre de variables, ou celles-ci ne sont pas du
bon type.
6
3. invalid subscript selector
L’op´eration de s´election d’un ´el´ement (d’une liste) est impossible. En g´en´eral c’est une boucle mal initialis´ee qui demande `
a Maple de calculer des objets comme L[0] ou L[-1].
4. attempting to assign to ... which is protected
Certain noms d’objets sont prot´eg´es (par exemple ”D”, ”max”, ”sum”, ”diff”, etc). Si vous tentez de les
modifier, ce message apparaˆıt.
Dans le mˆeme genre d’erreurs on a aussi ”illegal use of an object as a name”.
5. reserved word ...unexpected
Maple a lu une commande qu’il ne s’attendait pas `a lire `a cet endroit. Il s’agit le plus souvent d’une
instruction if, for, while erron´ee, par exemple un fi ou od manquant.
6. illegal use of a formal parameter
Les arguments d’une proc´edure ne peuvent pas ˆetre modifi´es. Pour ´eviter ce message, il suffit de passer
par une variable auxiliaire.
4
Exercices
Exercice 8 Ecrire une proc´edure somme prenant en arguments deux entiers a et b et qui calcule la somme des
carr´es de tous les nombres entiers compris entre a et b inclus.
A l’aide de votre proc´edure, v´erifiez la formule suivante sur plusieurs exemples :
n
X
k=1
k2 =
n(n + 1)(2n + 1)
6
Exercice 9 Ecrire une proc´edure insertion qui prend en arguments une liste (non vide) L, un entier p, un
nombre a, et qui renvoie une liste correspondant `
a L apr`es insertion du nombre a en p`eme position.
Exercice 10 Ecrire une proc´edure fibo prenant en argument un entier n ≥ 2 qui calcule le terme un de la
suite de Fibonacci d´efinie par
u0 = 1, u1 = 1 et uk+2 = uk+1 + uk
Exercice 11 Ecrire une proc´edure maxliste prenant en argument une liste L qui renvoie l’indice du plus
grand ´el´ement de la liste. Si plusieurs indices conviennent, la proc´edure renverra le plus petit.
Exercice 12 Ecrire une proc´edure termeliste prenant en arguments une liste L et un nombre a qui renvoie
une liste contenant les positions du nombre a dans la liste L et une liste vide si a n’apparaˆıt pas dans L.
Exercice 13 Sachant que ex = lim
n
X
xk
, ´ecrire une proc´edure erreur qui prend en arguments deux r´eels
n
x X xk x et et qui renvoie le plus petit entier n tel que e −
< .
k! n→∞
k=0
k!
k=0
7

Download Report