QuaternionCategory(R)

quat.spad line 1 [edit on github]

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

* : (%, %) -> %
from Magma
* : (%, R) -> %
from RightModule(R)
* : (%, Fraction(Integer)) -> % if R has Field
from RightModule(Fraction(Integer))
* : (%, Integer) -> % if R has LinearlyExplicitOver(Integer)
from RightModule(Integer)
* : (R, %) -> %
from LeftModule(R)
* : (Fraction(Integer), %) -> % if R has Field
from LeftModule(Fraction(Integer))
* : (Integer, %) -> %
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
+ : (%, %) -> %
from AbelianSemiGroup
- : % -> %
from AbelianGroup
- : (%, %) -> %
from AbelianGroup
0 : () -> %
from AbelianMonoid
1 : () -> %
from MagmaWithUnit
< : (%, %) -> 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
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 : (%, Mapping(R, R)) -> %
from DifferentialExtension(R)
D : (%, Mapping(R, R), NonNegativeInteger) -> %
from DifferentialExtension(R)
D : (%, NonNegativeInteger) -> % if R has DifferentialRing
from DifferentialRing
D : (%, Symbol) -> % if R has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
D : (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing(Symbol)
from PartialDifferentialRing(Symbol)
^ : (%, Integer) -> % if R has Field
from DivisionRing
^ : (%, NonNegativeInteger) -> %
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
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 : R -> %
from Algebra(R)
coerce : Fraction(Integer) -> % if R has RetractableTo(Fraction(Integer)) or R has Field
from Algebra(Fraction(Integer))
coerce : Integer -> %
from NonAssociativeRing
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> %
from NonAssociativeRng
conjugate : % -> %

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

convert : % -> InputForm if R has ConvertibleTo(InputForm)
from ConvertibleTo(InputForm)
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 : (%, Mapping(R, R)) -> %
from DifferentialExtension(R)
differentiate : (%, Mapping(R, R), NonNegativeInteger) -> %
from DifferentialExtension(R)
differentiate : (%, NonNegativeInteger) -> % if R has DifferentialRing
from DifferentialRing
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 : (%, R, R) -> % if R has Evalable(R)
from InnerEvalable(R, R)
eval : (%, 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(Equation(R))) -> % if R has Evalable(R)
from Evalable(R)
eval : (%, List(Symbol), List(R)) -> % if R has InnerEvalable(Symbol, R)
from InnerEvalable(Symbol, 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 : (Mapping(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) -> %
from NonAssociativeAlgebra(R)
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(%) -> Matrix(R)
from LinearlyExplicitOver(R)
reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer)
from LinearlyExplicitOver(Integer)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(R), vec : Vector(R))
from LinearlyExplicitOver(R)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if R has LinearlyExplicitOver(Integer)
from LinearlyExplicitOver(Integer)
retract : % -> R
from RetractableTo(R)
retract : % -> Fraction(Integer) if R has RetractableTo(Fraction(Integer))
from RetractableTo(Fraction(Integer))
retract : % -> Integer if R has RetractableTo(Integer)
from RetractableTo(Integer)
retractIfCan : % -> Union(R, "failed")
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)
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
~= : (%, %) -> Boolean
from BasicType

CharacteristicNonZero

Comparable

ConvertibleTo(InputForm)

noZeroDivisors

CoercibleFrom(R)

NonAssociativeSemiRng

BasicType

Monoid

AbelianMonoid

BiModule(R, R)

LeftModule(Fraction(Integer))

DivisionRing

DifferentialExtension(R)

NonAssociativeAlgebra(R)

Algebra(R)

CancellationAbelianMonoid

OrderedSet

MagmaWithUnit

NonAssociativeRing

RightModule(R)

RightModule(Fraction(Integer))

RetractableTo(Integer)

LinearlyExplicitOver(Integer)

RetractableTo(R)

LinearlyExplicitOver(R)

LeftModule(%)

LeftModule(R)

FullyLinearlyExplicitOver(R)

RightModule(%)

Algebra(Fraction(Integer))

SetCategory

CoercibleTo(OutputForm)

NonAssociativeAlgebra(Fraction(Integer))

Rng

Module(Fraction(Integer))

TwoSidedRecip

Magma

SemiGroup

InnerEvalable(R, R)

PartialOrder

PartialDifferentialRing(Symbol)

BiModule(%, %)

CoercibleFrom(Integer)

unitsKnown

AbelianGroup

AbelianSemiGroup

RetractableTo(Fraction(Integer))

NonAssociativeSemiRing

FullyEvalableOver(R)

InnerEvalable(Symbol, R)

Module(R)

Eltable(R, %)

DifferentialRing

Evalable(R)

RightModule(Integer)

NonAssociativeRng

Ring

BiModule(Fraction(Integer), Fraction(Integer))

SemiRng

CoercibleFrom(Fraction(Integer))

EntireRing

FullyRetractableTo(R)

CharacteristicZero

SemiRing