|
spad )abbrev domain EQ Equation
--FOR THE BENEFIT OF LIBAX0 GENERATION
++ Author: Stephen M. Watt, enhancements by Johannes Grabmeier
++ Date Created: April 1985
++ Date Last Updated: June 3, 1991; September 2, 1992
++ Basic Operations: =
++ Related Domains:
++ Also See:
++ AMS Classifications:
++ Keywords: equation
++ Examples:
++ References:
++ Description:
++ Equations as mathematical objects. All properties of the basis domain,
++ e.g. being an abelian group are carried over the equation domain, by
++ performing the structural operations on the left and on the
++ right hand side.
-- The interpreter translates "=" to "equation". Otherwise, it will
-- find a modemap for "=" in the domain of the arguments.
Equation(S: Type): public == private where
Ex ==> OutputForm
public ==> Type with
"=": (S, S) -> $
++ a=b creates an equation.
equation: (S, S) -> $
++ equation(a,b) creates an equation.
swap: $ -> $
++ swap(eq) interchanges left and right hand side of equation eq.
lhs: $ -> S
++ lhs(eqn) returns the left hand side of equation eqn.
rhs: $ -> S
++ rhs(eqn) returns the right hand side of equation eqn.
map: (S -> S, $) -> $
++ map(f,eqn) constructs a new equation by applying f to both
++ sides of eqn.
if S has InnerEvalable(Symbol,S) then
InnerEvalable(Symbol,S)
if S has SetCategory then
SetCategory
CoercibleTo Boolean
if S has Evalable(S) then
eval: ($, $) -> $
++ eval(eqn, x=f) replaces x by f in equation eqn.
eval: ($, List $) -> $
++ eval(eqn, [x1=v1, ... xn=vn]) replaces xi by vi in equation eqn.
if S has AbelianSemiGroup then
AbelianSemiGroup
"+": (S, $) -> $
++ x+eqn produces a new equation by adding x to both sides of
++ equation eqn.
"+": ($, S) -> $
++ eqn+x produces a new equation by adding x to both sides of
++ equation eqn.
if S has AbelianGroup then
AbelianGroup
leftZero : $ -> $
++ leftZero(eq) subtracts the left hand side.
rightZero : $ -> $
++ rightZero(eq) subtracts the right hand side.
"-": (S, $) -> $
++ x-eqn produces a new equation by subtracting both sides of
++ equation eqn from x.
"-": ($, S) -> $
++ eqn-x produces a new equation by subtracting x from both sides of
++ equation eqn.
if S has SemiGroup then
SemiGroup
"*": (S, $) -> $
++ x*eqn produces a new equation by multiplying both sides of
++ equation eqn by x.
"*": ($, S) -> $
++ eqn*x produces a new equation by multiplying both sides of
++ equation eqn by x.
if S has Monoid then
Monoid
leftOne : $ -> Union($,"failed")
++ leftOne(eq) divides by the left hand side, if possible.
rightOne : $ -> Union($,"failed")
++ rightOne(eq) divides by the right hand side, if possible.
if S has Group then
Group
leftOne : $ -> Union($,"failed")
++ leftOne(eq) divides by the left hand side.
rightOne : $ -> Union($,"failed")
++ rightOne(eq) divides by the right hand side.
if S has Ring then
Ring
BiModule(S,S)
if S has CommutativeRing then
Module(S)
--Algebra(S)
if S has IntegralDomain then
factorAndSplit : $ -> List $
++ factorAndSplit(eq) make the right hand side 0 and
++ factors the new left hand side. Each factor is equated
++ to 0 and put into the resulting list without repetitions.
if S has PartialDifferentialRing(Symbol) then
PartialDifferentialRing(Symbol)
if S has Field then
VectorSpace(S)
"/": ($, $) -> $
++ e1/e2 produces a new equation by dividing the left and right
++ hand sides of equations e1 and e2.
inv: $ -> $
++ inv(x) returns the multiplicative inverse of x.
if S has ExpressionSpace then
subst: ($, $) -> $
++ subst(eq1,eq2) substitutes eq2 into both sides of eq1
++ the lhs of eq2 should be a kernel
private ==> add
Rep := Record(lhs: S, rhs: S)
eq1,eq2: $
s : S
if S has IntegralDomain then
factorAndSplit eq ==
(S has factor : S -> Factored S) =>
eq0 := rightZero eq
[equation(rcf.factor,0) for rcf in factors factor lhs eq0]
[eq]
l:S = r:S == [l, r]
equation(l, r) == [l, r] -- hack! See comment above.
lhs eqn == eqn.lhs
rhs eqn == eqn.rhs
swap eqn == [rhs eqn, lhs eqn]
map(fn, eqn) == equation(fn(eqn.lhs), fn(eqn.rhs))
if S has InnerEvalable(Symbol,S) then
s:Symbol
ls:List Symbol
x:S
lx:List S
eval(eqn,s,x) == eval(eqn.lhs,s,x) = eval(eqn.rhs,s,x)
eval(eqn,ls,lx) == eval(eqn.lhs,ls,lx) = eval(eqn.rhs,ls,lx)
if S has Evalable(S) then
eval(eqn1:$, eqn2:$):$ ==
eval(eqn1.lhs, eqn2 pretend Equation S) =
eval(eqn1.rhs, eqn2 pretend Equation S)
eval(eqn1:$, leqn2:List $):$ ==
eval(eqn1.lhs, leqn2 pretend List Equation S) =
eval(eqn1.rhs, leqn2 pretend List Equation S)
if S has SetCategory then
eq1 = eq2 == (eq1.lhs = eq2.lhs)@Boolean and
(eq1.rhs = eq2.rhs)@Boolean
coerce(eqn:$):Ex == eqn.lhs::Ex = eqn.rhs::Ex
coerce(eqn:$):Boolean == eqn.lhs = eqn.rhs
if S has AbelianSemiGroup then
eq1 + eq2 == eq1.lhs + eq2.lhs = eq1.rhs + eq2.rhs
s + eq2 == [s,s] + eq2
eq1 + s == eq1 + [s,s]
if S has AbelianGroup then
- eq == (- lhs eq) = (-rhs eq)
s - eq2 == [s,s] - eq2
eq1 - s == eq1 - [s,s]
leftZero eq == 0 = rhs eq - lhs eq
rightZero eq == lhs eq - rhs eq = 0
0 == equation(0$S,0$S)
eq1 - eq2 == eq1.lhs - eq2.lhs = eq1.rhs - eq2.rhs
if S has SemiGroup then
eq1:$ * eq2:$ == eq1.lhs * eq2.lhs = eq1.rhs * eq2.rhs
l:S * eqn:$ == l * eqn.lhs = l * eqn.rhs
l:S * eqn:$ == l * eqn.lhs = l * eqn.rhs
eqn:$ * l:S == eqn.lhs * l = eqn.rhs * l
-- We have to be a bit careful here: raising to a +ve integer is OK
-- (since it's the equivalent of repeated multiplication)
-- but other powers may cause contradictions
-- Watch what else you add here! JHD 2/Aug 1990
if S has Monoid then
1 == equation(1$S,1$S)
recip eq ==
(lh := recip lhs eq) case "failed" => "failed"
(rh := recip rhs eq) case "failed" => "failed"
[lh :: S, rh :: S]
leftOne eq ==
(re := recip lhs eq) case "failed" => "failed"
1 = rhs eq * re
rightOne eq ==
(re := recip rhs eq) case "failed" => "failed"
lhs eq * re = 1
if S has Group then
inv eq == [inv lhs eq, inv rhs eq]
leftOne eq == 1 = rhs eq * inv rhs eq
rightOne eq == lhs eq * inv rhs eq = 1
if S has Ring then
characteristic() == characteristic()$S
i:Integer * eq:$ == (i::S) * eq
if S has IntegralDomain then
factorAndSplit eq ==
(S has factor : S -> Factored S) =>
eq0 := rightZero eq
[equation(rcf.factor,0) for rcf in factors factor lhs eq0]
(S has Polynomial Integer) =>
eq0 := rightZero eq
MF ==> MultivariateFactorize(Symbol, IndexedExponents Symbol, _
Integer, Polynomial Integer)
p : Polynomial Integer := (lhs eq0) pretend Polynomial Integer
[equation((rcf.factor) pretend S,0) for rcf in factors factor(p)$MF]
[eq]
if S has PartialDifferentialRing(Symbol) then
differentiate(eq:$, sym:Symbol):$ ==
[differentiate(lhs eq, sym), differentiate(rhs eq, sym)]
if S has Field then
dimension() == 2 :: CardinalNumber
eq1:$ / eq2:$ == eq1.lhs / eq2.lhs = eq1.rhs / eq2.rhs
inv eq == [inv lhs eq, inv rhs eq]
if S has ExpressionSpace then
subst(eq1,eq2) ==
eq3 := eq2 pretend Equation S
[subst(lhs eq1,eq3),subst(rhs eq1,eq3)]
spad Compiling FriCAS source code from file
/var/zope2/var/LatexWiki/3334714725688983057-25px001.spad using
old system compiler.
EQ abbreviates domain Equation
processing macro definition Ex ==> OutputForm
processing macro definition public ==> -- the constructor category
processing macro definition private ==> -- the constructor capsule
------------------------------------------------------------------------
initializing NRLIB EQ for Equation
compiling into NRLIB EQ
****** Domain: S already in scope
augmenting S: (IntegralDomain)
augmenting $: (SIGNATURE $ factorAndSplit ((List $) $))
compiling exported factorAndSplit : $ -> List $
augmenting S: (SIGNATURE S factor ((Factored S) S))
Time: 0.08 SEC.
compiling exported = : (S,S) -> $
EQ;=;2S$;2 is replaced by CONS
Time: 0 SEC.
compiling exported equation : (S,S) -> $
EQ;equation;2S$;3 is replaced by CONS
Time: 0 SEC.
compiling exported lhs : $ -> S
EQ;lhs;$S;4 is replaced by QCAR
Time: 0 SEC.
compiling exported rhs : $ -> S
EQ;rhs;$S;5 is replaced by QCDR
Time: 0 SEC.
compiling exported swap : $ -> $
Time: 0 SEC.
compiling exported map : (S -> S,$) -> $
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (InnerEvalable (Symbol) S)
compiling exported eval : ($,Symbol,S) -> $
Time: 0.02 SEC.
compiling exported eval : ($,List Symbol,List S) -> $
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (Evalable S)
compiling exported eval : ($,$) -> $
Time: 0.01 SEC.
compiling exported eval : ($,List $) -> $
Time: 0.07 SEC.
****** Domain: S already in scope
augmenting S: (SetCategory)
compiling exported = : ($,$) -> Boolean
Time: 0.01 SEC.
compiling exported coerce : $ -> OutputForm
Time: 0.01 SEC.
compiling exported coerce : $ -> Boolean
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (AbelianSemiGroup)
augmenting $: (SIGNATURE $ + ($ S $))
augmenting $: (SIGNATURE $ + ($ $ S))
compiling exported + : ($,$) -> $
Time: 0 SEC.
compiling exported + : (S,$) -> $
Time: 0 SEC.
compiling exported + : ($,S) -> $
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (AbelianGroup)
augmenting $: (SIGNATURE $ leftZero ($ $))
augmenting $: (SIGNATURE $ rightZero ($ $))
augmenting $: (SIGNATURE $ - ($ S $))
augmenting $: (SIGNATURE $ - ($ $ S))
compiling exported - : $ -> $
Time: 0.01 SEC.
compiling exported - : (S,$) -> $
Time: 0 SEC.
compiling exported - : ($,S) -> $
Time: 0 SEC.
compiling exported leftZero : $ -> $
Time: 0 SEC.
compiling exported rightZero : $ -> $
Time: 0 SEC.
compiling exported Zero : () -> $
Time: 0 SEC.
compiling exported - : ($,$) -> $
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (SemiGroup)
augmenting $: (SIGNATURE $ * ($ S $))
augmenting $: (SIGNATURE $ * ($ $ S))
compiling exported * : ($,$) -> $
Time: 0.01 SEC.
compiling exported * : (S,$) -> $
Time: 0 SEC.
compiling exported * : (S,$) -> $
Time: 0 SEC.
compiling exported * : ($,S) -> $
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (Monoid)
augmenting $: (SIGNATURE $ leftOne ((Union $ failed) $))
augmenting $: (SIGNATURE $ rightOne ((Union $ failed) $))
compiling exported One : () -> $
Time: 0 SEC.
compiling exported recip : $ -> Union($,failed)
Time: 0 SEC.
compiling exported leftOne : $ -> Union($,failed)
Time: 0 SEC.
compiling exported rightOne : $ -> Union($,failed)
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (Group)
augmenting $: (SIGNATURE $ leftOne ((Union $ failed) $))
augmenting $: (SIGNATURE $ rightOne ((Union $ failed) $))
compiling exported inv : $ -> $
Time: 0.06 SEC.
compiling exported leftOne : $ -> Union($,failed)
Time: 0 SEC.
compiling exported rightOne : $ -> Union($,failed)
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (Ring)
compiling exported characteristic : () -> NonNegativeInteger
Time: 0.01 SEC.
compiling exported * : (Integer,$) -> $
Time: 0 SEC.
****** Domain: S already in scope
augmenting S: (IntegralDomain)
augmenting $: (SIGNATURE $ factorAndSplit ((List $) $))
compiling exported factorAndSplit : $ -> List $
augmenting S: (SIGNATURE S factor ((Factored S) S))
extension of ##1 to (Polynomial (Integer)) ignored
processing macro definition MF ==> MultivariateFactorize(Symbol,IndexedExponents Symbol,Integer,Polynomial Integer)
Time: 0.18 SEC.
****** Domain: S already in scope
augmenting S: (PartialDifferentialRing (Symbol))
compiling exported differentiate : ($,Symbol) -> $
Time: 0.01 SEC.
****** Domain: S already in scope
augmenting S: (Field)
augmenting $: (SIGNATURE $ / ($ $ $))
augmenting $: (SIGNATURE $ inv ($ $))
compiling exported dimension : () -> CardinalNumber
Time: 0 SEC.
compiling exported / : ($,$) -> $
Time: 0 SEC.
compiling exported inv : $ -> $
Time: 0.01 SEC.
****** Domain: S already in scope
augmenting S: (ExpressionSpace)
augmenting $: (SIGNATURE $ subst ($ $ $))
compiling exported subst : ($,$) -> $
Time: 0.01 SEC.
****** Domain: S already in scope
augmenting S: (Evalable S)
****** Domain: S already in scope
augmenting S: (SetCategory)
augmenting $: (SIGNATURE $ eval ($ $ $))
augmenting $: (SIGNATURE $ eval ($ $ (List $)))
****** Domain: S already in scope
augmenting S: (AbelianGroup)
augmenting $: (SIGNATURE $ leftZero ($ $))
augmenting $: (SIGNATURE $ rightZero ($ $))
augmenting $: (SIGNATURE $ - ($ S $))
augmenting $: (SIGNATURE $ - ($ $ S))
****** Domain: S already in scope
augmenting S: (Field)
augmenting $: (SIGNATURE $ / ($ $ $))
augmenting $: (SIGNATURE $ inv ($ $))
****** Domain: S already in scope
augmenting S: (AbelianGroup)
augmenting $: (SIGNATURE $ leftZero ($ $))
augmenting $: (SIGNATURE $ rightZero ($ $))
augmenting $: (SIGNATURE $ - ($ S $))
augmenting $: (SIGNATURE $ - ($ $ S))
****** Domain: S already in scope
augmenting S: (AbelianSemiGroup)
augmenting $: (SIGNATURE $ + ($ S $))
augmenting $: (SIGNATURE $ + ($ $ S))
****** Domain: S already in scope
augmenting S: (ExpressionSpace)
augmenting $: (SIGNATURE $ subst ($ $ $))
****** Domain: S already in scope
augmenting S: (Field)
augmenting $: (SIGNATURE $ / ($ $ $))
augmenting $: (SIGNATURE $ inv ($ $))
****** Domain: S already in scope
augmenting S: (Group)
augmenting $: (SIGNATURE $ leftOne ((Union $ failed) $))
augmenting $: (SIGNATURE $ rightOne ((Union $ failed) $))
****** Domain: S already in scope
augmenting S: (InnerEvalable (Symbol) S)
****** Domain: S already in scope
augmenting S: (IntegralDomain)
augmenting $: (SIGNATURE $ factorAndSplit ((List $) $))
****** Domain: S already in scope
augmenting S: (Monoid)
augmenting $: (SIGNATURE $ leftOne ((Union $ failed) $))
augmenting $: (SIGNATURE $ rightOne ((Union $ failed) $))
****** Domain: S already in scope
augmenting S: (PartialDifferentialRing (Symbol))
****** Domain: S already in scope
augmenting S: (Ring)
****** Domain: S already in scope
augmenting S: (SemiGroup)
augmenting $: (SIGNATURE $ * ($ S $))
augmenting $: (SIGNATURE $ * ($ $ S))
****** Domain: S already in scope
augmenting S: (SetCategory)
(time taken in buildFunctor: 9)
;;; *** |Equation| REDEFINED
;;; *** |Equation| REDEFINED
Time: 0.20 SEC.
Semantic Errors:
[1] factorAndSplit: rcf has two modes:
Warnings:
[1] factorAndSplit: not known that (IntegralDomain) is of mode (CATEGORY domain (SIGNATURE factorAndSplit ((List $) $)))
[2] factorAndSplit: not known that (IntegralDomain) is of mode (CATEGORY S (SIGNATURE factor ((Factored S) S)))
Cumulative Statistics for Constructor Equation
Time: 0.70 seconds
finalizing NRLIB EQ
Processing Equation for Browser database:
--------(= ($ S S))---------
--------(equation ($ S S))---------
--------(swap ($ $))---------
--------(lhs (S $))---------
--------(rhs (S $))---------
--------(map ($ (Mapping S S) $))---------
--------(eval ($ $ $))---------
--------(eval ($ $ (List $)))---------
--------(+ ($ S $))---------
--------(+ ($ $ S))---------
--------(leftZero ($ $))---------
--------(rightZero ($ $))---------
--------(- ($ S $))---------
--------(- ($ $ S))---------
--------(* ($ S $))---------
--------(* ($ $ S))---------
--------(leftOne ((Union $ failed) $))---------
--------(rightOne ((Union $ failed) $))---------
--------(leftOne ((Union $ failed) $))---------
--------(rightOne ((Union $ failed) $))---------
--------(factorAndSplit ((List $) $))---------
--------(/ ($ $ $))---------
--------(inv ($ $))---------
--------(subst ($ $ $))---------
--------constructor---------
; (DEFUN |Equation;| ...) is being compiled.
;; The variable IDENTITY is undefined.
;; The compiler will assume this variable is a global.
------------------------------------------------------------------------
Equation is now explicitly exposed in frame initial
Equation will be automatically loaded when needed from
/var/zope2/var/LatexWiki/EQ.NRLIB/code
|