structures de données
4.2.3 Les procédures et les fonctions Syntaxe généraleSyntaxe générale
Comme bien d’autres langages informatiques,Sage permet à l’utilisateur de définir des fonctions ou des instructionssur mesure. La commandedef dont la syntaxe est détaillée ci-dessous autorise la définition de procédures
— qui ne renvoient pas de résultat — ou defonctions — qui renvoient un résultat — avec un ou plusieurs arguments. Ce premier exemple définit la fonction (x, y)7→x2+y2 :
sage: def fct2 (x, y):
... return x^2 + y^2 ...
sage: a = var('a') sage: fct2 (a, 2*a) 5*a^2
L’évaluation de la fonction se termine par la commandereturndont l’argu-ment, icix2+y2, est le résultat de la fonction.
Une procédure est définie de la même façon sans renvoyer explicitement de résultat, et en l’absence de l’instruction return le bloc d’instructions définissant le sous-programme est évalué jusqu’au bout. En fait la procédure renvoie la valeur Nonequi veut bien dire ce qu’elle veut dire.
Par défautSage considère que toutes les variables intervenant dans une fonction sont locales. Ces variables sont créées à chaque appel de la fonction, détruites à la fin, et sont indépendantes d’autres variables de même nom pouvant déjà exister, comme dans les autres langages de programmation ; les variables globales ne sont pas modifiées par l’évaluation d’une fonction ayant des variables locales du même nom, et réciproquementSage empêche par défaut la modification des variables globales à l’intérieur d’une fonction :
BR
OUILLON
sage: def essai (u):
... t = u^2
... return t*(t+1) ...
sage: t = 1 ; u = 2 sage: essai(3), t, u (90, 1, 2)
L’exemple suivant reprend le calcul de la moyenne arithmético-harmonique de deux nombres supposés strictement positifs :
sage: def MoyAH (u, v):
... u, v = min(u, v), max(u, v) ; ... while v-u > 2.0e-8:
... u, v = 2*u*v/(u+v), (u+v)/2 ... return (u+v) / 2
...
sage: MoyAH (1., 2.) 1.41421...
sage: MoyAH # correspond à une fonction
<function MoyAH at ...>
La fonction MoyAH comporte deux paramètres notés u et v qui sont des variables locales dont les valeurs initiales sont fixées lors de l’appel de cette fonction ; par exemple moyAH(1., 2.)débute l’exécution de cette fonction avec ces valeurs 1.et 2.des variablesuetv.
La programmation structurée conseille de définir une fonction de façon à ce que la commande return soit la dernière instruction du bloc de la procédure. Placée au milieu du bloc d’instructions d’une fonction, cette commande returntermine l’exécution de la fonction en interrompant avant la fin l’évaluation complète de ce bloc ; en outre il peut y en avoir plusieurs dans différentes branches des tests.
La traduction informatique de l’état d’esprit des mathématiques suggère de programmer des fonctions renvoyant chacune un résultat à partir de leurs arguments, plutôt que des procédures affichant ces résultats par une commandeprint. Le système de calcul formelSage repose d’ailleurs sur de très nombreuses fonctions, par exempleexpousolve qui renvoient toute un résultat, par exemple un nombre, une expression, une liste de solutions, etc.
Méthode itérative et méthode récursive
Une fonction définie par l’utilisateur est construite comme une suite d’instructions. Une fonction est dite récursive lorsque son évaluation nécessite dans certains cas d’exécuter cette même fonction avec d’autres paramètres.
La suite factorielle (n!)n∈N en est un exemple simple :
0! = 1, (n+ 1)! = (n+ 1)n! pour toutn∈N.
BR
OUILLON
Les deux fonctions suivantes aboutissent au même résultat à partir d’un argument entier natureln; la première fonction utilise la méthode itérative avec une boucle for, et la seconde la méthode récursive traduisant mot pour mot la définition récurrente précédente :
sage: def fact1 (n):
... res = 1
... for k in [1..n]: res = res*k ... return res
...
sage: def fact2 (n):
... if n == 0: return 1
... else: return n*fact2(n-1) ...
La suite de Fibonacci est une suite récurrente d’ordre 2 car la valeur deun+2 dépend uniquement de celles deun et de un+1 :
u0= 1, u1 = 1, un+2=un+1+un pour toutn∈N. La fonction fib1 ci-dessous applique une méthode de calcul itératif des termes de la suite de Fibonacci en utilisant deux variables intermédiairesU et Vpour mémoriser les deux valeurs précédentes de la suite avant de passer au terme suivant :
sage: def fib1 (n):
... if n == 0 or n == 1: return 1 ... else:
... U = 1 ; V = 1 # les termes initiaux u0 et u1 ... for k in [2..n]: W = U+V ; U = V ; V = W ... return V
...
sage: fib1(8) 34
(Note : on peut aussi écrire U, V = V, U+V à la place de W = U+V ; U = V ; V = W.) La boucle applique à partir de n= 2 la relation un = un−1+ un−2. Cette méthode est efficace mais sa programmation doit transformer la définition de la suite de façon à l’adapter aux manipulations des variables.
Au contraire la fonction récursive fib2 suit de beaucoup plus près la définition mathématique de cette suite, ce qui facilite sa programmation et sa compréhension :
sage: def fib2 (n):
... if 0 <= n <= 1: return 1 # pour n == 0 ou n == 1 ... else: return fib2(n-1) + fib2(n-2)
...
Le résultat de cette fonction est la valeur renvoyée par l’instruction condi-tionnelle : 1 pourn= 0 etn= 1, et la somme fib2(n-1)+fib2(n-2)sinon ;
BR
OUILLON
chaque branche du test comporte une instructionreturn.
Cette méthode est cependant moins efficace car beaucoup de calculs sont inutilement répétés. Par exemple fib2(5)évalue fib2(3) et fib2(4) qui sont eux aussi calculés de la même manière. Ainsi Sage évalue deux fois fib2(3)et trois foisfib2(2). Ce processus se termine lors de l’évaluation defib2(0)ou defib2(1)de valeur 1, et l’évaluation defib2(n)consiste à calculer finalementunpar 1+1+· · ·+1. Le nombre d’additions effectuées pour déterminerunest sa valeur, car u0 =u1= 1 ; ce nombre est considérable et croît très rapidement. Aucun ordinateur, aussi rapide soit-il, ne peut calculer ainsiu50. D’autres méthodes sont aussi possibles, par exemple mémoriser les calculs intermédiaires par la commande cached_functionou exploiter une propriété des puissances de matrices pour calculer le millionième terme de cette suite présentée dans le paragraphe suivant d’exponentiation rapide.