Vous êtes sur la page 1sur 2

Li

en e 1  ULIN101 Cours  Ph. Janssen et J.F. Vilarem Septembre 2004 p. 18/ 23


6 Memento Maple
Types et Algo. Types et Opérations Exemple Remarques
Maple
Entier integer +,-,*,mod,... 12345 268 435 448 hires
Réel float +,-,*,/,, ..., log, sin, 4.
exp,... 41.87 ou 0.4187e2 mantisse : 4187 exposant : -2
fra tion +,-,*,/,,... 15/9 Pas un type de base. Utilisé
souvent en Maple. Pas de
onversion en ottant, don
al uls longs.
Booléen boolean and,or,not true,false Règles de maple identiques à
elles du ours.
opérations de evalf evalf(2/3) onvertit l'argument numé-
onversion rique en l'approximation
ottante, i i 0.66666...
floor, eil, trun , fra , floor(45.67) renvoie un entier, i i 45
round
evalb evalb(x = 5 ) évalue son argument en tant
qu'expression booléenne.

Instru tion du Lang. Algo. Tradu tion en Maple


variable := expression ; variable := expression ;
Instru tion1 ; Instru tion2 ; ... ; Instru tion n Instru tion1 ; Instru tion2 ; ... ; Instru tion n
Algorithme
Algorithme : ExAlgo ExAlgo := pro (a::integer, b::integer)::integer ;
Données : a,b : Entier des ription " Des ription de la pro édure" ;
Résultat : des ription du résultat qui # i i la dé laration de variables lo ales
est, par exemple, entier lo al u :: integer , m :: boolean ;
/*Partie éventuelle de dé laration des instru tion 1 ;
variables lo ales, par exemple : */ ... ;
u :Entier, m :booléen; return u ;
début end pro ;
instru tion 1 ;
... ;
retourner u ;
n algorithme
Cas parti ulier d'une pro édure à un paramètre et dont le orps est limité au al ul d'une expression. Maple permet d'utiliser
le ra our i dit "pro édure è he". Exemple :
Algorithme : ExFon tion ExFon tion := a -> 2 * a + 1 ;
Données : a : Entier
Résultat : L'entier 2 * a + 1
début
retourner 2*a + 1 ;
n algorithme
Les instru tions onditionnelles :
si Cond alors if Cond then
Inst1 ; Inst1;
... ; ...;
Instn; Instn;
n si end if ;
si Cond alors if Cond then
Inst1 ;... ;Instk Inst1 ; ...;Instk ;
sinon else
Instk+1 ;... ;Instn
n si Instk+1 ; ...;Instn ;
end if ;
si Cond1 alors if Cond1 then
Inst1 ; ... ; Inst1 ; ...;
elif Cond2 then
sinon si Cond2 alors Inst2 ; ...;
Inst2 ;... ;
else
sinon
Inst3 ;... ; Inst3 ; ...;
n si end if ;

suite ->
Li en e 1  ULIN101 Cours  Ph. Janssen et J.F. Vilarem Septembre 2004 p. 19/ 23
Les variantes des itérations pour
pour V ar de Exp1 à Exp2 par pas de for Var from exp1 to exp2 by exp3 do
Expr3 faire Inst ; ... ;
Inst ; ... ; end do;
npour
pour V ar de Exp1 à Exp2 faire for Var from exp1 to exp2 do
Inst ; ... ; Inst ; ... ;
npour end do;
L'itération tant que
tant que Cond faire while ond do ;
Inst ; ... ; Inst ; ... ;
n tq end do;

Tableaux en Langage Algorithmique Tableaux en Maple


Attention, en Maple on dé lare un tableau, mais on ne peut typer ses éléments. Dommage.
T : array 1..5 of Entier; T :: array(1..5) ;
T[1℄ := 3; T[3℄ := 5; T[1℄ := 3; T[3℄ := 5;
Dé laration et initialisation. Notez bien le := à la pla e du : :
T : array 1..3 of Entier; T := array(1..3, [8,7,6℄) ;
T[1℄ := 8; T[2℄ := 7 ; T[3℄ := 6;
A ès aux éléments d'un tableau.
T : array 1..3 of Entier; T := array(1..3, [8,7,6℄) ;
T[1℄ := 8; T[2℄ := 7 ; T[3℄ := 6; T[2℄ := T[1℄ mod T[3℄;
T[2℄ := T[1℄ mod T[3℄;

Tableau paramètre d'un algorithme.


Algorithme : f f := pro ( T::array(integer))::integer;
Données : T un tableau d'entiers des ription "renvoie la somme des éléments de T";
Résultat : la somme des élements de T lo al i::integer, S::integer;
S,i : Entier; S := 0;
début for i from 1 to taille(T) do
S := 0; S := S + T[i℄;
pour i de 1 à taille(T) faire end do;
S := S + T[i℄ return S;
npour end pro ;
retourner S
n algorithme
x :: integer;
x : Entier; T := array(1..3, [8,7,6℄) ;
T : array 1..3 of Entier; x := f(T) ; ...;
T[1℄ := 8; T[2℄ := 7 ; T[3℄ := 6;
x := f(T); ...;

Tableau résultat d'un algorithme. Unique as où on s'autorise l'ae tation de tableaux. Attention à la syntaxe Maple.
Algorithme : f f := pro ( N::integer)::array(integer);
Données : N un entier positif des ription "renvoie le tableau des N premiers impairs";
Résultat : Le tableau de taille N dont lo al i::integer, T::array ;
les éléments sont les N T :=array(1..N);
premiers entiers impairs non for i from 1 to N do
nuls T[i℄ := 2 * i - 1;
i : Entier ; T : array 1..N of Entier ; end do;
début return eval(T);
pour i de 1 à N faire end pro ;
T[i℄ := 2*i - 1 R:array;
npour R := array(1..3) ;
retourner T R := f(3);...;
n algorithme
R : array 1..3 of Entier;
R := f(3); ...;