# FloatingPointSystem¶

This category is intended as a model for floating point systems. A floating point system is a model for the real numbers. In fact, it is an approximation in the sense that not all real numbers are exactly representable by floating point numbers. A floating point system is characterized by the following: 1: base of the exponent. (actual implementations are usually binary or decimal) 2: precision of the mantissa (arbitrary or fixed) 3: rounding error for operations Because a Float is an approximation to the real numbers, even though it is defined to be a join of a Field and OrderedRing, some of the attributes do not hold. In particular associative(`"+"`) does not hold. Algorithms defined over a field need special considerations when the field is a floating point system.

0: %

from AbelianMonoid

1: %

from MagmaWithUnit

*: (%, %) -> %

from LeftModule %

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

from AbelianGroup

*: (NonNegativeInteger, %) -> %

from AbelianMonoid

*: (PositiveInteger, %) -> %

from AbelianSemiGroup

+: (%, %) -> %

from AbelianSemiGroup

-: % -> %

from AbelianGroup

-: (%, %) -> %

from AbelianGroup

/: (%, %) -> %

from Field

/: (%, Integer) -> %

`x / i` computes the division from `x` by an integer `i`.

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

^: (%, Fraction Integer) -> %

^: (%, Integer) -> %

from DivisionRing

^: (%, NonNegativeInteger) -> %

from MagmaWithUnit

^: (%, PositiveInteger) -> %

from Magma

~=: (%, %) -> Boolean

from BasicType

abs: % -> %

from OrderedRing

annihilate?: (%, %) -> Boolean

from Rng

antiCommutator: (%, %) -> %
associates?: (%, %) -> Boolean

from EntireRing

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

`base()` returns the base of the exponent.

bits: () -> PositiveInteger

`bits()` returns ceiling`'s` precision in bits.

bits: PositiveInteger -> PositiveInteger if % has arbitraryPrecision

`bits(n)` set the precision to `n` bits.

ceiling: % -> %

from RealNumberSystem

characteristic: () -> NonNegativeInteger
coerce: % -> %

from Algebra %

coerce: % -> OutputForm
coerce: Fraction Integer -> %
coerce: Integer -> %
commutator: (%, %) -> %
convert: % -> DoubleFloat
convert: % -> Float
convert: % -> Pattern Float
convert: % -> String
decreasePrecision: Integer -> PositiveInteger if % has arbitraryPrecision

`decreasePrecision(n)` decreases the current precision precision by `n` decimal digits.

digits: () -> PositiveInteger

`digits()` returns ceiling`'s` precision in decimal digits.

digits: PositiveInteger -> PositiveInteger if % has arbitraryPrecision

`digits(d)` set the precision to `d` digits.

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

from EuclideanDomain

euclideanSize: % -> NonNegativeInteger

from EuclideanDomain

exponent: % -> Integer

`exponent(x)` returns the exponent part of `x`.

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

from EntireRing

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

from EuclideanDomain

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

from EuclideanDomain

factor: % -> Factored %
float: (Integer, Integer) -> %

`float(a, e)` returns `a * base() ^ e`.

float: (Integer, Integer, PositiveInteger) -> %

`float(a, e, b)` returns `a * b ^ e`.

floor: % -> %

from RealNumberSystem

fractionPart: % -> %

from RealNumberSystem

gcd: (%, %) -> %

from GcdDomain

gcd: List % -> %

from GcdDomain

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

from GcdDomain

increasePrecision: Integer -> PositiveInteger if % has arbitraryPrecision

`increasePrecision(n)` increases the current precision by `n` decimal digits.

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(x)` returns the mantissa part of `x`.

max: (%, %) -> %

from OrderedSet

max: () -> % if % hasn’t arbitraryExponent and % hasn’t arbitraryPrecision

`max()` returns the maximum floating point number.

min: (%, %) -> %

from OrderedSet

min: () -> % if % hasn’t arbitraryExponent and % hasn’t arbitraryPrecision

`min()` returns the minimum floating point number.

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

from EuclideanDomain

negative?: % -> Boolean

from OrderedRing

norm: % -> %

from RealNumberSystem

nthRoot: (%, Integer) -> %

one?: % -> Boolean

from MagmaWithUnit

opposite?: (%, %) -> Boolean

from AbelianMonoid

order: % -> Integer

`order x` is the order of magnitude of `x`. Note: `base ^ order x <= |x| < base ^ (1 + order x)`.

patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %)
plenaryPower: (%, PositiveInteger) -> %
positive?: % -> Boolean

from OrderedRing

precision: () -> PositiveInteger

`precision()` returns the precision in digits base.

precision: PositiveInteger -> PositiveInteger if % has arbitraryPrecision

`precision(n)` set the precision in the base to `n` decimal digits.

prime?: % -> Boolean
principalIdeal: List % -> Record(coef: List %, generator: %)
quo: (%, %) -> %

from EuclideanDomain

recip: % -> Union(%, failed)

from MagmaWithUnit

rem: (%, %) -> %

from EuclideanDomain

retract: % -> Fraction Integer
retract: % -> Integer
retractIfCan: % -> Union(Fraction Integer, failed)
retractIfCan: % -> Union(Integer, failed)
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: % -> %

squareFree: % -> Factored %
squareFreePart: % -> %
subtractIfCan: (%, %) -> Union(%, failed)
toString: % -> String

`toString(x)` returns the string representation of `x`.

toString: (%, NonNegativeInteger) -> String

`toString(x, n)` returns a string representation of `x` truncated to `n` decimal digits.

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

Approximate

BasicType

BiModule(%, %)

CancellationAbelianMonoid

canonicalsClosed

canonicalUnitNormal

CharacteristicZero

CommutativeRing

CommutativeStar

Comparable

DivisionRing

EntireRing

EuclideanDomain

Field

GcdDomain

IntegralDomain

LeftOreRing

Magma

MagmaWithUnit

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors

OrderedAbelianGroup

OrderedAbelianMonoid

OrderedAbelianSemiGroup

OrderedCancellationAbelianMonoid

OrderedRing

OrderedSet

PartialOrder

PrincipalIdealDomain

RealConstant

RealNumberSystem

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

TwoSidedRecip

UniqueFactorizationDomain

unitsKnown