System.Random.PCG

Standard PCG Random Number Generator with chosen streams. See http://www.pcg-random.org for details.

import Control.Monad.ST
import System.Random.PCG

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

Generator

data Gen s

State of the random number generator

Instances

Eq (Gen s)

Ord (Gen s)

(PrimMonad m, (~) * s (PrimState m)) => Generator (Gen s) m

type GenIO = Gen RealWorld

Type alias of Gen specialized to IO.

type GenST s = Gen s

Type alias of Gen specialized to ST. (

create :: PrimMonad m => m (Gen (PrimState m))

Create a Gen from a fixed initial seed.

createSystemRandom :: IO GenIO

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 -> Word64 -> m (Gen (PrimState m))

Initialize a generator with two words.

>>> initialize 0 0 >>= save
FrozenGen 6364136223846793006 1

withSystemRandom :: PrimMonad m => (Gen (PrimState m) -> m 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.

Instances

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 ()

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
3640764222
>>> create >>= \g -> replicateM_ 500 (uniformD g) >> uniformW32 g
3640764222
>>> create >>= \g -> advance 1000 g >> uniformW32 g
3640764222

retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()

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

>>> create >>= \g -> replicateM 3 (uniformW32 g)
[355248013,41705475,3406281715]
>>> create >>= \g -> retract 1 g >> replicateM 3 (uniformW32 g)
[19683962,355248013,41705475]

Frozen generator

data FrozenGen

Immutable snapshot of the state of a Gen.

Instances

Eq FrozenGen

Ord FrozenGen

Show FrozenGen

Storable FrozenGen

RandomGen FrozenGen

save :: PrimMonad m => Gen (PrimState m) -> m FrozenGen

Save the state of a Gen in a FrozenGen.

restore :: PrimMonad m => FrozenGen -> m (Gen (PrimState m))

Restore a Gen from a FrozenGen.

seed :: FrozenGen

Fixed seed.

initFrozen :: Word64 -> Word64 -> FrozenGen

Generate a new seed using two Word64s.

>>> initFrozen 0 0
FrozenGen 6364136223846793006 1

Type restricted versions

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