Agena 2.36.1

Agena est un langage de programmation qui utilise un type de syntaxe comparable à Algol 68, tout en comprenant également des caractéristiques de LUA, SQL ou Maple. Il fonctionne comme un langage impératif, ce qui signifie qu'il exige la saisie de chaque étape qu'une application doit franchir pour atteindre un état ou produire un résultat.

Ce langage de programmation est principalement destiné à des usages scientifiques, linguistiques et éducatifs, mais il peut même être utilisé pour la création de scripts, selon les intentions et les exigences de ses utilisateurs. Il offre une vitesse de traitement satisfaisante pour les opérations mathématiques et graphiques réelles et complexes.

Agena supporte une variété de fonctions de base spécifiques à ce type de langage de programmation, telles que les affectations, les conditions ('If', 'Then', 'Elif', 'OnSuccess', 'Else'), les boucles ('For', 'In', 'While', 'Do / As', 'Do / Until'), les procédures et bien d'autres.

Ce langage peut travailler avec plusieurs types de données, allant des nombres complexes et rationnels aux booléens, en passant par les valeurs nulles, les vecteurs, les threads, dont les plus basiques sont intégrés dans son noyau pour des raisons de performance. En même temps, le logiciel Agena supporte les procédures avec une portée lexicale complète.

Agena propose diverses fonctions de contrôle de flux, telles que :
- Les conditions if/then/elif/onsuccess/else.
- Des conditions case of/onsuccess/else similaires aux instructions switch/case du C.
- Opérateur if pour renvoyer des valeurs alternatives.
- Boucles numériques for/from/to/by où les valeurs de départ, d'arrêt et de pas sont facultatives, et correction automatique des erreurs d'arrondi des variables d'itération.
- Les boucles numériques for/from/downto/by où les valeurs de pas sont facultatives,
les boucles numériques combinées for/while.
- Les boucles for/in sur des chaînes de caractères et des structures de données complexes.
- Des boucles while, do/as et do/until similaires aux itérateurs while et repeat/until not() de Modula.
- Une instruction skip pour déclencher prématurément l'itération suivante d'une boucle.
- Une instruction break pour quitter prématurément une boucle.
- Une instruction redo pour redémarrer l'itération actuelle d'une boucle.
- Une instruction relaunch pour redémarrer une boucle depuis le début.
- Try/catch pour gérer les exceptions.
- Les nombres rationnels et complexes, avec des extensions telles que l'infini et l'indéfini.
- Les chaînes de caractères.
- Les booléens tels que true, false et fail.
- La valeur null qui signifie "rien".
- Des tableaux polyvalents implémentés sous forme de tableaux associatifs pour contenir tout type de données, tirés de Lua.
- Les ensembles de Cantor en tant que collections d'éléments uniques.
- Des séquences, c'est-à-dire des vecteurs, pour stocker en interne des éléments dans un ordre séquentiel strict.
- Les paires pour contenir deux valeurs ou passer des arguments dans n'importe quel ordre aux procédures.
- Des registres, c'est-à-dire des vecteurs de taille fixe qui peuvent également contenir des données grâce à leur pointeur vers le sommet.
- Des types définis pour les séquences, les tableaux, les registres et les paires afin de permettre des manipulations spécifiques.
- La validation des types de données à l'aide des opérateurs : : et :- et la possibilité d'utiliser les deux-points dans les listes de paramètres.
- Les threads, userdata et lightuserdata hérités de Lua.
- Les multisets (sacs), les listes à liaison simple, simple non enroulée et double, les tas, les cartes bidirectionnelles et les nombres doubles.

avec un scoping lexical complet sont également supportés, et fournissent les extensions suivantes :
- La syntaxe << (args) -> expression >> pour définir facilement des fonctions simples.
- Des tables de mémorisation pour effectuer une récursion à grande vitesse et à faible consommation de mémoire, pour se souvenir des résultats déjà calculés, et pour utiliser des résultats prédéfinis.
- Des types définis par l'utilisateur.
- La variable système nargs qui contient le nombre d'arguments réellement passés à une procédure.
- Des métaméthodes héritées à l'origine de Lua pour définir des opérations pour les tables, les ensembles, les séquences, les registres, les paires et les données utilisateur.
- Des méthodes de style OOP pour les tables.
- Des opérateurs binaires auto-définis.

Nouveautés & Corrections

Version 2.36.1 du 30/01/2023
- `io.open` did not accept the 'a+', 'r+' and 'w+' options and also did not recognise the 'b' switch. This has been fixed.
- `io.infile` and `io.readfile` now support pattern matching.
- `skycrane.isemail` has been significantly improved, now also accepting preceding or trailing comments in the local-part of an address.
- The new C API function `agn_strmatch` searches a string for a substring, supporting pattern matching.
- The new C API functions `luaL_newref`, `luaL_pushref` and `luaL_freeref` originally written by Rici Lake for Lua 5.1 allow to work with C reference to objects in the Agena stack.

Version 2.36.0 du 26/01/2023
- The new function `stack.cbrtd` computes the cubic root of the top element of the current numeric stack.
- The new function `stack.hypotd` computes the hypotenuse of the two top elements of the current numeric stack.
- The new function `stack.hypot4d` computes sqrt(x^2 - y^2) of the two top elements of the current numeric stack.
- The new function `stack.invhypotd` computes the inverse hypotenuse of the two top elements of the current numeric stack.
- The new function `stack.pythad` computes the Pythagorean equation a^2 + b^2 of the two top elements of the current numeric stack.
- The new function `stack.fmad` conducts the fused multiply-add operation x*y+z for the top three elements of the current numeric stack.
- The new function `stack.sinhd` computes the hyperbolic sine of the top element of the current numeric stack, in radians.
- The new function `stack.coshd` computes the hyperbolic cosine of the top element of the current numeric stack, in radians.
- The new function `stack.tanhd` computes the hyperbolic tangent of the top element of the current numeric stack, in radians.
- The new function `stack.arcsinhd` computes the inverse hyperbolic sine of the top element of the current numeric stack, in radians.
- The new function `stack.arccoshd` computes the inverse hyperbolic cosine of the top element of the current numeric stack, in radians.
- The new function `stack.arctanhd` computes the inverse hyperbolic tangent of the top element of the current numeric stack, in radians.
- The new function `stack.arctan2d` computes the arc tangent of y/x of the two top elements of the current numeric stack, in radians.
- `stack.mapd` can now entirely work on the stack and not only process one stack element, but others too, if the first argument `true` is given. Example: We have a function of three parameters x, y, z that returns x*y + z. The call puts the top three argumements 3, 2, 4
- > pushd 3, 2, 4
- > stack.mapd(true, << x, y, z -> fma(x, y, z) >>):
- `stack.mapd` did not properly check for invalid indexes. This has been fixed. Also improved error messages.
- Extended the C API: The new C macros `lua_istrue`, `lua_isfalse` and `lua_isfail` check whether a stack value is a boolean and then whether it is true, false or fail.
- For speed, the C API functions `agn_istrue`, `agn_isfalse` and `agn_isfail` have become C macros.