| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Data.PCGen
Description
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.