MachineFloatΒΆ

fortmac.spad line 51

A domain which models the floating point representation used by machines in the AXIOM-NAG link.

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (%, Fraction Integer) -> %
from RightModule Fraction Integer
*: (Fraction Integer, %) -> %
from LeftModule Fraction Integer
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
/: (%, %) -> %
from Field
/: (%, Integer) -> %
from FloatingPointSystem
<: (%, %) -> Boolean
from PartialOrder
<=: (%, %) -> Boolean
from PartialOrder
=: (%, %) -> Boolean
from BasicType
>: (%, %) -> Boolean
from PartialOrder
>=: (%, %) -> Boolean
from PartialOrder
^: (%, Fraction Integer) -> %
from RadicalCategory
^: (%, Integer) -> %
from DivisionRing
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
~=: (%, %) -> Boolean
from BasicType
abs: % -> %
from OrderedRing
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
associates?: (%, %) -> Boolean
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
base: () -> PositiveInteger
base() returns the base of the model
base: PositiveInteger -> PositiveInteger
base(b) sets the base of the model to b
bits: () -> PositiveInteger
from FloatingPointSystem
ceiling: % -> %
from RealNumberSystem
changeBase: (Integer, Integer, PositiveInteger) -> %
changeBase(exp, man, base) is undocumented.
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
coerce: % -> %
from Algebra %
coerce: % -> Float
coerce(u) transforms a MachineFloat to a standard Float
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: Float -> %
from RetractableTo Float
coerce: Fraction Integer -> %
from RetractableTo Fraction Integer
coerce: Integer -> %
from NonAssociativeRing
coerce: MachineInteger -> %
coerce(u) transforms a MachineInteger into a MachineFloat
commutator: (%, %) -> %
from NonAssociativeRng
convert: % -> DoubleFloat
from ConvertibleTo DoubleFloat
convert: % -> Float
from ConvertibleTo Float
convert: % -> Pattern Float
from ConvertibleTo Pattern Float
convert: % -> String
from ConvertibleTo String
digits: () -> PositiveInteger
from FloatingPointSystem
divide: (%, %) -> Record(quotient: %, remainder: %)
from EuclideanDomain
euclideanSize: % -> NonNegativeInteger
from EuclideanDomain
exponent: % -> Integer
exponent(u) returns the exponent of u
expressIdealMember: (List %, %) -> Union(List %, failed)
from PrincipalIdealDomain
exquo: (%, %) -> Union(%, failed)
from EntireRing
extendedEuclidean: (%, %) -> Record(coef1: %, coef2: %, generator: %)
from EuclideanDomain
extendedEuclidean: (%, %, %) -> Union(Record(coef1: %, coef2: %), failed)
from EuclideanDomain
factor: % -> Factored %
from UniqueFactorizationDomain
float: (Integer, Integer) -> %
from FloatingPointSystem
float: (Integer, Integer, PositiveInteger) -> %
from FloatingPointSystem
floor: % -> %
from RealNumberSystem
fractionPart: % -> %
from RealNumberSystem
gcd: (%, %) -> %
from GcdDomain
gcd: List % -> %
from GcdDomain
gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial %
from GcdDomain
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
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
mantissa: % -> Integer
mantissa(u) returns the mantissa of u
max: (%, %) -> %
from OrderedSet
max: () -> % if % hasn’t arbitraryPrecision and % hasn’t arbitraryExponent
from FloatingPointSystem
maximumExponent: () -> Integer
maximumExponent() returns the maximum exponent in the model
maximumExponent: Integer -> Integer
maximumExponent(e) sets the maximum exponent in the model to e
min: (%, %) -> %
from OrderedSet
min: () -> % if % hasn’t arbitraryPrecision and % hasn’t arbitraryExponent
from FloatingPointSystem
minimumExponent: () -> Integer
minimumExponent() returns the minimum exponent in the model
minimumExponent: Integer -> Integer
minimumExponent(e) sets the minimum exponent in the model to e
multiEuclidean: (List %, %) -> Union(List %, failed)
from EuclideanDomain
negative?: % -> Boolean
from OrderedRing
norm: % -> %
from RealNumberSystem
nthRoot: (%, Integer) -> %
from RadicalCategory
one?: % -> Boolean
from MagmaWithUnit
opposite?: (%, %) -> Boolean
from AbelianMonoid
order: % -> Integer
from FloatingPointSystem
patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %)
from PatternMatchable Float
positive?: % -> Boolean
from OrderedRing
precision: () -> PositiveInteger
precision() returns the number of digits in the model
precision: PositiveInteger -> PositiveInteger
precision(p) sets the number of digits in the model to p
prime?: % -> Boolean
from UniqueFactorizationDomain
principalIdeal: List % -> Record(coef: List %, generator: %)
from PrincipalIdealDomain
quo: (%, %) -> %
from EuclideanDomain
recip: % -> Union(%, failed)
from MagmaWithUnit
rem: (%, %) -> %
from EuclideanDomain
retract: % -> Float
from RetractableTo Float
retract: % -> Fraction Integer
from RetractableTo Fraction Integer
retract: % -> Integer
from RetractableTo Integer
retractIfCan: % -> Union(Float, failed)
from RetractableTo Float
retractIfCan: % -> Union(Fraction Integer, failed)
from RetractableTo Fraction Integer
retractIfCan: % -> Union(Integer, failed)
from RetractableTo Integer
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
round: % -> %
from RealNumberSystem
sample: %
from AbelianMonoid
sign: % -> Integer
from OrderedRing
sizeLess?: (%, %) -> Boolean
from EuclideanDomain
smaller?: (%, %) -> Boolean
from Comparable
sqrt: % -> %
from RadicalCategory
squareFree: % -> Factored %
from UniqueFactorizationDomain
squareFreePart: % -> %
from UniqueFactorizationDomain
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
toString: % -> String
from FloatingPointSystem
toString: (%, NonNegativeInteger) -> String
from FloatingPointSystem
truncate: % -> %
from RealNumberSystem
unit?: % -> Boolean
from EntireRing
unitCanonical: % -> %
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %)
from EntireRing
wholePart: % -> Integer
from RealNumberSystem
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianSemiGroup

Algebra %

Algebra Fraction Integer

Approximate

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicZero

CoercibleTo OutputForm

CommutativeRing

CommutativeStar

Comparable

ConvertibleTo DoubleFloat

ConvertibleTo Float

ConvertibleTo Pattern Float

ConvertibleTo String

DivisionRing

EntireRing

EuclideanDomain

Field

FloatingPointSystem

FortranMachineTypeCategory

GcdDomain

IntegralDomain

LeftModule %

LeftModule Fraction Integer

LeftOreRing

Magma

MagmaWithUnit

Module %

Module Fraction Integer

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

OrderedAbelianGroup

OrderedAbelianMonoid

OrderedAbelianSemiGroup

OrderedCancellationAbelianMonoid

OrderedRing

OrderedSet

PartialOrder

PatternMatchable Float

PrincipalIdealDomain

RadicalCategory

RealConstant

RealNumberSystem

RetractableTo Float

RetractableTo Fraction Integer

RetractableTo Integer

RightModule %

RightModule Fraction Integer

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

UniqueFactorizationDomain

unitsKnown