splitmix-0.1.0.4: Fast Splittable PRNG
Safe Haskell Trustworthy
Language Haskell2010

System.Random.SplitMix32

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

Instances details
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 Source #

readList :: ReadS [ SMGen ] Source #

readPrec :: ReadPrec SMGen Source #

readListPrec :: ReadPrec [ SMGen ] Source #

Show SMGen Source #
Instance details

Defined in System.Random.SplitMix32

Methods

showsPrec :: Int -> SMGen -> ShowS Source #

show :: SMGen -> String Source #

showList :: [ SMGen ] -> ShowS Source #

NFData SMGen Source #
Instance details

Defined in System.Random.SplitMix32

Methods

rnf :: SMGen -> () Source #

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 Word32 s.

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

nextInteger :: Integer -> Integer -> SMGen -> ( Integer , SMGen ) Source #

Generate an Integer in closed [x, y] range.

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 w32 generates random numbers in closed-open range of [0, w32) .

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

Bitmask with rejection method of generating subrange of Word32 .

bitmaskWithRejection32' w32 generates random numbers in closed-closed range of [0, w32] .

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 entropy available on the 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 .