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 |
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]
- data Gen
- create :: IO Gen
- createSystemRandom :: IO Gen
- initialize :: Word64 -> IO Gen
- withSystemRandom :: (Gen -> IO a) -> IO a
- class Variate a where
- 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
State of the random number generator
createSystemRandom :: IO Gen Source
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 Source
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 Source
Seed with system random number. ("/dev/urandom
" on Unix-like
systems, time otherwise).
Getting random numbers
uniform :: Generator g m => g -> m a Source
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 Source
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 Source
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.
Variate Bool Source | |
Variate Double Source | |
Variate Float Source | |
Variate Int Source | |
Variate Int8 Source | |
Variate Int16 Source | |
Variate Int32 Source | |
Variate Int64 Source | |
Variate Word Source | |
Variate Word8 Source | |
Variate Word16 Source | |
Variate Word32 Source | |
Variate Word64 Source | |
(Variate a, Variate b) => Variate (a, b) Source | |
(Variate a, Variate b, Variate c) => Variate (a, b, c) Source | |
(Variate a, Variate b, Variate c, Variate d) => Variate (a, b, c, d) Source |
retract :: Word64 -> Gen -> IO () Source
Retract the given generator n steps in log(2^64-n) time. This
is just advance (-n)
.
Type restricted versions
uniform
uniformW16 :: Generator g m => g -> m Word16 Source
uniformW32 :: Generator g m => g -> m Word32 Source
uniformW64 :: Generator g m => g -> m Word64 Source
uniformI16 :: Generator g m => g -> m Int16 Source
uniformI32 :: Generator g m => g -> m Int32 Source
uniformI64 :: Generator g m => g -> m Int64 Source
uniformBool :: Generator g m => g -> m Bool Source
uniformR
uniformB
uniformBW8 :: Generator g m => Word8 -> g -> m Word8 Source
uniformBW16 :: Generator g m => Word16 -> g -> m Word16 Source
uniformBW32 :: Generator g m => Word32 -> g -> m Word32 Source
uniformBW64 :: Generator g m => Word64 -> g -> m Word64 Source
uniformBI8 :: Generator g m => Int8 -> g -> m Int8 Source
uniformBI16 :: Generator g m => Int16 -> g -> m Int16 Source
uniformBI32 :: Generator g m => Int32 -> g -> m Int32 Source
uniformBI64 :: Generator g m => Int64 -> g -> m Int64 Source
uniformBBool :: Generator g m => Bool -> g -> m Bool Source