# Quaternion RΒΆ

quat.spad line 209 [edit on github]

Quaternion implements Hamilton quaternions over a commutative ring.

- 0: %
from AbelianMonoid

- 1: %
from MagmaWithUnit

- *: (%, %) -> %
from LeftModule %

- *: (%, Fraction Integer) -> % if R has Field
from RightModule Fraction Integer

- *: (%, R) -> %
from RightModule R

- *: (Fraction Integer, %) -> % if R has Field
from LeftModule Fraction Integer

- *: (Integer, %) -> %
from AbelianGroup

- *: (NonNegativeInteger, %) -> %
from AbelianMonoid

- *: (PositiveInteger, %) -> %
from AbelianSemiGroup

- *: (R, %) -> %
from LeftModule R

- +: (%, %) -> %
from AbelianSemiGroup

- -: % -> %
from AbelianGroup

- -: (%, %) -> %
from AbelianGroup

- <=: (%, %) -> Boolean if R has OrderedSet
from PartialOrder

- <: (%, %) -> Boolean if R has OrderedSet
from PartialOrder

- >=: (%, %) -> Boolean if R has OrderedSet
from PartialOrder

- >: (%, %) -> Boolean if R has OrderedSet
from PartialOrder

- ^: (%, Integer) -> % if R has Field
from DivisionRing

- ^: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- ^: (%, PositiveInteger) -> %
from Magma

- abs: % -> R if R has RealNumberSystem
from QuaternionCategory R

- annihilate?: (%, %) -> Boolean
from Rng

- antiCommutator: (%, %) -> %

- associates?: (%, %) -> Boolean if R has EntireRing
from EntireRing

- associator: (%, %, %) -> %
from NonAssociativeRng

- characteristic: () -> NonNegativeInteger
from NonAssociativeRing

- charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: Fraction Integer -> % if R has Field or R has RetractableTo Fraction Integer
- coerce: Integer -> %
from NonAssociativeRing

- coerce: R -> %
from CoercibleFrom R

- commutator: (%, %) -> %
from NonAssociativeRng

- conjugate: % -> %
from QuaternionCategory R

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

- D: % -> % if R has DifferentialRing
from DifferentialRing

- D: (%, List Symbol) -> % if R has PartialDifferentialRing Symbol
- D: (%, List Symbol, List NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
- D: (%, NonNegativeInteger) -> % if R has DifferentialRing
from DifferentialRing

- D: (%, R -> R) -> %
from DifferentialExtension R

- D: (%, R -> R, NonNegativeInteger) -> %
from DifferentialExtension R

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

- differentiate: % -> % if R has DifferentialRing
from DifferentialRing

- differentiate: (%, List Symbol) -> % if R has PartialDifferentialRing Symbol
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
- differentiate: (%, NonNegativeInteger) -> % if R has DifferentialRing
from DifferentialRing

- differentiate: (%, R -> R) -> %
from DifferentialExtension R

- differentiate: (%, R -> R, NonNegativeInteger) -> %
from DifferentialExtension R

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

- eval: (%, Equation R) -> % if R has Evalable R
from Evalable R

- eval: (%, List Equation R) -> % if R has Evalable R
from Evalable R

- eval: (%, List R, List R) -> % if R has Evalable R
from InnerEvalable(R, R)

- eval: (%, List Symbol, List R) -> % if R has InnerEvalable(Symbol, R)
from InnerEvalable(Symbol, R)

- eval: (%, R, R) -> % if R has Evalable R
from InnerEvalable(R, R)

- eval: (%, Symbol, R) -> % if R has InnerEvalable(Symbol, R)
from InnerEvalable(Symbol, R)

- exquo: (%, %) -> Union(%, failed) if R has EntireRing
from EntireRing

- hash: % -> SingleInteger
from SetCategory

- hashUpdate!: (HashState, %) -> HashState
from SetCategory

- imagI: % -> R
from QuaternionCategory R

- imagJ: % -> R
from QuaternionCategory R

- imagK: % -> R
from QuaternionCategory R

- inv: % -> % if R has Field
from DivisionRing

- latex: % -> String
from SetCategory

- leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- leftPower: (%, PositiveInteger) -> %
from Magma

- leftRecip: % -> Union(%, failed)
from MagmaWithUnit

- map: (R -> R, %) -> %
from FullyEvalableOver R

- max: (%, %) -> % if R has OrderedSet
from OrderedSet

- min: (%, %) -> % if R has OrderedSet
from OrderedSet

- norm: % -> R
from QuaternionCategory R

- one?: % -> Boolean
from MagmaWithUnit

- opposite?: (%, %) -> Boolean
from AbelianMonoid

- quatern: (R, R, R, R) -> %
from QuaternionCategory R

- rational?: % -> Boolean if R has IntegerNumberSystem
from QuaternionCategory R

- rational: % -> Fraction Integer if R has IntegerNumberSystem
from QuaternionCategory R

- rationalIfCan: % -> Union(Fraction Integer, failed) if R has IntegerNumberSystem
from QuaternionCategory R

- real: % -> R
from QuaternionCategory R

- recip: % -> Union(%, failed)
from MagmaWithUnit

- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
from LinearlyExplicitOver R

- reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
- reducedSystem: Matrix % -> Matrix R
from LinearlyExplicitOver R

- retract: % -> Fraction Integer if R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retract: % -> Integer if R has RetractableTo Integer
from RetractableTo Integer

- retract: % -> R
from RetractableTo R

- retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer
from RetractableTo Integer

- retractIfCan: % -> Union(R, failed)
from RetractableTo R

- rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- rightPower: (%, PositiveInteger) -> %
from Magma

- rightRecip: % -> Union(%, failed)
from MagmaWithUnit

- sample: %
from AbelianMonoid

- smaller?: (%, %) -> Boolean if R has OrderedSet
from Comparable

- subtractIfCan: (%, %) -> Union(%, failed)

- unit?: % -> Boolean if R has EntireRing
from EntireRing

- unitCanonical: % -> % if R has EntireRing
from EntireRing

- unitNormal: % -> Record(unit: %, canonical: %, associate: %) if R has EntireRing
from EntireRing

- zero?: % -> Boolean
from AbelianMonoid

Algebra Fraction Integer if R has Field

Algebra R

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer) if R has Field

BiModule(R, R)

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleFrom Fraction Integer if R has RetractableTo Fraction Integer

CoercibleFrom Integer if R has RetractableTo Integer

Comparable if R has OrderedSet

ConvertibleTo InputForm if R has ConvertibleTo InputForm

DifferentialRing if R has DifferentialRing

DivisionRing if R has Field

Eltable(R, %) if R has Eltable(R, R)

EntireRing if R has EntireRing

Evalable R if R has Evalable R

InnerEvalable(R, R) if R has Evalable R

InnerEvalable(Symbol, R) if R has InnerEvalable(Symbol, R)

LeftModule Fraction Integer if R has Field

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

Module Fraction Integer if R has Field

Module R

noZeroDivisors if R has EntireRing

OrderedSet if R has OrderedSet

PartialDifferentialRing Symbol if R has PartialDifferentialRing Symbol

PartialOrder if R has OrderedSet

RetractableTo Fraction Integer if R has RetractableTo Fraction Integer

RetractableTo Integer if R has RetractableTo Integer

RightModule Fraction Integer if R has Field

TwoSidedRecip if R has Field