QuaternionCategory RΒΆ

quat.spad line 1

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

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (%, 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
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: (%, %) -> %
from NonAssociativeSemiRng
associates?: (%, %) -> Boolean if R has EntireRing
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
charthRoot: % -> Union(%, failed) if R has CharacteristicNonZero
from CharacteristicNonZero
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: Fraction Integer -> % if R has RetractableTo Fraction Integer or R has Field
from Algebra Fraction Integer
coerce: Integer -> %
from NonAssociativeRing
coerce: R -> %
from RetractableTo R
commutator: (%, %) -> %
from NonAssociativeRng
conjugate: % -> %
conjugate(q) negates the imaginary parts of quaternion q.
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
from PartialDifferentialRing Symbol
D: (%, List Symbol, List NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
from 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
from PartialDifferentialRing Symbol
D: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: % -> % if R has DifferentialRing
from DifferentialRing
differentiate: (%, List Symbol) -> % if R has PartialDifferentialRing Symbol
from PartialDifferentialRing Symbol
differentiate: (%, List Symbol, List NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
from 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
from PartialDifferentialRing Symbol
differentiate: (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing Symbol
from 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: % -> 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.
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.
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
from LinearlyExplicitOver Integer
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
from LinearlyExplicitOver R
reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
from 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)
from CancellationAbelianMonoid
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

Algebra R

BasicType

BiModule(%, %)

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

BiModule(R, R)

CancellationAbelianMonoid

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleTo OutputForm

Comparable if R has OrderedSet

ConvertibleTo InputForm if R has ConvertibleTo InputForm

DifferentialExtension R

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

FullyEvalableOver R

FullyLinearlyExplicitOver R

FullyRetractableTo R

InnerEvalable(R, R) if R has Evalable R

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

LeftModule %

LeftModule Fraction Integer if R has Field

LeftModule R

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

LinearlyExplicitOver R

Magma

MagmaWithUnit

Module Fraction Integer if R has Field

Module R

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

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

RetractableTo R

RightModule %

RightModule Fraction Integer if R has Field

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

unitsKnown