Des exemples de programmes
Voici quelques exemples destinés à montrer les capacités d'Algae et à vous donner une idée de la manière dont il est utilisé. Le répertoire «exemples» de la distribution source d'Algae contient du code supplémentaire à consulter.
- Conversion de température : conversions de degrés Fahrenheit en degrés Celsius
- Lecture et sommation de nombres : lecture et sommation de nombres.
- Puissances entières : puissances entières.
Conversion de température
Ce programme Algae affiche un tableau des températures en degrés Fahrenheit et de leurs équivalents en degrés Celsius :
- # Conversions de température d'impression
-
- fahr = sort (0:300:20, 32, 212);
- celsius = (5/9)*(fahr-32);
- [fahr;celsius]'?
Son résultat ressemble à ceci :
[ 0.000 -17.78 ][ 20.00 -6.667 ]
[ 32.00 0.000 ]
[ 40.00 4.444 ]
[ 60.00 15.56 ]
[ 80.00 26.67 ]
[ 100.0 37.78 ]
[ 120.0 48.89 ]
[ 140.0 60.00 ]
[ 160.0 71.11 ]
[ 180.0 82.22 ]
[ 200.0 93.33 ]
[ 212.0 100.0 ]
[ 220.0 104.4 ]
[ 240.0 115.6 ]
[ 260.0 126.7 ]
[ 280.0 137.8 ]
[ 300.0 148.9 ]
Ce programme fait beaucoup de choses en seulement quatre lignes. La première ligne est entièrement un commentaire (car elle commence par #) et est ignorée par Algae.
Dans la deuxième ligne, nous définissons les températures Fahrenheit de notre tableau. L'expression 0:300:20 donne un vecteur allant de 0 à 300 par pas de 20. Nous ajoutons deux autres éléments, 32 et 212, à ce vecteur en utilisant l'opérateur virgule. Ensuite, nous utilisons la fonction de tri pour le trier par ordre croissant. Enfin, notre vecteur de températures Fahrenheit est affecté à la variable fahr. Rien n'est imprimé par cette instruction, car elle se termine par un point-virgule.
La troisième ligne calcule les équivalents Celsius en utilisant la formule de conversion familière. D'abord 32 est soustrait de chaque élément de fahr. Ensuite, chaque élément est multiplié par 5/9. Le résultat est affecté à la variable celsius. Ici encore, rien n'est affiché.
Même si jusqu'à présent tous les termes étaient des entiers, Celsius est un vecteur à valeur réelle. Contrairement à certains langages de programmation, la division entière dans Algae n'entraîne pas de troncature : l'expression 5/9 renvoie une valeur réelle d'environ 0,556.
La dernière ligne affiche les températures sous forme de matrice, avec les températures en degrés Fahrenheit dans la première colonne et leurs équivalents en degrés Celsius dans la deuxième colonne. Nous le faisons en utilisant des parenthèses pour former une matrice avec Fahr dans la première ligne et Celsius dans la deuxième ligne, puis en transposant la matrice avec l'opérateur «'». Le point d'interrogation à la fin n'est pas nécessaire, car la matrice serait également imprimée sans lui, mais il attire l'attention sur la ligne comme une ligne s'affichant.
Lecture et sommation de nombres
Ce programme Algae lit un tas de nombres, les additionne et affiche le résultat :
- # Lire et additionner quelques nombres
- sum = 0;
- $read = 1;
- while ($read) { sum += readnum(); }
- sum?
Le programme lit les nombres un par un et les additionne à sum, donc dans la première ligne sum est initialisé à zéro. La fonction readnum est utilisée pour lire les nombres. Cette fonction est l'une des rares fonctions standard qui a un effet secondaire : elle attribue à la variable $read le nombre de valeurs qu'elle lit. Il sera inférieur au nombre que vous avez demandé si readnum n'a plus de données.
La boucle while exécute ses instructions à plusieurs reprises jusqu'à ce que sa condition soit vraie. Nous définissons d'abord $read à 1 (vrai), donc nous savons que la boucle while s'exécutera au moins une fois. Après cela, la boucle while continue jusqu'à ce que $read soit finalement défini à 0 par la fonction readnum. Lorsque la boucle while est terminée, la dernière ligne affiche sum.
En général, nous donnons à la fonction readnum deux paramètres : un vecteur "shape" et un nom de fichier. Le vecteur "shape" décrit le nombre de valeurs à lire et sous quelle forme (vecteur, matrice,...) elles doivent être renvoyées. Les valeurs sont lues à partir du fichier nommé. Étant donné que le programme ci-dessus ne donne aucun paramètre, readnum lit simplement une valeur à partir du périphérique d'entrée standard.
L'opérateur += ajoute la valeur de droite à la variable de gauche ; l'expression sum+=readnum() fait la même chose que sum=sum+readnum(). Chaque fois que la boucle while se répète, sum est augmenté de la valeur renvoyée par readnum. Lorsque readnum n'a plus de données, il renvoie 0 (donc sum n'est pas modifié) et définit $read sur 0 (donc la boucle while arrête de boucler).
À moins que vous ne redirigiez l'entrée standard, ce programme lira tranquillement ce que vous tapez jusqu'à ce que vous signaliez une fin de fichier (C-d sur les systèmes UNIX et C-z sur VMS).
Puissances entières
Ce programme illustre l'utilisation d'une fonction. Nous y définissons la fonction power calculant les puissances entières de son paramètre. Nous montrons également du code Algae appelant power.
- # power: élever « x » à la puissance « n »
- power = function (x; n)
- {
- local (y);
- y = x;
- while (n > 1)
- {
- y = y * x;
- n -= 1;
- }
- return y;
- };
-
- power (2; 8)?
- power ([ 1, 2; 2, 3 ]; 4)?
La première ligne de ce programme est une instruction d'affectation ordinaire, affectant la fonction de son côté droit à la variable power. Les paramètres de la fonction sont définis dans les parenthèses suivant le mot-clef function. Dans ce cas, il y a deux paramètres : x et n.
Dans Algae, tous les paramètres de fonction sont appelés «par valeur». Lorsqu'une fonction est appelée, elle obtient des copies de ce que le programme appelant a donné comme arguments et peut les modifier sans changer les valeurs retenues par le programme appelant. Dans la fonction power, nous décrémentons n à chaque fois dans la boucle while, mais cela n'a aucun effet sur le programme appelant.
L'instruction locale définit son argument, la variable y, comme ayant une portée locale. Cela signifie que power a sa propre variable temporaire appelée y qui est définie uniquement dans cette fonction. Cette y reçoit d'abord la valeur de x puis, à l'intérieur de la boucle while, elle est multipliée à plusieurs reprises par x jusqu'à ce que n ne soit plus supérieur à 1.
La valeur que power calcule est renvoyée à son appelant par l'instruction return. N'importe quelle expression peut suivre return, et n'importe quel nombre d'instructions return peut apparaître dans une fonction. Si la fonction n'a pas d'instruction de retour, elle renvoie NULL à son appelant.
La première fois que nous appelons power, elle renvoie (et le programme appelant imprime) la valeur 256. Dans ce cas, power n'est vraiment pas très utile, car nous aurions pu obtenir le même résultat avec l'expression 2^8 en utilisant l'opérateur d'exponentiation d'Algae.
La fonction power a cependant une utilité, comme le montre le deuxième appel. L'opérateur d'exponentiation d'Algae fonctionne dans un sens élément par élément, donc [1,2;2,3]^4 renvoie :
[ 1 16 ][ 16 81 ]
En revanche, la puissance fonctionne dans un sens matriciel. Dans le programme ci-dessus, elle renvoie :
[ 89 144 ][ 144 233 ]
L'algorithme utilisé dans la fonction puissance ci-dessus peut être amélioré en utilisant des élévations successives au carré :
- power = function (x; n)
- {
- if (n == 1)
- {
- return x;
- elseif (n%2)
- return x * self (x; n-1);
- else
- x = self (x; n/2);
- return x * x;
- }
- };
Cette fonction de puissance peut être utile, mais elle n'est certainement pas prête à être utilisée. Notez qu'elle donne des réponses erronées si n est 0 ou un entier négatif. Que se passe-t-il pour l'expression power(4;1/2), dans laquelle n n'est pas un entier ? Pour rendre la fonction power plus robuste, vous souhaiterez probablement ajouter des instructions if pour vérifier les arguments illégaux.