login  home  contents  what's new  discussion  bug reports help  links  subscribe  changes  refresh  edit

 Submitted by : (unknown) at: 2007-11-17T21:52:38-08:00 (11 years ago) Name : Axiom Version : default friCAS-20090114 Axiom-20050901 OpenAxiom-20091012 OpenAxiom-20110220 OpenAxiom-Release-141 Category : Axiom Aldor Interface Axiom Compiler Axiom Library Axiom Interpreter Axiom Documentation Axiom User Interface building Axiom from source lisp system MathAction Doyen CD Reduce Axiom on Windows Axiom on Linux Severity : critical serious normal minor wishlist Status : open closed rejected not reproducible fix proposed fixed somewhere duplicate need more info Optional subject :   Optional comment :

Vladimir Bondarenko wrote:

> -----------------------
> -- even worse
> -----------------------
>
> -> romberg(z+->simplify(%i^2), 0, 1, 0.1, 0.1, 10, 12)
>
>    [value= - 1.0,error= 0.0,totalpts= 2049,success= true]
>    Time: 3.07 (IN) + 2.25 (EV) + 0.18 (OT) + 0.48 (GC) = 5.98 sec
>
> .........................................................................
>
> A bloodcurdling guesswork, Does AXIOM each time call simplify/expand ?!
>
> Or... or what causes this user's nightmare?

I tried the above,

[snipped]

Function Selection for ^
Arguments: (COMPLEX INT,PI)

[1]  signature:   (COMPLEX INT,PI) -> COMPLEX INT
implemented: slot $$(PositiveInteger) from COMPLEX INT [2] signature: (COMPLEX INT,PI) -> COMPLEX INT implemented: slot$$(PositiveInteger) from COMPLEX INT

----- This is the cause of the problem: Complex arithmetic

Function Selection for simplify
Arguments: COMPLEX INT
Target type: FLOAT

[1]  signature:   EXPR COMPLEX INT -> EXPR COMPLEX INT
implemented: slot (Expression (Complex (Integer)))(Expression (Complex (In
eger))) from TRMANIP(COMPLEX INT,EXPR COMPLEX INT)

----- The only simplify is from EXPR Complex Integer

Function Selection for map by coercion facility (map)
Arguments: ((COMPLEX INT -> INT),EXPR COMPLEX INT)
Target type: EXPR INT

[1]  signature:   ((COMPLEX INT -> INT),EXPR COMPLEX INT) -> EXPR INT
implemented: slot (Expression (Integer))(Mapping (Integer) (Complex (Integ
r)))(Expression (Complex (Integer))) from EXPR2(COMPLEX INT,INT)

----- which requires the answer to stay in EXPR Complex Integer after
----- "simplification", which then require ti to be converted

and found that the interpreter printed out 2049 (or thereabout)

Function Selection for map by coercion facility (map)
Arguments: ((COMPLEX INT -> INT),EXPR COMPLEX INT)
Target type: EXPR INT

[1]  signature:   ((COMPLEX INT -> INT),EXPR COMPLEX INT) -> EXPR INT
implemented: slot (Expression (Integer))(Mapping (Integer) (Complex
(Integer)))(Expression (Complex (Integer))) from EXPR2(COMPLEX INT,INT)

which means that it is applying the map function to evaluate the
z+->simplify(%i^2) function 2049 times. Of course, evaluating is not the
problem, the problem is how the function is evaluated. In Axiom, the appearance
of %i means it has to convert the value to Float because romberg requires the
first argument to be a function: Float -> Float.

To understand what is happening and indeed it is troubling to find out, try the
following:

(3) -> g:Float->Float
Type: Void
(4) -> g(z)==simplify(%i^2)::Float
Type: Void
(5) -> g(5)
Compiling function g with type Float -> Float

(5)  - 1.0
Type: Float
(6) -> )time on
(6) -> romberg(g, 0, 1, 0.1, 0.1, 10, 12)

(6)  [value= - 1.0,error= 0.0,totalpts= 2049,success= true]
Type: Record(value: Float,error: Float,totalpts: Integer,success: Boolean)
Time: 2.78 (IN) + 2.18 (EV) + 0.27 (OT) + 0.60 (GC) = 5.83 sec

there is no improvement at all! The interpreter DID use the compiled version of
g but the code reflects faithfully the definition of g, not what it simplifies
to! Notice below, g has been compiled at (5).

(7) -> g(7)

Function Selection for g
Arguments: FLOAT

[1]  signature:   FLOAT -> FLOAT
implemented: local function *1;g;1;initial

Function Selection for map by coercion facility (map)
Arguments: ((COMPLEX INT -> INT),EXPR COMPLEX INT)
Target type: EXPR INT

[1]  signature:   ((COMPLEX INT -> INT),EXPR COMPLEX INT) -> EXPR INT
implemented: slot (Expression (Integer))(Mapping (Integer) (Complex (Integ
er)))(Expression (Complex (Integer))) from EXPR2(COMPLEX INT,INT)

(7)  - 1.0
Type: Float
Time: 0.02 (OT) = 0.02 sec

The issue is therefore one of mathematical optimization in the compiler, but
compilers are only built to optimize code, not mathematics.
So the moral is: Do not expect compiler to simplify (mathematically) your code.

Incidentally, timing in Axiom, and also in Maple, may not be very reliable.
Running Maple 5, starting from scratch, I got different timing for below (Maple
may cache values), but the worst time is the simplest code on first run in the
order given:

restart; time(evalf(Int(expand(sqrt(-1)^2), z=0..1)));
>

.015

> restart; time(evalf(Int((sqrt(-1)^2), z=0..1)));
>

.016

> restart; time(evalf(Int(simplify(expand(sqrt(-1)^2)), z=0..1)));
>

.015

> restart; time(evalf(Int(expand(simplify(sqrt(-1)^2)), z=0..1)));

.016

> restart; time(evalf(Int(1, z=0..1)));

.032

When the last command is repeated, time becomes .016.

In Mathematica, there are two ways to define a function: Set and SetDelayed and
SetDelayed will also exhibit a big penalty:

Set[g[z_], Simplify[I^2]];
SetDelayed[h[z_], Simplify[I^2]];
Timing[Table[g[z],{z,1,10000}];]
{0.04 Second, Null}
Timing[Table[h[z],{z,1,10000}];]
{0.55 Second, Null}

I think there is no equivalent to Set in Axiom. So the more you try to coax
Axiom to "simplify", the worse it becomes:

(8) -> g(z) == eval(simplify(%i^2)::Float)

Compiled code for g has been cleared.
1 old definition(s) deleted for function or rule g

Type: Void
(9) -> g(5)

Compiling function g with type Float -> Float

(9)  - 1.0
Type: Float

(10) -> romberg(z+->g(z), 0, 1, 0.1, 0.1, 10, 12)

(10)  [value= - 1.0,error= 0.0,totalpts= 2049,success= true]
Type: Record(value: Float,error: Float,totalpts: Integer,success: Boolean)
Time: 3.08 (IN) + 2.87 (EV) + 0.28 (OT) + 0.35 (GC) = 6.58 sec

The only way I found that can simulate Set is to do this in two steps (and you
must include the coercion to Float):

(19) -> a:= simplify(%i^2)::Float

(20) -> g(z)==a

(21) -> romberg(g, 0, 1, 0.1, 0.1, 10, 12)

Time: 0.03 (EV) + 0.03 (OT) = 0.07 sec

William

------------------------------------------------------------

... --kratt6, Fri, 28 Dec 2007 14:33:17 -0800

Category: Axiom Mathematics => Axiom Interpreter
Status: open => rejected



 Subject:   Be Bold !! ( 14 subscribers )