System.Random.PCG.Class

Classes for working with random numbers along with utility functions. In a future release this module may disappear and use another module for this functionality.

Classes

class Monad m => Generator g m where

Methods

uniform1 :: (Word32 -> a) -> g -> m a

uniform2 :: (Word32 -> Word32 -> a) -> g -> m a

uniform1B :: Integral a => (Word32 -> a) -> Word32 -> g -> m a

Instances

Generator Gen IO

Methods

uniform1 :: (Word32 -> a) -> Gen -> IO a

uniform2 :: (Word32 -> Word32 -> a) -> Gen -> IO a

uniform1B :: Integral a => (Word32 -> a) -> Word32 -> Gen -> IO a

(PrimMonad m, (~) * s (PrimState m)) => Generator (Gen s) m

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

(PrimMonad m, (~) * s (PrimState m)) => Generator (Gen s) m

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

(PrimMonad m, (~) * s (PrimState m)) => Generator (Gen s) m

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

(PrimMonad m, (~) * s (PrimState m)) => Generator (Gen s) m

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

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 Bool

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

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

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

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 Int8

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 Int16

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

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

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 Word

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 Word8

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 Word16

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

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

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 a, Variate b) => Variate (a, b)

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)

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)

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)

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

Utilities

type family Unsigned a :: *

Instances

type Unsigned Int = Word

type Unsigned Int8 = Word8

type Unsigned Int16 = Word16

type Unsigned Int32 = Word32

type Unsigned Int64 = Word64

type Unsigned Word = Word

type Unsigned Word8 = Word8

type Unsigned Word16 = Word16

type Unsigned Word32 = Word32

type Unsigned Word64 = Word64

wordsTo64Bit :: Integral a => Word32 -> Word32 -> a

wordToBool :: Word32 -> Bool

wordToFloat :: Word32 -> Float

wordsToDouble :: Word32 -> Word32 -> Double

sysRandom :: IO Word64

Generate a random number using System.Entropy.

Use RDRAND if available and XOR with /dev/urandom on Unix and CryptAPI on Windows. This entropy is considered cryptographically secure but not true entropy.