RE: [Axiom-developer] Lisp Packages and Axiom

[Page, Bill]

Martin, 

ON Wednesday, December 07, 2005 1:47 PM you wrote:
> 
> I'd just would like to drop a note that in any case the
> Algebra should stay/become as disconnected from Lisp as
> possible (and sensible).

I agree. The proper language for Algebra code is Aldor and
Spad.

The support for Lisp and Boot on MathAction is focused on
Axiom developers (the people who maintain and extended the
interpreter and the compilers) - not those people who I call
Axiom library programmers (who *use* the interpreter and
the compilers). For them MathAction already has {axiom}
{spad} and {aldor}.

>... Introducing more Lisp at the Algebra level would 
> definitively be counterproductive to this goal [of
> moving to Aldor].

So far as I know there is no Algebra code as such at the
Lisp or even Boot levels in Axiom. In some cases the Spad
code does make some assumptions about the underlying
representation of the data and by so doing it can take
advantage of functions already implemented in Lisp (or
some external library accessible to Lisp).

Both Lisp and Boot however are used to implement Spad
itself.

> 
> The issue might be different for the interpreter,
> although I doubt it.

Similarly Lisp and Boot are used to implement the
interpreter itself, but this is at a different functional
level than the algebra.

> ... 
> A very different point is to write functionality enabling
> the use of existing lisp / c / python / whatever code as
> packages in Axiom, just as I did for polymake.
> 

Doing some careful interface programming at the Lisp level
would make it possible to directly use packages and external
libraries like polymake instead of having to communicate
through files and sessions. Depending on the particular
application and the data to be passed, such an high
performanc interface might be critical.

For example, we have available to Axiom the complete Lisp
code for exact real arithmetic from the package author.
One approach to providing exact reals in Axiom would be
to incorporate and interface to these routines. This
interface would be encapsulated as an Axiom domain, and
mostly written in Spad and callable from both Spad and
the Axiom interpreter. Because for practical purposes we
may be very concerned about performance, using the Lisp
interface for this might be preferable to re-writing
the algorithms using Spad/Aldor. The situation is very
similar to the way that gcl depends on the gmp math
library for infinite precision integer arithmetic. And
of course it is also desirable to assimilate rather than
re-write because of limited resources.

Regards,
Bill Page.