`FixedPointDecimals.RoundThrows`

— Constant`RoundThrows`

Raises an `InexactError`

if any rounding is necessary.

`FixedPointDecimals.FixedDecimal`

— Type`FixedDecimal{T <: Integer, f::Int}`

A fixed-point decimal type backed by integral type `T`

, with `f`

digits after the decimal point stored.

`FixedPointDecimals._apply_exact_float`

— Method`_apply_exact_float(f, T, x::Real, i::Integer)`

Compute `f(T, x, i)::T`

but avoiding possible loss of precision from an intermediate conversion of `i`

to a floating point type by instead using a `BigFloat`

with sufficient precision if necessary.

`FixedPointDecimals._round_to_nearest`

— Method`_round_to_nearest(quotient, remainder, divisor, ::RoundingMode{M})`

Round `quotient + remainder / divisor`

to the nearest integer, given that `0 ≤ remainder < divisor`

or `0 ≥ remainder > divisor`

. (This assumption is satisfied by the return value of `fldmod`

in all cases, and the return value of `divrem`

in cases where `divisor`

is known to be positive.) The tie is decided depending on the `RoundingMode`

.

`FixedPointDecimals.ceilmul`

— Function`ceilmul(I, x, y) :: I`

Compute `ceil(I, x * y)`

, returning the result as type `I`

. For floating point values, this function can be more accurate than `ceil(x * y)`

.

`FixedPointDecimals.checked_rdiv`

— Method`FixedPointDecimals.checked_rdiv(x::FD, y::FD) -> FD`

Calculates `x / y`

, checking for overflow errors where applicable.

The overflow protection may impose a perceptible performance penalty.

See also:

`Base.checked_div`

for truncating division.

`FixedPointDecimals.coefficient`

— Method`coefficient(::Type{FD{T, f}}) -> T`

Compute `10^f`

as an Integer without overflow. Note that overflow will not occur for any constructable `FD{T, f}`

.

`FixedPointDecimals.floormul`

— Function`floormul(I, x, y) :: I`

Compute `floor(I, x * y)`

, returning the result as type `I`

. For floating point values, this function can be more accurate than `floor(x * y)`

.

`FixedPointDecimals.max_exp10`

— Method`max_exp10(T)`

The highest value of `x`

which does not result in an overflow when evaluating `T(10)^x`

. For types of `T`

that do not overflow -1 will be returned.

NOTE: This function is expensive, since it contains a while-loop, but it is actually computing a constant value for types, so it really only needs to be run once per type. We achieve this by `@eval`

ing new methods in a loop, below. Users can do this themselves to add more "frozen" methods for custom Integer types: `julia @eval FixedPointDecimals.max_exp10(::Type{CustomIntType}) = $(max_exp10(CustomIntType))`

This function does not have or depend on any side-effects.

`FixedPointDecimals.required_precision`

— Method`required_precision(n::Integer)`

Compute the number of bits of precision needed to represent an integer exactly as a floating point number.

This is equivalent to counting the number of bits needed to represent the integer, excluding any trailing zeros.

`FixedPointDecimals.truncmul`

— Function`truncmul(I, x, y) :: I`

Compute `trunc(I, x * y)`

, returning the result as type `I`

. For floating point values, this function can be more accurate than `trunc(x * y)`

.