Edit detail for SandBoxSymbolic revision 18 of 35

Symbolic Integers

A simple form of symbolic computation using just Variable and Integer.

(1) -> a:Union(Variable a,Integer)

b:Union(Variable b,Integer)

c:=a*3-b*2

(1)

p:UP(x,Integer):=x*2-7

(2)

pc := p c

(3)

f(x)==x^3-x^2+1

fb := f b

Compiling function f with type Variable(b) -> Polynomial(Integer)

(4)

a:=1

(5)

b:=-3

(6)

c

(7)

eval(pc,['a=a,'b=b])

(8)

eval(c,['a=a,'b=b])

(9)

eval(fb,['a=a,'b=b])

(10)

a:=3.14  -- not permitted!

   Cannot convert right-hand side of assignment
   3.14

      to an object of the type Union(Variable(a),Integer) of the 
      left-hand side.

For more complex cases it is necessary to define a new domain of "indeterminants". These are symbols and unevaluated expressions that can be evaluated at a later time. This domain is modeled after InputForm? which provides all of the basic functionality.

)abbrev domain INDET Indeterminant
++ Description:
++   Based on InputForm
Indeterminant():
  Join(SExpressionCategory(String,Symbol,Integer,DoubleFloat,OutputForm),
       ConvertibleTo SExpression) with
    eval: % -> Any
      ++ eval(f) passes f to the interpreter.
    binary   : (%, List %) -> %
      ++ \spad{binary(op, [a1,...,an])} returns the input form
      ++ corresponding to  \spad{a1 op a2 op ... op an}.
    function : (%, List Symbol, Symbol) -> %
      ++ \spad{function(code, [x1,...,xn], f)} returns the input form
      ++ corresponding to \spad{f(x1,...,xn) == code}.
    lambda   : (%, List Symbol) -> %
      ++ \spad{lambda(code, [x1,...,xn])} returns the input form
      ++ corresponding to \spad{(x1,...,xn) +-> code} if \spad{n > 1},
      ++ or to \spad{x1 +-> code} if \spad{n = 1}.
    "+"      : (%, %) -> %
      ++ \spad{a + b} returns the input form corresponding to \spad{a + b}.
    "-"      : (%, %) -> %
      ++ \spad{a - b} returns the input form corresponding to \spad{a - b}.
    "-"      : % -> %
      ++ \spad{-a} returns the input form corresponding to \spad{-a}.
    "*"      : (%, %) -> %
      ++ \spad{a * b} returns the input form corresponding to \spad{a * b}.
    "/"      : (%, %) -> %
      ++ \spad{a / b} returns the input form corresponding to \spad{a / b}.
    "**"     : (%, NonNegativeInteger) -> %
      ++ \spad{a ** b} returns the input form corresponding to \spad{a ** b}.
    "**"     : (%, Integer) -> %
      ++ \spad{a ** b} returns the input form corresponding to \spad{a ** b}.
    unparse  : % -> String
      ++ unparse(f) returns a string s such that the parser
      ++ would transform s to f.
      ++ Error: if f is not the parsed form of a string.
    declare  : List %   -> Symbol
      ++ declare(t) returns a name f such that f has been
      ++ declared to the interpreter to be of type t, but has
      ++ not been assigned a value yet.
      ++ Note: t should be created as \spad{devaluate(T)$Lisp} where T is the
      ++ actual type of f (this hack is required for the case where
      ++ T is a mapping type).
    compile  : (Symbol, List %) -> Symbol
      ++ \spad{compile(f, [t1,...,tn])} forces the interpreter to compile
      ++ the function f with signature \spad{(t1,...,tn) -> ?}.
      ++ returns the symbol f if successful.
      ++ Error: if f was not defined beforehand in the interpreter,
      ++ or if the ti's are not valid types, or if the compiler fails.
    coerce : Integer -> %
 == SExpression add
    Rep := SExpression

    mkProperOp: Symbol -> %
    strsym    : % -> String
    tuplify   : List Symbol -> %

    coerce(x:Integer):% == convert(x)
    coerce(x:%):OutputForm == expr x

    convert(x:%):SExpression == x pretend SExpression

    conv(ll : List %): % ==
      convert(ll pretend List SExpression)$SExpression pretend %

    lambda(f,l) == conv([convert("+->"::Symbol),tuplify l,f]$List(%))

    eval x ==
      v := interpret(x)$Lisp
      mkObj(unwrap(objVal(v)$Lisp)$Lisp, objMode(v)$Lisp)$Lisp

    convert(x:DoubleFloat):% ==
      convert(x)$Rep

    strsym s ==
      string? s => string s
      symbol? s => string symbol s
      error "strsym: form is neither a string or symbol"

    unparse x ==
      atom?(s:% := form2String(x)$Lisp) => strsym s
      concat [strsym a for a in destruct s]

    declare signature ==
      declare(name := new()$Symbol, signature)$Lisp
      name

    compile(name, types) ==
      symbol car cdr car
        selectLocalMms(mkProperOp name, convert(name)@%,
          types, nil$List(%))$Lisp

    mkProperOp name ==
      op := mkAtree(nme := convert(name)@%)$Lisp
      transferPropsToNode(nme, op)$Lisp
      convert op

    binary(op, args) ==
      (n := #args) < 2 => error "Need at least 2 arguments"
      n = 2 => convert([op, first args, last args]$List(%))
      convert([op, first args, binary(op, rest args)]$List(%))

    tuplify l ==
      empty? rest l => convert first l
      conv
        concat(convert("Tuple"::Symbol), [convert x for x in l]$List(%))

    function(f, l, name) ==
      nn := convert(new(1 + #l, convert(nil()$List(%)))$List(%))@%
      conv([convert("DEF"::Symbol), conv(cons(convert(name)@%,
                        [convert(x)@% for x in l])), nn, nn, f]$List(%))

    s1 + s2 ==
      conv [convert("+"::Symbol), s1, s2]$List(%)

    s1 - s2 ==
      conv [convert("-"::Symbol), s1, s2]$List(%)

    _-(s1) ==
      conv [convert("-"::Symbol), s1]$List(%)

    s1 * s2 ==
      conv [convert("*"::Symbol), s1, s2]$List(%)

    s1:% ** n:Integer ==
      conv [convert("**"::Symbol), s1, convert n]$List(%)

    s1:% ** n:NonNegativeInteger == s1 ** (n::Integer)

    s1 / s2 ==
      conv [convert("/"::Symbol), s1, s2]$List(%)

   Compiling FriCAS source code from file 
      /var/lib/zope2.10/instance/axiom-wiki/var/LatexWiki/7483143363411555740-25px002.spad
      using system compiler.
   INDET abbreviates domain Indeterminant 
------------------------------------------------------------------------
   initializing NRLIB INDET for Indeterminant 
   compiling into NRLIB INDET 

   >> System error:
   invalid number of arguments: 5

Symbolic Matrices

)clear all

   All user variables and function definitions have been cleared.

m:Union(Indeterminant,Matrix Integer)

   You cannot now use Indeterminant in the context you have it.

)clear all

   All user variables and function definitions have been cleared.

d: Union(Variable d, Float)

d*2

(11)

will be problematic, and the assignment between symbolic integers is not allowed.

a: Union(Variable a, Integer)

b: Union(Variable b, Integer)

b:=a

   a is declared as being in Union(Variable(a),Integer) but has not 
      been given a value.

p:=2*d

(12)

eval(p,d=3.14)

(13)

But there is still a problem since I can write:

a:Union(Variable a,Integer)

a:=3.14

   Cannot convert right-hand side of assignment
   3.14

      to an object of the type Union(Variable(a),Integer) of the 
      left-hand side.

and Axiom does not complain about the eval request because as far as Polynomial Integer is concerned d is just a Symbol.

In the case of the example Indeterminant domain, evaluation of symbolic expressions is always delayed so an appropriate eval operation could be defined that properly respects the type.