[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Axiom-developer] Re: More AxiomUI

From: Bob McElrath
Subject: [Axiom-developer] Re: More AxiomUI
Date: Tue, 21 Jun 2005 18:47:00 -0700
User-agent: Mutt/1.5.6+20040523i

Page, Bill address@hidden wrote:
> "Suppose we try a naive approach. We could decorate each domain (those
> parts of Axiom which have an internal representation) with a function
> that would return the internal representation recursively expanded
> into a lisp s-expression. We could also give each domain a function
> that takes this s-expression and tries to simplify it. But we run into
> an issue. What would be the return type of such a simplify function?"

The integrate() function seems to work quite well, despite the fact that
I might add two disparate things.

(8) -> integrate(log(x)+x, x)
(8) -> 
        2x log(x) + x  - 2x
   (8)  -------------------
                                          Type: Union(Expression Integer,...)

Simplification rules must be domain-specific.  However the domain that
is used in most engineering-type CAS' (maple/mathematica/maxima) is
essentially "Complex Expression".  Is Union(Expression Integer,...)

It's been mentioned before that the "Expression" domain needs a lot of
work.  This talk of simplification probably belongs there.

However if we were very smart we would have domain-specific rules, and a
generic format (such as the s-expression example you mention above), and
*one* set of simplify/factor/expand functions.  The result would be as
it is from integrate(), Union(something) or Expression(something).  The
type should be derivable...

Bob McElrath [Univ. of California at Davis, Department of Physics]

    "One of the best ways to get yourself a reputation as a dangerous citizen
    these days is to go about repeating the very phrases which our founding
    fathers used in the great struggle for independence." --Charles A. Beard

Attachment: signature.asc
Description: Digital signature

reply via email to

[Prev in Thread] Current Thread [Next in Thread]