-----------------------------------------------------------------------------
-- |
-- Module      :  Numeric.Random.Distribution.Uniform
-- Copyright   :  (c) Matthew Donadio 2003
-- License     :  GPL
--
-- Maintainer  :  m.p.donadio@ieee.org
-- Stability   :  experimental
-- Portability :  portable
--
-- Functions for turning a list of random integers (as 'Word32') in a list
-- of Uniform RV's
--
-----------------------------------------------------------------------------

module Numeric.Random.Distribution.Uniform where

import Data.Word

-- Float  : 1 sign, 8 exp,  23 fraction
-- Double : 1 sign, 11 exp, 52 fraction

-- | 32 bits in [0,1]

-- 4294967295 = 2^32 - 1

uniform32cc :: [Word32] -- ^ X
            -> [Double] -- ^ U

uniform32cc :: [Word32] -> [Double]
uniform32cc [Word32]
xs = forall a b. (a -> b) -> [a] -> [b]
map ((forall a. Fractional a => a -> a -> a
/ Double
4294967295.0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall a b. (a -> b) -> a -> b
$ [Word32]
xs

-- | 32 bits in [0,1)

-- 4294967296 = 2^32

uniform32co :: [Word32] -- ^ X
            -> [Double] -- ^ U

uniform32co :: [Word32] -> [Double]
uniform32co [Word32]
xs = forall a b. (a -> b) -> [a] -> [b]
map ((forall a. Fractional a => a -> a -> a
/ Double
4294967296.0) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) forall a b. (a -> b) -> a -> b
$ [Word32]
xs

-- | 32 bits in (0,1]

uniform32oc :: [Word32] -- ^ X
            -> [Double] -- ^ U

uniform32oc :: [Word32] -> [Double]
uniform32oc [Word32]
xs = forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= Double
0) forall a b. (a -> b) -> a -> b
$ [Word32] -> [Double]
uniform32cc forall a b. (a -> b) -> a -> b
$ [Word32]
xs

-- | 32 bits in (0,1)

uniform32oo :: [Word32] -- ^ X
            -> [Double] -- ^ U

uniform32oo :: [Word32] -> [Double]
uniform32oo [Word32]
xs = forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= Double
1) forall a b. (a -> b) -> a -> b
$ [Word32] -> [Double]
uniform32oc forall a b. (a -> b) -> a -> b
$ [Word32]
xs

-- | 53 bits in [0,1], ie 64-bit IEEE 754 in [0,1]

-- 67108864 = 2^26
-- 9007199254740991 = 2^53 - 1

uniform53cc :: [Word32] -- ^ X
            -> [Double] -- ^ U

uniform53cc :: [Word32] -> [Double]
uniform53cc [Word32]
xs = forall {a} {a}. (Fractional a, Integral a) => [a] -> [a]
uniform' [Word32]
xs
    where uniform' :: [a] -> [a]
uniform' (a
u1:a
u2:[a]
us) = (a
a forall a. Num a => a -> a -> a
* a
67108864.0 forall a. Num a => a -> a -> a
+ a
b) forall a. Fractional a => a -> a -> a
/ a
9007199254740991.0 forall a. a -> [a] -> [a]
: [a] -> [a]
uniform' [a]
us
              where a :: a
a = forall a b. (Integral a, Num b) => a -> b
fromIntegral a
u1 forall a. Fractional a => a -> a -> a
/ a
32.0 -- 27 bits
                    b :: a
b = forall a b. (Integral a, Num b) => a -> b
fromIntegral a
u2 forall a. Fractional a => a -> a -> a
/ a
64.0 -- 26 bits
          uniform' [a]
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"uniform53cc: input list must be infinite"

-- | 53 bits in [0,1), ie 64-bit IEEE 754 in [0,1)

-- 67108864 = 2^26
-- 9007199254740992 = 2^53

uniform53co :: [Word32] -- ^ X
            -> [Double] -- ^ U

uniform53co :: [Word32] -> [Double]
uniform53co [Word32]
xs = forall {a} {a}. (Fractional a, Integral a) => [a] -> [a]
uniform' forall a b. (a -> b) -> a -> b
$ [Word32]
xs
    where uniform' :: [a] -> [a]
uniform' (a
u1:a
u2:[a]
us) = (a
a forall a. Num a => a -> a -> a
* a
67108864.0 forall a. Num a => a -> a -> a
+ a
b) forall a. Fractional a => a -> a -> a
/ a
9007199254740992.0 forall a. a -> [a] -> [a]
: [a] -> [a]
uniform' [a]
us
              where a :: a
a = forall a b. (Integral a, Num b) => a -> b
fromIntegral a
u1 forall a. Fractional a => a -> a -> a
/ a
32.0 -- 27 bits
                    b :: a
b = forall a b. (Integral a, Num b) => a -> b
fromIntegral a
u2 forall a. Fractional a => a -> a -> a
/ a
64.0 -- 26 bits
          uniform' [a]
_ = forall a. HasCallStack => [Char] -> a
error [Char]
"uniform53co: input list must be infinite"

-- | 53 bits in (0,1]

uniform53oc :: [Word32] -- ^ X
            -> [Double] -- ^ U

uniform53oc :: [Word32] -> [Double]
uniform53oc [Word32]
xs = forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= Double
0) forall a b. (a -> b) -> a -> b
$ [Word32] -> [Double]
uniform53cc forall a b. (a -> b) -> a -> b
$ [Word32]
xs

-- | 53 bits in (0,1)

uniform53oo :: [Word32] -- ^ X
            -> [Double] -- ^ U

uniform53oo :: [Word32] -> [Double]
uniform53oo [Word32]
xs = forall a. (a -> Bool) -> [a] -> [a]
filter (forall a. Eq a => a -> a -> Bool
/= Double
1) forall a b. (a -> b) -> a -> b
$ [Word32] -> [Double]
uniform53oc forall a b. (a -> b) -> a -> b
$ [Word32]
xs

-- | transforms uniform [0,1] to [a,b]

uniform :: Double   -- ^ a
        -> Double   -- ^ b
        -> [Double] -- ^ U
        -> [Double] -- ^ U'

uniform :: Double -> Double -> [Double] -> [Double]
uniform Double
a Double
b [Double]
us = forall a b. (a -> b) -> [a] -> [b]
map (\Double
u -> (Double
bforall a. Num a => a -> a -> a
-Double
a)forall a. Num a => a -> a -> a
*Double
u forall a. Num a => a -> a -> a
+ Double
a) [Double]
us