Name | Modified | Size | Downloads / Week | Status |
---|---|---|---|---|

Totals: 5 Items | 195.4 kB | 4 | ||

Manuals | 2016-08-15 | 11 | ||

Sources | 2016-08-14 | 7 | ||

Binaries | 2016-08-14 | 11 | ||

Packages | 2016-01-02 | 1 | ||

README.TXT | 2016-08-15 | 195.4 kB | 4 |

agena >>
`The Power of Procedural Programming`
What are the Changes ?
----------------------
2.9.8, August 14, 2016
New features:
- The new `|` operator compares two numbers a, b, and returns -1 if a < b, 0 if a = b, and 1 if a > b. It is twice than fast as the `sign` operator.
- The new `|-` operator computes the absolute difference of two numbers x and y, i.e. abs(x - y).
- The new `identity` function just returns all its arguments.
- The new function `strings.compare` compares two strings and returns the first position where they differ, or 0 if both strings are equal. If called with any option, the function returns the result of the C function strcmp.
- The new `astro.cweek` function returns the calendar week of the given date, a number in the range 1 to 53, according to the ISO 8601 standard.
- The new function `astro.lastcweek` determines the last week of a year.
- The new function `astro.cweekmonsun` computes the Gregorian dates of the Monday and Sunday for a given calendar week.
- The new function `os.esd` computes the Excel Serial Date.
- The new function `os.tzdiff` computes the difference between the system's local time zone and UTC in minutes and a Boolean indicating whether daylight Saving Time is active for the given date.
- The new function `stats.freqd` returns a frequency distribution function for a sample that can be iterated subsequently to return the number of all occurrences step by step.
- The new `xbase.fieldtype` function returns the dBASE data type of the given field.
- The new `xbase.write` function writes a number, string, or boolean to a dBASE file. It can be used instead of `xbase.writenumber`, `xbase.writefloat`, `xbase.writestring`, `xbase.writeboolean`, etc.
- The new C API function `agn_checknonnegint` checks for non-negative integers.
- The new C API function `agn_datetosecs` takes a structure or at least three numbers and returns the number of seconds elapsed since the epoch of the system (usually January 01, 1970).
- The new C API function `agnL_createpairnumbers` puts a pair of two numbers on top of Agena's C stack.
Improvements:
- `hypot` has become around 40 % faster. `polar`, `approx`, `ilog2`, `calc.eucliddist`, `stats.neighbours` and various fractals package functions benefit from this increas in speed, as well.
- `math.roundf` has become 13 percent faster.
- `calc.eucliddist` now accepts multivariate functions and returns more precise results.
- `calc.iscont` and `calc.limit` now can also process multivariate functions. If you would like give a self-defined epsilon, it must be passed as an 'eps':<value> option as the very last argument. For example, if the function is f := << (x, y) -> x + y >>, with x = 1, y = 3, and eps = 1e-4, the call would be: `calc.limit(f, 1, 3, eps = 1e-4)`.
- `calc.diff` now can also process multivariate functions. If you want to pass a user-defined accuracy value h, pass the eps=h option as the very last argument instead of passing h as the third argument.
- `calc.limit` can now return the left-sided limit by passing the side='left' option, the right-sided limit by passing the side='right' option, the left- and right-sided limit by passing the side='both' option; and the bidirectional, the left-sided, and the right-sided limits with the side='all' option.
- `os.date`: the day of week ('wday' field) is now determined according to the ISO 8601 norm, where 1 is Monday, and 7 is Sunday. You may switch back to the old behaviour (1 for Sunday, 7 for Saturday) by issueing
environ.kernel(iso8601 = false).
- `os.date`: The '*j' (Julian Date) and '*l' (Lotus Serial Date) options have been re-introduced as they have been inadvertently removed in Agena 2.8.4. Contrary to the former results returned with the '*l' format, the function now
returns correct values.
- `os.now` and `os.settime` now accept year, month, and day, and optionally hours, minutes and seconds.
- `os.date` now also accepts a table array of integers representing year, month, day, and optionally hour, minute, second.
- `os.datetosecs` now accepts no argument at all and in this case returns the number of seconds elapsed till the current
date and time.
- When passing `false` as the last argument to `os.lsd`, the function acknowledges daylight saving time (by default, the function always returns a Standard Time value even if Daylight Saving Time is active for the given date).
- `astro.cdate` now also returns hours, minutes and seconds in ordinary sexagesimal notation.
- In Windows and eComStation, `os.realpath` now by default returns a path with slashes instead of backslashes. You can override this by passing `false` as a second option.
- `stats.obcount` and `stats.obpart` can now be passed the number of classes into which a distribution shall be subdivided with the new 'classes' option. Also, if no third argument is passed to the function, it automatically computes the step size (aka class width), with no upper limit (it is suggested to choose between 5 or 30 classes).
- `stats.obcount` now accepts an optional fourth argument, a procedure that is applied on any element of a distribution before the function decides into which subinterval to sort it for the final count.
- Improved memory allocation error management of `stats.quartiles` and `stats.fivenum`.
- Improved error handling of `stats.checkcoordinate` `math.inttofpb`, `math.tobinary`.
- `xbase.new` now also accepts the data type name 'Numeric' which is equal to 'N' and 'Number'. (There is no dBASE data type called 'Number'.)
- The xbase package now supports signed 4-byte integers (Visual Fox Pro 'I' or 'Long' data type). Use `xbase.writelong` or `xbase.writenumber` to write 4-byte integers to a dbf file. The function automatically truncates Agena numbers to their integral part and issues an error if the numeric range [-2'147'483'647, +2'147'483'647] is exceeded. Longs can be read by LibreOffice 5.x Calc, but not by Excel.
- The xbase package now supports timestamps (Visual Fox Pro 'T' data type). Use `xbase.writetime` to write them.
- dBASE binary Double values can now be read by LibreOffice 5.x Calc. They can still not be read by current Excel editions.
- `xbase.attrib` now also returns the dBASE version number.
- `xbase.new` can now be given an explicit dBASE version number with the new version=x option. (See documentation of `xbase.new` for valid values for x). If no version option is passed, then by default the dBASE version is 0x03 = 3 decimal = dBASE III+. If at least one of the given fields is of type 'Double', then the version number is automatically changed to 0x30 = 48 decimal = Visual Fox Pro. This allows dBASE files created with Agena and containing binary Doubles to be imported into LibreOffice 5.x. Current versions of Excel still cannot read Visual Fox Pro dbf files, so you might pass the version option.
- Besides xBASE doubles, `xbase.writenumber` can now also write xBASE floats, longs, and binary doubles. Thus, you must no longer need to check whether to use `xbase.writefloat`, `xbase.writelong`, or `xbase.writedouble`. Also improved error message.
- The manual has been improved.
Bug Fixes:
- `calc.limit` sometimes returned wrong results with removable singularities. This has been fixed.
- The already documented `hypot2` function has now been implemented. It computes sqrt(1 + x^2), avoiding over- and underflows.
- `os.lsd` works again if one or more arguments have been passed to it, and also now returns a correct result with dates before March 01, 1900.
- `os.settime` now works as described in the manual.
- `os.drivestat` and `os.settime` are available (again) in Linux.
- `zx.genseries` always crashed. This has been fixed.
- `utils.readcsv` now returns an error if both enclosing single and double quotes shall be removed from field values.
- `skycrane.readcsv` now by default only deletes enclosing double quotes; single quotes around fields can no longer be
removed.
- `stats.obcount` and `stats.obpart`: The following feature does now work as described in the manual: "[...] if an element in a distribution equals the right border of the overall interval, it is considered part of the last subinterval."
- `math.tosgesim` has been rewritten in C, improved in precision and no longer returns the second or minute 60 or greater. It has also become 30 percent faster.
- `math.nthdigit` could not retrieve a digit in the fractional part of a number. This has been fixed.
- `mdf` and `xdf` rounded all numbers to the wrong direction. This has been fixed. Thus, `xdf` can now be used to truncate floats to a given decimal place.
- `gdi.pointplot` may not have worked when evaluating thickness and linestyle options. This has been fixed.
- `os.drivestat` might not have worked in Sun Solaris. This has been fixed.
2.9.7, February 01, 2016
- The new `intdiv` statement conducts an integer division of its operands and reassigns the result to the first operand.
- The new function `calc.iscont` returns `true` if a real function is continuous at a given point, and `false` otherwise.
- The new function `calc.limit` returns the limit of a function at a given point.
- The new function `calc.eucliddist` computes the Euclidian distance, i.e. the straight-line distance, of two points on a curve defined by a function in one real.
- The new function `calc.arclen` returns the arc length (curvilinear length) of a function in one real between two points.
- The new function `calc.sinuosity` computes the ratio of the curvilinear length and the Euclidean distance between the end points of a curve.
- The new function `calc.symdiff` computes the symmetric derivative of a function at a point. The function is three times faster than `calc.xpdiff`, but a little less accurate.
- `math.eps` can now also compute a `mathematical` epsilon value that also takes into account the magnitude of its argument, by passing any second argument. It prevents huge precision errors with computations on very small and very large numbers.
- `environ.kernel` returns the maximum path length with the 'pathmax' option.
- `clock.tm` has been tuned.
- Added another fix to `math.convertbase` with respect to the internal stack used.
- `utils.readcsv` did not correctly strip empty quoted fields and fields enclosed by quotes containing delimiters - this has been fixed.
- `approx` returned a wrong result (i.e. `true`) if at one of its first two arguments was `infinity` and the other one was finite. This has been fixed.
- In Windows, when pressing CTRL + C to quit the interpreter, the warning `This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information.` should no longer be issued.
- The test suite has been corrected.
- The number of internal number stacks has been extended from one to three stacks. You can switch between them by calling the new function `switchd` with its argument between 1 and 3. The default is stack #1. The new function `stack.selected` returns the currently selected/active stack.
When given a stack number, `allotted` returns the current number of values in the given stack. `stack.resetd` now also accepts one or more stacks to be cleared by passing their number(s).
- The new function `stack.sorted` sorts all or the last given number of elements in the stack in ascending order.
- The new function `stack.choosed` returns the number of the stack with the least number of stored values.
- `stack.reversed` did not correctly check negative arguments. This has been fixed.
- `pushd` can now insert values into a given stack by passing the stack = <stack number> option as the last argument, avoiding explicit stack switches with calls to `switchd`. Using this option, however, may slow down the operation since processing an option takes quite some computation time. You may be better off calling `switchd`.
2.9.6, January 03, 2016
- The `create table` statement can now pre-allocate both the array _and_ hash parts of a new table, e.g. `create table a(10, 200)`.
- `math.convertbase` generally cleared the built-in numerical stack and thus could interfere with other functions still needing it. This has been changed.
- In Windows, the `bye` statement sometimes caused unnecessary warnings of the operating system. This has been fixed by now conducting a final standard garbage collection and completely closing the state of the interpreter.
- `os.exit` now by default clears the interpreter state before leaving. The description of the function in the manual has been corrected, too.
- `pushd` now accepts a sequence of numbers to be added to the built-in number stack.
- `stack.reversed` can now reverse the last n values pushed onto the stack, e.g. `stack.reversed(n)`.
- `resetd` has been moved to the `stack` library. An alias to this former base library function has been added for backward compatibility.
- If the initialiser of `tables.dimension` is a structure, the function now creates an indidual copy of it to avoid referencing to the same structure. This was the behaviour of the former `dimension` baselib function.
- The `mapm` package did not correctly free some of the consumed memory at exit. This has been fixed. Also, the garbage collection of the package trims the memory usage to significantly reduce general footprint of this library.
- In Debian, the `gdi` package has been recompiled and hopefully would now only need the zlib package as a dependency ... Also, libexpat2 and libgd2-xpm are no longer pre-requisites for the Debian installer.
2.9.5, December 30, 2015
- The new function `math.tobinary` converts a non-negative integer into its binary representation, a sequence of zeros and ones.
- The new function `tables.newtable` returns a table with a given number or pre-allocated array and hash slots.
- `dimension` has been completely rewritten and can now create any kind of n-dimensional table. The function has also been moved to the `tables` library (new function `tables.dimension`). An alias to the former `dimension` function in the basic library has been added for backward compatibility.
- The `to` indexing method for tables did not work properly with some types of index ranges and in theses cases wrongly returned all elements in the array part of a table. This has been fixed.
- With structures, the `case/of` statement now compares values for strict equality (like the `==` operator). Formerly, a Cantor-like equality check has been conducted where positions and the number of occurence of elements in a structure do not matter.
- `stack.dumpd` can now also dump the last n values pushed onto the stack.
- If `ads.iterate` receives a file handle only, the very first key ~ value pair in the base is returned (same as passing the empty string as the second argument). The function now can also read sequences: in this case, the function returns an iterator function that when called returns the next entry in the sequence database.
- `ads.getall` now returns an Agena sequence of all the entries stored in a sequence database if any second argument is given. The entries are returned in the order of their physical presence in the database file; if one and the same entry is stored multiple times, it is returned multiple times.
- `ads.createbase` now returns nothing, since returning the handle of a closed file did not make sense.
- Memory leaks in `ads.createbase` and `ads.iterate` have been removed.
- `ads.filepos` has been documented.
2.9.4a, December 26, 2015
- Windows only: Due to a very kind hint by an Agena user, the missing dynamic link library libgcc_s_dw2-1.dll needed by the gdi and gzip packages has been added to the Windows installers.
2.9.4, December 07, 2015
- The new function `stats.midrange` computes the sum of the minimum and maximum value of a distribution, divided by two.
- The new `|` operator compares two finite numbers a, b, determines whether a is less than b, a is equal to b, or a is greater than b, and returns -1, 0, or 1 respectively.
- A numerical stack has been built into Agena. It can store numbers only. See Chapter 7.41 of the Primer and Reference for details.
- Agena for Windows has been recompiled with GCC 4.8.1. The binaries are around 20 percent faster now.
- `math.tobytes` had been rewritten for it did not work correctly if Agena had been compiled with GCC 4.8.x or higher. Thus, it now also works in DOS.
- `mapm.xtonumber` could not convert a mapm arbitrary precision number into an Agena number. This has been fixed.
- Improved error messages of `gzip.lines` and of `run`.
- Some source files have been cleaned up, so Agena should compile better with very pedantic C compilers.
- Extended the test suite.
2.9.3, November 17, 2015
- The new `// ... \\` constructor allows to define a table of constant numbers and/or strings the simple way: items may not be separated by commas, and strings do not need to be put in quotes as long as they satisfy the criteria for valid variable names (name starting with a hyphen or letter, including diacritics). Records are supported as well. Expressions like `sin(0)` etc. are _not_ parsed. Example:
> a := // 0~0 1 2 3 zero one two three '2and3' \\:
[0 ~ 0, 1 ~ 1, 2 ~ 2, 3 ~ 3, 4 ~ zero, 5 ~ one, 6 ~ two, 7 ~ three, 8 ~ 2and3]
- The new function `math.wrap` conducts a range reduction of a number to a given interval [min, max).
- The new `inrange` operator checks whether a number is part of an interval. It is five times faster than the `in` operator. "inrange(x, a, b)" is equivalent to "x in a:b".
- C-style comments ( /* ... */ ) are now supported.
- The `**` operator turned into an infinite loop if the exponent was +/- `infinity` or `undefined`. This has been fixed.
- The new `zx` package provides various elimentary mathematical functions implementing Chebyshev polynomials for sine, cosine, tangent, arcus sine, arcus cosine, arcus tangent, natural logarithm, exponentiation to the base E, general exponentiation, and square root. These functions are C implementations of the corresponding Sinclair ZX Spectrum 48k ROM Z80 assembler routines.
Furthermore, some auxiliary functions are provided to directly compute Chebyshev polynomial with a given coefficient vector, to reduce the range of arguments, and to retrieve or change Chebyshev coefficients. For completeness, pendents of all other ZX Spectrum math and Boolean functions are available, as well.
2.9.2, November 04, 2015
- The new `utils.uuid` function creates a random version 4 universally unique identifier (UUID), or the nil UUID.
- `os.exit` now closes the state of the interpreter before leaving for the operating system if its last argument is the Boolean `true`.
- In eComStation, the 'halt' switch to `os.terminate` can now halt the system, but it does not power it off.
- The new `registry` package provides limited access to the registry and should be used instead of the `debug.getregistry` function.
- The `system` function in the `debug` library has been moved to the `environ` package. An alias has been provided for backward compatibility.
- Garbage collection has been changed when deleting set entries via indexing.
- In the manual, the chapters on sandboxes and scripting have been improved. Also, userdata, lightuserdata, and the registry are now briefly described. The Crash Course has been extended, as well.
2.9.1, October 30, 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.
2.9.0, October 23, 2015
- The new `case of <condition>` syntax flavour is an alternative to the `if` statement, similar to the `switch` statement in the Go programming language. It may improve the readability of code. Example:
> case
> of x < 0 then return -1
> of x = 0 then return 0
> else return 1
> esac
- `case` statements can now check whether numbers or characters are included in ranges, e.g.:
> case value
> of -1 to 1 then return true
> of 'a' to 'c' then return true
> esac
- In `case` statements, the arrow token (->) can be used instead of the `then` keyword.
- The new `odd` operator checks for odd numbers (integers).
- The new `mod` statement computes the modulus of its operands and reassigns the result to the first operand.
- The new function `math.isinfinity` checks for positive or negative infinity in one call.
- The new `numarray` package implements arrays of C doubles, 32-bit integers, and unsigned chars and can also read and write binary files.
- `math.tobytes` can convert an integer into a sequence of four bytes if given the optional number 4. Likewise, `math.tonumber` can convert a sequence of four bytes to a number.
- The `environ.kernel/minlong` and `environ.kernel/maxlong` settings have been moved to `debug.system`. Two new constants have been added to the math package: `math.smallest` and `math.largest` represent the smallest and largest positive representable number and - contrary to the debug.system settings - are computed and assigned during start-up.
- In Solaris, eComStation - OS/2, and DOS, the `abs` operator returns a more precise result with complex numbers.
- `environ.kernel` can now return the smallest positive and largest representable Agena number (= C double). More number ranges have been added to `debug.system`.
- Sometimes the `print` funtion printed one and the same table value with a numeric key twice. This has been fixed.
- `calc.linterp` and `calc.polygen` could possibly crash Agena, this has been fixed.
- In Windows 2000 and earlier, `os.cpuload` crashed Agena. This has been fixed.
- Corrected error message of `llist.purge`.
- The `hashes` package accidently also stored its package table to the registry. This has been changed.
2.8.6, September 29, 2015
- The new function `math.rint` rounds a float to an integer according to the current rounding mode (see environ.kernel/rounding).
- The new function `os.realpath` converts each pathname argument to an absolute pathname, with symbolic links resolved to their actual targets and no . or .. directory entries.
- The new function `os.strerror` returns the text message for the given error code, or the latest error issued by the underlying operating system.
- `os.setenv` now allows to remove environment variables by passing the second argument `null` (as already mentioned in the manual).
- A potential memory leak has been removed from the Windows version of `os.getenv`.
- Agena crashed in the Windows edition of `os.setenv` if the environment variable name or its value exceeded 32,766 characters. This has been fixed.
- The new command-line option `-s` issues a user-defined slogan at start-up.
- The new command-line option `-x` surpresses the initialisation of the main Agena library file lib/library.agn at start-up. Setting this switch may be useful for debugging purposes only, or to save memory. Many functions, however, will not be available if this option is used.
- The `-n` (do not run initialisation file(s)) command-line switch has been ignored by the `restart` statement. This has been fixed.
- The new `environ.kernel` settings `skipinis` and `skipmainlib` control whether Agena initialisation files and the main Agena library are loaded during a `restart`.
- The new `environ.kernel` setting `rounding` sets or retrieves the current rounding mode.
- `environ.kernel`: Agena could crash when reading or changing the `digits` setting. This has been fixed.
- The new C API functions `agn_isvalidindex` and `agn_stackborders` determine valid stack positions. The functions may be useful for debugging purposes, only.
2.8.5, September 01, 2015
- `antilog2` and `antilog10` now automatically use the same function called by the `^` exponentiation operator (i.e. C's pow) if their arguments are out of the bounds +/- 308.2547155599167 and +/- 1024, respectively, instead of simply returning 0 or `infinity`.
- The new `xnor` operator implements the if-and-only-if Boolean operator which return true if both its operands are the same, and `false` otherwise.
- With functions of two arguments called like binary operators: before, only simple names could be used in the call expression; now, indexed names and even esoteric calls to functions returning functions are allowed, as well:
> add := << x, y -> x + y >>;
> 1 add 2: # -> 3
> t := [add = << x, y -> x + y >>];
> 1 t.add 2: # -> 3
> 1 t['add'] 2: # -> 3
> subtract := proc() is return << x, y -> x - y >> end
> 2 subtract() 2:
- The new function `math.fdima` returns x - y if x >= y, and a default otherwise.
- `os.system` could not detect properly detect Windows 10. This has been fixed.
- `os.unmount` crashed in Sun Solaris 10. This has been fixed.
- The plus library DLL files in the portable Windows version of Agena 2.8.4 had been out-of-date. This has been changed.
- `xor`, `nand`, and `nor` have been tuned a little bit.
2.8.4, August 23, 2015
- The new function `math.quadrant` returns the quadrant of an angle given in radians and returns an integer in [1, 4].
- The new function `math.fdim` returns x - y if its argument x is greater than y, else returns 0.
- The new function `math.isminuszero` checks for minus zero (-0).
- The new function `math.symtrunc` returns its argument if it is in a given range, and a default otherwise.
- In Windows, Solaris, and Debian, `math.signbit`, `math.isordered`, `fma`, `finite`, `log2`, as well as `int`, `frac` and their related functions now use C functions provided by the underlying platform instead of self-defined implementations.
- `math.signbit` now returns correct values on formerly unsupported platforms, instead of just zero.
- Both `antilog10` and `antilog2` have become five times faster by using the respective Cephes Math Library implementations. Please note the new ranges for the arguments: +/- 308.2547155599167 and +/- 1024, respectively. If the argument is out of these bounds, the operators return 0 or `infinity`. For very small arguments, you might use the `^` operator.
- `stats.prange`, `stats.iqmean`, `stats.trimean`, `stats.quartiles`, `stats.fivenum`, `stats.smm`, and `stats.gsmm` now use the introsort algorithm to sort observations instead of traditional recursive Quicksort, to speed up computation times.
- Positive numbers can now be preceded with the `+` token, as asserted in the manual. This will not effect anything.
- `os.cpuload` crashed in Windows 2000 and earlier. This has been fixed.
- `os.symlink` may have crashed in Windows. This has been fixed.
- The `to` statement (not the `for` statement) could corrupt the stack in Agena 2.8.3. This has been fixed.
- Fixed the -0 constant bug when loading or running script files.
- Minor change to `os.system` et al: future Windows releases beyond 10 are now properly handled, provided no Win API changes will be made.
- `os.terminate` is no longer available in Mac OS X since the Carbon framework formerly being linked caused memory leaks in Agena.
- Improved the scheme files and parts of the Primer and Reference.
2.8.3, July 29, 2015
- A new flavour of the `with` statement is available: with <name> do: within the body of this statement, the table <name> can be referenced by just an underscore. It also allows to actively change values in the table <name>. Example:
> zips := [duedo = 4000, bonn = 5300]
> with zips do
> print(_.bonn);
> _.bonn := 53111
> od
5300
> zips:
[bonn ~ 53111, duedo ~ 4000]
This is syntactic sugar for:
> scope
> local _ := zips;
> print(_.bonn);
> _.bonn := 53111
> epocs
All flavours of the `with` statement now allow its block to be surrounded by the `do` and `od` - instead of the `scope` and `epocs` keywords - just as allowed by Modula-2.
- Numeric `for` loops with stop value 0 (zero) and a fractional step size did not stop at 0 but one step before. This has been fixed. Optimised internals of numeric for loops, as well.
- The new function `rot` rotates a two-dimensional vector, represented by a (complex) number, through a given angel.
- The new function `everyth` returns every given k-th element of a structure and returns a new structure.
- `stats.iqr` has become six times faster if the distribution is unsorted.
- `tanc` has become twelve percent faster.
- The new function `stats.qcd` determines the quartile coefficient of dispersion.
- `math.dms` returned imprecise results. This has been fixed. The function has also become 25 percent faster.
- `math.random` behaved poorly if called with no arguments. This has been fixed.
2.8.2, July 14, 2015
- The new function `calc.ibeta` implements the incomplete beta integral.
- The new function `calc.invibeta` evaluates the inverse of the incomplete beta integral.
- `stats.acf` now optionally accepts a pre-computed arithmetic mean and the sum of all values in a distribution. This option reduces computation time to a third.
- The new `tanc` function returns tan(x)/x for real or complex x <> 0, and 1 for x = 0.
- The new `stats.invnormald` implements the inverse Normal distribution function.
- The arguments of `calc.igamma` and `calc.igammac` have been swapped to comply with related integral functions.
- `stats.gammadc` evaluated the Gamma distribution function instead of the complemented one. This has been fixed.
- `calc.polygen` does not accept more than 256 arguments any longer for this could corrupt an internal stack.
- The following functions now properly free internal memory in case of errors: `stats.acf`, `stats.acv`, `stats.prange`, `stats.neighbours`, `stats.nearby`, `calc.interp`, `calc.newtoncoeffs`.
2.8.1, July 07, 2015
- `stats.trimean` now optionally accepts a given percentile rank determining the lower and upper margin.
- The new function `stats.fivenum` returns the five-number summary of a distribution, plus the arithmetic mean.
- The new functions `calc.Ai` and `calc.Bi` compute the Airy wave functions and their respective first derivatives.
- The new `calc.zeta` function computes the Riemann zeta function.
- The new `calc.polylog` function computes the polylogarithm of a given order and point in the real domain.
- The new function `calc.En` computes the exponential integral int(exp(-x*t)/t^n, t = 1 .. infinity).
- The new `calc.igamma` evaluates the incomplete gamma integral.
- The new `calc.igammac` evaluates the complemented incomplete gamma integral.
- The new `stats.gammad` Gamma distribution function returns the integral from zero to x of the gamma probability density function.
- The new `stats.gammadc` complemented Gamma distribution function returns the integral from x to infinity of the gamma probability density function.
- `calc.polygen` has become twenty times faster by using the same technique to access internal data as `calc.linterp` has done. The former bug that wrong results have been returned when passing more than 254 coefficients thus has also implicitely been fixed.
- The index of the Primer and Reference, and the Crash Course have been improved, as well.
2.8.0, June 23, 2015
- The new `with` statement unpacks values from a table, declares them local and then is able to access them in a block. The new names are variables on their own and do not refer to the indexed values in the table:
zips := ['duedo' ~ 40210:40629, 'bonn' ~ 53111:53229, 'cologne' ~ 50667:51149];
with duedo, bonn in zips scope
print(duedo, bonn, cologne);
duedo := null # zips.duedo is not changed
epocs;
-> 40210:40629 53111:53229 null
print(zips.duedo)
-> 40210:40629
- The former `with` function has been renamed to `initialise`, but there are no changes to the `import` statement.
- The assignment statement has been extended to unpack values from a table, the `local` statement is supported, as well. Thus,
duedo, bonn in zips
is equal to
(local) duedo, bonn := zips.duedo, zips.bonn
Both extensions are based on a Lua 5.1 power patch written by Peter Shook.
- Record fields in tables can now be defined more easily by using the equals sign separating the - unquoted - record field name and the corresponding value. Thus,
zips := ['duedo' ~ 40210:40629, 'bonn' ~ 53111:53229, 'cologne' ~ 50667:51149];
is equal to
zips := [duedo = 40210:40629, bonn = 53111:53229, cologne = 50667:51149];
The old way to define record fields using tildes is still supported. Both styles can be mixed:
zips := ['duedo' ~ 40210:40629, bonn = 53111:53229, cologne = 50667:51149];
Please note that if you want to enter the result of a Boolean equality check into a table, use the `==` token instead of the `=` sign.
- `os.date` can return the Julian date if given the new '*j' format, or the Lotus 1-2-3 Serial Date if given the new '*l' format.
- The new function `os.lsd` computes the Lotus 1-2-3 Serial Date, which is also used in Excel (known there as `Excel Serial Date`), where January 01, 1900 is day 1. It returns a number. (Day 60 = non-existent February 29, 1900 is properly handled.)
- `os.now` also returns the Lotus 1-2-3 Serial Date with the 'lsd' key.
- `xbase.writedate` now accepts both strings and numbers as the date to be written to a dBASE file.
- `os.time` did not check for the existence of a given date and returned miraculous results with invalid dates. This has been fixed.
- Remember tables sometimes failed returning a cached result if too many entries have been stored to them. This bug has been fixed.
- The initialisation routine that searches for the main Agena library has become stricter to avoid unneccessary problems in UNIX.
- The `values` operator has been fixed to avoid problems with strict equality checks (`==` operator).
- On the interactive level, i.e. the Agena prompt, diacritics defined in the ISO 8859/1 Latin-1 codepage can now be part of names. Please note that within scripts stored to a file, diacratics still are not allowed within names.
- Deprecated `stats`, `linalg`, and `xbase` functions now are correctly initialised in the compat.agn compatibility file.
2.7.0, June 12, 2015
- Formerly, only one expected type of return could be defined for procedures, now you can specify up to four basic types by putting them in curly brackets, e.g.:
> f := proc(x) :: {number, complex} is return 'a' end
> f()
In stdin at line 1:
Error in `return`: unexpected type string in return.
- There has been a subtle change on how Agena treats the last iteration value of numeric for loops if such loops are executed _on the interactive level_, i.e. not within a function: if the loop is part of a block, then the last iteration value now is accessible only in this `scope` block, but not in outer blocks:
> scope
> for i to 10 do od;
> print(i)
> epocs
11
> print(i)
null
> for i to 10 do od
> print(i)
11
This fix has been applied to comply with the description in the Primer and Reference, so that the behaviour now is the same both with functions and the interactive level.
- If you assign a procedure to `environ.onexit`, then when quittung Agena with `bye`, `os.exit`, or CTRL-C, this procedure will be called before exiting the interpreter. The procedure is also called when issuing the `restart` statement. Thus you may conduct file system clean-up, pass back information if Agena is being piped, save variables to disk, or anything else.
- Remember tables can now already be assigned during procedure definition: just put the statement `feature reminisce` right after the `is` keyword. You may thus save an explicit call to `rtable.rinit` after the procedure has been defined. Thus, also anonymous procedures support remember tables now.
- `os.system` can now directly detect Windows 10 and Windows 10 Server. The function also now correctly acknowledges Windows Server 2012 R2.
- The `tar` package (UNIX tape archive reader) has become a part of the Agena distribution.
- The new function `gdi.lineplot` plots lines between 2-dimensional points. It is just an easy-to-use wrapper around `gdi.pointplot` with the connect = true option.
- `gdi.pointplot` with the connect = true option now supports the `thickness` and `linestyle` options for lines.
- `gdi.setline`, `gdi.setcircle`, `gdi.setarc`, `gdi.setellipse`, `gdi.setrectangle`, `gdi.settriangle` now accept a thickness value as the very last argument. By default, it is 1 (= normal).
- The new function `math.decompose` splits an integer of any base into its digits.
- `math.ndigits` has been ported to C, and processes non-positive values, as well. It has not necessarily become faster.
- The new C API function `agn_checkposint` checks whether a value is a positive integer.
- The new C macro `lua_regsetinumber` sets an Agena number to the given index of a register.
- The scheme files have been improved.
- `environ.attrib` now checks whether a register has been assigned a user-defined type.
2.6.1, May 27, 2015
- A slightly improved version of the tar package including better documentation has been uploaded:
http://sourceforge.net/projects/agena/files/Packages/tar.agn/download.
- Chapter 6.24 of the Primer and Reference on object-oriented programming has been extended:
http://sourceforge.net/projects/agena/files/Manuals/agena.pdf/download.
2.6.1, May 25, 2015
- `environ.kernel` returns all current kernel settings when called with no argument.
- In Windows, eComStation, and UNIX incl. Mac OS X `os.memstate`, now also returns the page size in bytes. If the memory status could not be determined in eComStation, then `os.memstate` now returns a table with all the values set to `undefined` instead of just returng `fail`.
- `os.fattrib` now accepts a number (representing an octal value, like the argument to the UNIX chmod command)to change the mode of a file, so for example UNIX `chmod 755 file` = Agena `os.fattrib(file, 0o755)`.
- `strings.tochars` now also accepts a sequence of numbers (unsigned chars) to be converted to a string.
- The new function `binio.lines` creates an iterator that returns a line in a file step-by-step.
- The new function `binio.isfdesc` checks whether a file handle is valid.
- `binio.rewind` now accepts an optional position. If given, the function resets the file pointer to this position relative to the beginning of the file.
- The new function `math.tobytes` returns a sequence with all the bytes of a number in Little Endian order.
- The new function `math.tonumber` takes a sequence of numbers representing bytes and converts it into an Agena number.
- The error messages of various I/O functions in the io and binio packages now give more detail.
- `strings.tochars` has been patched to cope with embedded zeros.
- `os.fattrib` could not change the date and time of files. This has been fixed. Also, in UNIX, `os.settime` issued errors - this has been fixed, too.
- Corrected error messages of `os.datetosecs`.
- The `ignorespaces` default (formerly true) has been changed: now `utils.readcsv` does not delete spaces in 1fields any longer. Also, if fields are enclosed in double qoutes, the function also automatically deletes these quotes. You can set the new `removedoublequotes = false` option to avoid this.
- Agena for Windows now runs around 10 % faster, as it has been compiled with MinGW/GCC 4.5.2 instead of 4.6.2.
- Two new packages have been uploaded to http://sourceforge.net/projects/agena/files/Packages:
- a package to list, read, and extract individual files from a UNIX tar archive, and
- a package called `Agner` with phone line availability formulaes developed by Danish Scientist Agner Krarup Erlang.
Please see the respective Agena source files for the documentation.
2.6.0, May 10/11, 2015
- You can now `define` your own binary operators just by using functions of two arguments,
> plus := proc(x, y) is return x + y end;
the following way:
> 1 plus 2:
3
When using a function as a binary operator, it has always the highest precedence.
- Agena now supports OOP-style methods. To define a method for a table object,
> account := ['balance' ~ 0]
enter something like (please note the two `@` tokens):
> proc account@@deposit(x) is
> inc self.balance, x;
> return self.balance
> end
The name `self` always refers to the table object. Call the method using two `@` characters:
> account@@deposit(100)
Query the object.
> account:
[balance ~ 100, deposit ~ procedure(016D6820)]
For more information, check http://www.lua.org/pil/16.html.
- Added `divs.asine`, `divs.acosine`, `divs.asecant`, `divs.hsine`, `divs.hcosine`, `divs.htangent` and the proper metamethods for the arcsin, arccos, arcsec, sinh, cosh, and tanh operators, to the `divs` package. The `recip` and `~<>` operators now also support fractions.
- The new `<<<<` and `>>>>` operators return the number x (left operand) rotated a given amount of bits (right operand) to the left or the right.
- `inc`, `dec`, `mul`, and `div` accepted function calls as the first argument. This has been fixed.
- The `linalg` package now supports the division operator for vectors, and the `~<>` operator for both vectors and matrices.
- Some `linalg` functions have been marginally improved with regards to runtime behaviour.
- The list of available metamethods in Appendix A2 of the Primer and Reference has been extended.
- The `shift` operator has been removed. Please use the `<<<` operator for left-shift operations, and `>>>` for right-shifts. An alias, however, has been provided for backward compatibility.
- Extended the scheme files.
- The undocumented reserved words `algform` and `kthmoment` have been removed.
- The agena-2.6.0-win32-gcc452* installers feature a Windows version of Agena that runs around ten percent faster.
2.5.4, May 06, 2015
- Due to a suggestion by a forum user, you may now include double quotes in a string delimited by single quotes without using a backslash. The same applies to single quotes embedded in a string delimited by double quotes, e.g. "'agena'" is now a valid string.
- `inc`, `dec`, `mul`, and `div` accepted function calls as the first argument. This has been fixed.
- The `typeof` operator could not determine user-defined types for userdata. This has been fixed.
- The `cls` and `bye` statements can now be included in chunks (e.g. loop or procedure bodies), there are no longer syntax errors. Thus, os.execute('/usr/bin/clear') or os.exit() statements in chunks are no longer needed.
- Two variables in `gdi.plotfn` had been declared global. This has been fixed.
- The Linux build scripts have been corrected.
2.5.3, April 26, 2015
- A non-yum based WarpIN installer of Agena for eComStation has been uploaded due to a kind hint from Serenity Systems, Italy.
2.5.3, April 12, 2015
- Due to an idea from Serbia, a new type check metamethod '__oftype' has been introduced for all structures and for userdata. If a type check metamethod exists for such an object, then it is run with calls to the :: and :- operators. If the object does not satisfy the criteria defined in the metamethod, then Agena returns `false`.
This also applies to function calls: if the check fails, Agena issues an error, e.g.:
> mt := [ '__oftype' ~ proc(x) is return type(x) = pair and left(x) :: number and right(x) :: number end ];
> duo := 1:2;
> setmetatable(duo, mt);
> f := proc(x :: pair) is return x end;
> f(duo):
1:2
> duo := 'a':'b';
> setmetatable(duo, mt);
> f(duo):
In stdin:
argument #1 does not satisfy type check metamethod
'__oftype' metamethods can also check results to procedure calls if an expected result type is specified in a procedure definition (e.g. `f := proc(x :: pair) :: pair is return x end;`).
- User-defined types can now also be set to registers.
- `stats.sumdataln` returned incorrect results. This has been fixed.
- `stats.gmean` has been rewritten using logarithmic sums and now is twice as fast.
- The new function `stats.meanvar` returns both the artithmetic mean and the variance of a distribution.
- The new function `stats.standardise` normalises a distribution so that they become comparable.
- The new function `stats.covar` computes the covariance of two distributions.
- The '__sin' metamethod has been removed.
2.5.2, April 07, 2015
- `gdi.plotfn` now can also plot graphs of high slope functions correctly thanks to a contribution by a Serbian user.
- The following binary operators are now at least thrice as fast: `xor`, `atendof`, `&&`, `||`, `^^`, `~~`, `<<<`, `>>>`, `::`, `:-`, `*%`, `/%`, `+%`, `-%`, `@`, and `$`.
- The new `~<>` binary operator checks whether two numbers or complex numbers are not approximately equal, i.e. it is the negation of the `~=` operator.
- The new `nand` and `nor` operators are the negations of `and` and `or`, respectively.
- The new function `stats.cauchy` returns the probability density function 1/(Pi*b*(1+((x-a)/b)^2)), of the Cauchy distribution.
- The new function `stats.sumdataln` sums up the natural logarithms of the observations in a distribution.
- The new functions `stats.durbinwatson` tests the autocorrelation in the residuals from a linear regression.
- The functions `stats.sum` and `stats.sumdata` have been merged, i.e. `sumdata` now also accepts a data selection function. `stats.sum` has been deprecated, but an alias is provided for backward-compatibility.
- Most statistics functions now ignore `infinity` and `undefined` if present in tables. With sequences, the functions have already skipped these non-finite values.
2.5.1, March 30, 2015
- Agena allowed to start a string with a single quote and finish it with a double quote, and vice versa. This has been changed: string delimiters must now either be single or double quotes.
- Besides including one or more single quotes within a number to group digits, also underscores (like in Ada) can be used. Underscores and single quotes, however, cannot be mixed.
- Functions alternatively can be defined using the Algol-like syntax: proc <name>(<arguments>) is <statements> end, which is equal to <name> := proc(<arguments>) is <statements> end.
- The new `cis` operator computes the complex exponential function exp(I*x) = cos(x) + I*sin(x) for any real or complex argument x and is around 25 % faster than the equivalent expression exp(I*x).
- If any Boolean is given as the last argument to `math.random`, then the sequence of random numbers should be arbitrary.
- The new function `stats.chisquare` returns the probability density function
x^((nu-2)/2) * exp(-x/2)/2^(nu/2)/gamma(nu/2), of the chisquare distribution.
- The new function `stats.fratio` returns the probability density function
gamma( (nu1+nu2)/2)/gamma(nu1/2)/gamma(nu2/2)*(nu1/nu2)^(nu1/2)*
x^((nu1-2)/2) / ( 1+ (nu1/nu2)*x) ^ ((nu1+nu2)/2),
of Fisher's F distribution.
- The new function `stats.normald` returns the the probability density function
exp( -(x-mu)^2/2/sigma^2 ) / sqrt(2*Pi*sigma^2), of the normal distribution.
- The new `stats.studentst` function returns the probability density function
gamma( (nu+1)/2 )/gamma(nu/2)/sqrt(nu*Pi)/(1+t^2/nu)^((nu+1)/2),
of the Student's t-distribution.
- `stats.skewness` can now compute the sample skewness of a distribution by passing an optional argument.
- The new function `stats.kurtosis` determines the kurtosis (peakedness) of symmetric and unimodal distributions.
- `skycrane.dice` now creates truely random numbers.
- Agena cow correctly returns `undefined` with the numeric expressions 0^0 and 0**0. For the sake of speed of the exponentiation operators, it still incorrectly returns 1 instead of `undefined` for infinity^0.
2.5.0, March 23, 2015
- `utils.writecsv` can now also write a header and enclose each value with a given string. Also, any option can now be given in the form `option = value`. The old way of sequentially passing options is still supported.
- `stats.gmean` has been rewritten for it returned wrong values with distributions containing very small or very large values provoking underflows or overflows. Also, the function no longer returns complex values if the sign of the product of all observations is negative (returning `undefined` instead), and issues an error if the distribution contains complex values for it now computes in the real domain, only. The function has become twice as fast.
- `<<<`, and `>>>`, `stats.skewness`, and `fractals.dragon` have been tuned a little bit.
- `unpack` with a given register may have crashed Agena if the interpreter had not been compiled with GCC.
- The `shift`, `<<<`, and `>>>` bitshift operators could crash Agena when called with non-numbers. This has been fixed.
- Registers had not been correctly garbage-collected, leading to out-of-memory errors with large registers. This has been fixed.
- The test suite now properly cleans up the namespace.
- The manual and the scheme files have been corrected.
- The following deprecated operators and functions have now been removed, the following list includes their substitutes right after the `->` token. Except is/si and ->, all of these functions can be used by running the `/lib/compat.agn' file.
-> mapping -> @ operator
bags.attribs -> bags.attrib
calc.newton -> calc.interp
clock.dectotm -> clock.totm
clock.tmtodec -> clock.todec
gethigh -> math.gethigh
getlow -> math.getlow
io.flush -> io.sync
is and si -> if and fi
linalg.backsubs -> linalg.gsolve
linalg.meq -> linalg.maeq
linalg.veq -> linalg.vaeq
math.log2exp -> ilog2
math.tworaised -> antilog2
notisnegint -> isnonnegint
notisposint -> isnonposint
optnnonneg -> optnnonnegative;
registers.gettop -> size
sethigh -> math.sethigh
setlow -> math.setlow
stats.kosumdata -> stats.sumdata
stats.ssd -> stats.sd
utils.cdate -> astro.cdate
utils.decode64 -> utils.decodeb64
utils.isleapyear -> astro.isleapyear
varprep -> qmdev
xbase.field -> xbase.readdbf
xbase.isVoid -> xbase.isvoid
2.4.5, March 10, 2015
- Two new modifiers for `strings.format`, `printf`, and related functions have been introduced to prevent quarrels with numerical functions that can return non-numbers in case of errors: 'D' prints an integer if the argument is a number, and the C double representation of undefined otherwise. 'F' likewise either prints a float, or the C double pendant of undefined.
- the q modifier to `strings.format`, `printf`, etc. now works as described in the manual. The new Maple-like a modifier works like the q modifier but does not include trailing and leading double quotes.
- The new function `strings.diffs` counts the differences between two strings: substitutions, transpositions, deletions, and insertions. Besides returning the number of differences, it can also return the types of differences. The function is thrice as fast as `strings.dleven`, but may count differently.
- The name of the former `varprep` operator has been changed to `qmdev`. An alias has been provided for backward-compatibility (put varprep's argument in brackets).
- The order of arguments to `stats.sd` has been changed:
a) if any third argument is given (formerly second argument), the coefficient of variation is computed.
b) if the optional second argument evaluates to `true`, the (unbiased) sample standard deviation is returned, otherwise the population standard deviation is computed.
- `stats.var` has been extended to also compute the (unbiased) sample variance or the index of dispersion.
- `stats.moment` can now also compute sample moments by passing `true` as the new fourth argument.
- `stats.trimean` returned some sort of garbage if the distribution contained less than two observations. This has been fixed.
- `stats.ssd` has been deprecated, please use `stats.sd(<distribution>, true)` instead.
- Improved error handling of `stats.checkcoordinate`.
- The former `gethigh`, `getlow`, `sethigh`, and `setlow` operators are now functions moved into the math library, i.e. the new names are `math.gethigh`, etc. Aliases have been provided for backward compatibility.
- Corrected the scheme files.
2.4.4, March 04, 2015
- The new function `descend` recursively descends into a deeply nested structure and returns all elements that satisfy a given condition.
- `recurse` now accepts multivariate functions.
- `stats.moment` now uses the Kahan-Babuka method to prevent round-off errors.
- `stats.kosumdata` has been renamed to `stats.sumdata`. For backward compatibility, an alias has been provided.
- Corrected error messages of `stats.acv`. Improved error messages in some other stats functions in case of memory allocation failures.
- `stats.iqmean`, `stats.trimean` and `stats.quartile` had to be patched once again to avoid crashes with distributions containing the value `undefined`.
2.4.3, February 18, 2015
- `stats.acf`, `stats.acv`, `stats.ad, `stats.amean`, `stats.ema`, `stats.gini`, `stats.gsm`, `stats.iqmean`, `stats.meanmed`, `stats.sma`, `stats.kosum`, and `stats.zscore` and now use the Kahan-Babushka instead of the Kahan-Ozawa summation algorithm, and thus have become up to 20 percent faster now. Kahan-Babuka adds a corrective value to the pre-computed result after the last iteration, whereas Kahan and Kahan-Ozawa adds it in each iteration.
- `stats.prange`, `stats.iqmean`, `stats.trimean`, `stats.quartiles` crashed Agena if an observation contained the value `undefined`. `stats.prange` sometimes also crashed Agena due to other reasons. This has all been fixed.
- The `sadd` operator now uses Kahan-Babushka summation to prevent round-off errors.
2.4.2, February 15, 2015
- The new operator `sinc` implements the unnormalised cardinal sine function, i.e. sin(x)/x.
- The new function `rect` implements the rectangular function.
- The new `linalg.reshape` function restructures a matrix to new dimensions and works like the corresponding Octave function of the same name.
- The new function `math.signbit` checks whether its numeric argument has its sign bit set.
- The new function `math.eps` returns the relative spacing between its numeric argument and its adjacent number in the machines floating point system.
- The new function `stats.iqmean` returns the arithmetic mean of the interquartile range of a distribution.
- The new function `stats.trimean` (not to be confused with `stats.trimmean`) returns the trimean and the median of a distribution to check whether it is biased.
- Numeric `for` loops with fractional step sizes can now alternatively use the enhanced Kahan-Ozawa summation algorithm instead of the default original Kahan one, by the setting: environ.kernel(kahanozawa = true).
- The `copy` operator can now explicitely extract the array or the hash part of a table by passing the new optional second argument 'array' or 'hash'.
- `stats.quartiles` has been ported to C and is at least twice as fast now. Furthermore, it no longer assumes a sorted distribution. Also, the function no longer issues an error if the distribution contains less than two observations, but just returns `fail`.
- The new `varprep` operator pre-computes a `variance sum` which must be divided either by the number of elements n in a distribution to calculate its population variance, or by n - 1 to compute its sample variance.
- `stats.var` and `stats.sd` returned wrong results especially if the variance is close to the arithmetic mean of a distribution; the results sometimes were even negative or had imprecise accuracy. This has been changed by using an algorithm published by Donald Knuth / B. P. Welford, which is much more accurate - to the disadvantage of speed.
- All statistics functions that determine or work with quartiles now determine the first and third quartile according to the NIST rule which has always been used by `stats.quartiles` (which had been wrongly documented): position of Q1 := entier(1/4*(n + 1)), position of Q3 := entier(3/4*(n + 1)), where n is the number of observations in a distribution.
- `stats.isany` and `stats.isall` crashed with sequences. This has been changed.
- Changed the `xbase` sources to prevent compiler warnings.
- This release has been Valgrind-checked on x86 Linux and Mac to ensure there are no memory leaks.
2.4.1a, February 03, 2015
- The `lower` and `upper` operators have been tuned by around 6 %.
- Applied changes to some source files to reduce compilation problems with GCC >= 4.6.
- The Windows version has become around 5 % faster (measured by comparing test suite runs) by recompiling the sources with GCC 4.6.2 and the -O3 switch.
- The eCS, Solaris, Windows, Linux, Mac OS X, and DOS versions have been recompiled.
- This release has been Valgrind-checked on x86 Linux and Mac to ensure there are no memory leaks.
2.4.1, February 01, 2015
- The new operators `antilog2` and `antilog10` raise 2 and 10 to the power of the given arguments, respectively. Depending on the support of the underlying C functions exp2 and exp10, they are around 30 % faster than the corresponding a^x operations.
- The new `signum` operator returns 1 if its real argument is non-negative, and -1 otherwise. For complex argument z, it returns z/|z|.
- The new function `math.koadd` adds two numbers using Kahan-Ozawa round-off error prevention.
- The new function `stats.peaks` uses an alternative algorithm to determine peaks and valleys in time-series.
- The new function `stats.md` returns the median deviation in a distribution.
- The new functions `stats.isany` and `stats.isall` check whether distributions contains non-zero elements.
- `stats.extrema` now is twice as fast than its former version.
- The new function `stats.checkcoordinate` checks whether its argument is a pair consisting of two numbers.
- The new function `optnumber` checks whether its argument is a number. If its argument is `null`, it returns a default number.
- The new function `optpositive` checks whether its argument is a positive number. If its argument is `null`, it returns a default positive number. Likewise, `optposint` checks for positive integers.
- The new function `optnonnegative` checks whether its argument is a non-negative number; if its argument is `null`, it returns a default non-negative number. Likewise, `optnonnegint` checks for positive integers.
- The new function `optboolean` checks whether its argument is a Boolean; if its argument is `null`, it returns a default Boolean.
- The new function `optstring` checks whether its argument is a string; if its argument is `null`, it returns a default string.
- The new function `optcomplex` checks whether its argument is a (complex) number. If its argument is `null`, it returns a default (complex) number.
- On Windows, `os.drivestat` returns further information on a drive: total number of clusters, number of free clusters, sectors per cluster, and bytes per sector.
- `os.unmount` might have crashed in Solaris. This has been fixed.
- `fma`, `isordered`, `trunc`, `log2`, and `isfinite` did not use the underlying C functions if available on the respective platform. Instead they used alternative definitions. This has been fixed.
- Minor non-functional changes to the standard library file `lib/library.agn`.
- The Agena Quick Reference is now edited with LibreOffice 3.4 instead of OpenOffice 4.1 due to issues with the latter application.
- This release has been Valgrind-checked on x86 Linux and Mac to ensure there are no memory leaks.
2.4.0, January 11, 2015
The following measures have been taken to totally hide data in registers:
- The `size` operator no longer returns the total size of a register regardless of the setting of the current top pointer. Instead, it simply returns the position of the top pointer at the time of its call. Since now there no longer is a way to determine the actual size of a register, you have to store its original size yourself. This measure also simplifies programming procedures that operate on registers, sequences, and tables.
- Agena formerly allowed to assign values above the current top of a register. This bug has been fixed.
- Error messages no longer indicate whether data has been hidden (obmission of the `current` word).
Other changes are:
- Both indices and and index ranges can now be mixed, e.g. a[2 to 3, 2] now is a valid expression.
- The following functions now also support registers: `replace`, `join`, `qsadd`, `sadd`, and `smul`, `bintersect`, `bminus`, `bisequal`, `augment`, `columns`, and `utils.writecsv`.
- The new function `os.iseCS` determines whether Agena is running on eComStation.
- The new function `os.islinux` determines whether Agena is running on Linux.
- The new function `os.unmount` unmounts filesystems in the UNIX-based editions.
- The new function `getbits` returns all 32 bits in an integer; the new function `setbits` sets the given bits to an integer.
- `qsadd` now uses fused-multiply add to compute more accurate results.
- The new function `os.terminate` halts, reboots, sleeps, or hibernates the system. It can also logoff or lock the current user session. It is available in the Windows, eCS, and Mac OS X editions.
- The new function `os.monitor` puts a monitor on and off, or on stand-by. It is available in the Windows and Linux editions, only.
- The new function `os.mouse` returns information on the number of mouse buttons, vertical and horizontal scroll wheels, a flag on whether the left and right buttons have been swapped, and the speed and threshold. It is avail

__Screenshot instructions:__

Windows

Mac

Red Hat Linux
Ubuntu

__Click URL instructions:__

Right-click on ad, choose "Copy Link", then paste here →

(This may not be possible with some types of ads)