# QuaternionCategory R¶

QuaternionCategory describes the category of quaternions and implements functions that are not representation specific.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

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

from RightModule R

*: (Fraction Integer, %) -> % if R has Field
*: (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

from BasicType

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

~=: (%, %) -> Boolean

from BasicType

abs: % -> R if R has RealNumberSystem

`abs(q)` computes the absolute value of quaternion `q` (sqrt of norm).

annihilate?: (%, %) -> Boolean

from Rng

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

from EntireRing

associator: (%, %, %) -> %
characteristic: () -> NonNegativeInteger
charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero
coerce: % -> OutputForm
coerce: Fraction Integer -> % if R has RetractableTo Fraction Integer or R has Field
coerce: Integer -> %
coerce: R -> %

from CoercibleFrom R

commutator: (%, %) -> %
conjugate: % -> %

`conjugate(q)` negates the imaginary parts of quaternion `q`.

convert: % -> InputForm if R has 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) -> %
D: (%, R -> R, NonNegativeInteger) -> %
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) -> %
differentiate: (%, R -> R, NonNegativeInteger) -> %
differentiate: (%, Symbol) -> % if R has PartialDifferentialRing Symbol
differentiate: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
elt: (%, R) -> % if R has Eltable(R, R)

from Eltable(R, %)

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

imagI: % -> R

`imagI(q)` extracts the imaginary `i` part of quaternion `q`.

imagJ: % -> R

`imagJ(q)` extracts the imaginary `j` part of quaternion `q`.

imagK: % -> R

`imagK(q)` extracts the imaginary `k` part of quaternion `q`.

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

`norm(q)` computes the norm of `q` (the sum of the squares of the components).

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

plenaryPower: (%, PositiveInteger) -> %
quatern: (R, R, R, R) -> %

`quatern(r, i, j, k)` constructs a quaternion from scalars.

rational?: % -> Boolean if R has IntegerNumberSystem

`rational?(q)` returns *`true`* if all the imaginary parts of `q` are zero and the real part can be converted into a rational number, and *`false`* otherwise.

rational: % -> Fraction Integer if R has IntegerNumberSystem

`rational(q)` tries to convert `q` into a rational number. Error: if this is not possible. If `rational?(q)` is `true`, the conversion will be done and the rational number returned.

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

`rationalIfCan(q)` returns `q` as a rational number, or “failed” if this is not possible. Note: if `rational?(q)` is `true`, the conversion can be done and the rational number will be returned.

real: % -> R

`real(q)` extracts the real part of quaternion `q`.

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
retract: % -> Integer if R has RetractableTo Integer
retract: % -> R

from RetractableTo R

retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer
retractIfCan: % -> Union(Integer, failed) if R has 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

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra Fraction Integer if R has Field

BasicType

BiModule(%, %)

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

BiModule(R, R)

CancellationAbelianMonoid

Comparable if R has OrderedSet

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

Magma

MagmaWithUnit

Module Fraction Integer if R has Field

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

OrderedSet if R has OrderedSet

PartialOrder if R has OrderedSet

RightModule Fraction Integer if R has Field

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip if R has Field

unitsKnown