Release date: 
Monday, 9 March, 2009



Authors/Port authors:

Agena is an easy-to-learn procedural programming language suited for everyday usage. It has been implemented as an interpreter and can be used in scientific, educational, linguistic, and many other applications. Its syntax looks like very simplified Algol 68 with elements taken from Lua and SQL.

This software is distributed as compressed package. You have to download and manually install it; if prerequisites are required, you will have to manually install them too.

Manual installation

Available both as 7 ZIP and WarpIN package:

  • download the 7 ZIP package to temporary directory and unpack it to destination folder;
  • the WarpIN package is self-installing.

See below for download link(s).

You can install the prerequisites with rpm running the following string in a command line:

yum install libc libcx libgcc1 libssp libstdc++6 libstdc++ libsupc++6 libsupc++ libgcc-fwd readline ncurses

Following ones are the download links for manual installation:

Agena v. 2.32.0 (24/9/2022, Alexander Walz) Readme/What's new
2.32.0, September 24, 2022 - Added six arithmetic binary operators that detect potential numeric overflow, underflow and division by zero and allow the user to invoke proper self-written functions that handle them: `inc` for addition, `dec` for subtraction, `mul` for multiplication, `div` for division and `intdiv` for integer division, plus `mod` for modulus. The operators after checking possible exceptions call user-defined handlers along with the operands and information on the kind of exception: `inc` calls `math.add`, `dec` calls `math.subtract`, `mul` calls `math.multiply`, `div` calls `math.divide`, `intdiv` calls `math.intdivide` and `mod` calls `math.modulo` (not `math.modulus`). Two examples: Division: the handler might look like this (`math.intdivide` and `math.modulo` may be similar, since the values for `kind` are the same): > math.divide := proc(n, d, kind) is > case kind > of 0b000 then return n/d # no exception > of 0b001 then error('division by zero') # denominator is zero, do not return `undefined` but throw an exception > of 0b010 then error('underflow') # very large value to be divided by very small value close to 0 > of 0b100 then return n/d # both numerator and denominator are close to 0 > esac > end; > 1 div 0: division by zero See Chapter 4.6.8 and 14.2 of the Primer and Reference for more examples, including addition and multiplication. The threshold that defines whether a value is `close to zero` can be set with `environ.kernel/closetozero`, which by default is `DoubleEps`, e.g.: > environ.kernel(closetozero = 1e-20); The type of numerical exception that occurred the last time one the six new operators has been invoked can also be queried by calling the new function `environ.arithstate` which returns the type of exception as a bit field, see case/of clauses above: > 1e308 inc 1e308: overflow > environ.arithstate(): 1 - Added various constants with a precision of 1,000 digits to the arbitrary precision MAPM package: Pi, E, sqrt(2), ln(2), Golden Ratio, etc. See the Primer and Reference, Chapter 11.3, for a list. - `mapm.xnumber` now accepts a second optional argument, the precision, that will be used for the specific value to be defined. The default still is 20. - In OS/2 and DOS, the `mapm` package did not correctly clean up memory, causing lost bytes at exit. This has been fixed. - Included examples on how to use the MAPM package in the Primer and Reference.
Agena Manual v. 2.32.0 (, Alexander Walz)
Agena source code v. 2.32.0 (Source code, , Alexander Walz)
Record updated last time on: 24/09/2022 - 19:59

Translate to...


Hello, thank you very much for listing me. Greetings from Bonn, Rhineland, Alex

Add new comment