Copyright	Copyright (c) 2014-2015 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

System.Random.PCG.Single

Contents

Gen
Getting random numbers
Seeds
Type restricted versions

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

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
withFrozen :: FrozenGen -> (forall s. Gen s -> ST s a) -> (a, FrozenGen)
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
uniformRW8 :: Generator g m => (Word8, Word8) -> g -> m Word8
uniformRW16 :: Generator g m => (Word16, Word16) -> g -> m Word16
uniformRW32 :: Generator g m => (Word32, Word32) -> g -> m Word32
uniformRW64 :: Generator g m => (Word64, Word64) -> g -> m Word64
uniformRI8 :: Generator g m => (Int8, Int8) -> g -> m Int8
uniformRI16 :: Generator g m => (Int16, Int16) -> g -> m Int16
uniformRI32 :: Generator g m => (Int32, Int32) -> g -> m Int32
uniformRI64 :: Generator g m => (Int64, Int64) -> g -> m Int64
uniformRF :: Generator g m => (Float, Float) -> g -> m Float
uniformRD :: Generator g m => (Double, Double) -> g -> m Double
uniformRBool :: Generator g m => (Bool, Bool) -> g -> m Bool
uniformBW8 :: Generator g m => Word8 -> g -> m Word8
uniformBW16 :: Generator g m => Word16 -> g -> m Word16
uniformBW32 :: Generator g m => Word32 -> g -> m Word32
uniformBW64 :: Generator g m => Word64 -> g -> m Word64
uniformBI8 :: Generator g m => Int8 -> g -> m Int8
uniformBI16 :: Generator g m => Int16 -> g -> m Int16
uniformBI32 :: Generator g m => Int32 -> g -> m Int32
uniformBI64 :: Generator g m => Int64 -> g -> m Int64
uniformBF :: Generator g m => Float -> g -> m Float
uniformBD :: Generator g m => Double -> g -> m Double
uniformBBool :: Generator g m => Bool -> g -> m Bool

Gen

data Gen s Source #

State of the random number generator

Instances

Eq (Gen s) Source #
Instance details Methods (==) :: Gen s -> Gen s -> Bool # (/=) :: Gen s -> Gen s -> Bool #
Ord (Gen s) Source #
Instance details Methods compare :: Gen s -> Gen s -> Ordering # (<) :: Gen s -> Gen s -> Bool # (<=) :: Gen s -> Gen s -> Bool # (>) :: Gen s -> Gen s -> Bool # (>=) :: Gen s -> Gen s -> Bool # max :: Gen s -> Gen s -> Gen s # min :: Gen s -> Gen s -> Gen s #
(PrimMonad m, s ~ PrimState m) => Generator (Gen s) m Source #
Instance details Methods uniform1 :: (Word32 -> a) -> Gen s -> m a Source # uniform2 :: (Word32 -> Word32 -> a) -> Gen s -> m a Source # uniform1B :: Integral a => (Word32 -> a) -> Word32 -> Gen s -> m a Source #

type GenIO = Gen RealWorld Source #

type GenST = Gen Source #

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

Create a Gen from a fixed initial seed.

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 and CryptAPI on Windows).

withFrozen :: FrozenGen -> (forall s. Gen s -> ST s a) -> (a, FrozenGen) Source #

Run an action with a frozen generator, returning the result and the new frozen generator.

Getting random numbers

class Variate a where Source #

Minimal complete definition

uniform, uniformR, uniformB

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 #
Instance details Methods uniform :: Generator g m => g -> m Bool Source # uniformR :: Generator g m => (Bool, Bool) -> g -> m Bool Source # uniformB :: Generator g m => Bool -> g -> m Bool Source #
Variate Double Source #
Instance details Methods uniform :: Generator g m => g -> m Double Source # uniformR :: Generator g m => (Double, Double) -> g -> m Double Source # uniformB :: Generator g m => Double -> g -> m Double Source #
Variate Float Source #
Instance details Methods uniform :: Generator g m => g -> m Float Source # uniformR :: Generator g m => (Float, Float) -> g -> m Float Source # uniformB :: Generator g m => Float -> g -> m Float Source #
Variate Int Source #
Instance details Methods uniform :: Generator g m => g -> m Int Source # uniformR :: Generator g m => (Int, Int) -> g -> m Int Source # uniformB :: Generator g m => Int -> g -> m Int Source #
Variate Int8 Source #
Instance details Methods uniform :: Generator g m => g -> m Int8 Source # uniformR :: Generator g m => (Int8, Int8) -> g -> m Int8 Source # uniformB :: Generator g m => Int8 -> g -> m Int8 Source #
Variate Int16 Source #
Instance details Methods uniform :: Generator g m => g -> m Int16 Source # uniformR :: Generator g m => (Int16, Int16) -> g -> m Int16 Source # uniformB :: Generator g m => Int16 -> g -> m Int16 Source #
Variate Int32 Source #
Instance details Methods uniform :: Generator g m => g -> m Int32 Source # uniformR :: Generator g m => (Int32, Int32) -> g -> m Int32 Source # uniformB :: Generator g m => Int32 -> g -> m Int32 Source #
Variate Int64 Source #
Instance details Methods uniform :: Generator g m => g -> m Int64 Source # uniformR :: Generator g m => (Int64, Int64) -> g -> m Int64 Source # uniformB :: Generator g m => Int64 -> g -> m Int64 Source #
Variate Word Source #
Instance details Methods uniform :: Generator g m => g -> m Word Source # uniformR :: Generator g m => (Word, Word) -> g -> m Word Source # uniformB :: Generator g m => Word -> g -> m Word Source #
Variate Word8 Source #
Instance details Methods uniform :: Generator g m => g -> m Word8 Source # uniformR :: Generator g m => (Word8, Word8) -> g -> m Word8 Source # uniformB :: Generator g m => Word8 -> g -> m Word8 Source #
Variate Word16 Source #
Instance details Methods uniform :: Generator g m => g -> m Word16 Source # uniformR :: Generator g m => (Word16, Word16) -> g -> m Word16 Source # uniformB :: Generator g m => Word16 -> g -> m Word16 Source #
Variate Word32 Source #
Instance details Methods uniform :: Generator g m => g -> m Word32 Source # uniformR :: Generator g m => (Word32, Word32) -> g -> m Word32 Source # uniformB :: Generator g m => Word32 -> g -> m Word32 Source #
Variate Word64 Source #
Instance details Methods uniform :: Generator g m => g -> m Word64 Source # uniformR :: Generator g m => (Word64, Word64) -> g -> m Word64 Source # uniformB :: Generator g m => Word64 -> g -> m Word64 Source #
(Variate a, Variate b) => Variate (a, b) Source #
Instance details Methods uniform :: Generator g m => g -> m (a, b) Source # uniformR :: Generator g m => ((a, b), (a, b)) -> g -> m (a, b) Source # uniformB :: Generator g m => (a, b) -> g -> m (a, b) Source #
(Variate a, Variate b, Variate c) => Variate (a, b, c) Source #
Instance details Methods uniform :: Generator g m => g -> m (a, b, c) Source # uniformR :: Generator g m => ((a, b, c), (a, b, c)) -> g -> m (a, b, c) Source # uniformB :: Generator g m => (a, b, c) -> g -> m (a, b, c) Source #
(Variate a, Variate b, Variate c, Variate d) => Variate (a, b, c, d) Source #
Instance details Methods uniform :: Generator g m => g -> m (a, b, c, d) Source # uniformR :: Generator g m => ((a, b, c, d), (a, b, c, d)) -> g -> m (a, b, c, d) Source # uniformB :: Generator g m => (a, b, c, d) -> g -> m (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

data FrozenGen Source #

Instances

Eq FrozenGen Source #
Instance details Methods (==) :: FrozenGen -> FrozenGen -> Bool # (/=) :: FrozenGen -> FrozenGen -> Bool #
Data FrozenGen Source #
Instance details Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FrozenGen -> c FrozenGen # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c FrozenGen # toConstr :: FrozenGen -> Constr # dataTypeOf :: FrozenGen -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c FrozenGen) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c FrozenGen) # gmapT :: (forall b. Data b => b -> b) -> FrozenGen -> FrozenGen # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FrozenGen -> r # gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FrozenGen -> r # gmapQ :: (forall d. Data d => d -> u) -> FrozenGen -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> FrozenGen -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> FrozenGen -> m FrozenGen # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FrozenGen -> m FrozenGen # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FrozenGen -> m FrozenGen #
Ord FrozenGen Source #
Instance details Methods compare :: FrozenGen -> FrozenGen -> Ordering # (<) :: FrozenGen -> FrozenGen -> Bool # (<=) :: FrozenGen -> FrozenGen -> Bool # (>) :: FrozenGen -> FrozenGen -> Bool # (>=) :: FrozenGen -> FrozenGen -> Bool # max :: FrozenGen -> FrozenGen -> FrozenGen # min :: FrozenGen -> FrozenGen -> FrozenGen #
Show FrozenGen Source #
Instance details Methods showsPrec :: Int -> FrozenGen -> ShowS # show :: FrozenGen -> String # showList :: [FrozenGen] -> ShowS #
Generic FrozenGen Source #
Instance details Associated Types type Rep FrozenGen :: * -> * # Methods from :: FrozenGen -> Rep FrozenGen x # to :: Rep FrozenGen x -> FrozenGen #
Storable FrozenGen Source #
Instance details Methods sizeOf :: FrozenGen -> Int # alignment :: FrozenGen -> Int # peekElemOff :: Ptr FrozenGen -> Int -> IO FrozenGen # pokeElemOff :: Ptr FrozenGen -> Int -> FrozenGen -> IO () # peekByteOff :: Ptr b -> Int -> IO FrozenGen # pokeByteOff :: Ptr b -> Int -> FrozenGen -> IO () # peek :: Ptr FrozenGen -> IO FrozenGen # poke :: Ptr FrozenGen -> FrozenGen -> IO () #
RandomGen FrozenGen Source #
Instance details Methods next :: FrozenGen -> (Int, FrozenGen) # genRange :: FrozenGen -> (Int, Int) # split :: FrozenGen -> (FrozenGen, FrozenGen) #
type Rep FrozenGen Source #
Instance details type Rep FrozenGen = D1 (MetaData "FrozenGen" "System.Random.PCG.Single" "pcg-random-0.1.3.5-D0Q8vtxnQxHc6Db55grkM" True) (C1 (MetaCons "FrozenGen" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 Word64)))

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.

seed :: FrozenGen Source #

Standard initial seed.

initFrozen :: Word64 -> FrozenGen Source #

Generate a new seed using single Word64.

>>> initFrozen 0
FrozenGen 1876011003808476466

Type restricted versions

uniform

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

uniformW16 :: Generator g m => g -> m Word16 Source #

uniformW32 :: Generator g m => g -> m Word32 Source #

uniformW64 :: Generator g m => g -> m Word64 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 #

uniformRW16 :: Generator g m => (Word16, Word16) -> g -> m Word16 Source #

uniformRW32 :: Generator g m => (Word32, Word32) -> g -> m Word32 Source #

uniformRW64 :: Generator g m => (Word64, Word64) -> g -> m Word64 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 #

uniformBW16 :: Generator g m => Word16 -> g -> m Word16 Source #

uniformBW32 :: Generator g m => Word32 -> g -> m Word32 Source #

uniformBW64 :: Generator g m => Word64 -> g -> m Word64 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 #