Equation SΒΆ

equation1.spad line 48

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.

0: % if S has AbelianGroup
from AbelianMonoid
1: % if S has Monoid
from MagmaWithUnit
*: (%, %) -> % if S has SemiGroup
from Magma
*: (%, S) -> % if S has SemiGroup
eqn*x produces a new equation by multiplying both sides of equation eqn by x.
*: (Integer, %) -> % if S has AbelianGroup
from AbelianGroup
*: (NonNegativeInteger, %) -> % if S has AbelianGroup
from AbelianMonoid
*: (PositiveInteger, %) -> % if S has AbelianSemiGroup
from AbelianSemiGroup
*: (S, %) -> % if S has SemiGroup
x*eqn produces a new equation by multiplying both sides of equation eqn by x.
+: (%, %) -> % if S has AbelianSemiGroup
from AbelianSemiGroup
+: (%, S) -> % if S has AbelianSemiGroup
eqn+x produces a new equation by adding x to both sides of equation eqn.
+: (S, %) -> % if S has AbelianSemiGroup
x+eqn produces a new equation by adding x to both sides of equation eqn.
-: % -> % if S has AbelianGroup
from AbelianGroup
-: (%, %) -> % if S has AbelianGroup
from AbelianGroup
-: (%, S) -> % if S has AbelianGroup
eqn-x produces a new equation by subtracting x from both sides of equation eqn.
-: (S, %) -> % if S has AbelianGroup
x-eqn produces a new equation by subtracting both sides of equation eqn from x.
/: (%, %) -> % if S has Group or S has Field
e1/e2 produces a new equation by dividing the left and right hand sides of equations e1 and e2.
/: (%, S) -> % if S has Field
from VectorSpace S
=: (%, %) -> Boolean if S has SetCategory
from BasicType
=: (S, S) -> %
a=b creates an equation.
^: (%, Integer) -> % if S has Group
from Group
^: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit
^: (%, PositiveInteger) -> % if S has SemiGroup
from Magma
~=: (%, %) -> Boolean if S has SetCategory
from BasicType
annihilate?: (%, %) -> Boolean if S has Ring
from Rng
antiCommutator: (%, %) -> % if S has Ring
from NonAssociativeSemiRng
associator: (%, %, %) -> % if S has Ring
from NonAssociativeRng
characteristic: () -> NonNegativeInteger if S has Ring
from NonAssociativeRing
coerce: % -> Boolean if S has SetCategory
from CoercibleTo Boolean
coerce: % -> OutputForm if S has SetCategory
from CoercibleTo OutputForm
coerce: Integer -> % if S has Ring
from NonAssociativeRing
commutator: (%, %) -> % if S has Ring or S has Group
from NonAssociativeRng
conjugate: (%, %) -> % if S has Group
from Group
D: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
D: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
D: (%, Symbol) -> % if S has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
D: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, Symbol) -> % if S has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
dimension: () -> CardinalNumber if S has Field
from VectorSpace S
equation: (S, S) -> %
equation(a, b) creates an equation.
eval: (%, %) -> % if S has Evalable S and S has SetCategory
eval(eqn, x=f) replaces x by f in equation eqn.
eval: (%, List %) -> % if S has Evalable S and S has SetCategory
eval(eqn, [x1=v1, ... xn=vn]) replaces xi by vi in equation eqn.
eval: (%, List Symbol, List S) -> % if S has InnerEvalable(Symbol, S)
from InnerEvalable(Symbol, S)
eval: (%, Symbol, S) -> % if S has InnerEvalable(Symbol, S)
from InnerEvalable(Symbol, S)
factorAndSplit: % -> List % if S has IntegralDomain
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.
hash: % -> SingleInteger if S has SetCategory
from SetCategory
hashUpdate!: (HashState, %) -> HashState if S has SetCategory
from SetCategory
inv: % -> % if S has Group or S has Field
inv(x) returns the multiplicative inverse of x.
latex: % -> String if S has SetCategory
from SetCategory
leftOne: % -> Union(%, failed) if S has Monoid
leftOne(eq) divides by the left hand side, if possible.
leftPower: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit
leftPower: (%, PositiveInteger) -> % if S has SemiGroup
from Magma
leftRecip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit
leftZero: % -> % if S has AbelianGroup
leftZero(eq) subtracts the left hand side.
lhs: % -> S
lhs(eqn) returns the left hand side of equation eqn.
map: (S -> S, %) -> %
map(f, eqn) constructs a new equation by applying f to both sides of eqn.
one?: % -> Boolean if S has Monoid
from MagmaWithUnit
opposite?: (%, %) -> Boolean if S has AbelianGroup
from AbelianMonoid
recip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit
rhs: % -> S
rhs(eqn) returns the right hand side of equation eqn.
rightOne: % -> Union(%, failed) if S has Monoid
rightOne(eq) divides by the right hand side, if possible.
rightPower: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> % if S has SemiGroup
from Magma
rightRecip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit
rightZero: % -> % if S has AbelianGroup
rightZero(eq) subtracts the right hand side.
sample: % if S has Monoid or S has AbelianGroup
from AbelianMonoid
subst: (%, %) -> % if S has ExpressionSpace
subst(eq1, eq2) substitutes eq2 into both sides of eq1 the lhs of eq2 should be a kernel
subtractIfCan: (%, %) -> Union(%, failed) if S has AbelianGroup
from CancellationAbelianMonoid
swap: % -> %
swap(eq) interchanges left and right hand side of equation eq.
zero?: % -> Boolean if S has AbelianGroup
from AbelianMonoid

AbelianGroup if S has AbelianGroup

AbelianMonoid if S has AbelianGroup

AbelianSemiGroup if S has AbelianSemiGroup

BasicType if S has SetCategory

BiModule(%, %) if S has Ring

BiModule(S, S) if S has Ring

CancellationAbelianMonoid if S has AbelianGroup

CoercibleTo Boolean if S has SetCategory

CoercibleTo OutputForm if S has SetCategory

Group if S has Group

InnerEvalable(Symbol, S) if S has InnerEvalable(Symbol, S)

LeftModule % if S has Ring

LeftModule S if S has Ring

Magma if S has SemiGroup

MagmaWithUnit if S has Monoid

Module S if S has CommutativeRing

Monoid if S has Monoid

NonAssociativeRing if S has Ring

NonAssociativeRng if S has Ring

NonAssociativeSemiRing if S has Ring

NonAssociativeSemiRng if S has Ring

PartialDifferentialRing Symbol if S has PartialDifferentialRing Symbol

RightModule % if S has Ring

RightModule S if S has Ring

Ring if S has Ring

Rng if S has Ring

SemiGroup if S has SemiGroup

SemiRing if S has Ring

SemiRng if S has Ring

SetCategory if S has SetCategory

unitsKnown if S has Ring or S has Group

VectorSpace S if S has Field