Portability | Haskell 98 |
---|---|
Stability | stable |
Maintainer | haskell@henning-thielemann.de |
This module contains internal functions (*Unsafe) that I had liked to re-use in the NumericPrelude type hierarchy. However since the Eq and Ord instance already require the Num class, we cannot use that in the NumericPrelude.
- data T a
- fromChunks :: C a => [a] -> T a
- fromNumber :: C a => a -> T a
- toChunks :: T a -> [a]
- toNumber :: C a => T a -> a
- zero :: T a
- normalize :: C a => T a -> T a
- isNull :: C a => T a -> Bool
- isPositive :: C a => T a -> Bool
- minMaxDiff :: C a => T a -> T a -> (T a, T a, Bool)
- fromChunksUnsafe :: [a] -> T a
- toChunksUnsafe :: T a -> [a]
Documentation
A chunky non-negative number is a list of non-negative numbers. It represents the sum of the list elements. It is possible to represent a finite number with infinitely many chunks by using an infinite number of zeros.
Note the following problems:
Addition is commutative only for finite representations.
E.g. let y = min (1+y) 2 in y
is defined,
let y = min (y+1) 2 in y
is not.
fromChunks :: C a => [a] -> T aSource
fromNumber :: C a => a -> T aSource
isPositive :: C a => T a -> BoolSource
minMaxDiff :: C a => T a -> T a -> (T a, T a, Bool)Source
In minMaxDiff x y == (z,r,b)
z
represents min x y
,
r
represents max x y - min x y
,
and xy == b
or x>y ==> not b
,
for x==y
the value of b is arbitrary.
fromChunksUnsafe :: [a] -> T aSource
toChunksUnsafe :: T a -> [a]Source
This routine exposes the inner structure of the lazy number
and is actually the same as toChunks
.
It was considered dangerous,
but you can observe the lazy structure
in tying-the-knot applications anyway.
So the explicit revelation of the chunks seems not to be worse.