[Axiom-developer] tracing complex on windows

[Vanuxem Grégory]

Hi Bill,

Can you test this on the windows version of axiom.

)tr Complex
complex(0.1::SF,0.3::SF)

On my version (32 bits Windows(R)) gcl "caught fatal error".

Cheers,

Greg


> -----Message d'origine-----
> De : address@hidden
> [mailto:address@hidden la part de
> Page, Bill
> Envoyé : mardi 28 juin 2005 21:51
> À : 'Francois Maltey'
> Cc : address@hidden
> Objet : RE: [Axiom-math] lot of questions about functions.
>
>
> Francois,
>
> On Tuesday, June 28, 2005 10:00 AM you wrote:
>
> > I want to play with generic functions of type
> > expression -> expression.
>
> I think you have the right idea but perhaps you do not realize
> just how rigorous Axiom is when it comes to defining and
> operating on functions. What Axiom does is quite simple but
> not simply explained. You may have to read several sections of
> the Axiom Book carefully several times - sometimes between the
> lines.
>
> E.g.
>
> 6.3 Introduction to Functions
> 6.4 Declaring the Type of Functions
> 6.6 Declared vs. Undeclared Functions
> 6.7 Functions vs. Operations
> 6.9 How Axiom Determines What Function to Use
> 9.3 BasicOperator
> 9.50 MakeFunction
> 9.51 MappingPackage1
> 10.10 Automatic Newton Iteration Formulas
>
> And here is some discussion of this on MathAction:
>
> http://page.axiom-developer.org/zope/mathaction/FunctionalMapping
> http://page.axiom-developer.org/zope/mathaction/114MapOnFunctionsCrash
>
> Sometimes even reading the library code helps. (See mappkg.spad.pamphlet)
>
> --------
>
> There are two important things to remember that might seem
> quite odd to someone who has used Mupad, Mathematica or Maple:
>
> 1) The name cos is just a name, it is *not* a function.
> 2) Functions in Axiom are objects of type "mapping", i.e. A -> B
>    (also called signature).
>
> In Axiom the same name can be used in more than one way (overloading).
> The Axiom interpreter has elaborate sometimes heuristic rules for
> trying to decide on what mapping to associate with a given name.
> Sometimes you have to give it a little help.
>
> > I use (cos@@100)(1.0) with mupad when I want u100, with u0=1 and
> > u(n+1)=cos u(n)
>
> This works in Axiom but you have to provide some additional
> information
>
> (1) -> cos:Expression Float -> Expression Float := x +-> cos(x)
>
>    (1)  theMap(Closure)
>                        Type: (Expression Float -> Expression Float)
> (2) -> (cos**100)(1.0)
>
>    (2)  0.7390851332 1516064351
>                        Type: Expression Float
>
> Another way is to specify explicitly the package to use for the
> function composition. E.g.
>
> (3) -> FuncExpr:=MappingPackage3(Expression Integer, _
>                                  Expression Integer, _
>                                  Expression Integer);
>                         Type: Domain
>
> (4) -> ((sin*exp)$FuncExpr)(x)
>
>                x
>    (4)  sin(%e )
>                         Type: Expression Integer
>
> (5) -> )show MappingPackage1
>
> (5) -> )show MappingPackage3
>
> >...
> > Is there a the difference between f := t -> 2*t + 1 and
> > f(x)==2*x+1 ?
>
> You mean
>
> (5) -> f := t +-> 2*t + 1
>
>    (5)  t +-> 2t + 1
>                         Type: AnonymousFunction
>
> (6) -> f(2)
>
>    (6)  5
>                         Type: PositiveInteger
>
> This defines an "anonymous" function. On page of The Book
> it says:
>
> "Every function in Axiom is identified by a name and type.
> (An exception is an "anonymous function" discussed in 6.17 on
> page 268.) The type of a function is always a mapping of the
> form Source -> Target where Source and Target are types. To enter
> a type from the keyboard, enter the arrow by using a hyphen "-"
> followed by a greater-than sign ">", e.g. Integer -> Integer."
>
> You must declare the type of the function before you can
> use it in functional composition:
>
> (7) -> (f::(Expression Integer->Expression Integer)**3)(3)
>
>    (7)  31
>                                                      Type: Expression
> Integer
> (8) -> f := (t:INT):INT +-> 2*t + 1
>
>    (8)  theMap(Closure)
>                                                    Type: (Integer ->
> Integer)
> (9) -> (f**3)(3)
>
>    (9)  31
>                                                         Type:
> PositiveInteger
>
> The different between an anonymous function and the following
> is subtle and as far as I can see only be significant if the
> function definition depended on free (global) variables.
>
> (10) -> f(x)==2*x+1
>                         Type: Void
>
> In this case f(x) is not (yet) a function. We only know it's
> functional form, not it's type. More over, the expression on
> the right hand side has not be evaluated (i.e. compiled).
>
> (11) -> f(2)
>    Compiling function f with type PositiveInteger -> PositiveInteger
>
>    (11)  5
>                         Type: PositiveInteger
>
>
> > How can I do f o f o f o ...o f = x -> f(f(f(f...f(x)))) ?
> >    (I iterate 10 or 100 times)
>
> See examples above.
>
> > f := x +-> 3*x
> > g := x +-> 2*x+3
> > It seems impossible to add 2 anonymous functions. I can
> > compute f(x)+g(x) but I can't use (f+g)(x)
>
> You mean that you would like to treat + as a functional operator?
>
> This one is harder. Trying to do this in the interpret seems
> to cause several different kinds of problems in the Axiom
> interpreter (such as recently reported by here Ralf Hemmecke).
>
> The proper way to do this is to compiled a new package for the
> Axiom library. I wrote a very simple example here:
>
> http://page.axiom-developer.org/zope/mathaction/SanboxFunctionalAddition
>
> It's only about 10 lines of SPAD code. Let me know if you have
> any questions about how it works.
>
> >> Can I do (f o g) or can I only compute f(g(x)) = f g x.
>
> Function composition works using symbol * show above.
>
> > With mupad (sqrt@@2)(16) and (address@hidden@sin)(PI) compute $2$ and $0$.
>
> This works in Axiom.
>
> (1) -> MEI:=MappingPackage1(EXPR INT)
>
>    (1)  MappingPackage1 Expression Integer
>                                Type: Domain
> (2) -> ((sqrt**2)$MEI)(16)
>
>    (2)  2
>                                Type: Expression Integer
>
> (3) -> MEI3:=MappingPackage3(EXPR INT,EXPR INT,EXPR INT)
>
>    (3)
>    MappingPackage3(Expression Integer,Expression
> Integer,Expression Integer)
>                                Type: Domain
> (4) -> ((log*cos*sin)$MEI3)(%pi)
>
>    (4)  0
>                                Type: Expression Integer
>
> ----------
>
> Thanks for asking these questions!
>
> Regards,
> Bill Page.
>
>
> _______________________________________________
> Axiom-math mailing list
> address@hidden
> http://lists.nongnu.org/mailman/listinfo/axiom-math
>