C.

Armana false
armana@[Link] Parfois, quand Maple ne dispose pas d’informations suffisantes, il ne peut pas évaluer
l’expression booléenne ; par exemple :
MK1 "Calcul formel" Maple > evalb(x>=y);
y−x≤0
Attention, la fonction evalb ne sait pas faire des calculs algébriques (contrairement à simplify),
TP5 : Programmation comme le montre l’exemple suivant :
> evalb( x^2-y^2 = (x-y) * (x+y) );
false
1.2 Les opérateurs logiques
Ils permettent de modifier des expressions booléennes :
Commandes pour les caractères spéciaux not (non)
Voici les commandes pour obtenir les caractères qui ne sont pas présents sur les claviers Mac. and (et)
pour { : Alt ( pour [ : Alt Shift ( or (ou inclusif)
pour } : Alt ) pour ] : Alt Shift ) (remarque : ils ne nécessitent pas d’utiliser evalb)
> not(1<2);
But du TP5
false
Maple est un langage de calcul formel, mais c’est aussi un langage de programmation. Nous
> 1<2 and 4<3;
allons voir comment créer des programmes avec Maple. Pour cela, nous allons utiliser des
structures communes à la plupart des langages de programmation : procédures, tests (if), boucles ( false
for, while), fonctions récursives. 1.3 Les fonctions booléennes
Les fonctions booléennes sont des commandes de Maple qui renvoient true ou false. Par exemple,
Et surtout, n’oubliez pas de vous (et de me) poser des questions ! nous avons vu la fonction iscont, qui permet de tester la continuité d’une fonction sur un
intervalle :
> iscont(tan(x),x=0..1);
1. Les booléens true
Il y a aussi la fonction type, qui permet de tester si une expression est d’un type donné. Par
On appelle expression booléenne une expression dont l’évaluation conduit ou bien à la valeur
exemple, la commande suivante permet de tester si Pi est un entier (integer) :
true (vrai) ou bien à la valeur false (faux). L’évaluation des expressions booléennes se fait par la
> type(Pi,integer);
commande evalb.
Les expressions booléennes sont très utiles en programmation car elles permettent d’effectuer false
des tests qui détermineront la suite des instructions à effectuer. Voici différentes méthodes pour (pour en savoir plus sur la commande type et les différents types possibles, consultez l’aide)
fabriquer des expressions booléennes..
1.1 Les opérateurs de comparaison 2. Les procédures
On peut former une expression booléenne en comparant deux expressions de même type à l’aide Une procédure est un petit programme qui a un nom, des entrées et une sortie. Au coeur du
d’un des opérateurs suivants : programme, il y a une suite d’instructions à accomplir. Une procédure utilise des variables qui lui
= (égale) sont propres (variables locales). Par exemple, la procédure suivante, qui se nomme différence,
<> (est différent de)
prend en entrées deux nombres x et y et renvoie leur différence.
< (est strictement inférieur à)
> différence:=proc(x,y)
> (est strictement supérieur à)
RETURN(x-y);
<= (est inférieur ou égal à)
end;
>= (est supérieur ou égal à)
Dans l’exemple suivant, on définit une expression booléenne avant de l’évaluer. différence := proc(x, y) RETURN(x − y ) end proc
> restart; > différence(4,5);
bool:=1<2; -1
bool := 1 < 2 (pour aller à la ligne lorsque vous tapez une procédure, utilisez les touches Maj Entrée )
> evalb(bool); * proc signifie que l’on est en train de définir une procédure (attention, il ne faut pas mettre de
true point-virgule après proc).
> evalb(Pi=3.14); * RETURN (en majuscules !) affiche le résultat de la procédure.
 fi false
* end signifie que la définition de la procédure est terminée. booléenne condition_2 et procède de même. Si aucune des expressions booléennes
Voici une procédure qui se nomme sommeproduit, qui prend en entrées trois nombres a,b et c, et condition_1,..,condition_n n’est vraie, Maple effectue les instructions_(n+1).
qui renvoie la liste formée de leur somme et leur produit. Au cours de la procédure, on stocke les
calculs intermédiaires dans des variables locales, qui sont auparavant déclarées par la ligne (rappels pour les non-anglophones : if=si, then=alors, else=sinon, elif est une contraction de else
local. if)
> sommeproduit:=proc(a,b,c)
local s,p; 4. Les boucles (for, while)
s:=a+b+c; Ce sont des structures itératives qui permettent de répéter un groupe de commandes un certai
p:=a*b*c; nombre de fois. Elles peuvent être employées dans des procédures.
RETURN([s,p]);
end: 4.1 For
> sommeproduit(2,3,4); Lorsqu’on sait à l’avance le nombre de répétitions, on utilise for, dont la syntaxe est :
[9, 24 ] for i from début to fin do instructions od ;
Cela signifie: pour i allant de début à fin, exécuter les instructions (i est une variable choisie par
Recommandation
l’utilisateur). En général, début et fin sont des nombres entiers. Par exemple, voici une boucle
En programmation, il est important de bien réfléchir à ce que l’on veut faire avant de passer sur la
for qui, pour i variant de 1 à 10, affiche i! .
machine. Avec un papier et un crayon, réfléchissez d’abord au programme : ses entrées, ses
> for i from 1 to 10 do
instructions, ses sorties. Ensuite, implémentez-le sur Maple. Cela permet de mieux distinguer les
i!
erreurs qui viennent de la conception du programme de celles dues à une mauvais syntaxe des
od;
commandes.
1
3. Le test (if) 2
La structure if permet de tester si une condition est vérifiée. Elle peut être employée dans une 6
procédure. Elle commence par un if et se termine par un [Link] un exemple avec une procédure 24
qui calcule le minimum de deux nombres : 120
> minimum:=proc(x,y) 720
if x<y then RETURN(x) else RETURN(y) fi ;
end: 5040
> minimum(7,-2); 40320
-2 362880
Les syntaxes possibles sont les suivantes. A chaque fois, les conditions sont des expressions 3628800
booléennes et les instructions sont des commandes Maple. Par défaut, le pas est 1. On peut spécifier un autre pas d’incrémentation à l’aide de by. Par
* Pour une exécution conditionnelle : exemple, si on décide d’aller de 2 en 2 :
if condition then instructions fi ; > for i from 1 to 10 by 2 do
Maple évalue d’abord l’expression booléenne condition. Si le résultat est true, alors les i!
instructions sont effectuées. Sinon, Maple passe à la suite (après le fi). od;
* Pour un choix binaire : 1
if condition then instructions_1 else instructions_2 fi; 6
Maple évalue d’abord l’expression booléenne condition_1. Si le résultat est true, alors les
120
instructions_1 sont effectuées. Sinon, Maple effectue les instructions_2.
* Pour un choix multiple : 5040
if condition_1 then instructions_1 362880
elif condition_2 then instructions_2 4.2 While
... On utilise la boucle while quand on doit déterminer "en cours de route" le nombre de
elif condition_n then instructions_n répétitions. Sa syntaxe est :
else instructions_(n+1) while condition do instructions od ;
fi La condition est une expression booléenne et les instructions sont des commandes Maple. Maple
Maple évalue l’expression booléenne condition_1. Si le résultat est true, alors les instructions_1 évalue l’expression booléenne condition. Tant qu’elle est vraie, il exécute les instructions.
sont effectuées et Maple passe à la suite (après le fi). Si c’est false, Maple évalue l’expression Quand elle est fausse, il passe à la suite (après le od).
(rappel pour les non-anglophones : while = tant que)
 5173
Par exemple, on souhaite calculer le plus petit entier n tel que la somme des entiers de 1 à n soit
3125
supérieure ou égale à 1000.
> somme:=0: a:=0: 32665061773
while somme<1000 do 30517578125
a:=a+1;
somme:=somme+a;
od:
a;
45
5. La récursivité
Maple accepte des fonctions et des procédure récursives , c’est-à-dire qui s’appellent elles-memes.
Soyez particulièrement soigneux lorsque vous utilisez la récursivité, c’est une source d’erreurs
importante. Il faut notamment prévoir un "cas d’arret" (un cas particulier sans appel récursif) et
etre sur qu’il se réalisera ; faute de quoi la récurrence ne s’arrete jamais !
Par exemple, la factorielle est définie sur les entiers naturels par la récurrence : n! = n * (n-1) !
avec 0!=1. On peut programmer la factorielle dans une procédure récursive :
> factorielle:=proc(n)
if n=0 then RETURN(1) # cas d’arret
else RETURN(n*factorielle(n-1)) # on appelle la procédure avec
l’entrée n-1
fi;
end:
> factorielle(0); factorielle(10);
1
3628800
> factorielle(-1);
Error, (in factorielle) too many levels of recursion

Voilà le message d’erreur qu’on obtient quand aucun cas d’arret n’a été prévu !

On aurait également pu définir la factorielle dans une fonction :

> f:=n->n*f(n-1); # relation de récurrence
f := n → n f(n − 1 )
> f(0):=1; # initialisation
f(0 ) := 1
> f(10);
3628800
Un autre exemple : la suite récurrente définie par :
si n ≤ 0, un = 3
4 un − 1 + 1
si 0 < n, un =
5
> u:=proc(n)
if n<=0 then RETURN(3) else RETURN((4*u(n-1)+1)/5) fi;
end:
> u(-3); u(0); u(5); u(15);
3
3
Université Paris 7 Premier semestre 2005-2006
Licence 1ère année MK1 - Maple

Feuille d’exercices n˚5

Exercice 1. Ecrire une procédure qui prend en entrée une fonction et qui trace sa
dérivée en sortie.

Exercice 2. Afficher la séquence des 20 premiers nombres premiers (ithprime) :

1) Avec la commande seq.
2) Avec une boucle for.

Exercice 3. Ecrire une procédure qui, étant donné les coordonnées x, y d’un point du
plan, calcule la distance entre les points (x, y) et (3, 4)· Calculer la distance de (7, −5) à
(3, 4).

Exercice 4. Ecrire une procédure permettant de savoir si un triangle est équilatéral,

étant données les longueurs de chacun des côtés. Même question pour un triangle rectangle.

Exercice 5. Nombres de Mersenne

Le n-ème nombre de Mersenne est Mn = 2n − 1, pour n ≥ 0. Ces nombres ont la propriété
suivante : si Mn est un nombre premier, alors n est un nombre premier. Cependant, la
réciproque n’est pas vraie.
1) Calculer le plus petit nombre premier p tel que Mp ne soit pas premier (isprime,
nextprime).
2) Donner Mp et sa factorisation en nombres premiers (ifactor ).

Exercice 6. Suite de Fibonacci

La suite de Fibonacci est la suite récurrente d’ordre deux définie par :


u0 = 0
u1 = 1


un+2 = un+1 + un pour n ≥ 2
1) Définir la suite de Fibonacci.
2) Calculer u10 , u25 .
3) Calculer u50 . Que remarquez-vous ? Pouvez-vous expliquez cela ?