### 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 met ensuite `:=` puis on met entre des accolades (ou entre `begin` et `end`) le bloc qui définit la fonction c’est à dire la suite des instructions (chaque instuction se termine par `;`) et si l’algorithme définissant la fonction a besoin de variables locales, ces variables devront être déclarées en mettant au début du bloc `local` 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 :

    toto(a,b):={
    local q,r,s;
    <instrucion-1>;
    ........... ;
    <instrucion-n>;
    return r;
    }

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`.
Si on veut qu’une variable déclarèe avec `local` 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ées
    [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`