splitmix-0.1.0.3: Fast Splittable PRNG

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 #

SplitMix generator state.

#### Instances

Instances details

Read SMGen # |
    >>> 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 # |
Instance details Defined in System.Random.SplitMix32 Methods showsPrec :: Int -> SMGen -> ShowS # show :: SMGen -> String # showList :: [SMGen] -> ShowS #
NFData SMGen # |
Instance details Defined in System.Random.SplitMix32 Methods rnf :: SMGen -> () #

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

Generate a `Word32`.

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

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

Generate a `Word64`, by generating to `Word32`s.

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

Generate two `Word32`.

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

Generate an `Int`.

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

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

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

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

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

Split a generator into a two uncorrelated generators.

# Generation

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

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

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

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

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 #

Preferred way to deterministically construct `SMGen`.

    >>> mkSMGen 42
    SMGen 142593372 1604540297

initSMGen :: IO SMGen #

Initialize `SMGen` using entropy available on the system (time, ...)

newSMGen :: IO SMGen #

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

seedSMGen #

Arguments

:: Word32 | seed
-> Word32 | gamma
-> SMGen |

Create `SMGen` using seed and gamma.

    >>> seedSMGen 2 2
    SMGen 2 3

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

Like `seedSMGen` but takes a pair.

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

Extract current state of `SMGen`.