MachineComplex

fortmac.spad line 350 [edit on github]

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

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

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

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

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

from ElementaryFunctionCategory

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

from RadicalCategory

^: (%, Integer) -> %

from DivisionRing

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

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 COmplex Float

coerce: % -> OutputForm

from CoercibleTo OutputForm

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

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

convert: SparseUnivariatePolynomial MachineFloat -> %

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

convert: Vector MachineFloat -> %

from FramedModule MachineFloat

coordinates: % -> Vector MachineFloat

from FramedModule MachineFloat

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

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

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

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

coordinates: Vector % -> Matrix MachineFloat

from FramedModule 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

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

from DifferentialExtension MachineFloat

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

definingPolynomial: () -> SparseUnivariatePolynomial MachineFloat

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

derivationCoordinates: (Vector %, 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: (%, MachineFloat -> MachineFloat) -> %

from DifferentialExtension MachineFloat

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

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

from FiniteFieldCategory

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

from PolynomialFactorizationExplicit

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: (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?: % -> Boolean if MachineFloat has IntegerNumberSystem

from ComplexCategory MachineFloat

rational: % -> Fraction Integer 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: Fraction SparseUnivariatePolynomial MachineFloat -> Union(%, failed)

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

reduce: SparseUnivariatePolynomial MachineFloat -> %

from MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial 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

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

from LinearlyExplicitOver Integer

reducedSystem: Matrix % -> Matrix 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, Vector %) -> %

from FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

represents: Vector MachineFloat -> %

from FramedModule 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

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

Algebra MachineFloat

arbitraryPrecision if MachineFloat has arbitraryPrecision

ArcHyperbolicFunctionCategory if MachineFloat has TranscendentalFunctionCategory

ArcTrigonometricFunctionCategory if MachineFloat has TranscendentalFunctionCategory

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

BiModule(MachineFloat, MachineFloat)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicNonZero if MachineFloat has CharacteristicNonZero

CharacteristicZero

CoercibleFrom Fraction Integer

CoercibleFrom Integer

CoercibleFrom MachineFloat

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable

ComplexCategory MachineFloat

ConvertibleTo Complex DoubleFloat

ConvertibleTo Complex Float

ConvertibleTo InputForm if MachineFloat has ConvertibleTo InputForm

ConvertibleTo Pattern Float

ConvertibleTo Pattern Integer if MachineFloat has ConvertibleTo Pattern Integer

ConvertibleTo SparseUnivariatePolynomial MachineFloat

DifferentialExtension MachineFloat

DifferentialRing if MachineFloat has DifferentialRing

DivisionRing

ElementaryFunctionCategory if MachineFloat has TranscendentalFunctionCategory

Eltable(MachineFloat, %) if MachineFloat has Eltable(MachineFloat, MachineFloat)

EntireRing

EuclideanDomain

Evalable MachineFloat if MachineFloat has Evalable MachineFloat

Field

FieldOfPrimeCharacteristic if MachineFloat has FiniteFieldCategory

Finite if MachineFloat has Finite

FiniteFieldCategory if MachineFloat has FiniteFieldCategory

FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

FortranMachineTypeCategory

FramedAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

FramedModule MachineFloat

FullyEvalableOver MachineFloat

FullyLinearlyExplicitOver MachineFloat

FullyPatternMatchable MachineFloat

FullyRetractableTo MachineFloat

GcdDomain

Hashable if MachineFloat has Hashable

HyperbolicFunctionCategory if MachineFloat has TranscendentalFunctionCategory

InnerEvalable(MachineFloat, MachineFloat) if MachineFloat has Evalable MachineFloat

InnerEvalable(Symbol, MachineFloat) if MachineFloat has InnerEvalable(Symbol, MachineFloat)

IntegralDomain

LeftModule %

LeftModule Fraction Integer

LeftModule MachineFloat

LeftOreRing

LinearlyExplicitOver Integer if MachineFloat has LinearlyExplicitOver Integer

LinearlyExplicitOver MachineFloat

Magma

MagmaWithUnit

Module %

Module Fraction Integer

Module MachineFloat

MonogenicAlgebra(MachineFloat, SparseUnivariatePolynomial MachineFloat)

Monoid

multiplicativeValuation if MachineFloat has IntegerNumberSystem

NonAssociativeAlgebra %

NonAssociativeAlgebra Fraction Integer

NonAssociativeAlgebra MachineFloat

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

OrderedSet

PartialDifferentialRing Symbol if MachineFloat has PartialDifferentialRing Symbol

PartialOrder

Patternable MachineFloat

PatternMatchable Float

PatternMatchable Integer if MachineFloat has PatternMatchable Integer

PolynomialFactorizationExplicit if MachineFloat has PolynomialFactorizationExplicit

PrincipalIdealDomain

RadicalCategory if MachineFloat has TranscendentalFunctionCategory

RetractableTo Fraction Integer

RetractableTo Integer

RetractableTo MachineFloat

RightModule %

RightModule Fraction Integer

RightModule Integer if MachineFloat has LinearlyExplicitOver Integer

RightModule MachineFloat

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

StepThrough if MachineFloat has FiniteFieldCategory

TranscendentalFunctionCategory if MachineFloat has TranscendentalFunctionCategory

TrigonometricFunctionCategory if MachineFloat has TranscendentalFunctionCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown