Copyright | Copyright (c) 2014, 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 |
Single variant of the PCG random number generator. This module only uses a single stream. See http://www.pcg-random.org for details.
import Control.Monad.ST import System.Random.PCG.Single three :: [Double] three = runST $ do g <- create a <- uniform g b <- uniform g c <- uniform g return [a,b,c]
- data Gen s
- type GenIO = Gen RealWorld
- type GenST = Gen
- create :: PrimMonad m => m (Gen (PrimState m))
- createSystemRandom :: IO GenIO
- initialize :: PrimMonad m => Word64 -> m (Gen (PrimState m))
- withSystemRandom :: (GenIO -> IO a) -> IO a
- class Variate a where
- advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()
- retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()
- data FrozenGen
- save :: PrimMonad m => Gen (PrimState m) -> m FrozenGen
- restore :: PrimMonad m => FrozenGen -> m (Gen (PrimState m))
- seed :: FrozenGen
- initFrozen :: Word64 -> FrozenGen
- 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
Gen
State of the random number generator
createSystemRandom :: IO GenIO 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 :: PrimMonad m => Word64 -> m (Gen (PrimState m)) Source
Initialize a generator a single word.
>>>
initialize 0 >>= save
FrozenGen 1876011003808476466
withSystemRandom :: (GenIO -> 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.
Variate Bool | |
Variate Double | |
Variate Float | |
Variate Int | |
Variate Int8 | |
Variate Int16 | |
Variate Int32 | |
Variate Int64 | |
Variate Word | |
Variate Word8 | |
Variate Word16 | |
Variate Word32 | |
Variate Word64 | |
(Variate a, Variate b) => Variate (a, b) | |
(Variate a, Variate b, Variate c) => Variate (a, b, c) | |
(Variate a, Variate b, Variate c, Variate d) => Variate (a, b, c, d) |
advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m () Source
Advance the given generator n steps in log(n) time. (Note that a
"step" is a single random 32-bit (or less) Variate
. Data types
such as Double
or Word64
require two "steps".)
>>>
create >>= \g -> replicateM_ 1000 (uniformW32 g) >> uniformW32 g
787992099>>>
create >>= \g -> replicateM_ 500 (uniformD g) >> uniformW32 g
787992099>>>
create >>= \g -> advance 1000 g >> uniformW32 g
787992099
retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m () Source
Retract the given generator n steps in log(2^64-n) time. This
is just advance (-n)
.
>>>
create >>= \g -> replicateM 3 (uniformW32 g)
[1499251125,2252584727,2021901712]>>>
create >>= \g -> retract 1 g >> replicateM 3 (uniformW32 g)
[4031155981,1499251125,2252584727]
Seeds
initFrozen :: Word64 -> FrozenGen Source
Generate a new seed using single Word64
.
>>>
initFrozen 0
FrozenGen 1876011003808476466
Type restricted versions
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