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

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

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

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