GeneralQuaternion(R, p, q)

quat.spad line 174 [edit on github]

GeneralQuaternion implements general quaternions over a commutative ring. The main constructor function is quatern which takes 4 arguments: the real part, the i imaginary part, the j imaginary part and the k imaginary part.

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