les fonctions en Scilab

Les fonctions en Scilab

Une fonction est un bloc d'instructions nommé, réutilisable, qui accepte des paramètres d'entrée et retourne des résultats de sortie. Utiliser des fonctions permet de structurer le code, éviter la duplication et faciliter la maintenance.

1. Définition d'une fonction

// Forme complète — n sorties, p entrées
function [y1, y2, ..., yn] = nomFonction(x1, x2, ..., xp)
    // corps de la fonction
endfunction

// Forme avec une seule sortie
function y = nomFonction(x1, x2)
    // corps de la fonction
endfunction

// Forme sans sortie (procédure)
function nomFonction(x1, x2)
    // corps de la fonction
endfunction

Exemples de définition

Exemple n°1 — Fonction à une entrée, une sortie

// Fonction qui multiplie x par 2
function y = doubler(x)
    y = 2 * x
endfunction

// Appels
disp(doubler(5))     // 10
disp(doubler(-3))    // -6

10
-6

--> doubler(7)
 ans =
    14.

Exemple n°2 — Fonction à deux entrées, deux sorties

// Fonction qui retourne 2*x1 et 3*x2
function [y1, y2] = simplef(x1, x2)
    y1 = 2 * x1
    y2 = 3 * x2
endfunction

Cette fonction peut être appelée de trois façons selon le nombre de sorties souhaitées :

// Appel sans variable de sortie → résultat dans ans (y1 uniquement)
--> simplef(1, 2)
 ans =
    2.

// Appel avec une seule variable de sortie → récupère y1
--> y1 = simplef(1, 2)
 y1 =
    2.

// Appel avec les deux variables de sortie
--> [y1, y2] = simplef(1, 2)
 y1 =
    2.
 y2 =
    6.

// simplef(1, 2) sans capture → ans = 2.
// [y1, y2] = simplef(1, 2)  → y1 = 2. | y2 = 6.

// Récupérer seulement y2 (ignorer y1)
[~, y2] = simplef(1, 2)
disp(y2)   // 6.

Exercices appliqués

function f = factorielle(N)
    f = 1
    for i = 2 : N
        f = f * i
    end
endfunction

// Tests
for n = [0, 1, 5, 10]
    disp("factorielle(" + string(n) + ") = " + string(factorielle(n)))
end

factorielle(0)  = 1
factorielle(1)  = 1
factorielle(5)  = 120
factorielle(10) = 3628800

function [m, M] = minmax(a, b)
    if ( a <= b ) then
        m = a
        M = b
    else
        m = b
        M = a
    end
endfunction

// Test
[petit, grand] = minmax(7, 3)
disp("Min = " + string(petit) + "  |  Max = " + string(grand))

Min = 3  |  Max = 7

2. Instruction return

L'instruction return provoque la sortie immédiate de la fonction en cours, même s'il reste des instructions dans le corps. Elle est utile pour gérer les cas limites ou les erreurs d'entrée en début de fonction.

function y = maFonction(x)
    if ( condition_invalide ) then
        y = valeur_par_defaut
        return      // ← quitte immédiatement la fonction
    end
    // instructions normales (non atteintes si return déclenché)
    y = calcul(x)
endfunction

// ❌ Sans early return — imbrication profonde
function y = f(x)
    if (x >= 0) then
        if (x <= 100) then
            y = x * 2   // logique principale enfouie
        end
    end
endfunction

// ✅ Avec early return — logique principale en évidence
function y = f(x)
    if (x < 0)    then y = 0; return; end
    if (x > 100)  then y = 0; return; end
    y = x * 2    // logique principale visible immédiatement
endfunction

Exemple n°3 — Somme des entiers de istart à iend

function y = mysum(istart, iend)
    // Cas limite 1 — borne de départ négative
    if ( istart < 0 ) then
        y = 0
        return
    end
    // Cas limite 2 — ordre incorrect
    if ( iend < istart ) then
        y = 0
        return
    end
    // Cas normal — calcul de la somme
    y = sum(istart : iend)
endfunction

Vérifions les trois cas de comportement :

// Cas normal : somme de 1 à 5 = 1+2+3+4+5
disp(mysum(1, 5))     // 15

// Cas limite : istart négatif → return immédiat
disp(mysum(-1, 5))    // 0

// Cas limite : iend < istart → return immédiat
disp(mysum(2, 1))     // 0

// Cas normal : somme d'un seul élément
disp(mysum(4, 4))     // 4

15
0
0
4

function r = diviser(a, b)
    if ( b == 0 ) then
        disp("Erreur : division par zéro !")
        r = 0
        return
    end
    r = a / b
endfunction

// Tests
disp(diviser(10, 2))    // 5.
disp(diviser(7, 0))     // Erreur + 0
disp(diviser(9, 3))     // 3.

5.
Erreur : division par zéro !
0
3.

Récapitulatif