QuaternionCategory R

quat.spad line 1 [edit on github]

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

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 CoercibleFrom 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?: % -> 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

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

CoercibleFrom Fraction Integer if R has RetractableTo Fraction Integer

CoercibleFrom Integer if R has RetractableTo Integer

CoercibleFrom R

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

TwoSidedRecip if R has Field

unitsKnown