OpenAxiom: The Open Scientific Computation Platform

1. Base Reference Document

OpenAxiom is a descendent of the AXIOM computer algebra system as described by Richard Jenks and Robert Sutor in AXIOM: The Scientific Computation System. That book is the base reference document for OpenAxiom.

2. Changes From The Base Document

2.1. OpenAxiom-1.4.0

This release introduces the following changes from the base document

2.1.1 Interpreter

2.1.2. Compiler

The compiler now accepts interpreter-style unnamed functions.
The compiler now generate far better (Lisp) codes for Spad libraries or scripts. The compiler now applies more aggressive (but sound) optimizations, including domain inlining, type propagations.
The compiler now accepts interpreter-style unnamed functions.
Parameterized macros are now supported by the compiler.
The compiler now support exception handling. In particular, the try/finally programming construct was added to support reliable resource management (e.g. opening/closing or creating/removing files.)

2.1.3. Algebra

In addition to novelties in OpenAxiom-1.3.0, the following types have been added to OpenAxiom-1.4.0:

The category BooleanLogic has been added. It is now extended by PropositionalLogic and BitAggregate. The domain SingleInteger now satisfies BooleanLogic.
It it now possible to obtain the string representation of a DoubleFloat value. The function
```
           string: DoubleFloat -> %
       
```
was added to the domain String
A function matrix is now exported by the category MatrixCategory to allow construction of matrices whose entries can be succinctely described by a function. For instance, the 4-by-4 Hilbert matrix may be expressed as
```
           m: Matrix Fraction Integer := matrix(4,4,(i,j) +-> 1/(i+j))
       
```
Note that the third argument is a function that computes the value of the (i,j)th entry.
The category StringCategory was removed as it was essentially redundant with the category StringAggregate.
The category MappingCategory is now part of the algebra as a builtin category constructor.

The following operators

           less?: (%,NonNegativeInteger) -> Boolean
           more?: (%,NonNegativeInteger) -> Boolean
           size?: (%,NonNegativeInteger) -> Boolean

have been moved from the category Aggregate to StreamAggregate where they seem more appropriate.

The domain InnerTaylorSeries now satisfies the category BiModule.
The domains FreeModule and OrderedFreeMonoid now satisfy the newly added FreeMonoidCategory.
The list of domains for OpenAxiom program manipulation has been expanded.
Support for range and segment bindings now includes RangeBinding.

2.1.4. Boot

Boot, the programming language used to write the OpenAxiom compiler, has been vastly improved. Lisp codes are being phased out.

2.2. OpenAxiom-1.4.1

2.2.1. Algebra

The domain ScriptFormulaFormat and the package ScriptFormulaFormat1 have been removed.

2.3. OpenAxiom-1.4.2

2.3.1. Algebra

The function test was removed from the domain Boolean.
The following domains no longer implement the exports of OpenMath category: Float, Fraction, Complex, Integer, List, DoubleFloat, SingleInteger, String, Symbol.
The domain Integer no longer satisfies the category ConvertibleTo String. Use the function
```
	      string: Integer -> %
      
```
from the domain String to get the string representation of an integer.
The domain Identifier no longer satisfies the properties CoercibleTo Symbol and CoercibleTo String. Rather, the domain Symbol now satisfies RetractableTo Symbol and a new operation
```
	      string: Identifier -> %
      
```
has been added to the domain String.
The internal domains IndexedString and IndxedList were removed.
The domain Reference now satisfies the category SetCategory. In addition, the following operations
```
           elt: % -> S
           setelt: (%,S) -> S
        
```
were removed because they were redundant with deref and setref, and they were sort of syntax abuse leading to hard read codes.
A new category Dioid of canonically ordered semirings has been added.
The following categories were added:
- BinaryOperatorCategory
- IdempotentOperatorCategory
- SemiGroupOperatorCategory
- MonoidOperatorCategory
The following domains were added:
- BinaryOperation
- SemiGroupOperation
- MonoidOperation

2.3.2. Compiler

A bug in the compiler where certain functors were incorrectly treated as forgetful was fixed. Now, functor such as D defined by
```
	D(T: SetCategory): Public == Private where
          Public == SetCategory with
             makeD : T -> %
	  Private == T add
	     makeD x == per x
      
```
(where the base domain is a paramater) are now correctly compiled as extension functors as opposed to forgetful functors. Note that an extension functor is one whose category extends the base functor's category. Any other situation is still correctly compiled as a forgetful functor.
The library compiler now allows storage class and type specifier in a for iterator. A storage class for a loop variable can be one of local or free.
- A loop variable with local storage class means that the variable is local to the loop. This is the default behaviour when no storage class is explicitly specified, or when only the type of the variable is specified.
- A loop variable with free storage class means that the variable retains its last stored value at the exit of the loop. A matching declaration in an enclosing scope must be in effect.
The library compiler now properly converts category constructors and functors to function objects where needed. In particular, they can now be used as function arguments.
The identifier assume is now a considered a keyword by the library compiler. It was already a keyword in the interpreter.
A domain inlining bug has been fixed.