Scilab Data type

functions - procédures Scilab et objets Scilab

### Description

Les fonctions Scilab sont des procédures ("macros", "fonction" et "procédures" ont la même signification).

### Définition de fonctions

Les fonctions sont tapées dans un éditeur de texte et chargées dans Scilab avec la commande `getf` ou via une librairie (voir `lib` ou `genlib`). Mais elles peuvent être définies en ligne (voir `deff` ou `function`). Une fonction est définie en deux parties :

- - une ligne de déclaration formelle

     function [y1,...,yn]=foo(x1,...,xm)
     function [y1,...,yn,varargout]=foo(x1,...,xm,varargin)

- - une suite d'instructions Scilab.

La "ligne de définition" donne la syntaxe d'appel complète de la fonction. Les `yi` sont les variables de sortie, calculées à partir des variables d'entrée `xi` et des variables existantes dans le contexte appelant lorsque la fonction est exécutée. On peut utiliser éventuellement un sous-ensemble de ces variables d'entrée et de sortie.

### Appel à une fonction

LA syntaxe d'appel est habituellement `[y1,...,yn]=foo(x1,...,xm)`. On peut utiliser éventuellement un sous-ensemble de ces variables d'entrée et de sortie. Dans ce cas, seules les premières variables à partir de la gauche sont utilisées. La fonction `argn` peut être utilisée pour connaître le nombre effectif d'arguments d'appel.

Il est aussi possible d'utiliser des "arguments nommés" pour spécifier les valeurs des arguments d'entrée : supposons que la fonction `fun1` est définie ainsi `function y1=fun1(x1,x2,x3)` alors on peut utiliser la syntaxe `y=fun1(x1=33,x3=[1 2 3])`, et dans `fun1` x2 ne sera pas défini. Il est possible de vérifier quelles sont les variables définies avec la fonction `exists`.

Quand une fonction n'a pas d'argument de sortie et est appelée avec des arguments d'entrée de type chaîne de caractère, la syntaxe d'appel peut être simplifiée : `fun('a','toto','une chaîne')` est alors équivalent à `fun a toto 'une chaîne'`

### Divers

Les fonctions sont des objets Scilab (numéro de type 13 ou 11). Elles peuvent être manipulées (passées en argument, sauvées, chargées, ...) comme toute autre variable.

Un ensemble de fonctions peut être assemblé dans une librairie. Les fonctions dont le nom commence par le caractère `%` (exemple : `%foo`) sont utilisées pour la surcharge des opérateurs (voir `overloading`) ou des fonctions pour des nouveaux types de données.

### Exemples

    // définition en ligne
    function [x,y]=myfct(a,b)
    x=a+b
    y=a-b
    endfunction

    [x,y]=myfct(3,2)

    // autre type de définition en ligne
    deff('[x,y]=myfct(a,b)',['x=a+b';
                             'y=a-b'])
    // définition dans un fichier texte (voir exec)
    exec SCI/macros/elem/asin.sci;

    // définition dans un fichier texte (voir getf)
    getf SCI/macros/elem/asin.sci;

### Voir aussi

`function` `deff` `getf` `comp` `lib` `getd` `genlib` `exists` `varargin` `varargout`