Quaternion(R)

quat.spad line 209 [edit on github]

• R : CommutativeRing

Quaternion implements Hamilton quaternions over a commutative ring.

* : (%, %) -> %

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

from QuaternionCategory(R)

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 Field or R has RetractableTo(Fraction(Integer))

from Algebra(Fraction(Integer))

coerce : Integer -> %

from NonAssociativeRing

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

commutator : (%, %) -> %

from NonAssociativeRng

conjugate : % -> %

from QuaternionCategory(R)

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

from QuaternionCategory(R)

imagJ : % -> R

from QuaternionCategory(R)

imagK : % -> R

from QuaternionCategory(R)

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

from QuaternionCategory(R)

one? : % -> Boolean

from MagmaWithUnit

opposite? : (%, %) -> Boolean

from AbelianMonoid

plenaryPower : (%, PositiveInteger) -> %

from NonAssociativeAlgebra(R)

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

from QuaternionCategory(R)

rational : % -> Fraction(Integer) if R has IntegerNumberSystem

from QuaternionCategory(R)

rational? : % -> Boolean if R has IntegerNumberSystem

from QuaternionCategory(R)

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

from QuaternionCategory(R)

real : % -> R

from QuaternionCategory(R)

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

Module(Fraction(Integer))

Comparable

ConvertibleTo(InputForm)

noZeroDivisors

LeftModule(Fraction(Integer))

CoercibleFrom(R)

Algebra(R)

Monoid

AbelianMonoid

BiModule(R, R)

NonAssociativeAlgebra(Fraction(Integer))

RightModule(Integer)

NonAssociativeAlgebra(R)

CancellationAbelianMonoid

PartialOrder

OrderedSet

MagmaWithUnit

RetractableTo(Fraction(Integer))

AbelianGroup

RightModule(Fraction(Integer))

CoercibleFrom(Fraction(Integer))

RetractableTo(Integer)

SemiRing

QuaternionCategory(R)

LinearlyExplicitOver(Integer)

Module(R)

LeftModule(%)

LeftModule(R)

PartialDifferentialRing(Symbol)

RightModule(%)

SetCategory

Ring

Algebra(Fraction(Integer))

InnerEvalable(Symbol, R)

TwoSidedRecip

Magma

Rng

NonAssociativeRing

DifferentialExtension(R)

NonAssociativeRng

InnerEvalable(R, R)

BiModule(%, %)

CoercibleFrom(Integer)

unitsKnown

CoercibleTo(OutputForm)

AbelianSemiGroup

FullyLinearlyExplicitOver(R)

NonAssociativeSemiRing

FullyEvalableOver(R)

DivisionRing

RightModule(R)

SemiGroup

Eltable(R, %)

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

CharacteristicZero

DifferentialRing

Evalable(R)

RetractableTo(R)

LinearlyExplicitOver(R)

SemiRng

EntireRing

NonAssociativeSemiRng

BasicType

FullyRetractableTo(R)