System.Random.PCG.Fast

Fast variant of the PCG random number generator. This module performs around 20% faster than the multiple streams version but produces slightly lower quality (still good) random numbers.

See http://www.pcg-random.org for details.

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

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

Gen

data Gen s

State of the random number generator

Instances

Eq (Gen s)

Defined in System.Random.PCG.Fast

Methods

(==) :: Gen s -> Gen s -> Bool

(/=) :: Gen s -> Gen s -> Bool

Ord (Gen s)

Defined in System.Random.PCG.Fast

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

Defined in System.Random.PCG.Fast

Methods

uniform1 :: (Word32 -> a) -> Gen s -> m a

uniform2 :: (Word32 -> Word32 -> a) -> Gen s -> m a

uniform1B :: Integral a => (Word32 -> a) -> Word32 -> Gen s -> m a

type GenIO = Gen RealWorld

type GenST = Gen

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

Initialize a generator a single word.

>>> initialize 0 >>= save
FrozenGen 1

withSystemRandom :: (GenIO -> IO a) -> IO a

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)

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

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.

uniformB :: Generator g m => a -> g -> m a

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 Int16

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Int16

uniformR :: Generator g m => (Int16, Int16) -> g -> m Int16

uniformB :: Generator g m => Int16 -> g -> m Int16

Variate Int32

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Int32

uniformR :: Generator g m => (Int32, Int32) -> g -> m Int32

uniformB :: Generator g m => Int32 -> g -> m Int32

Variate Int64

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Int64

uniformR :: Generator g m => (Int64, Int64) -> g -> m Int64

uniformB :: Generator g m => Int64 -> g -> m Int64

Variate Int8

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Int8

uniformR :: Generator g m => (Int8, Int8) -> g -> m Int8

uniformB :: Generator g m => Int8 -> g -> m Int8

Variate Word16

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Word16

uniformR :: Generator g m => (Word16, Word16) -> g -> m Word16

uniformB :: Generator g m => Word16 -> g -> m Word16

Variate Word32

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Word32

uniformR :: Generator g m => (Word32, Word32) -> g -> m Word32

uniformB :: Generator g m => Word32 -> g -> m Word32

Variate Word64

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Word64

uniformR :: Generator g m => (Word64, Word64) -> g -> m Word64

uniformB :: Generator g m => Word64 -> g -> m Word64

Variate Word8

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Word8

uniformR :: Generator g m => (Word8, Word8) -> g -> m Word8

uniformB :: Generator g m => Word8 -> g -> m Word8

Variate Bool

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Bool

uniformR :: Generator g m => (Bool, Bool) -> g -> m Bool

uniformB :: Generator g m => Bool -> g -> m Bool

Variate Double

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Double

uniformR :: Generator g m => (Double, Double) -> g -> m Double

uniformB :: Generator g m => Double -> g -> m Double

Variate Float

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Float

uniformR :: Generator g m => (Float, Float) -> g -> m Float

uniformB :: Generator g m => Float -> g -> m Float

Variate Int

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Int

uniformR :: Generator g m => (Int, Int) -> g -> m Int

uniformB :: Generator g m => Int -> g -> m Int

Variate Word

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m Word

uniformR :: Generator g m => (Word, Word) -> g -> m Word

uniformB :: Generator g m => Word -> g -> m Word

(Variate a, Variate b) => Variate (a, b)

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m (a, b)

uniformR :: Generator g m => ((a, b), (a, b)) -> g -> m (a, b)

uniformB :: Generator g m => (a, b) -> g -> m (a, b)

(Variate a, Variate b, Variate c) => Variate (a, b, c)

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m (a, b, c)

uniformR :: Generator g m => ((a, b, c), (a, b, c)) -> g -> m (a, b, c)

uniformB :: Generator g m => (a, b, c) -> g -> m (a, b, c)

(Variate a, Variate b, Variate c, Variate d) => Variate (a, b, c, d)

Defined in System.Random.PCG.Class

Methods

uniform :: Generator g m => g -> m (a, b, c, d)

uniformR :: Generator g m => ((a, b, c, d), (a, b, c, d)) -> g -> m (a, b, c, d)

uniformB :: Generator g m => (a, b, c, d) -> g -> m (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
3725702568
>>> create >>= \g -> replicateM_ 500 (uniformD g) >> uniformW32 g
3725702568
>>> create >>= \g -> advance 1000 g >> uniformW32 g
3725702568

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)
[2951688802,2698927131,361549788]
>>> create >>= \g -> retract 1 g >> replicateM 3 (uniformW32 g)
[954135925,2951688802,2698927131]

Seeds

data FrozenGen

Immutable state of a random number generator. Suitable for storing for later use.

Instances

Data FrozenGen

Defined in System.Random.PCG.Fast

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 :: forall r r'. (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

Storable FrozenGen

Defined in System.Random.PCG.Fast

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

Generic FrozenGen

Defined in System.Random.PCG.Fast

Associated Types

type Rep FrozenGen :: Type -> Type

Methods

from :: FrozenGen -> Rep FrozenGen x

to :: Rep FrozenGen x -> FrozenGen

Show FrozenGen

Defined in System.Random.PCG.Fast

Methods

showsPrec :: Int -> FrozenGen -> ShowS

show :: FrozenGen -> String

showList :: [FrozenGen] -> ShowS

Eq FrozenGen

Defined in System.Random.PCG.Fast

Methods

(==) :: FrozenGen -> FrozenGen -> Bool

(/=) :: FrozenGen -> FrozenGen -> Bool

Ord FrozenGen

Defined in System.Random.PCG.Fast

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

RandomGen FrozenGen

Defined in System.Random.PCG.Fast

Methods

next :: FrozenGen -> (Int, FrozenGen)

genWord8 :: FrozenGen -> (Word8, FrozenGen)

genWord16 :: FrozenGen -> (Word16, FrozenGen)

genWord32 :: FrozenGen -> (Word32, FrozenGen)

genWord64 :: FrozenGen -> (Word64, FrozenGen)

genWord32R :: Word32 -> FrozenGen -> (Word32, FrozenGen)

genWord64R :: Word64 -> FrozenGen -> (Word64, FrozenGen)

genShortByteString :: Int -> FrozenGen -> (ShortByteString, FrozenGen)

genRange :: FrozenGen -> (Int, Int)

split :: FrozenGen -> (FrozenGen, FrozenGen)

type Rep FrozenGen

Defined in System.Random.PCG.Fast

type Rep FrozenGen = D1 ('MetaData "FrozenGen" "System.Random.PCG.Fast" "pcg-random-0.1.4.0-inplace" 'True) (C1 ('MetaCons "FrozenGen" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Word64)))

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

Save the state of a Gen in a Seed.

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

Restore a Gen from a Seed.

seed :: FrozenGen

Standard initial seed.

initFrozen :: Word64 -> FrozenGen

Generate a new seed using single Word64.

>>> initFrozen 0
FrozenGen 1

Type restricted versions

uniform

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

uniformR

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

uniformB

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