Copyright	Copyright (c) 2014-2015 Christopher Chalmers <c.chalmers@me.com>
License	BSD3
Maintainer	Christopher Chalmers <c.chalmers@me.com>
Stability	experimental
Portability	CPP, FFI
Safe Haskell	None
Language	Haskell2010

System.Random.PCG.Unique

Contents

Gen
Getting random numbers
Type restricted versions

Description

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]

Synopsis

data Gen
create :: IO Gen
createSystemRandom :: IO Gen
initialize :: Word64 -> IO Gen
withSystemRandom :: (Gen -> IO a) -> IO a
class Variate a where
- uniform :: Generator g m => g -> m a
- uniformR :: Generator g m => (a, a) -> g -> m a
- uniformB :: Generator g m => a -> g -> m a
advance :: Word64 -> Gen -> IO ()
retract :: Word64 -> Gen -> IO ()
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
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
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

Gen

data Gen #

State of the random number generator

Instances

Eq Gen #
Instance details Defined in System.Random.PCG.Unique Methods (==) :: Gen -> Gen -> Bool # (/=) :: Gen -> Gen -> Bool #
Ord Gen #
Instance details Defined in System.Random.PCG.Unique 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 #
Instance details Defined in System.Random.PCG.Unique 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 #

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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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 #
Instance details Defined in System.Random.PCG.Class 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) #
Instance details Defined in System.Random.PCG.Class 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) #
Instance details Defined in System.Random.PCG.Class 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) #
Instance details Defined in System.Random.PCG.Class 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) #