pcg-random-0.1.2.0: Haskell bindings to the PCG random number generator.

Copyright Copyright (c) 2014-2015, Christopher Chalmers BSD3 Christopher Chalmers experimental CPP, FFI None Haskell2010

System.Random.PCG.Single

Description

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]
```

Synopsis

# Gen

data Gen s Source

State of the random number generator

Instances

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

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

Create a `Gen` from a fixed initial seed.

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

class Variate a where Source

Methods

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.

Instances

 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

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

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

Save the state of a `Gen` in a `Seed`.

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

Restore a `Gen` from a `Seed`.

Standard initial seed.

Generate a new seed using single `Word64`.

````>>> ````initFrozen 0
```FrozenGen 1876011003808476466
```

# Type restricted versions

## uniform

uniformW8 :: Generator g m => g -> m Word8 Source

uniformI8 :: Generator g m => g -> m Int8 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

uniformF :: Generator g m => g -> m Float Source

uniformD :: Generator g m => g -> m Double Source

uniformBool :: Generator g m => g -> m Bool Source

## uniformR

uniformRW8 :: Generator g m => (Word8, Word8) -> g -> m Word8 Source

uniformRI8 :: Generator g m => (Int8, Int8) -> g -> m Int8 Source

uniformRI16 :: Generator g m => (Int16, Int16) -> g -> m Int16 Source

uniformRI32 :: Generator g m => (Int32, Int32) -> g -> m Int32 Source

uniformRI64 :: Generator g m => (Int64, Int64) -> g -> m Int64 Source

uniformRF :: Generator g m => (Float, Float) -> g -> m Float Source

uniformRD :: Generator g m => (Double, Double) -> g -> m Double Source

uniformRBool :: Generator g m => (Bool, Bool) -> g -> m Bool Source

## uniformB

uniformBW8 :: Generator g m => Word8 -> g -> m Word8 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

uniformBF :: Generator g m => Float -> g -> m Float Source

uniformBD :: Generator g m => Double -> g -> m Double Source

uniformBBool :: Generator g m => Bool -> g -> m Bool Source