-->racine_carree(2)
ans =
 1.4142136 
On voit là l'importance des parenthèses vide lorsque l'on utilise une fonction qui n'a pas de paramètre. Par exemple
a = gce
crée une copie de la fonction codice_142, tandis que
a = gce()
met dans la variable "a" le résultat de la fonction codice_142 (voir "Graphiques et sons > Organisation des entités graphiques").
Définition compacte d'une fonction.
Une fonction peut aussi se définir en une ligne à l'aide de l'instruction codice_144 :
deff ("[y] = f(x)", "y=2*x")
Cette définition est équivalente à :
function [y] = f(x)
 y = 2*x
endfunction
Cette syntaxe permet également de définir des fonctions comportant plusieurs instructions :
deff ("[y] = puissance(x, n)", "y = 1, if n > 0 then, for i = 1:n, y = y*x, end, end")
Cette écriture, bien que compacte, rend difficile la compréhension de la fonction, et ne devrait être réservé qu'aux fonctions simples.
De même qu'avec le mot clef codice_145, le résultat des calculs n'est pas affiché à l'intérieur d'une fonction.
Gérer le nombre de paramètres transmis.
Lorsqu'une fonction est créée pour un seul programme, on peut facilement gérer le nombre de paramètres : le programmeur sait ce qu'il doit transmettre lors de l'appel de la fonction. Mais une fonction peut être amenée à être utilisée dans d'autres programmes, par d'autre programmeurs, par exemple en étant intégrée à une bibliothèque (voir "Bibliothèque de fonctions" et "Recommandations". Il faut alors envisager
Si un paramètre codice_146 peut avoir une valeur par défaut, on peut tester son existence avec codice_147 :
function [y] = monproduit(x, p)
 // paramètre optionnel
 if exists("p", "l") == 0...
 then p = 1; end // valeur par défaut
 y = x*p;
endfunction
On peut définir une fonction avec un nombre variable d'arguments. Le dernier argument doit alors être codice_148 "(variable arguments input)" ; dans la fonction, codice_148 est une liste, codice_150 donne donc le i-ème argument optionnel. Le nombre total d'arguments est donné par la commande codice_151(le « 2 » est un paramètre imposé). Par exemple
function [y] = produit_multiple(x, varargin)
 // paramètre optionnel
 n = argn(2);
 y = x;
 for i = 1:n - 1
 y = y*varargin(i);
 end
endfunction
que l'on peut tester avec
 produit_multiple(5)
 produit_multiple(5, 4)
 produit_multiple(5, 4, 2)
Si l'on veut utiliser la totalité des paramètres, il faut utiliser codice_152. Par exemple, si l'on ne désire tracer que les dix premiers points d'un jeu de données mais en permettant de passer des paramètres pour modifier le tracé :
function [y] = trace_10_premiers(x, y, varargin)
 plot(x(1:10), y(1:10), varargin(:))
endfunction
que l'on peut tester par exemple avec
 x = rand(1, 100)
 y = rand(1, 100)
 scf(0); plot(x, y)
 scf(1); trace_10_premiers(x, y, "r", "thickness", 2)
De la même manière, on peut utiliser codice_153 "(variable arguments output)" dans les paramètres de sortie, et « remplir » la liste codice_153 dans la fonction. Le nombre total de paramètres de sortie est donné par codice_155. Si codice_153 est le seul paramètre de sortie, alors les éléments de la liste sont « égrénés », par exemple
function [varargout] = test_varargout()
 varargout = list(1, 2, 3, 4);
endfunction
donne :
--> a = test_varargout()
 a = 
 1.
--> [a, b] = test_varargout()
 b = 
 2.
 a = 
 1.
S'il y a d'autres arguments de sortie que codice_153, alors la liste est transmise comme une variable unique. Par exemple :
function [n, varargout] = test_varargout1()
 varargout = list(1, 2, 3, 4);
 n = argn(1);
endfunction
donne :
--> a = test_varargout1()
 a = 
 1.
--> [N, L] = test_varargout1()
L = 
 L(1)
 1.
 L(2)
 2.
 L(3)
 3.
 L(4)
 4.
 N = 
 2.
Notons que dans ce cas-là, on a un nombre de paramètres de sortie fixe, pas variable, puisque codice_153 est "un" paramètre unique. On pourrait utiliser n'importe quel nom de liste.
Informations sur une fonction.
La commande codice_159 donne la liste des paramètres d'entrée et sortie de la fonction codice_160, sous la forme d'un vecteur :
La commande codice_161 renvoie un vecteur de chaînes de caractères contenant la définition de la fonction.
La commande codice_162 renvoie les commentaires situés au début de la fonction codice_160.
On peut aussi vouloir caractériser un script complet. Une manière de faire consiste à mettre le script dans une fonction et à utiliser la commande codice_164. On peut aussi comparer, avec codice_165, la liste des variables, obtenue avec codice_166, avant et après le chargement du script. Par exemple
variables_avant = who("local");
exec("monscript.sce");
variables_du_script = setdiff(variables_avant, who("local"));
Variables locales ou globales.
Par défaut, toutes les variables sont locales, c'est-à-dire qu'elle sont définie dans un environnement d'exécution "(workspace)". Ainsi, une variable dans une fonction peut avoir le même nom qu'une variable dans le programme principal ou dans une autre fonction, ce seront des variables distinctes ; modifier la valeur d'une variable dans une fonction ne modifie pas la valeur de cette variable dans le programme principal.
On peut modifier ce comportement avec la commande codice_167 ; c'est une manière inélégante — voire risquée, car on ne maîtrise pas totalement la valeur de la variable — de gérer une valeur sans avoir à la passer en paramètre à une fonction. Cela peut être utile lorsqu'une valeur est utilisée et modifiée par de nombreuses fonctions — cela allège la syntaxe des fonctions —, mais cela rend le code moins portable (voir la section "Du code… Général"), et il faut être sûr de quelle fonction modifie la valeur et quand, voir par exemple sur Wikipédia "Parallélisme (informatique) > Dépendance des données".
Lorsque l'on veut partager une variable entre plusieurs environnements, il faut déclarer la variable comme globale dans chaque environnement. Par exemple, le script suivant :
clear()
// fonctions
function modifie()
 global("a") // déclare la variable comme globale dans l'environnement de la fonction
 a = 5
endfunction
// programme principal
global("a") // déclare la variable comme globale dans l'environnement de base (programme principal)
a = 1;
disp("Valeur initiale : "+string(a)) // affiche la valeur initiale
modifie();
disp("Valeur finale : "+string(a)) // affiche la nouvelle valeur
donne
 Valeur initiale : 1 
 Valeur finale : 5 
On peut partager une variable entre fonctions sans qu'elle soit partagée avec l'environnement du programme principal, par exemple le script
clear()
// fonctions
function initialisation()
 global("a")
 a = 1
 disp("a = "+string(a))
endfunction
function utilisation()
 global("a")
 disp("a = "+string(a))
endfunction
// programme principal
errcatch(4, "continue") // n'interrompt pas le programme lorsqu'une variable
// n'est pas définie
initialisation()
disp("a = "+string(a)) 
errclear(4) // apurement des erreurs de type 4
utilisation()
donne
 a = 1 
 disp("a = "+string(a))
 !--error 4 
 Variable non définie : a