Safe Haskell | Safe |
---|---|

Language | Haskell2010 |

This module contains a permuted linear congruential pseudorandom number
generator, as described by M.E. O'Neill (pcg-random.org). This version
holds two `Word64`

values and outputs a `Word32`

of randomness each time you
use it. Compared to the `StdGen`

type from System.Random, it's around a
2.5x to 3x speedup on a 64-bit system. It runs somewhat slower than `StdGen`

on a 32-bit system (the `Word64`

values must be emulated after all), but
there aren't too many of those in play these days anyway. Raspberry Pi is the
only common thing I can think of, which isn't the best for Haskell in the
first place. If you somehow are using 32-bit all the time I guess this module
isn't for you.

The first `Word64`

is the `state`

, which changes with each step of the
generator. The second `Word64`

is the `inc`

, which stays fixed from step to
step and controls what stream of numbers is generated. The `inc`

is always
bitwise OR'd with 1 during computations, so there are only 2^63 distinct
number streams (eg: `inc`

2 and 3 are the same number stream). The `state`

value eventually returns to it's initial value after 2^64 uses and the whole
sequence loops around.

# Documentation

The `PCGen`

data type. You can use the constructor yourself with two
`Word64`

values, but with human picked seeds the first result will generally
be 0. To avoid that you can use the `mkPCGen`

helper.

mkPCGen :: Integral i => i -> PCGen Source #

Creates a new PCGen value by using the Integral given as both the `state`

and `inc`

values for the generator. The state of the generator is then
advanced once, because otherwise the first result tends to be 0 with human
picked seeds.