### 9.1.2 La forme d’une fonction

Une fonction renvoie une valeur : l’instruction return valeur; ou retourne valeur; fait sortir du programme et renvoie valeur.
Une fonction a un nom (par exemple toto), puis on met entre des parenthèses les arguments de la fonction (par exemple si toto a besion de deux paramètres a et b on met toto(a,b)).
On peut définir une fonction :

1. soit avec les mots clés fonction....ffonction
   fonction toto(a,b) ....ffonction entourent le bloc qui définit la fonction toto c’est à dire les instructions qui définissent la fonction.
2. soit avec :=
   on met toto(a,b):= puis les accolades { et } (ou begin et end) entourent le bloc qui définit la fonction toto c’est à dire les instructions qui définissent la fonction.
3. soit si on utilise le langage Python, on utilise le mot-clé def (voir la compatibilité de Python dans Xcas).

Dans le bloc qui définit la fonction chaque instuction se termine par ;
Si l’algorithme qui définit la fonction a besoin de variables locales, ces variables devront être déclarées en mettant au début du bloc local (ou var) puis, les noms des variables locales séparés par des virgules puis, ; pour terminer cette déclaration. Ces variables locales peuvent être initialisées lors de leur déclaration. On écrit par exemple :

    fonction toto(a,b)
    local s,p;
    s:=a+b;
    p:=a*b;
    return [s,p];
    ffonction:;

ou

    toto(a,b):={
    local s,p;
    s:=a+b;
    p:=a*b;
    return [s,p];
    }:;

Attention Les variables locales ne sont pas des variables formelles et doivent toujours être affectèes dans le corps du programme : on ne définira donc pas les variables formelles,avec local (ou var).
Si on veut qu’une variable déclarèe avec local (ou var) soit formelle (par ex a), il faudra mettre dans le corps du programme soit purge(a) soit assume(a,symbol).
Exemple

    kk(a):={
    local x,c;
    c:=4*a;
    return solve((x-c)^2-a=0,x);
    }:;
    f(a):={
    local x,c;
    c:=4*a;
    assume(x,symbol);
    return solve((x-c)^2-a=0,x);
    }:;
    g(a):={
    local c;
    c:=4*a;
    return solve((x-c)^2-a=0,x);
    }:;

On tape :
kk(1),f(1),g(1)
On obtient :
list[],list[3,5],list[3,5] Il ne faut pas tenir compte du message renvoyé pas Xcas lors de la compilation :
"Attention : x, declarée(s) comme variable(s) globale(s) en compilant g" car dans solve la variable x est toujours symbolique.

Remarque on peut initialiser les variables locales en même temps que leur déclaration à condition de mettre des parenthèses, par exemple :
local (q:=1),(r:=0),s;

Attention Il est important de déclarer les variables locales car une variable globale est évaluée avant l’execution de la fonction qui s’en sert lorsque cette fonction est appelée par une autre fonction...on risque donc d’avoir des ennuis si une fonction qui utilise une variable globale est appelée par une autre fonction, par exemple :

      truc(a,b):={
        if (b!=0) {
          r:=irem(a,b);
        } else {
          r:=b;
        }
        return r;
      };

    machin(a,b):={
    local rr;
    rr:=truc(a,b);
    return rr;
    }

L’exécution de truc(45,6) ne pose pas de problème et renvoie 3, mais l’exécution de machin(45,6) renvoie le message d’erreurs :
sto 3 not allowed! Error: Bad Argument Type
car lorsque truc est appelé par machin r qui est une variable globale est evaluée et alors r:=irem(a,b) n’est pas possible car r vaut 3....
Il est donc important de tenir compte du message donné par Xcas lors de la compilation de truc :
//Parsing truc //Warning, check that the following variables are global: r compiling truc à condition que les variables signalées ne soient pas des variables formelles. Voici comme exemple le programme qui donne la valeur de la suite de Fibonnacci définie par u0=u0,u1=u1,un+2=un+1+un. Dans ce programme on utilise les variables formelles x,A,B qui doivent être purgées.
On tape :

    u(n,uo,u1):={
    local L,a,b;
    //verifier que A,B,x ne sont pas affect\'ees
    [a,b]:=solve(x^2-x-1,x);
    L:=linsolve([A+B=uo,A*a+B*b=u1],[A,B]);
    return normal(L[0]*a^n+L[1]*b^n);
    };

On tape :

u(3,0,1)

On obtient :

2

Dans ce programme, les variables x,A,B ne doivent pas être déclarées comme variables locales car ce sont des variables formelles : il ne faut donc pas tenir compte lors de la compilation du warning : // Warning: x A B declared as global variable(s) compiling u