Equation SΒΆ

equation1.spad line 48 [edit on github]

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.

=: (%, %) -> 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 Group or S has Ring

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

equation: (S, S) -> %

equation(a, b) creates an equation.

eval: (%, %) -> % if S has SetCategory and S has Evalable S

eval(eqn, x=f) replaces x by f in equation eqn.

eval: (%, List %) -> % if S has SetCategory and S has Evalable S

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

TwoSidedRecip if S has Group

unitsKnown if S has Group or S has Ring