-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Haskell bindings to the PCG random number generator.
--   
--   PCG is a family of simple fast space-efficient statistically good
--   algorithms for random number generation. Unlike many general-purpose
--   RNGs, they are also hard to predict.
--   
--   This library implements bindings to the standard C implementation.
--   This includes the standard, unique, fast and single variants in the
--   pcg family. There is a pure implementation that can be used as a
--   generator with the random package as well as a faster primitive api
--   that includes functions for generating common types.
--   
--   The generators in this module are suitable for use in parallel but
--   make sure threads don't share the same generator or things will go
--   horribly wrong.
@package pcg-random
@version 0.1.3.5


-- | 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.
module System.Random.PCG.Class
class Monad m => Generator g m
uniform1 :: Generator g m => (Word32 -> a) -> g -> m a
uniform2 :: Generator g m => (Word32 -> Word32 -> a) -> g -> m a
uniform1B :: (Generator g m, Integral a) => (Word32 -> a) -> Word32 -> g -> m a
class Variate a

-- | Generate a uniformly distributed random vairate.
--   
--   <ul>
--   <li>Use entire range for integral types.</li>
--   <li>Use (0,1] range for floating types.</li>
--   </ul>
uniform :: (Variate a, Generator g m) => g -> m a

-- | Generate a uniformly distributed random vairate in the given range.
--   
--   <ul>
--   <li>Use inclusive range for integral types.</li>
--   <li>Use (a,b] range for floating types.</li>
--   </ul>
uniformR :: (Variate a, Generator g m) => (a, 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
--   <a>Word32</a> (4294967295). Behaviour is undefined for negative
--   bounds.
uniformB :: (Variate a, Generator g m) => a -> g -> m a
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
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
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
type family Unsigned a :: *
wordsTo64Bit :: Integral a => Word32 -> Word32 -> a
wordToBool :: Word32 -> Bool
wordToFloat :: Word32 -> Float
wordsToDouble :: Word32 -> Word32 -> Double

-- | Generate a random number using <a>System.Entropy</a>.
--   
--   Use RDRAND if available and XOR with <tt>/dev/urandom</tt> on Unix and
--   CryptAPI on Windows. This entropy is considered cryptographically
--   secure but not true entropy.
sysRandom :: IO Word64
instance System.Random.PCG.Class.Variate GHC.Int.Int8
instance System.Random.PCG.Class.Variate GHC.Int.Int16
instance System.Random.PCG.Class.Variate GHC.Int.Int32
instance System.Random.PCG.Class.Variate GHC.Int.Int64
instance System.Random.PCG.Class.Variate GHC.Word.Word8
instance System.Random.PCG.Class.Variate GHC.Word.Word16
instance System.Random.PCG.Class.Variate GHC.Word.Word32
instance System.Random.PCG.Class.Variate GHC.Word.Word64
instance System.Random.PCG.Class.Variate GHC.Types.Bool
instance System.Random.PCG.Class.Variate GHC.Types.Float
instance System.Random.PCG.Class.Variate GHC.Types.Double
instance System.Random.PCG.Class.Variate GHC.Types.Word
instance System.Random.PCG.Class.Variate GHC.Types.Int
instance (System.Random.PCG.Class.Variate a, System.Random.PCG.Class.Variate b) => System.Random.PCG.Class.Variate (a, b)
instance (System.Random.PCG.Class.Variate a, System.Random.PCG.Class.Variate b, System.Random.PCG.Class.Variate c) => System.Random.PCG.Class.Variate (a, b, c)
instance (System.Random.PCG.Class.Variate a, System.Random.PCG.Class.Variate b, System.Random.PCG.Class.Variate c, System.Random.PCG.Class.Variate d) => System.Random.PCG.Class.Variate (a, b, c, d)


-- | Standard PCG Random Number Generator with chosen streams. See
--   <a>http://www.pcg-random.org</a> for details.
--   
--   <pre>
--   import Control.Monad.ST
--   import System.Random.PCG
--   
--   three :: [Double]
--   three = runST $ do
--     g &lt;- create
--     a &lt;- uniform g
--     b &lt;- uniform g
--     c &lt;- uniform g
--     return [a,b,c]
--   </pre>
module System.Random.PCG

-- | State of the random number generator
data Gen s

-- | Type alias of <a>Gen</a> specialized to <a>IO</a>.
type GenIO = Gen RealWorld

-- | Type alias of <a>Gen</a> specialized to <a>ST</a>.
type GenST s = Gen s

-- | Create a <a>Gen</a> from a fixed initial <a>seed</a>.
create :: PrimMonad m => m (Gen (PrimState m))

-- | Seed a PRNG with data from the system's fast source of pseudo-random
--   numbers. All the caveats of <a>withSystemRandom</a> apply here as
--   well.
createSystemRandom :: IO GenIO

-- | Initialize a generator with two words.
--   
--   <pre>
--   &gt;&gt;&gt; initialize 0 0 &gt;&gt;= save
--   FrozenGen 6364136223846793006 1
--   </pre>
initialize :: PrimMonad m => Word64 -> Word64 -> m (Gen (PrimState m))

-- | Seed with system random number. (<tt>/dev/urandom</tt> on Unix-like
--   systems and CryptAPI on Windows).
withSystemRandom :: (GenIO -> IO a) -> IO a

-- | Run an action with a frozen generator, returning the result and the
--   new frozen generator.
withFrozen :: FrozenGen -> (forall s. Gen s -> ST s a) -> (a, FrozenGen)
class Variate a

-- | Generate a uniformly distributed random vairate.
--   
--   <ul>
--   <li>Use entire range for integral types.</li>
--   <li>Use (0,1] range for floating types.</li>
--   </ul>
uniform :: (Variate a, Generator g m) => g -> m a

-- | Generate a uniformly distributed random vairate in the given range.
--   
--   <ul>
--   <li>Use inclusive range for integral types.</li>
--   <li>Use (a,b] range for floating types.</li>
--   </ul>
uniformR :: (Variate a, Generator g m) => (a, 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
--   <a>Word32</a> (4294967295). Behaviour is undefined for negative
--   bounds.
uniformB :: (Variate a, Generator g m) => a -> g -> m a

-- | Advance the given generator n steps in log(n) time. (Note that a
--   "step" is a single random 32-bit (or less) <a>Variate</a>. Data types
--   such as <a>Double</a> or <a>Word64</a> require two "steps".)
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 1000 (uniformW32 g) &gt;&gt; uniformW32 g
--   3640764222
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 500 (uniformD g) &gt;&gt; uniformW32 g
--   3640764222
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; advance 1000 g &gt;&gt; uniformW32 g
--   3640764222
--   </pre>
advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()

-- | Retract the given generator n steps in log(2^64-n) time. This is just
--   <tt>advance (-n)</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM 3 (uniformW32 g)
--   [355248013,41705475,3406281715]
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; retract 1 g &gt;&gt; replicateM 3 (uniformW32 g)
--   [19683962,355248013,41705475]
--   </pre>
retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()

-- | Immutable snapshot of the state of a <a>Gen</a>.
data FrozenGen

-- | Save the state of a <a>Gen</a> in a <a>FrozenGen</a>.
save :: PrimMonad m => Gen (PrimState m) -> m FrozenGen

-- | Restore a <a>Gen</a> from a <a>FrozenGen</a>.
restore :: PrimMonad m => FrozenGen -> m (Gen (PrimState m))

-- | Fixed seed.
seed :: FrozenGen

-- | Generate a new seed using two <a>Word64</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; initFrozen 0 0
--   FrozenGen 6364136223846793006 1
--   </pre>
initFrozen :: Word64 -> Word64 -> FrozenGen
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
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
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
instance GHC.Classes.Ord (System.Random.PCG.Gen s)
instance GHC.Classes.Eq (System.Random.PCG.Gen s)
instance GHC.Generics.Generic System.Random.PCG.FrozenGen
instance Data.Data.Data System.Random.PCG.FrozenGen
instance GHC.Classes.Ord System.Random.PCG.FrozenGen
instance GHC.Classes.Eq System.Random.PCG.FrozenGen
instance GHC.Show.Show System.Random.PCG.FrozenGen
instance (Control.Monad.Primitive.PrimMonad m, s Data.Type.Equality.~ Control.Monad.Primitive.PrimState m) => System.Random.PCG.Class.Generator (System.Random.PCG.Gen s) m
instance Foreign.Storable.Storable System.Random.PCG.FrozenGen
instance System.Random.RandomGen System.Random.PCG.FrozenGen


-- | Fast variant of the PCG random number generator. This module performs
--   around 20% faster than the multiple streams version but produces
--   slightly lower quality (still good) random numbers.
--   
--   See <a>http://www.pcg-random.org</a> for details.
--   
--   <pre>
--   import Control.Monad.ST
--   import System.Random.PCG.Fast
--   
--   three :: [Double]
--   three = runST $ do
--     g &lt;- create
--     a &lt;- uniform g
--     b &lt;- uniform g
--     c &lt;- uniform g
--     return [a,b,c]
--   </pre>
module System.Random.PCG.Fast

-- | State of the random number generator
data Gen s
type GenIO = Gen RealWorld
type GenST = Gen

-- | Create a <a>Gen</a> from a fixed initial seed.
create :: PrimMonad m => m (Gen (PrimState m))

-- | Seed a PRNG with data from the system's fast source of pseudo-random
--   numbers. All the caveats of <a>withSystemRandom</a> apply here as
--   well.
createSystemRandom :: IO GenIO

-- | Initialize a generator a single word.
--   
--   <pre>
--   &gt;&gt;&gt; initialize 0 &gt;&gt;= save
--   FrozenGen 1
--   </pre>
initialize :: PrimMonad m => Word64 -> m (Gen (PrimState m))

-- | Seed with system random number. (<tt>/dev/urandom</tt> on Unix-like
--   systems and CryptAPI on Windows).
withSystemRandom :: (GenIO -> IO a) -> IO a

-- | Run an action with a frozen generator, returning the result and the
--   new frozen generator.
withFrozen :: FrozenGen -> (forall s. Gen s -> ST s a) -> (a, FrozenGen)
class Variate a

-- | Generate a uniformly distributed random vairate.
--   
--   <ul>
--   <li>Use entire range for integral types.</li>
--   <li>Use (0,1] range for floating types.</li>
--   </ul>
uniform :: (Variate a, Generator g m) => g -> m a

-- | Generate a uniformly distributed random vairate in the given range.
--   
--   <ul>
--   <li>Use inclusive range for integral types.</li>
--   <li>Use (a,b] range for floating types.</li>
--   </ul>
uniformR :: (Variate a, Generator g m) => (a, 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
--   <a>Word32</a> (4294967295). Behaviour is undefined for negative
--   bounds.
uniformB :: (Variate a, Generator g m) => a -> g -> m a

-- | Advance the given generator n steps in log(n) time. (Note that a
--   "step" is a single random 32-bit (or less) <a>Variate</a>. Data types
--   such as <a>Double</a> or <a>Word64</a> require two "steps".)
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 1000 (uniformW32 g) &gt;&gt; uniformW32 g
--   3725702568
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 500 (uniformD g) &gt;&gt; uniformW32 g
--   3725702568
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; advance 1000 g &gt;&gt; uniformW32 g
--   3725702568
--   </pre>
advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()

-- | Retract the given generator n steps in log(2^64-n) time. This is just
--   <tt>advance (-n)</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM 3 (uniformW32 g)
--   [2951688802,2698927131,361549788]
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; retract 1 g &gt;&gt; replicateM 3 (uniformW32 g)
--   [954135925,2951688802,2698927131]
--   </pre>
retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()

-- | Immutable state of a random number generator. Suitable for storing for
--   later use.
data FrozenGen

-- | Save the state of a <a>Gen</a> in a <tt>Seed</tt>.
save :: PrimMonad m => Gen (PrimState m) -> m FrozenGen

-- | Restore a <a>Gen</a> from a <tt>Seed</tt>.
restore :: PrimMonad m => FrozenGen -> m (Gen (PrimState m))

-- | Standard initial seed.
seed :: FrozenGen

-- | Generate a new seed using single <a>Word64</a>.
--   
--   <pre>
--   &gt;&gt;&gt; initFrozen 0
--   FrozenGen 1
--   </pre>
initFrozen :: Word64 -> FrozenGen
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
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
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
instance GHC.Classes.Ord (System.Random.PCG.Fast.Gen s)
instance GHC.Classes.Eq (System.Random.PCG.Fast.Gen s)
instance GHC.Generics.Generic System.Random.PCG.Fast.FrozenGen
instance Data.Data.Data System.Random.PCG.Fast.FrozenGen
instance Foreign.Storable.Storable System.Random.PCG.Fast.FrozenGen
instance GHC.Classes.Ord System.Random.PCG.Fast.FrozenGen
instance GHC.Classes.Eq System.Random.PCG.Fast.FrozenGen
instance GHC.Show.Show System.Random.PCG.Fast.FrozenGen
instance (Control.Monad.Primitive.PrimMonad m, s Data.Type.Equality.~ Control.Monad.Primitive.PrimState m) => System.Random.PCG.Class.Generator (System.Random.PCG.Fast.Gen s) m
instance System.Random.RandomGen System.Random.PCG.Fast.FrozenGen


-- | Experimental pure haskell version of the fast variant of the PCG
--   random number generator. This module can perform faster than the c
--   bindings version, especially for parallel code.
--   
--   See <a>http://www.pcg-random.org</a> for details.
--   
--   <pre>
--   import Control.Monad.ST
--   import System.Random.PCG.Fast.Pure
--   
--   three :: [Double]
--   three = runST $ do
--     g &lt;- create
--     a &lt;- uniform g
--     b &lt;- uniform g
--     c &lt;- uniform g
--     return [a,b,c]
--   </pre>
module System.Random.PCG.Fast.Pure

-- | State of the random number generator.
data Gen s
type GenIO = Gen RealWorld
type GenST = Gen

-- | Create a <a>Gen</a> from a fixed initial seed.
create :: PrimMonad m => m (Gen (PrimState m))

-- | Seed a PRNG with data from the system's fast source of pseudo-random
--   numbers. All the caveats of <a>withSystemRandom</a> apply here as
--   well.
createSystemRandom :: IO GenIO

-- | Initialize a generator a single word.
--   
--   <pre>
--   &gt;&gt;&gt; initialize 0 &gt;&gt;= save
--   FrozenGen 1
--   </pre>
initialize :: PrimMonad m => Word64 -> m (Gen (PrimState m))

-- | Seed with system random number. ("<tt>/dev/urandom</tt>" on Unix-like
--   systems, time otherwise).
withSystemRandom :: (GenIO -> IO a) -> IO a
class Variate a

-- | Generate a uniformly distributed random vairate.
--   
--   <ul>
--   <li>Use entire range for integral types.</li>
--   <li>Use (0,1] range for floating types.</li>
--   </ul>
uniform :: (Variate a, Generator g m) => g -> m a

-- | Generate a uniformly distributed random vairate in the given range.
--   
--   <ul>
--   <li>Use inclusive range for integral types.</li>
--   <li>Use (a,b] range for floating types.</li>
--   </ul>
uniformR :: (Variate a, Generator g m) => (a, 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
--   <a>Word32</a> (4294967295). Behaviour is undefined for negative
--   bounds.
uniformB :: (Variate a, Generator g m) => a -> g -> m a

-- | Advance the given generator n steps in log(n) time. (Note that a
--   "step" is a single random 32-bit (or less) <a>Variate</a>. Data types
--   such as <a>Double</a> or <a>Word64</a> require two "steps".)
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 1000 (uniformW32 g) &gt;&gt; uniformW32 g
--   3725702568
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 500 (uniformD g) &gt;&gt; uniformW32 g
--   3725702568
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; advance 1000 g &gt;&gt; uniformW32 g
--   3725702568
--   </pre>
advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()

-- | Retract the given generator n steps in log(2^64-n) time. This is just
--   <tt>advance (-n)</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM 3 (uniformW32 g)
--   [2951688802,2698927131,361549788]
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; retract 1 g &gt;&gt; replicateM 3 (uniformW32 g)
--   [954135925,2951688802,2698927131]
--   </pre>
retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()
data FrozenGen

-- | Save the state of a <a>Gen</a> in a <tt>Seed</tt>.
save :: PrimMonad m => Gen (PrimState m) -> m FrozenGen

-- | Restore a <a>Gen</a> from a <tt>Seed</tt>.
restore :: PrimMonad m => FrozenGen -> m (Gen (PrimState m))

-- | Standard initial seed.
seed :: FrozenGen

-- | Generate a new seed using single <a>Word64</a>.
--   
--   <pre>
--   &gt;&gt;&gt; initFrozen 0
--   FrozenGen 1
--   </pre>
initFrozen :: Word64 -> FrozenGen
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
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
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
instance GHC.Show.Show System.Random.PCG.Fast.Pure.Pair
instance GHC.Generics.Generic System.Random.PCG.Fast.Pure.FrozenGen
instance Data.Data.Data System.Random.PCG.Fast.Pure.FrozenGen
instance Data.Primitive.Types.Prim System.Random.PCG.Fast.Pure.FrozenGen
instance GHC.Classes.Ord System.Random.PCG.Fast.Pure.FrozenGen
instance GHC.Classes.Eq System.Random.PCG.Fast.Pure.FrozenGen
instance GHC.Show.Show System.Random.PCG.Fast.Pure.FrozenGen
instance (Control.Monad.Primitive.PrimMonad m, s Data.Type.Equality.~ Control.Monad.Primitive.PrimState m) => System.Random.PCG.Class.Generator (System.Random.PCG.Fast.Pure.Gen s) m
instance System.Random.RandomGen System.Random.PCG.Fast.Pure.FrozenGen


-- | Standard PCG Random Number Generator with chosen streams, written in
--   pure haskell. See <a>http://www.pcg-random.org</a> for details.
--   
--   <pre>
--   import Control.Monad.ST
--   import System.Random.PCG.Pure
--   
--   three :: [Double]
--   three = runST $ do
--     g &lt;- create
--     a &lt;- uniform g
--     b &lt;- uniform g
--     c &lt;- uniform g
--     return [a,b,c]
--   </pre>
module System.Random.PCG.Pure

-- | State of the random number generator
data Gen s
type GenIO = Gen RealWorld
type GenST = Gen

-- | Create a <a>Gen</a> from a fixed initial seed.
create :: PrimMonad m => m (Gen (PrimState m))

-- | Seed with system random number. (<tt>/dev/urandom</tt> on Unix-like
--   systems and CryptAPI on Windows).
createSystemRandom :: IO GenIO

-- | Initialize a generator a single word.
--   
--   <pre>
--   &gt;&gt;&gt; initialize 0 0 &gt;&gt;= save
--   SetSeq 6364136223846793006 1
--   </pre>
initialize :: PrimMonad m => Word64 -> Word64 -> m (Gen (PrimState m))

-- | Seed with system random number. (<tt>/dev/urandom</tt> on Unix-like
--   systems and CryptAPI on Windows).
withSystemRandom :: (GenIO -> IO a) -> IO a
class Variate a

-- | Generate a uniformly distributed random vairate.
--   
--   <ul>
--   <li>Use entire range for integral types.</li>
--   <li>Use (0,1] range for floating types.</li>
--   </ul>
uniform :: (Variate a, Generator g m) => g -> m a

-- | Generate a uniformly distributed random vairate in the given range.
--   
--   <ul>
--   <li>Use inclusive range for integral types.</li>
--   <li>Use (a,b] range for floating types.</li>
--   </ul>
uniformR :: (Variate a, Generator g m) => (a, 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
--   <a>Word32</a> (4294967295). Behaviour is undefined for negative
--   bounds.
uniformB :: (Variate a, Generator g m) => a -> g -> m a

-- | Advance the given generator n steps in log(n) time. (Note that a
--   "step" is a single random 32-bit (or less) <a>Variate</a>. Data types
--   such as <a>Double</a> or <a>Word64</a> require two "steps".)
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 1000 (uniformW32 g) &gt;&gt; uniformW32 g
--   3640764222
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 500 (uniformD g) &gt;&gt; uniformW32 g
--   3640764222
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; advance 1000 g &gt;&gt; uniformW32 g
--   3640764222
--   </pre>
advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()

-- | Retract the given generator n steps in log(2^64-n) time. This is just
--   <tt>advance (-n)</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM 3 (uniformW32 g)
--   [355248013,41705475,3406281715]
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; retract 1 g &gt;&gt; replicateM 3 (uniformW32 g)
--   [19683962,355248013,41705475]
--   </pre>
retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()
type FrozenGen = SetSeq

-- | Save the state of a <a>Gen</a> in a <tt>Seed</tt>.
save :: PrimMonad m => Gen (PrimState m) -> m SetSeq

-- | Restore a <a>Gen</a> from a <tt>Seed</tt>.
restore :: PrimMonad m => FrozenGen -> m (Gen (PrimState m))

-- | Fixed seed.
seed :: SetSeq

-- | Create a new generator from two words.
--   
--   <pre>
--   &gt;&gt;&gt; initFrozen 0 0
--   SetSeq 6364136223846793006 1
--   </pre>
initFrozen :: Word64 -> Word64 -> SetSeq
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
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
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

-- | The multiple sequence varient of the pcg random number generator.
data SetSeq

-- | Version of <a>next</a> that returns a <a>Word32</a>.
next' :: SetSeq -> (Word32, SetSeq)

-- | Pure version of <a>advance</a>.
advanceSetSeq :: Word64 -> FrozenGen -> FrozenGen
instance GHC.Generics.Generic System.Random.PCG.Pure.SetSeq
instance Data.Data.Data System.Random.PCG.Pure.SetSeq
instance GHC.Classes.Eq System.Random.PCG.Pure.SetSeq
instance GHC.Classes.Ord System.Random.PCG.Pure.SetSeq
instance GHC.Show.Show System.Random.PCG.Pure.SetSeq
instance (Control.Monad.Primitive.PrimMonad m, s Data.Type.Equality.~ Control.Monad.Primitive.PrimState m) => System.Random.PCG.Class.Generator (System.Random.PCG.Pure.Gen s) m
instance System.Random.RandomGen System.Random.PCG.Pure.FrozenGen
instance Foreign.Storable.Storable System.Random.PCG.Pure.SetSeq


-- | Single variant of the PCG random number generator. This module only
--   uses a single stream. See <a>http://www.pcg-random.org</a> for
--   details.
--   
--   <pre>
--   import Control.Monad.ST
--   import System.Random.PCG.Single
--   
--   three :: [Double]
--   three = runST $ do
--     g &lt;- create
--     a &lt;- uniform g
--     b &lt;- uniform g
--     c &lt;- uniform g
--     return [a,b,c]
--   </pre>
module System.Random.PCG.Single

-- | State of the random number generator
data Gen s
type GenIO = Gen RealWorld
type GenST = Gen

-- | Create a <a>Gen</a> from a fixed initial seed.
create :: PrimMonad m => m (Gen (PrimState m))

-- | Seed a PRNG with data from the system's fast source of pseudo-random
--   numbers. All the caveats of <a>withSystemRandom</a> apply here as
--   well.
createSystemRandom :: IO GenIO

-- | Initialize a generator a single word.
--   
--   <pre>
--   &gt;&gt;&gt; initialize 0 &gt;&gt;= save
--   FrozenGen 1876011003808476466
--   </pre>
initialize :: PrimMonad m => Word64 -> m (Gen (PrimState m))

-- | Seed with system random number. (<tt>/dev/urandom</tt> on Unix-like
--   systems and CryptAPI on Windows).
withSystemRandom :: (GenIO -> IO a) -> IO a

-- | Run an action with a frozen generator, returning the result and the
--   new frozen generator.
withFrozen :: FrozenGen -> (forall s. Gen s -> ST s a) -> (a, FrozenGen)
class Variate a

-- | Generate a uniformly distributed random vairate.
--   
--   <ul>
--   <li>Use entire range for integral types.</li>
--   <li>Use (0,1] range for floating types.</li>
--   </ul>
uniform :: (Variate a, Generator g m) => g -> m a

-- | Generate a uniformly distributed random vairate in the given range.
--   
--   <ul>
--   <li>Use inclusive range for integral types.</li>
--   <li>Use (a,b] range for floating types.</li>
--   </ul>
uniformR :: (Variate a, Generator g m) => (a, 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
--   <a>Word32</a> (4294967295). Behaviour is undefined for negative
--   bounds.
uniformB :: (Variate a, Generator g m) => a -> g -> m a

-- | Advance the given generator n steps in log(n) time. (Note that a
--   "step" is a single random 32-bit (or less) <a>Variate</a>. Data types
--   such as <a>Double</a> or <a>Word64</a> require two "steps".)
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 1000 (uniformW32 g) &gt;&gt; uniformW32 g
--   787992099
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM_ 500 (uniformD g) &gt;&gt; uniformW32 g
--   787992099
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; advance 1000 g &gt;&gt; uniformW32 g
--   787992099
--   </pre>
advance :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()

-- | Retract the given generator n steps in log(2^64-n) time. This is just
--   <tt>advance (-n)</tt>.
--   
--   <pre>
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; replicateM 3 (uniformW32 g)
--   [1499251125,2252584727,2021901712]
--   
--   &gt;&gt;&gt; create &gt;&gt;= \g -&gt; retract 1 g &gt;&gt; replicateM 3 (uniformW32 g)
--   [4031155981,1499251125,2252584727]
--   </pre>
retract :: PrimMonad m => Word64 -> Gen (PrimState m) -> m ()
data FrozenGen

-- | Save the state of a <a>Gen</a> in a <tt>Seed</tt>.
save :: PrimMonad m => Gen (PrimState m) -> m FrozenGen

-- | Restore a <a>Gen</a> from a <tt>Seed</tt>.
restore :: PrimMonad m => FrozenGen -> m (Gen (PrimState m))

-- | Standard initial seed.
seed :: FrozenGen

-- | Generate a new seed using single <a>Word64</a>.
--   
--   <pre>
--   &gt;&gt;&gt; initFrozen 0
--   FrozenGen 1876011003808476466
--   </pre>
initFrozen :: Word64 -> FrozenGen
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
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
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
instance GHC.Classes.Ord (System.Random.PCG.Single.Gen s)
instance GHC.Classes.Eq (System.Random.PCG.Single.Gen s)
instance GHC.Generics.Generic System.Random.PCG.Single.FrozenGen
instance Data.Data.Data System.Random.PCG.Single.FrozenGen
instance Foreign.Storable.Storable System.Random.PCG.Single.FrozenGen
instance GHC.Classes.Ord System.Random.PCG.Single.FrozenGen
instance GHC.Classes.Eq System.Random.PCG.Single.FrozenGen
instance GHC.Show.Show System.Random.PCG.Single.FrozenGen
instance (Control.Monad.Primitive.PrimMonad m, s Data.Type.Equality.~ Control.Monad.Primitive.PrimState m) => System.Random.PCG.Class.Generator (System.Random.PCG.Single.Gen s) m
instance System.Random.RandomGen System.Random.PCG.Single.FrozenGen


-- | Unique variant of the PCG random number generator. Guarantees the
--   sequence to be unique by using the pointer address to select the
--   output sequence.
--   
--   There is no way to freeze the state because then it wouldn't be unique
--   anymore. Also, generators can't be initialized in ST because we don't
--   know what pointer reference they'll get.
--   
--   See <a>http://www.pcg-random.org</a> for details.
--   
--   <pre>
--   import System.Random.PCG.Unique
--   
--   three :: IO [Double]
--   three = do
--     g &lt;- create
--     a &lt;- uniform g
--     b &lt;- uniform g
--     c &lt;- uniform g
--     return [a,b,c]
--   </pre>
module System.Random.PCG.Unique

-- | State of the random number generator
data Gen

-- | Create a <a>Gen</a> from a fixed initial seed.
create :: IO Gen

-- | Seed a PRNG with data from the system's fast source of pseudo-random
--   numbers. All the caveats of <a>withSystemRandom</a> apply here as
--   well.
createSystemRandom :: IO Gen

-- | Create a generator from two words. Note: this is not the same as the
--   two words in a <tt>Seed</tt>.
initialize :: Word64 -> IO Gen

-- | Seed with system random number. ("<tt>/dev/urandom</tt>" on Unix-like
--   systems, time otherwise).
withSystemRandom :: (Gen -> IO a) -> IO a
class Variate a

-- | Generate a uniformly distributed random vairate.
--   
--   <ul>
--   <li>Use entire range for integral types.</li>
--   <li>Use (0,1] range for floating types.</li>
--   </ul>
uniform :: (Variate a, Generator g m) => g -> m a

-- | Generate a uniformly distributed random vairate in the given range.
--   
--   <ul>
--   <li>Use inclusive range for integral types.</li>
--   <li>Use (a,b] range for floating types.</li>
--   </ul>
uniformR :: (Variate a, Generator g m) => (a, 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
--   <a>Word32</a> (4294967295). Behaviour is undefined for negative
--   bounds.
uniformB :: (Variate a, Generator g m) => a -> g -> m a

-- | Advance the given generator n steps in log(n) time.
advance :: Word64 -> Gen -> IO ()

-- | Retract the given generator n steps in log(2^64-n) time. This is just
--   <tt>advance (-n)</tt>.
retract :: Word64 -> Gen -> IO ()
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
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
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
instance GHC.Classes.Ord System.Random.PCG.Unique.Gen
instance GHC.Classes.Eq System.Random.PCG.Unique.Gen
instance System.Random.PCG.Class.Generator System.Random.PCG.Unique.Gen GHC.Types.IO
