Safe Haskell	Trustworthy
Language	Haskell2010

System.Random.SplitMix32

Contents

Generation
Initialisation

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

data SMGen
nextWord32 :: SMGen -> (Word32, SMGen)
nextWord64 :: SMGen -> (Word64, SMGen)
nextTwoWord32 :: SMGen -> (Word32, Word32, SMGen)
nextInt :: SMGen -> (Int, SMGen)
nextDouble :: SMGen -> (Double, SMGen)
nextFloat :: SMGen -> (Float, SMGen)
nextInteger :: Integer -> Integer -> SMGen -> (Integer, SMGen)
splitSMGen :: SMGen -> (SMGen, SMGen)
bitmaskWithRejection32 :: Word32 -> SMGen -> (Word32, SMGen)
bitmaskWithRejection32' :: Word32 -> SMGen -> (Word32, SMGen)
bitmaskWithRejection64 :: Word64 -> SMGen -> (Word64, SMGen)
bitmaskWithRejection64' :: Word64 -> SMGen -> (Word64, SMGen)
mkSMGen :: Word32 -> SMGen
initSMGen :: IO SMGen
newSMGen :: IO SMGen
seedSMGen :: Word32 -> Word32 -> SMGen
seedSMGen' :: (Word32, Word32) -> SMGen
unseedSMGen :: SMGen -> (Word32, Word32)

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

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' :: 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.