splitmix-0.0.4: Fast Splittable PRNG

Safe HaskellTrustworthy
LanguageHaskell2010

System.Random.SplitMix32

Contents

Description

SplitMix is a splittable pseudorandom number generator (PRNG) that is quite fast.

This is 32bit variant (original one is 32 bit).

You really don't want to use this one.

Note: This module supports all GHCs since GHC-7.0.4, but GHC-7.0 and GHC-7.2 have slow implementation, as there are no native popCount.

Synopsis

Documentation

data SMGen Source #

SplitMix generator state.

Instances
Read SMGen Source #
>>> readMaybe "SMGen 1 1" :: Maybe SMGen
Just (SMGen 1 1)

>>> readMaybe "SMGen 1 2" :: Maybe SMGen
Nothing

>>> readMaybe (show (mkSMGen 42)) :: Maybe SMGen
Just (SMGen 142593372 1604540297)
Instance details

Defined in System.Random.SplitMix32

Methods

readsPrec :: Int -> ReadS SMGen #

readList :: ReadS [SMGen] #

readPrec :: ReadPrec SMGen #

readListPrec :: ReadPrec [SMGen] #

Show SMGen Source # 
Instance details

Defined in System.Random.SplitMix32

Methods

showsPrec :: Int -> SMGen -> ShowS #

show :: SMGen -> String #

showList :: [SMGen] -> ShowS #

NFData SMGen Source # 
Instance details

Defined in System.Random.SplitMix32

Methods

rnf :: SMGen -> () #

RandomGen SMGen Source # 
Instance details

Defined in System.Random.SplitMix32

Methods

next :: SMGen -> (Int, SMGen) #

genRange :: SMGen -> (Int, Int) #

split :: SMGen -> (SMGen, SMGen) #

nextWord32 :: SMGen -> (Word32, SMGen) Source #

Generate a Word32.

>>> take 3 $ map (printf "%x") $ unfoldr (Just . nextWord32) (mkSMGen 1337) :: [String]
["e0cfe722","a6ced0f0","c3a6d889"]

nextWord64 :: SMGen -> (Word64, SMGen) Source #

Generate a Word64, by generating to Word32s.

nextTwoWord32 :: SMGen -> (Word32, Word32, SMGen) Source #

Generate two Word32.

nextInt :: SMGen -> (Int, SMGen) Source #

Generate an Int.

nextDouble :: SMGen -> (Double, SMGen) Source #

Generate a Double in [0, 1) range.

>>> take 8 $ map (printf "%0.3f") $ unfoldr (Just . nextDouble) (mkSMGen 1337) :: [String]
["0.878","0.764","0.063","0.845","0.262","0.490","0.176","0.544"]

nextFloat :: SMGen -> (Float, SMGen) Source #

Generate a Float in [0, 1) range.

>>> take 8 $ map (printf "%0.3f") $ unfoldr (Just . nextFloat) (mkSMGen 1337) :: [String]
["0.878","0.652","0.764","0.631","0.063","0.180","0.845","0.645"]

splitSMGen :: SMGen -> (SMGen, SMGen) Source #

Split a generator into a two uncorrelated generators.

Generation

bitmaskWithRejection32 :: Word32 -> SMGen -> (Word32, SMGen) Source #

Bitmask with rejection method of generating subrange of Word32.

bitmaskWithRejection32' :: Word32 -> SMGen -> (Word32, SMGen) Source #

Bitmask with rejection method of generating subrange of Word32.

Since: 0.0.4

bitmaskWithRejection64 :: Word64 -> SMGen -> (Word64, SMGen) Source #

Bitmask with rejection method of generating subrange of Word64.

bitmaskWithRejection64 w64 generates random numbers in closed-open range of [0, w64).

>>> take 20 $ unfoldr (Just . bitmaskWithRejection64 5) (mkSMGen 1337)
[0,2,4,2,1,4,2,4,2,2,3,0,3,2,2,2,3,1,2,2]

bitmaskWithRejection64' :: Word64 -> SMGen -> (Word64, SMGen) Source #

Bitmask with rejection method of generating subrange of Word64.

bitmaskWithRejection64' w64 generates random numbers in closed-closed range of [0, w64].

>>> take 20 $ unfoldr (Just . bitmaskWithRejection64' 5) (mkSMGen 1337)
[0,2,4,2,1,4,2,4,5,5,2,2,5,3,5,0,3,2,2,2]

Since: 0.0.4

Initialisation

mkSMGen :: Word32 -> SMGen Source #

Preferred way to deterministically construct SMGen.

>>> mkSMGen 42
SMGen 142593372 1604540297

initSMGen :: IO SMGen Source #

Initialize SMGen using system time.

newSMGen :: IO SMGen Source #

Derive a new generator instance from the global SMGen using splitSMGen.

seedSMGen Source #

Arguments

:: Word32

seed

-> Word32

gamma

-> SMGen 

Create SMGen using seed and gamma.

>>> seedSMGen 2 2
SMGen 2 3

seedSMGen' :: (Word32, Word32) -> SMGen Source #

Like seedSMGen but takes a pair.

unseedSMGen :: SMGen -> (Word32, Word32) Source #

Extract current state of SMGen.