Module Data.Dec64

support for Decimal numbers

Imports

import Data.Bits as Bits
import frege.Prelude as Prelude
import Prelude.PreludeArrays as PreludeArrays
import Prelude.PreludeBase as PreludeBase
import Prelude.PreludeDecimal as PreludeDecimal
import Prelude.PreludeIO as PreludeIO
import Prelude.PreludeList as PreludeList
import Prelude.PreludeMonad as PreludeMonad
import Prelude.PreludeText as PreludeText
import Java.util.Regex as Regexp

Table of Content

Definitions

data Positive = pure native long

divu10 ∷ Long → Long

remu10 ∷ Long → Long

mulu10 ∷ Long → Long

expansionMax ∷ Long

coeffExpansionMax ∷ Long

positive ∷ Decimal → Positive

decimal ∷ Int → Positive → Decimal

normRight ∷ Positive → Positive

normLeft ∷ Positive → Positive

normLeftDecimal ∷ Decimal → Decimal

normLeftPositive ∷ Positive → Positive

ulpP ∷ Positive → Positive

ulp ∷ Decimal → Decimal

nextUp ∷ Decimal → Decimal

nextDown ∷ Decimal → Decimal

compareP ∷ Positive → Positive → Ordering

compareD ∷ Decimal → Decimal → Ordering

sigDigits ∷ Positive → Int

packResult ∷ Long → Int → Positive

addP ∷ Positive → Positive → Positive

diffP ∷ Positive → Positive → Positive

leadingZeroes ∷ Long → Int

relevantBits ∷ Long → Int

mulP ∷ Positive → Positive → Positive

recipP ∷ Positive → Positive

twoP ∷ Positive

recipCheck ∷ (Enum α, Integral α) ⇒ α → α → [(α, Decimal, Decimal)]

reciprocal ∷ Decimal → Decimal
Instances

instance Num Decimal

instance Ord Decimal

instance Ord Positive

instance Show Positive
Functions and Values by Type

Definitions

divu10 ∷ Long → Long

unsigned division by 10, using only 8 additions and 10 bit shifts

remu10 ∷ Long → Long

unsigned modulus 10, using only multiplication, addition and bit shifts

mulu10 ∷ Long → Long

multiplication by 10, with shift and add

this will be inlined, so only use strict variables as argument

data Positive = pure native long

We will do the real work with positive Decimals only and afterwards negate the result if need be

This will reduce the cases to be considered and ease overflow detection

Member Functions

coefficient ∷ Positive → Long

extract the coefficient from a Positive

This is simply an unsigned right shift by 8

exponent ∷ Positive → Int

extract the exponent, sign extended in an Int

fromBits ∷ Long → Positive
pure native (long)

Interpret the bits of the Long value as a Positive This is a no-operation, as Positives are Longs and every Long value is a valid Positive (though it might not be a number, see also Positive.nan).

isNaN ∷ Positive → Bool

tell if a Positive is not a number. This works for all 2^56 NaN values.

isZero ∷ Positive → Bool

tell if a Positive is 0. This works for all 255 0 values.

maxCoefficient ∷ Long
pure native 72057594037927935L

the largest possible coefficient is 72_057_594_037_927_935

maxExponent ∷ Int
pure native 127

the largest exponent is 127

minCoefficient ∷ Long
pure native 0L

the smalles possible coefficient is 0

minExponent ∷ Int
pure native 0xffffff81

the smallest exponent is -127

nan ∷ Positive
pure native 0xDeadBeef80L

The canonical not a number value.

Note that there are 2^56 NaN values, all comparing equal.

one ∷ Positive
pure native 0x100L

The canonical Positive 1

pack ∷ Long → Int → Positive

construct a Positive from a coefficient and an exponent

This will be Positive.nan if the coefficient is not in the range minCoefficient .. maxCoefficient or the exponent is not in the range minExponent .. maxExponent, even if the value could be represented. Thus:

 Positive.pack 72057594037927935 0     == 72057594037927935z
 Positive.pack 720575940379279350 (-1) == nan

toBits ∷ Positive → Long
pure native (long)

Interpret the bits of a Positive as Long value. The result will look like this

 mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm eeee eeee
         54        48        40        32        24        16        8 7        0

The 8 e bits 0..7 are the exponent in 2's complement encoding
The 56 m bits 8..63 are the unsigned coefficient.
an exponent of -128 (0x80) signals not-a-number (NaN)
the value of a number that is not NaN is coefficient*(exp^10)

Note that there are usually several encodings for one and the same value. 1, for example, could be 0x100 or 0xAFF (10E-1) Likewise 5 could be represented as 5e0, 50e-1, 0.5e1 and so forth.

This is a no-operation, as Positives are Longs. However, the Frege compiler sees them as totally unrelated types (and rightly so).

zero ∷ Positive
pure native 0L

The canonical Positive 0

expansionMax ∷ Long
pure native 922337203685477580L

a coeficient cannot be multiplied by 10 if it is greater than 922337203685477_580

coeffExpansionMax ∷ Long
pure native 7205759403792793L

a number greater than this, multiplied by 10, wouldn't fit anymore in the 56 coefficient bits

positive ∷ Decimal → Positive

get the absolute value of a Decimal as Positive

decimal ∷ Int → Positive → Decimal

convert a Positive back to a Decimal with the sign indicated by the first argument

normRight ∷ Positive → Positive

find the representation of a Positive with the smallest coefficient

NaN and 0 come out in their canonical forms

normLeft ∷ Positive → Positive

find the representation of a Positive with the greatest coefficient

NaN and 0 come out in their canonical forms

normLeftDecimal ∷ Decimal → Decimal

represent a Decimal with the greatest valid coefficient

NaN and 0 come out in their canonical forms

normLeftPositive ∷ Positive → Positive

represent a Positive with the greatest valid coefficient

NaN and 0 come out in their canonical forms

ulpP ∷ Positive → Positive

ulp ∷ Decimal → Decimal

find the smallest number that makes a difference when adding it to the given number

nextUp ∷ Decimal → Decimal

given a Decimal x find a Decimal y such that there is no Decimal z with x < z < y

nextDown ∷ Decimal → Decimal

given a Decimal x find a Decimal y such that there is no Decimal z with x > z > y

compareP ∷ Positive → Positive → Ordering

compareD ∷ Decimal → Decimal → Ordering

sigDigits ∷ Positive → Int

tell the number of significant digits

packResult ∷ Long → Int → Positive

Pack an arithmetic result by dividing the coefficient by 10 until it fits.

This will loose precision if the coefficient came out larger than 56 bits.

addP ∷ Positive → Positive → Positive

add 2 Positive numbers

both numbers must not be NaN

diffP ∷ Positive → Positive → Positive

difference between 2 Positive numbers, where the first one must be >= the second one

both numbers must not be NaN

leadingZeroes ∷ Long → Int
pure native java.lang.Long.numberOfLeadingZeros

relevantBits ∷ Long → Int

mulP ∷ Positive → Positive → Positive

recipP ∷ Positive → Positive

twoP ∷ Positive

recipCheck ∷ (Enum α, Integral α) ⇒ α → α → [(α, Decimal, Decimal)]

reciprocal ∷ Decimal → Decimal

Instances

instance Num Decimal

Member Functions

* ∷ Decimal → Decimal → Decimal
infixl 14
+ ∷ Decimal → Decimal → Decimal
infixl 13
- ∷ Decimal → Decimal → Decimal
infixl 13
abs ∷ Decimal → Decimal: inherited from Num.abs
fromInt ∷ Int → Decimal
fromInteger ∷ Integer → Decimal
isInfinite ∷ Decimal → Bool: inherited from Num.isInfinite
isNaN ∷ Decimal → Bool: tell if a Decimal is not a number. This works for all 2^56 NaN values.
isNumber ∷ Decimal → Bool: inherited from Num.isNumber
negate ∷ Decimal → Decimal
one ∷ Decimal
pure native 0x100L: The canonical Decimal 1
sign ∷ Decimal → Int: the sign of a Decimal (either -1, 0 or 1)
subtract ∷ Decimal → Decimal → Decimal: inherited from Num.subtract
zero ∷ Decimal
pure native 0L: The canonical Decimal 0

instance Ord Decimal

Member Functions

!= ∷ Decimal → Decimal → Bool
infix 7
< ∷ Decimal → Decimal → Bool
infix 9
<= ∷ Decimal → Decimal → Bool
infix 9
<=> ∷ Decimal → Decimal → Ordering
infix 8
== ∷ Decimal → Decimal → Bool
infix 7
> ∷ Decimal → Decimal → Bool
infix 9
>= ∷ Decimal → Decimal → Bool
infix 9
compare ∷ Decimal → Decimal → Ordering
infix 8: inherited from Ord.compare
hashCode ∷ Decimal → Int
max ∷ Decimal → Decimal → Decimal: inherited from Ord.max
min ∷ Decimal → Decimal → Decimal: inherited from Ord.min

instance Ord Positive

Member Functions

!= ∷ Positive → Positive → Bool
infix 7
< ∷ Positive → Positive → Bool
infix 9
<= ∷ Positive → Positive → Bool
infix 9
<=> ∷ Positive → Positive → Ordering
infix 8
== ∷ Positive → Positive → Bool
infix 7
> ∷ Positive → Positive → Bool
infix 9
>= ∷ Positive → Positive → Bool
infix 9
compare ∷ Positive → Positive → Ordering
infix 8: inherited from Ord.compare
hashCode ∷ Positive → Int
max ∷ Positive → Positive → Positive: inherited from Ord.max
min ∷ Positive → Positive → Positive: inherited from Ord.min

instance Show Positive

Member Functions

display ∷ Positive → String: inherited from Show.display
show ∷ Positive → String
showChars ∷ Positive → [Char]: inherited from Show.showChars
showList ∷ [Positive] → String → String: inherited from Show.showList
showsPrec ∷ Int → Positive → String → String: inherited from Show.showsPrec
showsub ∷ Positive → String: inherited from Show.showsub

Functions and Values by Type

[Positive] → String → String: Show_Positive.showList
Positive → Positive → Positive: addP, diffP, mulP, Ord_Positive.min, Ord_Positive.max
Positive → Positive → Bool: Ord_Positive.>=, Ord_Positive.>, Ord_Positive.!=, Ord_Positive.<, Ord_Positive.<=, Ord_Positive.==
Positive → Positive → Ordering: compareP, Ord_Positive.compare, Ord_Positive.<=>
Positive → String: Show_Positive.showsub, Show_Positive.display, Show_Positive.show
Positive → [Char]: Show_Positive.showChars
Positive → Positive: normLeft, normLeftPositive, normRight, recipP, ulpP
Positive → Bool: Positive.isNaN, Positive.isZero
Positive → Int: sigDigits, Ord_Positive.hashCode, Positive.exponent
Positive → Long: Positive.toBits, Positive.coefficient
Int → Positive → String → String: Show_Positive.showsPrec
Int → Positive → Decimal: decimal
Int → Decimal: Num_Decimal.fromInt
Integer → Decimal: Num_Decimal.fromInteger
Long → Int → Positive: packResult, Positive.pack
Long → Positive: Positive.fromBits
Long → Int: leadingZeroes, relevantBits
Long → Long: divu10, mulu10, remu10
Decimal → Decimal → Bool: Ord_Decimal.>=, Ord_Decimal.>, Ord_Decimal.!=, Ord_Decimal.<, Ord_Decimal.<=, Ord_Decimal.==
Decimal → Decimal → Ordering: compareD, Ord_Decimal.compare, Ord_Decimal.<=>
Decimal → Decimal → Decimal: Num_Decimal.subtract, Num_Decimal.-, Num_Decimal.*, Num_Decimal.+, Ord_Decimal.min, Ord_Decimal.max
Decimal → Positive: positive
Decimal → Bool: Num_Decimal.isNumber, Num_Decimal.isInfinite
Decimal → Int: Ord_Decimal.hashCode
Decimal → Decimal: nextDown, nextUp, normLeftDecimal, reciprocal, ulp, Num_Decimal.negate, Num_Decimal.abs
Positive: twoP, Positive.zero, Positive.one, Positive.nan
Int: Positive.minExponent, Positive.maxExponent
Long: coeffExpansionMax, expansionMax, Positive.minCoefficient, Positive.maxCoefficient
(Enum α, Integral α) ⇒ α → α → [(α, Decimal, Decimal)]: recipCheck