help links subscribe changes refresh edit

	SandBox
SandBoxSymbol ←	↑	→ SandBoxSymbolicExpressions

SandBoxSymbolic

last edited 11 years ago by test1

Edit detail for SandBoxSymbolic revision 5 of 35

	1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35
Editor: Bill Page Time: 2008/05/22 14:10:21 GMT-7
Note: Indeterminant domain

added:
\begin{spad}
)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.
    convert  : SExpression -> %
      ++ convert(s) makes s into an input form.
    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}.
    0        : constant -> %
      ++ \spad{0} returns the input form corresponding to 0.
    1        : constant -> %
      ++ \spad{1} returns the input form corresponding to 1.
    flatten  : % -> %
      ++ flatten(s) returns an input form corresponding to s with
      ++ all the nested operations flattened to triples using new
      ++ local variables.
      ++ If s is a piece of code, this speeds up
      ++ the compilation tremendously later on.
    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 -> %
    flatten0  : (%, Symbol, NonNegativeInteger) ->
                                             Record(lst: List %, symb:%)

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

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

    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):% ==
      zero? x => 0
      (x = 1) => 1
      convert(x)$Rep

    flatten s ==
      -- will not compile if I use 'or'
      atom? s => s
      every?(atom?,destruct s)$List(%) => s
      sy := new()$Symbol
      n:NonNegativeInteger := 0
      l2 := [flatten0(x, sy, n := n + 1) for x in rest(l := destruct s)]
      conv(concat(convert("SEQ"::Symbol)@%,
        concat(concat [u.lst for u in l2], conv(
           [convert("exit"::Symbol)@%, 1$%, conv(concat(first l,
               [u.symb for u in l2]))@%]$List(%))@%)))@%

    flatten0(s, sy, n) ==
      atom? s => [nil(), s]
      a := convert(concat(string sy, convert(n)@String)::Symbol)@%
      l2 := [flatten0(x, sy, n := n+1) for x in rest(l := destruct s)]
      [concat(concat [u.lst for u in l2], conv([convert(
        "LET"::Symbol)@%, a, conv(concat(first l,
             [u.symb for u in l2]))@%]$List(%))@%), a]

    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 ==
      s1 = 0 and n > 0 => 0
      s1 = 1 or zero? n => 1
      (n = 1) => s1
      conv [convert("**"::Symbol), s1, convert n]$List(%)

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

    s1 / s2 ==
      s2 = 1 => s1
      conv [convert("/"::Symbol), s1, s2]$List(%)
\end{spad}


changed:
-m:Union(InputForm,Matrix Integer)
-n:Union(InputForm,Matrix Integer)
-a:Union(InputForm,Integer)
-b:Union(InputForm,Integer)
-ab:=(a+b)*(a+ (-1)::InputForm*b)
-expr ab
-mn1:= m*n+(-1)::InputForm*n*m
-expr mn1
-mn2:=(m+n)*(m+(-1)::InputForm*n)
-expr mn2
m:Union(Indeterminant,Matrix Integer)
n:Union(Indeterminant,Matrix Integer)
a:Union(Indeterminant,Integer)
b:Union(Indeterminant,Integer)
ab:=(a+b)*(a-b)
mn1:= m*n-n*m
mn2:=(m+n)*(m-n)

changed:
-interpret mn1
eval mn1
eval mn2

Symbolic Integers

axiom
a:Union(Symbol,Integer)

Type: Void

axiom
b:Union(Symbol,Integer)

Type: Void

axiom
c:=a*3-b*2

(1)

Type: Polynomial Integer

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

(2)

Type: UnivariatePolynomial?(x,Integer)

axiom
pc := p c

(3)

Type: Fraction Polynomial Integer

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

Type: Void

axiom
fb := f b

axiom

Compiling function f with type Symbol -> Polynomial Integer

(4)

Type: Polynomial Integer

axiom
a:=1

(5)

Type: Union(Integer,...)

axiom
b:=-3

(6)

Type: Union(Integer,...)

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

(7)

Type: Fraction Polynomial Integer

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

(8)

Type: Polynomial Integer

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

(9)

Type: Polynomial Integer

axioma:=3.14
   Cannot convert right-hand side of assignment
   3.14
      to an object of the type Union(Symbol,Integer) of the left-hand 
      side.

spad)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.
    convert  : SExpression -> %
      ++ convert(s) makes s into an input form.
    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}.
    0        : constant -> %
      ++ \spad{0} returns the input form corresponding to 0.
    1        : constant -> %
      ++ \spad{1} returns the input form corresponding to 1.
    flatten  : % -> %
      ++ flatten(s) returns an input form corresponding to s with
      ++ all the nested operations flattened to triples using new
      ++ local variables.
      ++ If s is a piece of code, this speeds up
      ++ the compilation tremendously later on.
    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 -> %
    flatten0  : (%, Symbol, NonNegativeInteger) ->
                                             Record(lst: List %, symb:%)
    0                        == convert(0::Integer)
    1                        == convert(1::Integer)
    coerce(x:Integer):% == convert(x)
    coerce(x:%):OutputForm == expr x
    convert(x:%):SExpression == x pretend SExpression
    convert(x:SExpression):% == x
    conv(ll : List %): % ==
      convert(ll pretend List SExpression)$SExpression pretend %
    lambda(f,l) == conv([convert(+->),tuplify l,f]$List(%))
    eval x ==
      v := interpret(x)$Lisp
      mkObj(unwrap(objVal(v)$Lisp)$Lisp, objMode(v)$Lisp)$Lisp
    convert(x:DoubleFloat):% ==
      zero? x => 0
      (x = 1) => 1
      convert(x)$Rep
    flatten s ==
      -- will not compile if I use 'or'
      atom? s => s
      every?(atom?,destruct s)$List(%) => s
      sy := new()$Symbol
      n:NonNegativeInteger := 0
      l2 := [flatten0(x, sy, n := n + 1) for x in rest(l := destruct s)]
      conv(concat(convert(SEQ)@%,
        concat(concat [u.lst for u in l2], conv(
           [convert(exit)@%, 1$%, conv(concat(first l,
               [u.symb for u in l2]))@%]$List(%))@%)))@%
    flatten0(s, sy, n) ==
      atom? s => [nil(), s]
      a := convert(concat(string sy, convert(n)@String)::Symbol)@%
      l2 := [flatten0(x, sy, n := n+1) for x in rest(l := destruct s)]
      [concat(concat [u.lst for u in l2], conv([convert(
        LET)@%, a, conv(concat(first l,
             [u.symb for u in l2]))@%]$List(%))@%), a]
    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), [convert x for x in l]$List(%))
    function(f, l, name) ==
      nn := convert(new(1 + #l, convert(nil()$List(%)))$List(%))@%
      conv([convert(DEF), conv(cons(convert(name)@%,
                        [convert(x)@% for x in l])), nn, nn, f]$List(%))
    s1 + s2 ==
      conv [convert(+), s1, s2]$List(%)
    s1 - s2 ==
      conv [convert(-), s1, s2]$List(%)
    _-(s1) ==
      conv [convert(-), s1]$List(%)
    s1 * s2 ==
      conv [convert(*), s1, s2]$List(%)
    s1:% ** n:Integer ==
      s1 = 0 and n > 0 => 0
      s1 = 1 or zero? n => 1
      (n = 1) => s1
      conv [convert(**), s1, convert n]$List(%)
    s1:% ** n:NonNegativeInteger == s1 ** (n::Integer)
    s1 / s2 ==
      s2 = 1 => s1
      conv [convert(/), s1, s2]$List(%)

spad

   Compiling FriCAS source code from file 
      /var/zope2/var/LatexWiki/7037715791149105850-25px002.spad using 
      old system compiler.
   INDET abbreviates domain Indeterminant 
------------------------------------------------------------------------
   initializing NRLIB INDET for Indeterminant 
   compiling into NRLIB INDET 
   compiling exported Zero : () -> $
Time: 0.12 SEC.
   compiling exported One : () -> $
Time: 0.01 SEC.
   compiling exported coerce : Integer -> $
Time: 0 SEC.
   compiling exported coerce : $ -> OutputForm
Time: 0 SEC.
   compiling exported convert : $ -> SExpression
      INDET;convert;$Se;5 is replaced by x 
Time: 0 SEC.
   compiling exported convert : SExpression -> $
      INDET;convert;Se$;6 is replaced by x 
Time: 0 SEC.
   compiling local conv : List $ -> $
Time: 0.06 SEC.
   compiling exported lambda : ($,List Symbol) -> $
Time: 0.07 SEC.
   compiling exported eval : $ -> Any
Time: 0 SEC.
   compiling exported convert : DoubleFloat -> $
Time: 0.02 SEC.
   compiling exported flatten : $ -> $
Time: 0.08 SEC.
   compiling local flatten0 : ($,Symbol,NonNegativeInteger) -> Record(lst: List $,symb: $)
Time: 0.14 SEC.
   compiling local strsym : $ -> String
Time: 0.02 SEC.
   compiling exported unparse : $ -> String
Time: 0.01 SEC.
   compiling exported declare : List $ -> Symbol
Time: 0.01 SEC.
   compiling exported compile : (Symbol,List $) -> Symbol
Time: 0.06 SEC.
   compiling local mkProperOp : Symbol -> $
Time: 0 SEC.
   compiling exported binary : ($,List $) -> $
Time: 0.02 SEC.
   compiling local tuplify : List Symbol -> $
Time: 0.02 SEC.
   compiling exported function : ($,List Symbol,Symbol) -> $
Time: 0.03 SEC.
   compiling exported + : ($,$) -> $
Time: 0 SEC.
   compiling exported - : ($,$) -> $
Time: 0.01 SEC.
   compiling exported - : $ -> $
Time: 0.01 SEC.
   compiling exported * : ($,$) -> $
Time: 0 SEC.
   compiling exported ** : ($,Integer) -> $
Time: 0.08 SEC.
   compiling exported ** : ($,NonNegativeInteger) -> $
Time: 0 SEC.
   compiling exported / : ($,$) -> $
Time: 0.01 SEC.
(time taken in buildFunctor:  1)
;;;     ***       |Indeterminant| REDEFINED
;;;     ***       |Indeterminant| REDEFINED
Time: 0.01 SEC.
   Warnings: 
      [1] conv: pretend$ -- should replace by @
   Cumulative Statistics for Constructor Indeterminant
      Time: 0.79 seconds
   finalizing NRLIB INDET 
   Processing Indeterminant for Browser database:
--------(eval ((Any) %))---------
--------(convert (% (SExpression)))---------
--------(binary (% % (List %)))---------
--------(function (% % (List (Symbol)) (Symbol)))---------
--------(lambda (% % (List (Symbol))))---------
--------(+ (% % %))---------
--------(- (% % %))---------
--------(- (% %))---------
--------(* (% % %))---------
--------(/ (% % %))---------
--------(** (% % (NonNegativeInteger)))---------
--------(** (% % (Integer)))---------
--------((Zero) (%) constant)---------
--------((One) (%) constant)---------
--------(flatten (% %))---------
--------(unparse ((String) %))---------
--------(declare ((Symbol) (List %)))---------
--------(compile ((Symbol) (Symbol) (List %)))---------
--->-->Indeterminant((coerce (% (Integer)))): Not documented!!!!
--------constructor---------
------------------------------------------------------------------------
   Indeterminant is now explicitly exposed in frame initial 
   Indeterminant will be automatically loaded when needed from 
      /var/zope2/var/LatexWiki/INDET.NRLIB/code

Symbolic Matrices

axiom)clear all
   All user variables and function definitions have been cleared.

axiom
m:Union(Indeterminant,Matrix Integer)

Type: Void

axiom
n:Union(Indeterminant,Matrix Integer)

Type: Void

axiom
a:Union(Indeterminant,Integer)

Type: Void

axiom
b:Union(Indeterminant,Integer)

Type: Void

axiom
ab:=(a+b)*(a-b)

(10)

Type: Indeterminant

axiom
mn1:= m*n-n*m

(11)

Type: Indeterminant

axiom
mn2:=(m+n)*(m-n)

(12)

Type: Indeterminant

axiom
m:=matrix [[1,2],[3,4]]

(13)

Type: Union(Matrix Integer,...)

axiom
n:=matrix [[-1,-2],[-3,4]]

(14)

Type: Union(Matrix Integer,...)

axiom
eval mn1

(15)

Type: Matrix Integer

axiom
eval mn2

(16)

Type: Matrix Integer