[Axiom-developer] Lisp in Small Pieces

[daly]

> I find this very interesting. I wonder what would be involved in
> implementing continuations to exploit GCL's multiprocessing
> capabilities

There have been discussions, some of which are on this list, about using
provisos mapped to multiple processors. Consider an expression that
says something like a function provided x is not zero:

 f := [ function | x != 0 ]

If x is real we can rewrite this in interval notation as 2 distinct branches:

 f := [ function | x \in (-\infinity 0] and x \in [0 \infinity) ]

or in functional notation something like:

 f1 := [ function | x < 0 ] 
 f2 := [ function | x > 0 ]

 f := join(f1,f2)

Since each of the intervals is non-overlapping we can compute each
branch f1 and f2 independently and in parallel. This is a perfect fit
for a multiprocessor system. As the computation proceeds it potentially
branches again and again into distinct regions. Each branch can be a
continuation waiting for an available processor.

Combining these regions after the results amounts to logical or 
expression computations on the provisos.


Similar kind of proviso branching/combining algorithms can be defined
to handle matrix computations, region searching, multiple root finding,
and other algorithms that naturally break into regions. Geometric
algorithms, such as the exterior algebra links I posted, could benefit
greatly from this.

It is also applicable to algorithms such as integration where there
is a potential pole in the path of integration. The integral can be split
and the limits computed from each side to see if they match.

Essentially provisos enable a natural parallel processing mechanism.
They are much more powerful algebraically than an assume facility.

Tim