# Equation SΒΆ

equation1.spad line 48 [edit on github]

S: Type

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

- *: (%, 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

- 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 Group

- convert: % -> InputForm if S has ConvertibleTo InputForm
from ConvertibleTo InputForm

- D: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol
- D: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
- D: (%, Symbol) -> % if S has PartialDifferentialRing Symbol
- D: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol

- differentiate: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol
- differentiate: (%, Symbol) -> % if S has PartialDifferentialRing Symbol
- differentiate: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol

- 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.

- 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 AbelianGroup or S has Monoid
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

- 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

CancellationAbelianMonoid if S has AbelianGroup

CoercibleTo Boolean if S has SetCategory

CoercibleTo OutputForm if S has SetCategory

ConvertibleTo InputForm if S has ConvertibleTo InputForm

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

LeftModule % if S has Ring

LeftModule S if S has Ring

MagmaWithUnit if S has Monoid

Module S if S has CommutativeRing

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

SetCategory if S has SetCategory

TwoSidedRecip if S has Group

unitsKnown if S has Ring or S has Group