Procédures et Récursivité


Généralités.

En fonction des paramètres donnés, la procédure est évaluée et retourne un résultat qui est une expression Maple : tableau, liste, ....
Lorsqu'une procédure doit rendre plusieurs résultats, on rend en général la suite des résultats dans une seule liste.
On distingue dans une procédures 3 types de variables. On peut décrire des options dans une procédure :
Appel :

proc (arg1, arg2, ...,argn) local l1,l2, ...,ln; global g1,g2,...,gn; options remember(optionel),trace(optionnel); traitement end

Paramètres :
arg1, arg2, ... ,argn - arguments
l1,l2, ...,ln - variables locales
g1,g2,...,gn - variables globales

Exemple - Calcul de la somme des n premiers éléments d'un tableau T

somme:=proc(n)
       local i,s;
       global T;
       option remember;
       s:=0;
       for i from 1 to n do
          s:=s+T[i]
       od;
       RETURN(s)
end:
Attention, parfois la procédure ne peut rendre aucun résultat. On alors coutume de renvoyer une erreur en restituant la valeur prédéfinie en maple FAIL.
Exemple
divise:=proc(a,b)
          if b=0 then RETURN(FAIL) else RETURN(a/b) fi
end:
>divise(a,0);
                                 FAIL
>divise(8,4);
                                   2

Passage des paramètres.


Maple utilise toujous un passage de paramètres par valeur. Ainsi lorsqu'on appelle la procédure somme avec somme(a), la valeur de a est recopiée dans la variable n qui est interne à la procédure somme. Si l'on appelle la procédure avec une variable n (par exemple n:=3; double(n); ) il faut avoir à l'esprit que sous la lettre n se cachent deux entités autonomes Lors de l'appel de la procédure somme, il y a

Récursivité.

Examinons la suite définie par
u1=1
un=un-1+n pour n > 1
Nous avons vu qu'une procédure permettant le calcul de son nième terme est :
suite:=proc(n)
          local i,s;
          option remember;
          s:=0;
          for i from 1 to n do
              s:=s+i;
          od;
          RETURN(s)
end:
La récursivité consiste à remplacer une boucle par un appel à la procédure elle-même. L'exemple ci-dessus devient :
suite:=proc(n)
          option remember;
          if n=1 then RETURN(1) else RETURN(suite(n-1)+n) fi
end:
Plusieurs appels à la procédure peuvent être exécutés dans son corps. Soit la suite dite de fibonacci définie par :
u0=1
u1=1
un=un-1+un-2 pour n > 2
la procédure s'écrit tout aussi simplement
fibo:=proc(n)
          option remember;
          if (n=0) or (n=1) then RETURN(1) else RETURN(fibo(n-1)+fibo(n-2)) fi
end:
L'écriture récursive est parfois la plus naturelle!