MachineComplexΒΆ

fortmac.spad line 350

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
*: (%, 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 MachineFloat has CharacteristicNonZero or % has CharacteristicNonZero and MachineFloat has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
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 Algebra Fraction Integer
coerce: Integer -> %
from NonAssociativeRing
coerce: MachineFloat -> %
from RetractableTo 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: Integer) 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
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
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
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 FiniteRankAlgebra(MachineFloat, SparseUnivariatePolynomial 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: 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

additiveValuation if MachineFloat has additiveValuation

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

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

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 multiplicativeValuation

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 MachineFloat

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

StepThrough if MachineFloat has FiniteFieldCategory

TranscendentalFunctionCategory if MachineFloat has TranscendentalFunctionCategory

TrigonometricFunctionCategory if MachineFloat has TranscendentalFunctionCategory

UniqueFactorizationDomain

unitsKnown