MachineComplex

fortmac.spad line 350 [edit on github]

A domain which models the complex number representation used by machines in the AXIOM-NAG link.

* : (%, %) -> %

from Magma

* : (%, Fraction(Integer)) -> %

from RightModule(Fraction(Integer))

* : (%, Integer) -> % if MachineFloat has LinearlyExplicitOver(Integer)

from RightModule(Integer)

* : (%, MachineFloat) -> %

from RightModule(MachineFloat)

* : (Fraction(Integer), %) -> %

from LeftModule(Fraction(Integer))

* : (Integer, %) -> %

from AbelianGroup

* : (MachineFloat, %) -> %

from LeftModule(MachineFloat)

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

/ : (%, %) -> %

from Field

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

< : (%, %) -> Boolean

from PartialOrder

<= : (%, %) -> Boolean

from PartialOrder

= : (%, %) -> Boolean

from BasicType

> : (%, %) -> Boolean

from PartialOrder

>= : (%, %) -> Boolean

from PartialOrder

D : % -> % if MachineFloat has DifferentialRing

from DifferentialRing

D : (%, List(Symbol)) -> % if MachineFloat has PartialDifferentialRing(Symbol)

from PartialDifferentialRing(Symbol)

D : (%, List(Symbol), List(NonNegativeInteger)) -> % if MachineFloat has PartialDifferentialRing(Symbol)

from PartialDifferentialRing(Symbol)

D : (%, Mapping(MachineFloat, MachineFloat)) -> %

from DifferentialExtension(MachineFloat)

D : (%, Mapping(MachineFloat, MachineFloat), NonNegativeInteger) -> %

from DifferentialExtension(MachineFloat)

D : (%, NonNegativeInteger) -> % if MachineFloat has DifferentialRing

from DifferentialRing

D : (%, Symbol) -> % if MachineFloat has PartialDifferentialRing(Symbol)

from PartialDifferentialRing(Symbol)

D : (%, Symbol, NonNegativeInteger) -> % if MachineFloat has PartialDifferentialRing(Symbol)

from PartialDifferentialRing(Symbol)

^ : (%, %) -> % if MachineFloat has TranscendentalFunctionCategory

from ElementaryFunctionCategory

^ : (%, Fraction(Integer)) -> % if MachineFloat has TranscendentalFunctionCategory

from RadicalCategory

^ : (%, Integer) -> %

from DivisionRing

^ : (%, NonNegativeInteger) -> %

from MagmaWithUnit

^ : (%, PositiveInteger) -> %

from Magma

abs : % -> %

from ComplexCategory(MachineFloat)

acos : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcTrigonometricFunctionCategory

acosh : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcHyperbolicFunctionCategory

acot : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcTrigonometricFunctionCategory

acoth : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcHyperbolicFunctionCategory

acsc : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcTrigonometricFunctionCategory

acsch : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcHyperbolicFunctionCategory

annihilate? : (%, %) -> Boolean

from Rng

antiCommutator : (%, %) -> %

from NonAssociativeSemiRng

argument : % -> MachineFloat if MachineFloat has TranscendentalFunctionCategory

from ComplexCategory(MachineFloat)

asec : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcTrigonometricFunctionCategory

asech : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcHyperbolicFunctionCategory

asin : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcTrigonometricFunctionCategory

asinh : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcHyperbolicFunctionCategory

associates? : (%, %) -> Boolean

from EntireRing

associator : (%, %, %) -> %

from NonAssociativeRng

atan : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcTrigonometricFunctionCategory

atanh : % -> % if MachineFloat has TranscendentalFunctionCategory

from ArcHyperbolicFunctionCategory

basis : () -> Vector(%)

from FramedModule(MachineFloat)

characteristic : () -> NonNegativeInteger

from NonAssociativeRing

characteristicPolynomial : % -> SparseUnivariatePolynomial(MachineFloat)

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

charthRoot : % -> % if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

charthRoot : % -> Union(%, "failed") if % has CharacteristicNonZero and MachineFloat has PolynomialFactorizationExplicit or MachineFloat has CharacteristicNonZero

from CharacteristicNonZero

coerce : % -> %

from Algebra(%)

coerce : Complex(Float) -> %

coerce(u) transforms u into a MachineComplex

coerce : Complex(Integer) -> %

coerce(u) transforms u into a MachineComplex

coerce : Complex(MachineFloat) -> %

coerce(u) transforms u into a MachineComplex

coerce : Complex(MachineInteger) -> %

coerce(u) transforms u into a MachineComplex

coerce : Fraction(Integer) -> %

from CoercibleFrom(Fraction(Integer))

coerce : Integer -> %

from NonAssociativeRing

coerce : MachineFloat -> %

from CoercibleFrom(MachineFloat)

coerce : % -> Complex(Float)

coerce(u) transforms u into a COmplex Float

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

commutator : (%, %) -> %

from NonAssociativeRng

complex : (MachineFloat, MachineFloat) -> %

from ComplexCategory(MachineFloat)

conditionP : Matrix(%) -> Union(Vector(%), "failed") if % has CharacteristicNonZero and MachineFloat has PolynomialFactorizationExplicit or MachineFloat has FiniteFieldCategory

from PolynomialFactorizationExplicit

conjugate : % -> %

from ComplexCategory(MachineFloat)

convert : SparseUnivariatePolynomial(MachineFloat) -> %

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

convert : Vector(MachineFloat) -> %

from FramedModule(MachineFloat)

convert : % -> Complex(DoubleFloat)

from ConvertibleTo(Complex(DoubleFloat))

convert : % -> Complex(Float)

from ConvertibleTo(Complex(Float))

convert : % -> InputForm if MachineFloat has ConvertibleTo(InputForm)

from ConvertibleTo(InputForm)

convert : % -> Pattern(Float)

from ConvertibleTo(Pattern(Float))

convert : % -> Pattern(Integer) if MachineFloat has ConvertibleTo(Pattern(Integer))

from ConvertibleTo(Pattern(Integer))

convert : % -> SparseUnivariatePolynomial(MachineFloat)

from ConvertibleTo(SparseUnivariatePolynomial(MachineFloat))

convert : % -> Vector(MachineFloat)

from FramedModule(MachineFloat)

coordinates : Vector(%) -> Matrix(MachineFloat)

from FramedModule(MachineFloat)

coordinates : (Vector(%), Vector(%)) -> Matrix(MachineFloat)

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

coordinates : % -> Vector(MachineFloat)

from FramedModule(MachineFloat)

coordinates : (%, Vector(%)) -> Vector(MachineFloat)

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

cos : % -> % if MachineFloat has TranscendentalFunctionCategory

from TrigonometricFunctionCategory

cosh : % -> % if MachineFloat has TranscendentalFunctionCategory

from HyperbolicFunctionCategory

cot : % -> % if MachineFloat has TranscendentalFunctionCategory

from TrigonometricFunctionCategory

coth : % -> % if MachineFloat has TranscendentalFunctionCategory

from HyperbolicFunctionCategory

createPrimitiveElement : () -> % if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

csc : % -> % if MachineFloat has TranscendentalFunctionCategory

from TrigonometricFunctionCategory

csch : % -> % if MachineFloat has TranscendentalFunctionCategory

from HyperbolicFunctionCategory

definingPolynomial : () -> SparseUnivariatePolynomial(MachineFloat)

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

derivationCoordinates : (Vector(%), Mapping(MachineFloat, MachineFloat)) -> Matrix(MachineFloat)

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

differentiate : % -> % if MachineFloat has DifferentialRing

from DifferentialRing

differentiate : (%, List(Symbol)) -> % if MachineFloat has PartialDifferentialRing(Symbol)

from PartialDifferentialRing(Symbol)

differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> % if MachineFloat has PartialDifferentialRing(Symbol)

from PartialDifferentialRing(Symbol)

differentiate : (%, Mapping(MachineFloat, MachineFloat)) -> %

from DifferentialExtension(MachineFloat)

differentiate : (%, Mapping(MachineFloat, MachineFloat), NonNegativeInteger) -> %

from DifferentialExtension(MachineFloat)

differentiate : (%, NonNegativeInteger) -> % if MachineFloat has DifferentialRing

from DifferentialRing

differentiate : (%, Symbol) -> % if MachineFloat has PartialDifferentialRing(Symbol)

from PartialDifferentialRing(Symbol)

differentiate : (%, Symbol, NonNegativeInteger) -> % if MachineFloat has PartialDifferentialRing(Symbol)

from PartialDifferentialRing(Symbol)

discreteLog : % -> NonNegativeInteger if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

discreteLog : (%, %) -> Union(NonNegativeInteger, "failed") if MachineFloat has FiniteFieldCategory

from FieldOfPrimeCharacteristic

discriminant : () -> MachineFloat

from FramedAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

discriminant : Vector(%) -> MachineFloat

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

divide : (%, %) -> Record(quotient : %, remainder : %)

from EuclideanDomain

elt : (%, MachineFloat) -> % if MachineFloat has Eltable(MachineFloat, MachineFloat)

from Eltable(MachineFloat, %)

enumerate : () -> List(%) if MachineFloat has Finite

from Finite

euclideanSize : % -> NonNegativeInteger

from EuclideanDomain

eval : (%, Equation(MachineFloat)) -> % if MachineFloat has Evalable(MachineFloat)

from Evalable(MachineFloat)

eval : (%, List(Equation(MachineFloat))) -> % if MachineFloat has Evalable(MachineFloat)

from Evalable(MachineFloat)

eval : (%, List(MachineFloat), List(MachineFloat)) -> % if MachineFloat has Evalable(MachineFloat)

from InnerEvalable(MachineFloat, MachineFloat)

eval : (%, List(Symbol), List(MachineFloat)) -> % if MachineFloat has InnerEvalable(Symbol, MachineFloat)

from InnerEvalable(Symbol, MachineFloat)

eval : (%, MachineFloat, MachineFloat) -> % if MachineFloat has Evalable(MachineFloat)

from InnerEvalable(MachineFloat, MachineFloat)

eval : (%, Symbol, MachineFloat) -> % if MachineFloat has InnerEvalable(Symbol, MachineFloat)

from InnerEvalable(Symbol, MachineFloat)

exp : % -> % if MachineFloat has TranscendentalFunctionCategory

from ElementaryFunctionCategory

expressIdealMember : (List(%), %) -> Union(List(%), "failed")

from PrincipalIdealDomain

exquo : (%, %) -> Union(%, "failed")

from EntireRing

exquo : (%, MachineFloat) -> Union(%, "failed")

from ComplexCategory(MachineFloat)

extendedEuclidean : (%, %) -> Record(coef1 : %, coef2 : %, generator : %)

from EuclideanDomain

extendedEuclidean : (%, %, %) -> Union(Record(coef1 : %, coef2 : %), "failed")

from EuclideanDomain

factor : % -> Factored(%)

from UniqueFactorizationDomain

factorPolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if MachineFloat has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

factorSquareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if MachineFloat has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

factorsOfCyclicGroupSize : () -> List(Record(factor : Integer, exponent : NonNegativeInteger)) if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

gcd : (%, %) -> %

from GcdDomain

gcd : List(%) -> %

from GcdDomain

gcdPolynomial : (SparseUnivariatePolynomial(%), SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%)

from PolynomialFactorizationExplicit

generator : () -> %

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

hash : % -> SingleInteger if MachineFloat has Hashable

from Hashable

hashUpdate! : (HashState, %) -> HashState if MachineFloat has Hashable

from Hashable

imag : % -> MachineFloat

from ComplexCategory(MachineFloat)

imaginary : () -> %

from ComplexCategory(MachineFloat)

index : PositiveInteger -> % if MachineFloat has Finite

from Finite

init : () -> % if MachineFloat has FiniteFieldCategory

from StepThrough

inv : % -> %

from DivisionRing

latex : % -> String

from SetCategory

lcm : (%, %) -> %

from GcdDomain

lcm : List(%) -> %

from GcdDomain

lcmCoef : (%, %) -> Record(llcm_res : %, coeff1 : %, coeff2 : %)

from LeftOreRing

leftPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower : (%, PositiveInteger) -> %

from Magma

leftRecip : % -> Union(%, "failed")

from MagmaWithUnit

lift : % -> SparseUnivariatePolynomial(MachineFloat)

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

log : % -> % if MachineFloat has TranscendentalFunctionCategory

from ElementaryFunctionCategory

lookup : % -> PositiveInteger if MachineFloat has Finite

from Finite

map : (Mapping(MachineFloat, MachineFloat), %) -> %

from FullyEvalableOver(MachineFloat)

max : (%, %) -> %

from OrderedSet

min : (%, %) -> %

from OrderedSet

minimalPolynomial : % -> SparseUnivariatePolynomial(MachineFloat)

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

multiEuclidean : (List(%), %) -> Union(List(%), "failed")

from EuclideanDomain

nextItem : % -> Union(%, "failed") if MachineFloat has FiniteFieldCategory

from StepThrough

norm : % -> MachineFloat

from ComplexCategory(MachineFloat)

nthRoot : (%, Integer) -> % if MachineFloat has TranscendentalFunctionCategory

from RadicalCategory

one? : % -> Boolean

from MagmaWithUnit

opposite? : (%, %) -> Boolean

from AbelianMonoid

order : % -> OnePointCompletion(PositiveInteger) if MachineFloat has FiniteFieldCategory

from FieldOfPrimeCharacteristic

order : % -> PositiveInteger if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

patternMatch : (%, Pattern(Float), PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %)

from PatternMatchable(Float)

patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if MachineFloat has PatternMatchable(Integer)

from PatternMatchable(Integer)

pi : () -> % if MachineFloat has TranscendentalFunctionCategory

from TranscendentalFunctionCategory

plenaryPower : (%, PositiveInteger) -> %

from NonAssociativeAlgebra(%)

polarCoordinates : % -> Record(r : MachineFloat, phi : MachineFloat) if MachineFloat has TranscendentalFunctionCategory

from ComplexCategory(MachineFloat)

prime? : % -> Boolean

from UniqueFactorizationDomain

primeFrobenius : % -> % if MachineFloat has FiniteFieldCategory

from FieldOfPrimeCharacteristic

primeFrobenius : (%, NonNegativeInteger) -> % if MachineFloat has FiniteFieldCategory

from FieldOfPrimeCharacteristic

primitive? : % -> Boolean if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

primitiveElement : () -> % if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

principalIdeal : List(%) -> Record(coef : List(%), generator : %)

from PrincipalIdealDomain

quo : (%, %) -> %

from EuclideanDomain

random : () -> % if MachineFloat has Finite

from Finite

rank : () -> PositiveInteger

from FramedModule(MachineFloat)

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

from ComplexCategory(MachineFloat)

rational? : % -> Boolean if MachineFloat has IntegerNumberSystem

from ComplexCategory(MachineFloat)

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

from ComplexCategory(MachineFloat)

real : % -> MachineFloat

from ComplexCategory(MachineFloat)

recip : % -> Union(%, "failed")

from MagmaWithUnit

reduce : SparseUnivariatePolynomial(MachineFloat) -> %

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

reduce : Fraction(SparseUnivariatePolynomial(MachineFloat)) -> Union(%, "failed")

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

reducedSystem : Matrix(%) -> Matrix(Integer) if MachineFloat has LinearlyExplicitOver(Integer)

from LinearlyExplicitOver(Integer)

reducedSystem : Matrix(%) -> Matrix(MachineFloat)

from LinearlyExplicitOver(MachineFloat)

reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if MachineFloat has LinearlyExplicitOver(Integer)

from LinearlyExplicitOver(Integer)

reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(MachineFloat), vec : Vector(MachineFloat))

from LinearlyExplicitOver(MachineFloat)

regularRepresentation : % -> Matrix(MachineFloat)

from FramedAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

regularRepresentation : (%, Vector(%)) -> Matrix(MachineFloat)

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

rem : (%, %) -> %

from EuclideanDomain

representationType : () -> Union("prime", "polynomial", "normal", "cyclic") if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

represents : Vector(MachineFloat) -> %

from FramedModule(MachineFloat)

represents : (Vector(MachineFloat), Vector(%)) -> %

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

retract : % -> Fraction(Integer)

from RetractableTo(Fraction(Integer))

retract : % -> Integer

from RetractableTo(Integer)

retract : % -> MachineFloat

from RetractableTo(MachineFloat)

retractIfCan : % -> Union(Fraction(Integer), "failed")

from RetractableTo(Fraction(Integer))

retractIfCan : % -> Union(Integer, "failed")

from RetractableTo(Integer)

retractIfCan : % -> Union(MachineFloat, "failed")

from RetractableTo(MachineFloat)

rightPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower : (%, PositiveInteger) -> %

from Magma

rightRecip : % -> Union(%, "failed")

from MagmaWithUnit

sample : () -> %

from AbelianMonoid

sec : % -> % if MachineFloat has TranscendentalFunctionCategory

from TrigonometricFunctionCategory

sech : % -> % if MachineFloat has TranscendentalFunctionCategory

from HyperbolicFunctionCategory

sin : % -> % if MachineFloat has TranscendentalFunctionCategory

from TrigonometricFunctionCategory

sinh : % -> % if MachineFloat has TranscendentalFunctionCategory

from HyperbolicFunctionCategory

size : () -> NonNegativeInteger if MachineFloat has Finite

from Finite

sizeLess? : (%, %) -> Boolean

from EuclideanDomain

smaller? : (%, %) -> Boolean

from Comparable

solveLinearPolynomialEquation : (List(SparseUnivariatePolynomial(%)), SparseUnivariatePolynomial(%)) -> Union(List(SparseUnivariatePolynomial(%)), "failed") if MachineFloat has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

sqrt : % -> % if MachineFloat has TranscendentalFunctionCategory

from RadicalCategory

squareFree : % -> Factored(%)

from UniqueFactorizationDomain

squareFreePart : % -> %

from UniqueFactorizationDomain

squareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if MachineFloat has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

subtractIfCan : (%, %) -> Union(%, "failed")

from CancellationAbelianMonoid

tableForDiscreteLogarithm : Integer -> Table(PositiveInteger, NonNegativeInteger) if MachineFloat has FiniteFieldCategory

from FiniteFieldCategory

tan : % -> % if MachineFloat has TranscendentalFunctionCategory

from TrigonometricFunctionCategory

tanh : % -> % if MachineFloat has TranscendentalFunctionCategory

from HyperbolicFunctionCategory

trace : % -> MachineFloat

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

traceMatrix : () -> Matrix(MachineFloat)

from FramedAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

traceMatrix : Vector(%) -> Matrix(MachineFloat)

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

unit? : % -> Boolean

from EntireRing

unitCanonical : % -> %

from EntireRing

unitNormal : % -> Record(unit : %, canonical : %, associate : %)

from EntireRing

zero? : % -> Boolean

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

EntireRing

Module(Fraction(Integer))

Ring

ConvertibleTo(Complex(DoubleFloat))

Algebra(%)

CancellationAbelianMonoid

CommutativeStar

FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

ConvertibleTo(Pattern(Float))

Field

LinearlyExplicitOver(Integer)

SemiGroup

Hashable

OrderedSet

FullyEvalableOver(MachineFloat)

ArcTrigonometricFunctionCategory

PartialOrder

Monoid

NonAssociativeAlgebra(Fraction(Integer))

LeftModule(%)

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

noZeroDivisors

FullyPatternMatchable(MachineFloat)

ConvertibleTo(SparseUnivariatePolynomial(MachineFloat))

FortranMachineTypeCategory

TrigonometricFunctionCategory

Module(%)

FieldOfPrimeCharacteristic

FullyLinearlyExplicitOver(MachineFloat)

LeftOreRing

NonAssociativeSemiRing

NonAssociativeAlgebra(MachineFloat)

RetractableTo(Fraction(Integer))

ConvertibleTo(InputForm)

Rng

SemiRing

NonAssociativeAlgebra(%)

SetCategory

Algebra(MachineFloat)

CharacteristicNonZero

MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

BiModule(MachineFloat, MachineFloat)

PolynomialFactorizationExplicit

TwoSidedRecip

EuclideanDomain

CoercibleFrom(Fraction(Integer))

NonAssociativeRing

NonAssociativeRng

ConvertibleTo(Complex(Float))

Comparable

PrincipalIdealDomain

DivisionRing

LeftModule(MachineFloat)

CommutativeRing

FiniteFieldCategory

ArcHyperbolicFunctionCategory

ElementaryFunctionCategory

unitsKnown

AbelianSemiGroup

canonicalUnitNormal

LeftModule(Fraction(Integer))

PatternMatchable(Float)

Patternable(MachineFloat)

multiplicativeValuation

RetractableTo(MachineFloat)

IntegralDomain

RightModule(Integer)

arbitraryPrecision

DifferentialExtension(MachineFloat)

NonAssociativeSemiRng

GcdDomain

CharacteristicZero

PartialDifferentialRing(Symbol)

Algebra(Fraction(Integer))

LinearlyExplicitOver(MachineFloat)

HyperbolicFunctionCategory

AbelianGroup

InnerEvalable(MachineFloat, MachineFloat)

DifferentialRing

BasicType

Evalable(MachineFloat)

MagmaWithUnit

RadicalCategory

CoercibleFrom(MachineFloat)

CoercibleFrom(Integer)

AbelianMonoid

PatternMatchable(Integer)

CoercibleTo(OutputForm)

BiModule(%, %)

FullyRetractableTo(MachineFloat)

StepThrough

Finite

SemiRng

Module(MachineFloat)

RightModule(Fraction(Integer))

canonicalsClosed

FramedModule(MachineFloat)

Eltable(MachineFloat, %)

RightModule(MachineFloat)

UniqueFactorizationDomain

InnerEvalable(Symbol, MachineFloat)

TranscendentalFunctionCategory

ConvertibleTo(Pattern(Integer))

FramedAlgebra(MachineFloat, SparseUnivariatePolynomial(MachineFloat))

RightModule(%)

RetractableTo(Integer)

Magma

ComplexCategory(MachineFloat)