Agena 2.9.1 + Portable
This post was published 8 years ago. Download links are most likely obsolete. If that's the case, try asking the uploader to re-upload.
Agena 2.9.1 + Portable | 16.5 Mb
Agena is a programming language that uses a type of syntax that is comparable to Algol 68, while also comprising features from LUA, SQL or Maple. It functions as an imperative language, meaning that it requires the input of every step an application needs to go through in order to reach a state or output a result.
This programming language is aimed mainly at scientific, linguistic and educational uses, but it can even be used for scripting, depending on the intentions and requirements of its users. It offers a satisfying processing speed for real and complex mathematics and graphics operations.
Agena offers support for a variety of basic functions which are specific to this type pf programming languages, such as assignments, conditions ('If', 'Then', 'Elif', 'OnSuccess', 'Else'), loops ('For', 'In', 'While', 'Do / As', 'Do / Until'), procedures and many others.
This language can work with several data types, ranging from complex and rational numbers, to booleans, null value, vectors, threads, the most basic of which are integrated in its kernel for performance reasons. At the same time, Agena supports procedures with a full lexical scope.
Following an uneventful installation process, users can launch Agena either from the start menu or by entering 'agena' in a shell. At the same time, AgenaEdit is also installed, that users can work with in parallel. Users can start entering commands into the Console as well as being writing the code they wish to create in AgenaEdit.
By resorting to the extensive documentation, users can get a handle on this imperative language through the step by step indications, the statement and assignment examples provided, so they can gradually becoming proficient in its use.
To conclude, Agena is a procedural programming language that can be used for a variety of purposes, ranging from script writing to educational or scientific applications.
FEATURES
• an arbitrary precision mathematical library
• easy configuration of your personal environment via the Agena initialization file
• an easy-to-use package system also providing a means to load a library and define short names for all package procedures at a stroke (with function)
• enumeration and multiple assignments
• scope control via the scope/epocs keywords
• the external switch to a numeric for loop to pass the last iteration value to its surrounding block
• functions to support fast text processing (see in, replace, lower, and upper operators, as well as the functions in the strings and utils packages)
• the binio package to easily write and read files in binary mode,
• facility to store any Agena data to a file and read it back later into a new session (save and read functions)
• efficient statements for stack programming (insert/into and pop/from)
• undergraduate Calculus, Linear Algebra, and Statistics packages
• bitwise operators
• direct access to the file system
• xBase file support (complient to dBASE III) to exchange data with standard applications
New in version 2.9.1 (October 31, 2015)
• The new `++` operator returns the next representable number larger than its argument. Likewise, `--` returns the next representable number smaller than its argument. They can be used to create open intervals, e.g. "1 in ++1 : --2" returns false, and use the same underlying C function as math.nextafter. With variables passed as arguments, the operators do not modify, i.e. increase or decrease, them (see `inc` and `dec` statements instead)
• `put` now supports registers
• With sets, the standard assignment `setname[key] := value` is now supported. If value is `null`, key is deleted from the set. If value is not `null`, key is added to the set.
• `rawset` can now delete a value from a set by passing the value as the second and `null` as the third argument.
• The new function `numarray.purge` removes a given element from an array.
• `numarray.include` can now insert a single number instead of an array into a numarray. - The new function `numarray.used` returns the estimated number of bytes consumed by the given array.
• Arrays can now be reduced to zero size by `numarray.resize`.
• When shrinking an array, `numarray.resize` no longer fills slots to be deleted with zeros. This prevents arrays from being modified if memory re-allocation fails.
• The new environ.kernel/readlibbed setting returns a set of all the libraries imported in a session. The equivalent package.readlibbed set may be deprecated in the future. Likewise, environ.kernel/loaded returns the names of all standard libraries available after start-up.
• The `insert` and `delete` statements did not cope well with complex expressions, e.g. "insert 1 into f.g(x)", with function f.g returning a structure. This has been changed.
• With metamethods attached to tables, sequences and registers, the `insert` statement either failed or incorrectly added a value. This has all been fixed.
• The `delete` statement did not support metamethods and thus allowed to purge values from structures protected by a proper read-only metamethod. Now, the delete statement supports metamethods: it passes `null` as the value and the data to be deleted as its key to the __writeindex metamethod. To protect values stored to structures you might define: > readonly_mt.__writeindex := proc(t, k, v) is > if unassigned v or assigned rawget(t, k) then > error('cannot delete or modify') > else > rawset(t, k, v) > fi > end; - The `pop`, `rotate`, `duplicate`, and `exchange` statements now issue an error if a structure features a __writeindex metamethod. This prevents read-only structures from being modified. - The `restart` statement did not delete loaded metatables from the environment. This has been fixed.
• In DOS, `math.tobytes` did not work. The function now just returns `fail` on this operating system.
• Improved the manual.
OS: Windows 2K / XP / Vista / 7 / 8 / 8 64-bit / NT