On Sunday, March 19, 2006 5:54 AM Francois Maltey wrote:

axiom
resFloat   : Expression Float := cos (4.0 * x)

(1)

axiom
resInteger : Expression Integer := cos (4 * x)

(2)

axiom
resComplex : Expression Complex Integer := exp (3+4*%i)

(3)

How can I get Float from resFloat ? Integer from resInteger, etc. in a *.input file ?

I don't try to get the sub-argument, but the type of the subargument.

Imagine I know that a is an Expression... My function don't know if a is an Expression Float, or an Expression Integer...

I want to do as below in an *.input file:

  Myfunction (a : Expression ...) : String ==
    is a an Expression Integer => "Integer"   -- or an other calculus.
    is a an Expression Franction Integer => "Rationnal"
    is a an Expression Complex ... => "Complex"   -- so I can use real and imag.
    is a an Expression Float => "Float"
    "A rare domain"

On Monday, March 20, 2006 7:53 PM William Sit wrote:

This is a bit tricky, since any function in Axiom must have a specific domain as source. The Axiom domain ANY is a coverall. Here is a try:

axiom
)set function compile on

Myfunction(a:Any):String ==
  aDom := unparse ((domainOf a)::InputForm)
  substring?("Expression",aDom,1)=>delete(aDom, 1..11)
  "A rare domain"

   Function declaration Myfunction : Any -> String has been added to
      workspace.

To use the function, coerce the input to Any, such as:

axiom
Myfunction(resInteger::Any)

Compiling function Myfunction with type Any -> String

(4)

dom returns the domain of any expression as an "SExpression?" (SEX). An S-expression is the form used by Lisp and it can represent any expression as a special kind of list.

axiom
MyFunc2(a:ANY):OutputForm==
  if dom(a).1 = "Expression"::Symbol::SEX then
    dom(a).2 = ["Integer"::Symbol::SEX]::SEX =>
      "Integer"
    dom(a).2 = ["Float"::Symbol::SEX]::SEX =>
      "Float"
    dom(a).2 = ["Complex"::Symbol::SEX,["Integer"::
Symbol::SEX]::SEX]::SEX =>
      "Complex"
    "A rare domain"
  else
    return hconcat(message("Can not handle: ")$OutputForm,(dom
a)::OutputForm)

   Function declaration MyFunc2 : Any -> OutputForm has been added to
      workspace.

axiom
MyFunc2(resFloat)

Compiling function MyFunc2 with type Any -> OutputForm

(5)

axiom
MyFunc2(resInteger)

(6)

axiom
MyFunc2(resComplex)

(7)

axiom
MyFunc2(1)

(8)

axiom
MyFunc2(x::EXPR FRAC INT)

(9)

But, now a word of caution

Is this really what you want to do?

In generally, in Axiom we would like to use automatic polymorphism to select the appropriate function. In SPAD the "same" function can be defined many times using different signatures. So for example:

  plus(x::Expression Float):Expression Float == ...

and:

  plus(x::Expression Integer):Expression Integer == ...

can define different behaviours for the function plus depending on the type of the argument.

Unfortunately it is not possible to do this in the Axiom interpreter.

axiom
EI ==> Expression Integer

axiom
EF ==> Expression Float

axiom
ECI ==> Expression Complex Integer

axiom
MyFunc3(a:Union(EI, EF, ECI)):String ==
  a case EI => "Integer";
  a case EF => "Float";
  "Complex Integer"

   Function declaration MyFunc3 : Union(Expression Integer,Expression
      Float,Expression Complex Integer) -> String has been added to
      workspace.

axiom
MyFunc3(resFloat)

Compiling function MyFunc3 with type Union(Expression Integer,
      Expression Float,Expression Complex Integer) -> String

(10)

axiom
MyFunc3(resInteger)

(11)

axiom
MyFunc3(resComplex)

(12)

axiom
MyFunc3(n::EXPR FRAC INT)

   Conversion failed in the compiled user function MyFunc3 .

   Cannot convert from type Expression Fraction Integer to Union(
      Expression Integer,Expression Float,Expression Complex Integer)
      for value
   n

axiom
MyFunc4(a:ANY):String==
  myEI:Expression Integer
  myEF:Expression Float
  myECI:Expression Complex Integer
  myEFI:Expression Fraction Integer
  dom(a) = dom(myEI) => "Integer"
  dom(a) = dom(myEF) => "Float"
  dom(a) = dom(myEFI) => "Rational"
  dom(a) = dom(myECI) => "Complex"
  "A rare domain"

   Function declaration MyFunc4 : Any -> String has been added to
      workspace.

axiom
MyFunc4(resFloat)

Compiling function MyFunc4 with type Any -> String

(13)

axiom
MyFunc4(resInteger)

(14)

axiom
MyFunc4(resComplex)

(15)

axiom
MyFunc4(1)

(16)

axiom
MyFunc4(x::EXPR FRAC INT)

(17)

http://wiki.axiom-developer.org/axiom--test--1/src/algebra/AnySpad

we can see how to write this in Spad. Note that the function devaluate returns an S-expression that represents a domain.

spad
)abbrev package MYDOM MyDomain
MyDomain: with
    MyFunc:Any->String
  == add
    MyFunc(a:Any):String==
      myEI==>Expression Integer
      myEF==>Expression Float
      myECI==>Expression Complex Integer
      myEFI==>Expression Fraction Integer
      dom(a) = devaluate(myEI)$Lisp => "Integer"
      dom(a) = devaluate(myEF)$Lisp => "Float"
      dom(a) = devaluate(myEFI)$Lisp => "Rational"
      dom(a) = devaluate(myECI)$Lisp => "Complex"
      "A rare domain"

   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/7109084728131837944-25px010.spad using 
      old system compiler.
   MYDOM abbreviates package MyDomain 
------------------------------------------------------------------------
   initializing NRLIB MYDOM for MyDomain 
   compiling into NRLIB MYDOM 
   compiling exported MyFunc : Any -> String
   processing macro definition myEI ==> Expression Integer 
   processing macro definition myEF ==> Expression Float 
   processing macro definition myECI ==> Expression Complex Integer 
   processing macro definition myEFI ==> Expression Fraction Integer 
Time: 0.18 SEC.

(time taken in buildFunctor:  0)

;;;     ***       |MyDomain| REDEFINED

;;;     ***       |MyDomain| REDEFINED
Time: 0 SEC.

   Cumulative Statistics for Constructor MyDomain
      Time: 0.18 seconds

   finalizing NRLIB MYDOM 
   Processing MyDomain for Browser database:
--->-->MyDomain((MyFunc ((String) (Any)))): Not documented!!!!
--->-->MyDomain(constructor): Not documented!!!!
--->-->MyDomain(): Missing Description
------------------------------------------------------------------------
   MyDomain is now explicitly exposed in frame initial 
   MyDomain will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/MYDOM.NRLIB/code

axiom
MyFunc(resInteger)$MyDomain

(18)

axiom
MyFunc(x::EXPR FRAC INT)$MyDomain

(19)