JuliaComplexFloat

jobject.spad line 954 [edit on github]

JuliaFComplexloat implements arbitrary precision floating point arithmetic for complex numbers using Julia BigFloats (MPFR based). https://www.mpfr.org/

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from Magma

*: (%, Fraction Integer) -> %

from RightModule Fraction Integer

*: (%, Integer) -> %

*: (%, JuliaFloat) -> %

from RightModule JuliaFloat

*: (Fraction Integer, %) -> %

from LeftModule Fraction Integer

*: (Integer, %) -> %

from AbelianGroup

*: (JuliaFloat, %) -> %

from LeftModule JuliaFloat

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, %) -> %

from Field

/: (%, Integer) -> %

/: (Integer, %) -> %

=: (%, %) -> Boolean

from BasicType

^: (%, %) -> %

from ElementaryFunctionCategory

^: (%, Fraction Integer) -> %

from RadicalCategory

^: (%, Integer) -> %

from DivisionRing

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

abs: % -> %

from ComplexCategory JuliaFloat

acos: % -> %

from ArcTrigonometricFunctionCategory

acosh: % -> %

from ArcHyperbolicFunctionCategory

acot: % -> %

from ArcTrigonometricFunctionCategory

acoth: % -> %

from ArcHyperbolicFunctionCategory

acsc: % -> %

from ArcTrigonometricFunctionCategory

acsch: % -> %

from ArcHyperbolicFunctionCategory

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %

from NonAssociativeSemiRng

argument: % -> JuliaFloat

from ComplexCategory JuliaFloat

asec: % -> %

from ArcTrigonometricFunctionCategory

asech: % -> %

from ArcHyperbolicFunctionCategory

asin: % -> %

from ArcTrigonometricFunctionCategory

asinh: % -> %

from ArcHyperbolicFunctionCategory

associates?: (%, %) -> Boolean

from EntireRing

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

from NonAssociativeRng

atan: % -> %

atan(x) computes the inverse tangent of x.

atan: (%, %) -> %

atan(x, y) computes the inverse tangent of x/y.

atanh: % -> %

from ArcHyperbolicFunctionCategory

basis: () -> Vector %

from FramedModule JuliaFloat

characteristic: () -> NonNegativeInteger

from NonAssociativeRing

characteristicPolynomial: % -> SparseUnivariatePolynomial JuliaFloat

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

charthRoot: % -> % if JuliaFloat has FiniteFieldCategory

from FiniteFieldCategory

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

from PolynomialFactorizationExplicit

cis: % -> %

cis(x) returns exp(%i*x) computed efficiently.

cispi: % -> %

cispi(x) returns cis(%pi*x) computed efficiently.

coerce: % -> %

from Algebra %

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: Float -> %

coerce: Fraction Integer -> %

from Algebra Fraction Integer

coerce: Integer -> %

from NonAssociativeRing

coerce: JuliaFloat -> %

from CoercibleFrom JuliaFloat

coerce: JuliaFloat64 -> %

commutator: (%, %) -> %

from NonAssociativeRng

complex: (JuliaFloat, JuliaFloat) -> %

from ComplexCategory JuliaFloat

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

from PolynomialFactorizationExplicit

conjugate: % -> %

from ComplexCategory JuliaFloat

convert: % -> Complex DoubleFloat

from ConvertibleTo Complex DoubleFloat

convert: % -> Complex Float

from ConvertibleTo Complex Float

convert: % -> InputForm

from ConvertibleTo InputForm

convert: % -> Pattern Float

from ConvertibleTo Pattern Float

convert: % -> Pattern Integer if JuliaFloat has ConvertibleTo Pattern Integer

from ConvertibleTo Pattern Integer

convert: % -> SparseUnivariatePolynomial JuliaFloat

from ConvertibleTo SparseUnivariatePolynomial JuliaFloat

convert: % -> String

from ConvertibleTo String

convert: % -> Vector JuliaFloat

from FramedModule JuliaFloat

convert: SparseUnivariatePolynomial JuliaFloat -> %

from MonogenicAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

convert: Vector JuliaFloat -> %

from FramedModule JuliaFloat

coordinates: % -> Vector JuliaFloat

from FramedModule JuliaFloat

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

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

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

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

coordinates: Vector % -> Matrix JuliaFloat

from FramedModule JuliaFloat

cos: % -> %

from TrigonometricFunctionCategory

cosh: % -> %

from HyperbolicFunctionCategory

cot: % -> %

from TrigonometricFunctionCategory

coth: % -> %

from HyperbolicFunctionCategory

createPrimitiveElement: () -> % if JuliaFloat has FiniteFieldCategory

from FiniteFieldCategory

csc: % -> %

from TrigonometricFunctionCategory

csch: % -> %

from HyperbolicFunctionCategory

D: % -> %

from DifferentialRing

D: (%, JuliaFloat -> JuliaFloat) -> %

from DifferentialExtension JuliaFloat

D: (%, JuliaFloat -> JuliaFloat, NonNegativeInteger) -> %

from DifferentialExtension JuliaFloat

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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

D: (%, NonNegativeInteger) -> %

from DifferentialRing

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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

definingPolynomial: () -> SparseUnivariatePolynomial JuliaFloat

from MonogenicAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

derivationCoordinates: (Vector %, JuliaFloat -> JuliaFloat) -> Matrix JuliaFloat

from MonogenicAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

differentiate: % -> %

from DifferentialRing

differentiate: (%, JuliaFloat -> JuliaFloat) -> %

from DifferentialExtension JuliaFloat

differentiate: (%, JuliaFloat -> JuliaFloat, NonNegativeInteger) -> %

from DifferentialExtension JuliaFloat

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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

differentiate: (%, NonNegativeInteger) -> %

from DifferentialRing

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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

discreteLog: % -> NonNegativeInteger if JuliaFloat has FiniteFieldCategory

from FiniteFieldCategory

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

from FieldOfPrimeCharacteristic

discriminant: () -> JuliaFloat

from FramedAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

discriminant: Vector % -> JuliaFloat

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

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

from EuclideanDomain

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

from Eltable(JuliaFloat, %)

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

from Finite

euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

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

from Evalable JuliaFloat

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

from InnerEvalable(JuliaFloat, JuliaFloat)

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

from Evalable JuliaFloat

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

from InnerEvalable(JuliaFloat, JuliaFloat)

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

from InnerEvalable(Symbol, JuliaFloat)

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

from InnerEvalable(Symbol, JuliaFloat)

exp10: % -> %

exp10(x) computes the base 10 exponential of x.

exp1: () -> %

exp1() returns the JuliaComplexFloat ℯ (%e or exp(1)).

exp2: % -> %

exp2(x) computes the base 2 exponential of x.

exp: % -> %

from ElementaryFunctionCategory

exp: () -> %

exp() returns the JuliaComplexFloat ℯ (%e or exp(1)).

expm1: % -> %

expm1(x) computes accurately ℯ^x-1. It avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small values of x.

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

from PrincipalIdealDomain

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

from EntireRing

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

from ComplexCategory JuliaFloat

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

from EuclideanDomain

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

from EuclideanDomain

factor: % -> Factored %

from UniqueFactorizationDomain

factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if JuliaFloat has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

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

from FiniteFieldCategory

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

from PolynomialFactorizationExplicit

finite?: % -> Boolean

finite?(x) tests whether or not x is finite.

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

from GcdDomain

generator: () -> %

from MonogenicAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

hash: % -> SingleInteger if JuliaFloat has Hashable

from Hashable

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

from Hashable

imag: % -> JuliaFloat

from ComplexCategory JuliaFloat

imaginary: () -> %

from ComplexCategory JuliaFloat

index: PositiveInteger -> % if JuliaFloat has Finite

from Finite

init: % if JuliaFloat has FiniteFieldCategory

from StepThrough

integer?: % -> Boolean

integer?(x) tests whether or not x is an integer.

inv: % -> %

from DivisionRing

jcfloat: Float -> %

jcfloat: Fraction Integer -> %

jcfloat: Integer -> %

jlAbout: % -> Void

from JuliaObjectType

jlApply: (String, %) -> %

from JuliaObjectType

jlApply: (String, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %, %) -> %

from JuliaObjectType

jlApply: (String, %, %, %, %, %, %) -> %

from JuliaObjectType

jlApprox?: (%, %) -> Boolean

jlApprox?(x,y) computes inexact equality comparison with default parameters. Two numbers compare equal if their relative distance or their absolute distance is within tolerance bounds.

jlApprox?: (%, %, %) -> Boolean

jlApprox?(x,y,atol) computes inexact equality comparison with absolute tolerance atol. Two numbers compare equal if their relative distance or their absolute distance is within tolerance bounds.

jlId: % -> String

from JuliaObjectType

jlRef: % -> SExpression

from JuliaObjectType

jlref: String -> %

from JuliaObjectType

jlType: % -> String

from JuliaObjectType

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 JuliaFloat

from MonogenicAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

log10: % -> %

log10(x) computes the base 10 logarithm of x.

log1p: % -> %

log1p(x) computes accurately log(1+x)

log2: % -> %

log2(x) computes the base 2 logarithm of x.

log: % -> %

from ElementaryFunctionCategory

lookup: % -> PositiveInteger if JuliaFloat has Finite

from Finite

map: (JuliaFloat -> JuliaFloat, %) -> %

from FullyEvalableOver JuliaFloat

minimalPolynomial: % -> SparseUnivariatePolynomial JuliaFloat

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

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

from EuclideanDomain

mutable?: % -> Boolean

from JuliaObjectType

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

from StepThrough

norm: % -> JuliaFloat

from ComplexCategory JuliaFloat

nothing?: % -> Boolean

from JuliaObjectType

nrand: () -> %

nrand() returns an normally distributed random number.

nthRoot: (%, Integer) -> %

from RadicalCategory

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

order: % -> OnePointCompletion PositiveInteger if JuliaFloat has FiniteFieldCategory

from FieldOfPrimeCharacteristic

order: % -> PositiveInteger if JuliaFloat has FiniteFieldCategory

from FiniteFieldCategory

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

from PatternMatchable Float

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

from PatternMatchable Integer

pi: () -> %

from TranscendentalFunctionCategory

plenaryPower: (%, PositiveInteger) -> %

from NonAssociativeAlgebra Fraction Integer

polarCoordinates: % -> Record(r: JuliaFloat, phi: JuliaFloat)

from ComplexCategory JuliaFloat

precision: % -> PositiveInteger

precision(x) returns the precision of x.

precision: (%, PositiveInteger) -> %

precision(x, p) returns a copy of x with precision p.

prime?: % -> Boolean

from UniqueFactorizationDomain

primeFrobenius: % -> % if JuliaFloat has FiniteFieldCategory

from FieldOfPrimeCharacteristic

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

from FieldOfPrimeCharacteristic

primitive?: % -> Boolean if JuliaFloat has FiniteFieldCategory

from FiniteFieldCategory

primitiveElement: () -> % if JuliaFloat has FiniteFieldCategory

from FiniteFieldCategory

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

from PrincipalIdealDomain

quo: (%, %) -> %

from EuclideanDomain

random: () -> % if JuliaFloat has Finite

from Finite

rank: () -> PositiveInteger

from FramedModule JuliaFloat

rational?: % -> Boolean if JuliaFloat has IntegerNumberSystem

from ComplexCategory JuliaFloat

rational: % -> Fraction Integer if JuliaFloat has IntegerNumberSystem

from ComplexCategory JuliaFloat

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

from ComplexCategory JuliaFloat

real?: % -> Boolean

real?(x) tests whether or not x is real.

real: % -> JuliaFloat

from ComplexCategory JuliaFloat

recip: % -> Union(%, failed)

from MagmaWithUnit

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

from MonogenicAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

reduce: SparseUnivariatePolynomial JuliaFloat -> %

from MonogenicAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

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

from LinearlyExplicitOver Integer

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

from LinearlyExplicitOver JuliaFloat

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

from LinearlyExplicitOver Integer

reducedSystem: Matrix % -> Matrix JuliaFloat

from LinearlyExplicitOver JuliaFloat

regularRepresentation: % -> Matrix JuliaFloat

from FramedAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

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

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

rem: (%, %) -> %

from EuclideanDomain

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

from FiniteFieldCategory

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

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

represents: Vector JuliaFloat -> %

from FramedModule JuliaFloat

retract: % -> Fraction Integer

from RetractableTo Fraction Integer

retract: % -> Integer

from RetractableTo Integer

retract: % -> JuliaFloat

from RetractableTo JuliaFloat

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

from RetractableTo Fraction Integer

retractIfCan: % -> Union(Integer, failed)

from RetractableTo Integer

retractIfCan: % -> Union(JuliaFloat, failed)

from RetractableTo JuliaFloat

rightPower: (%, NonNegativeInteger) -> %

from MagmaWithUnit

rightPower: (%, PositiveInteger) -> %

from Magma

rightRecip: % -> Union(%, failed)

from MagmaWithUnit

sample: %

from AbelianMonoid

sec: % -> %

from TrigonometricFunctionCategory

sech: % -> %

from HyperbolicFunctionCategory

sin: % -> %

from TrigonometricFunctionCategory

sinh: % -> %

from HyperbolicFunctionCategory

size: () -> NonNegativeInteger if JuliaFloat has Finite

from Finite

sizeLess?: (%, %) -> Boolean

from EuclideanDomain

smaller?: (%, %) -> Boolean

from Comparable

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

from PolynomialFactorizationExplicit

sqrt: % -> %

from RadicalCategory

squareFree: % -> Factored %

from UniqueFactorizationDomain

squareFreePart: % -> %

from UniqueFactorizationDomain

squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if JuliaFloat has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

string: % -> String

string(fl) return the strings representation of fl.

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

from CancellationAbelianMonoid

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

from FiniteFieldCategory

tan: % -> %

from TrigonometricFunctionCategory

tanh: % -> %

from HyperbolicFunctionCategory

trace: % -> JuliaFloat

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

traceMatrix: () -> Matrix JuliaFloat

from FramedAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

traceMatrix: Vector % -> Matrix JuliaFloat

from FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

unit?: % -> Boolean

from EntireRing

unitCanonical: % -> %

from EntireRing

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

from EntireRing

urand01: () -> %

urand01() returns an uniformly distributed random number contained in [0,1].

zero?: % -> Boolean

from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

Algebra JuliaFloat

arbitraryPrecision

ArcHyperbolicFunctionCategory

ArcTrigonometricFunctionCategory

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

BiModule(JuliaFloat, JuliaFloat)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicNonZero if JuliaFloat has CharacteristicNonZero

CharacteristicZero

CoercibleFrom Fraction Integer

CoercibleFrom Integer

CoercibleFrom JuliaFloat

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable

ComplexCategory JuliaFloat

ConvertibleTo Complex DoubleFloat

ConvertibleTo Complex Float

ConvertibleTo InputForm

ConvertibleTo Pattern Float

ConvertibleTo Pattern Integer if JuliaFloat has ConvertibleTo Pattern Integer

ConvertibleTo SparseUnivariatePolynomial JuliaFloat

ConvertibleTo String

DifferentialExtension JuliaFloat

DifferentialRing

DivisionRing

ElementaryFunctionCategory

Eltable(JuliaFloat, %) if JuliaFloat has Eltable(JuliaFloat, JuliaFloat)

EntireRing

EuclideanDomain

Evalable JuliaFloat if JuliaFloat has Evalable JuliaFloat

Field

FieldOfPrimeCharacteristic if JuliaFloat has FiniteFieldCategory

Finite if JuliaFloat has Finite

FiniteFieldCategory if JuliaFloat has FiniteFieldCategory

FiniteRankAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

FramedAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

FramedModule JuliaFloat

FullyEvalableOver JuliaFloat

FullyLinearlyExplicitOver JuliaFloat

FullyPatternMatchable JuliaFloat

FullyRetractableTo JuliaFloat

GcdDomain

Hashable if JuliaFloat has Hashable

HyperbolicFunctionCategory

InnerEvalable(JuliaFloat, JuliaFloat) if JuliaFloat has Evalable JuliaFloat

InnerEvalable(Symbol, JuliaFloat) if JuliaFloat has InnerEvalable(Symbol, JuliaFloat)

IntegralDomain

JuliaObjectRing

JuliaObjectType

JuliaRing

JuliaType

LeftModule %

LeftModule Fraction Integer

LeftModule JuliaFloat

LeftOreRing

LinearlyExplicitOver Integer if JuliaFloat has LinearlyExplicitOver Integer

LinearlyExplicitOver JuliaFloat

Magma

MagmaWithUnit

Module %

Module Fraction Integer

Module JuliaFloat

MonogenicAlgebra(JuliaFloat, SparseUnivariatePolynomial JuliaFloat)

Monoid

multiplicativeValuation if JuliaFloat has IntegerNumberSystem

NonAssociativeAlgebra %

NonAssociativeAlgebra Fraction Integer

NonAssociativeAlgebra JuliaFloat

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

PartialDifferentialRing Symbol if JuliaFloat has PartialDifferentialRing Symbol

Patternable JuliaFloat

PatternMatchable Float

PatternMatchable Integer if JuliaFloat has PatternMatchable Integer

PolynomialFactorizationExplicit if JuliaFloat has PolynomialFactorizationExplicit

PrincipalIdealDomain

RadicalCategory

RetractableTo Fraction Integer

RetractableTo Integer

RetractableTo JuliaFloat

RightModule %

RightModule Fraction Integer

RightModule Integer if JuliaFloat has LinearlyExplicitOver Integer

RightModule JuliaFloat

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

StepThrough if JuliaFloat has FiniteFieldCategory

TranscendentalFunctionCategory

TrigonometricFunctionCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown