Data.FixedPoint

This FixedPoint module implements arbitrary sized fixed point types and computations. This module intentionally avoids converting to Integer for computations because one purpose is to allow easy translation to other languages to produce stand-alone fixed point libraries. Instead of using Integer, elementary long multiplication and long division are implemented explicitly along with sqrt, exp, and erf functions that are implemented using only primitive operations.

Fixedpoint types

type FixedPoint4816 = GenericFixedPoint Int64 Word128 Word16

type FixedPoint3232 = GenericFixedPoint Int64 Word128 Word32

type FixedPoint6464 = GenericFixedPoint Int128 Word256 Word64

type FixedPoint128128 = GenericFixedPoint Int256 Word512 Word128

type FixedPoint256256 = GenericFixedPoint Int512 Word1024 Word256

type FixedPoint512512 = GenericFixedPoint Int1024 Word2048 Word512

type FixedPoint10241024 = GenericFixedPoint Int2048 Word4096 Word1024

Common Operations

erf' :: (Eq a, Ord a, Num a, Fractional a) => Int -> a -> a

exp' :: (Ord a, Fractional a, Eq a) => Int -> a -> a

sqrt' :: (Eq a, Integral a, Num a, Bits a, Integral b, Bits b, Bits c) => Int -> GenericFixedPoint a b c -> GenericFixedPoint a b c

The square root operation uses Newton's method but is parameterized by the number of iterations and stops early if we have arrived at a fixed point (no pun intended). Suggested iterations: 500 (But it increases with the size of the input!)

pi' :: (Integral a, Bits a, Integral b, Num a, Bits b, Bits c) => GenericFixedPoint a b c

Big Int Types

type Int128 = BigInt Word128

A 128 bit int (signed)

type Int256 = BigInt Word256

A 256 bit int (signed)

type Int512 = BigInt Word512

A 512 bit int (signed)

type Int1024 = BigInt Word1024

A 1024 bit int (signed)

type Int2048 = BigInt Word2048

A 2048 bit int (signed)

type Int4096 = BigInt Word4096

A 4096 bit int (signed)

type Int8192 = BigInt Word8192

A 8192 bit int (signed)

Big Word Types

data Word128

Constructors

W128 !Word64 !Word64

Instances

Bounded Word128

Enum Word128

Eq Word128

Integral Word128

Num Word128

Ord Word128

Read Word128

Real Word128

Show Word128

Bits Word128

type Word256 = BigWord Word128

A 256 bit unsigned word

type Word512 = BigWord Word256

A 512 bit unsigned word

type Word1024 = BigWord Word512

A 1024 bit unsigned word

type Word2048 = BigWord Word1024

A 2048 bit unsigned word

type Word4096 = BigWord Word2048

A 4096 bit unsigned word

type Word8192 = BigWord Word4096

A 8192 bit unsigned word

Type Constructors

data GenericFixedPoint flat internal fracBitRepr

GenericFixedPoitn is a type constructor for arbitrarily-sized fixed point tyes. Take note the first type variable, flat, should be a signed int equal to the size of the fixed point integral plus fractional bits. The second type variable, internal, should be unsigned and twice as large a bit size as the flat type. The final type variable, fracBitRepr, should be a data structure of equal bit size to the fractional bits in the fixed point type. See the existing type aliases, such as FixedPoint4816, for examples.

Constructors

FixedPoint flat

Instances

(Enum a, Num a, Bits a, Bits c) => Enum (GenericFixedPoint a b c)

Eq flat => Eq (GenericFixedPoint flat internal fracBitRepr)

(Ord a, Integral a, Bits a, Num a, Bits b, Integral b, Bits c) => Fractional (GenericFixedPoint a b c)

(Ord a, Num a, Bits a, Bits b, Integral a, Integral b, Bits c) => Num (GenericFixedPoint a b c)

Ord flat => Ord (GenericFixedPoint flat internal fracBitRepr)

(Integral a, Bits a, Integral b, Num a, Bits b, Bits c) => Read (GenericFixedPoint a b c)

(Integral a, Ord a, Num a, Bits a, Bits b, Integral b, Bits c) => Real (GenericFixedPoint a b c)

(Integral a, Integral b, Bits a, Bits b, Bits c) => Show (GenericFixedPoint a b c)

(Ord a, Bits a, Bits b, Integral a, Integral b, Bits c) => Bits (GenericFixedPoint a b c)

newtype BigInt a

A type constructor for building 2^n bit signed ints. BigInt is normally just used as a wrapper around BigWord since twos-complement arithmatic is the same, we simply need to provide alternate show, read, and comparison operations.

Constructors

BigInt

Fields

unBI :: a

Instances

(Bounded a, Ord a, Bits a) => Bounded (BigInt a)

(Bits a, Ord a, Integral a, Bounded a, Num a) => Enum (BigInt a)

Eq a => Eq (BigInt a)

(Integral a, Bits a, Bounded a) => Integral (BigInt a)

(Num a, Bits a, Ord a) => Num (BigInt a)

(Ord a, Bits a) => Ord (BigInt a)

(Num a, Bits a, Ord a) => Read (BigInt a)

(Real a, Bounded a, Integral a, Bits a) => Real (BigInt a)

(Show a, Num a, Bits a, Ord a) => Show (BigInt a)

(Bits a, Ord a) => Bits (BigInt a)

data BigWord a

A type constuctor allowing construction of 2^n bit unsigned words The type variable represents half the underlying representation, so type Foo = BigWord Word13 would have a bit size of 26 (2*13).

Constructors

BigWord a a

Instances

Bounded a => Bounded (BigWord a)

(Bounded a, Eq a, Num a, Enum a) => Enum (BigWord a)

Ord a => Eq (BigWord a)

(Bounded a, Integral a, Bits a) => Integral (BigWord a)

(Bits a, Num a, Ord a) => Num (BigWord a)

Ord a => Ord (BigWord a)

(Num a, Bits a, Ord a) => Read (BigWord a)

(Bits a, Real a, Bounded a, Integral a) => Real (BigWord a)

(Bounded a, Bits a, Integral a) => Show (BigWord a)

(Ord a, Bits a) => Bits (BigWord a)