System.Random.PCG.Unique

Unique variant of the PCG random number generator. Guarantees the sequence to be unique by using the pointer address to select the output sequence.

There is no way to freeze the state because then it wouldn't be unique anymore. Also, generators can't be initialized in ST because we don't know what pointer reference they'll get.

See http://www.pcg-random.org for details.

import System.Random.PCG.Unique

three :: IO [Double]
three = do
  g <- create
  a <- uniform g
  b <- uniform g
  c <- uniform g
  return [a,b,c]

Gen

data Gen

State of the random number generator

Instances

Eq Gen

Methods

(==) :: Gen -> Gen -> Bool

(/=) :: Gen -> Gen -> Bool

Ord Gen

Methods

compare :: Gen -> Gen -> Ordering

(<) :: Gen -> Gen -> Bool

(<=) :: Gen -> Gen -> Bool

(>) :: Gen -> Gen -> Bool

(>=) :: Gen -> Gen -> Bool

max :: Gen -> Gen -> Gen

min :: Gen -> Gen -> Gen

Generator Gen IO

Methods

uniform1 :: (Word32 -> a) -> Gen -> IO a

uniform2 :: (Word32 -> Word32 -> a) -> Gen -> IO a

uniform1B :: Integral a => (Word32 -> a) -> Word32 -> Gen -> IO a

create :: IO Gen

Create a Gen from a fixed initial seed.

createSystemRandom :: IO Gen

Seed a PRNG with data from the system's fast source of pseudo-random numbers. All the caveats of withSystemRandom apply here as well.

initialize :: Word64 -> IO Gen

Create a generator from two words. Note: this is not the same as the two words in a Seed.

withSystemRandom :: (Gen -> IO a) -> IO a

Seed with system random number. ("/dev/urandom" on Unix-like systems, time otherwise).

Getting random numbers

class Variate a where

Minimal complete definition

uniform, uniformR, uniformB

Methods

uniform :: Generator g m => g -> m a

Generate a uniformly distributed random vairate.

• Use entire range for integral types.
• Use (0,1] range for floating types.

uniformR :: Generator g m => (a, a) -> g -> m a

Generate a uniformly distributed random vairate in the given range.

• Use inclusive range for integral types.
• Use (a,b] range for floating types.

uniformB :: Generator g m => a -> g -> m a

Generate a uniformly distributed random vairate in the range [0,b). For integral types the bound must be less than the max bound of Word32 (4294967295). Behaviour is undefined for negative bounds.

Instances

Variate Bool

Methods

uniform :: Generator g m => g -> m Bool

uniformR :: Generator g m => (Bool, Bool) -> g -> m Bool

uniformB :: Generator g m => Bool -> g -> m Bool

Variate Double

Methods

uniform :: Generator g m => g -> m Double

uniformR :: Generator g m => (Double, Double) -> g -> m Double

uniformB :: Generator g m => Double -> g -> m Double

Variate Float

Methods

uniform :: Generator g m => g -> m Float

uniformR :: Generator g m => (Float, Float) -> g -> m Float

uniformB :: Generator g m => Float -> g -> m Float

Variate Int

Methods

uniform :: Generator g m => g -> m Int

uniformR :: Generator g m => (Int, Int) -> g -> m Int

uniformB :: Generator g m => Int -> g -> m Int

Variate Int8

Methods

uniform :: Generator g m => g -> m Int8

uniformR :: Generator g m => (Int8, Int8) -> g -> m Int8

uniformB :: Generator g m => Int8 -> g -> m Int8

Variate Int16

Methods

uniform :: Generator g m => g -> m Int16

uniformR :: Generator g m => (Int16, Int16) -> g -> m Int16

uniformB :: Generator g m => Int16 -> g -> m Int16

Variate Int32

Methods

uniform :: Generator g m => g -> m Int32

uniformR :: Generator g m => (Int32, Int32) -> g -> m Int32

uniformB :: Generator g m => Int32 -> g -> m Int32

Variate Int64

Methods

uniform :: Generator g m => g -> m Int64

uniformR :: Generator g m => (Int64, Int64) -> g -> m Int64

uniformB :: Generator g m => Int64 -> g -> m Int64

Variate Word

Methods

uniform :: Generator g m => g -> m Word

uniformR :: Generator g m => (Word, Word) -> g -> m Word

uniformB :: Generator g m => Word -> g -> m Word

Variate Word8

Methods

uniform :: Generator g m => g -> m Word8

uniformR :: Generator g m => (Word8, Word8) -> g -> m Word8

uniformB :: Generator g m => Word8 -> g -> m Word8

Variate Word16

Methods

uniform :: Generator g m => g -> m Word16

uniformR :: Generator g m => (Word16, Word16) -> g -> m Word16

uniformB :: Generator g m => Word16 -> g -> m Word16

Variate Word32

Methods

uniform :: Generator g m => g -> m Word32

uniformR :: Generator g m => (Word32, Word32) -> g -> m Word32

uniformB :: Generator g m => Word32 -> g -> m Word32

Variate Word64

Methods

uniform :: Generator g m => g -> m Word64

uniformR :: Generator g m => (Word64, Word64) -> g -> m Word64

uniformB :: Generator g m => Word64 -> g -> m Word64

(Variate a, Variate b) => Variate (a, b)

Methods

uniform :: Generator g m => g -> m (a, b)

uniformR :: Generator g m => ((a, b), (a, b)) -> g -> m (a, b)

uniformB :: Generator g m => (a, b) -> g -> m (a, b)

(Variate a, Variate b, Variate c) => Variate (a, b, c)

Methods

uniform :: Generator g m => g -> m (a, b, c)

uniformR :: Generator g m => ((a, b, c), (a, b, c)) -> g -> m (a, b, c)

uniformB :: Generator g m => (a, b, c) -> g -> m (a, b, c)

(Variate a, Variate b, Variate c, Variate d) => Variate (a, b, c, d)

Methods

uniform :: Generator g m => g -> m (a, b, c, d)

uniformR :: Generator g m => ((a, b, c, d), (a, b, c, d)) -> g -> m (a, b, c, d)

uniformB :: Generator g m => (a, b, c, d) -> g -> m (a, b, c, d)

advance :: Word64 -> Gen -> IO ()

Advance the given generator n steps in log(n) time.

retract :: Word64 -> Gen -> IO ()

Retract the given generator n steps in log(2^64-n) time. This is just advance (-n).

Type restricted versions

uniform

uniformW8 :: Generator g m => g -> m Word8

uniformW16 :: Generator g m => g -> m Word16

uniformW32 :: Generator g m => g -> m Word32

uniformW64 :: Generator g m => g -> m Word64

uniformI8 :: Generator g m => g -> m Int8

uniformI16 :: Generator g m => g -> m Int16

uniformI32 :: Generator g m => g -> m Int32

uniformI64 :: Generator g m => g -> m Int64

uniformF :: Generator g m => g -> m Float

uniformD :: Generator g m => g -> m Double

uniformBool :: Generator g m => g -> m Bool

uniformR

uniformRW8 :: Generator g m => (Word8, Word8) -> g -> m Word8

uniformRW16 :: Generator g m => (Word16, Word16) -> g -> m Word16

uniformRW32 :: Generator g m => (Word32, Word32) -> g -> m Word32

uniformRW64 :: Generator g m => (Word64, Word64) -> g -> m Word64

uniformRI8 :: Generator g m => (Int8, Int8) -> g -> m Int8

uniformRI16 :: Generator g m => (Int16, Int16) -> g -> m Int16

uniformRI32 :: Generator g m => (Int32, Int32) -> g -> m Int32

uniformRI64 :: Generator g m => (Int64, Int64) -> g -> m Int64

uniformRF :: Generator g m => (Float, Float) -> g -> m Float

uniformRD :: Generator g m => (Double, Double) -> g -> m Double

uniformRBool :: Generator g m => (Bool, Bool) -> g -> m Bool

uniformB

uniformBW8 :: Generator g m => Word8 -> g -> m Word8

uniformBW16 :: Generator g m => Word16 -> g -> m Word16

uniformBW32 :: Generator g m => Word32 -> g -> m Word32

uniformBW64 :: Generator g m => Word64 -> g -> m Word64

uniformBI8 :: Generator g m => Int8 -> g -> m Int8

uniformBI16 :: Generator g m => Int16 -> g -> m Int16

uniformBI32 :: Generator g m => Int32 -> g -> m Int32

uniformBI64 :: Generator g m => Int64 -> g -> m Int64

uniformBF :: Generator g m => Float -> g -> m Float

uniformBD :: Generator g m => Double -> g -> m Double

uniformBBool :: Generator g m => Bool -> g -> m Bool