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


-- | Random number generation
--   
--   Random number generation based on orthogonal typeclasses for entropy
--   sources and random variable distributions, all served up on a monadic
--   platter. Aspires to be useful in an idiomatic way in both "pure" and
--   "impure" styles, as well as reasonably fast.
@package random-fu
@version 0.0.3

module Data.Random.Lift

-- | A class for "liftable" data structures. Conceptually an extension of
--   <a>MonadTrans</a> to allow deep lifting, but lifting need not be done
--   between monads only. Eg lifting between Applicatives is allowed.
--   
--   For instances where m and n have 'return'/'pure' defined, these
--   instances must satisfy <tt>lift (return x) == return x</tt>.
class Lift m n
lift :: (Lift m n) => m a -> n a
instance [incoherent] (Monad m) => Lift Identity m
instance [incoherent] Lift m m
instance [incoherent] (Monad m, MonadTrans t) => Lift m (t m)


-- | A few little functions I found myself writing inline over and over
--   again.
module Data.Random.Internal.Words
buildWord :: Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word64

-- | Pack 23 unspecified bits from a <a>Word64</a> into a <a>Float</a> in
--   the range [0,1). Used to convert a stdUniform <a>Word64</a> to a
--   stdUniform <a>Double</a>.
wordToFloat :: Word64 -> Float

-- | Same as wordToFloat, but also return the unused bits (as the 41 least
--   significant bits of a <a>Word64</a>)
wordToFloatWithExcess :: Word64 -> (Float, Word64)

-- | Pack 52 unspecified bits from a <a>Word64</a> into a <a>Double</a> in
--   the range [0,1). Used to convert a stdUniform <a>Word64</a> to a
--   stdUniform <a>Double</a>.
wordToDouble :: Word64 -> Double

-- | Same as wordToDouble, but also return the unused bits (as the 12 least
--   significant bits of a <a>Word64</a>)
wordToDoubleWithExcess :: Word64 -> (Double, Word64)

module Data.Random.Source

-- | A typeclass for monads with a chosen source of entropy. For example,
--   RVar is such a monad - the source from which it is (eventually)
--   sampled is the only source from which a random variable is permitted
--   to draw, so when directly requesting entropy for a random variable
--   these functions are used.
--   
--   The minimal definition is either <a>getRandomByte</a> or
--   <a>getRandomWord</a>. <a>getRandomDouble</a> is defaulted in terms of
--   <a>getRandomWord</a>.
class (Monad m) => MonadRandom m
getRandomByte :: (MonadRandom m) => m Word8
getRandomWord :: (MonadRandom m) => m Word64
getRandomDouble :: (MonadRandom m) => m Double

-- | A source of entropy which can be used in the given monad.
--   
--   The minimal definition is either <a>getRandomByteFrom</a> or
--   <a>getRandomWordFrom</a>. <a>getRandomDoubleFrom</a> is defaulted in
--   terms of <a>getRandomWordFrom</a>
class (Monad m) => RandomSource m s
getRandomByteFrom :: (RandomSource m s) => s -> m Word8
getRandomWordFrom :: (RandomSource m s) => s -> m Word64
getRandomDoubleFrom :: (RandomSource m s) => s -> m Double
instance (Monad m) => RandomSource m (m Word64)
instance (Monad m) => RandomSource m (m Word8)


-- | Random variables. An <a>RVar</a> is a sampleable random variable.
--   Because probability distributions form a monad, they are quite easy to
--   work with in the standard Haskell monadic styles. For examples, see
--   the source for any of the Distribution instances - they all are
--   defined in terms of <a>RVar</a>s.
module Data.Random.RVar

-- | An opaque type containing a "random variable" - a value which depends
--   on the outcome of some random process.
type RVar = RVarT Identity
runRVar :: (RandomSource m s) => RVar a -> s -> m a

-- | A random variable with access to operations in an underlying monad.
--   Useful examples include any form of state for implementing random
--   processes with hysteresis, or writer monads for implementing tracing
--   of complicated algorithms.
data RVarT n a

-- | "Runs" the monad.
runRVarT :: (Lift n m, RandomSource m s) => RVarT n a -> s -> m a

-- | A random variable evenly distributed over all unsigned integers from 0
--   to 2^(8*n)-1, inclusive.
nByteInteger :: Int -> RVarT m Integer

-- | A random variable evenly distributed over all unsigned integers from 0
--   to 2^n-1, inclusive.
nBitInteger :: Int -> RVarT m Integer
instance MonadRandom (RVarT n)
instance (MonadIO m) => MonadIO (RVarT m)
instance Lift (RVarT Identity) (RVarT m)
instance MonadTrans RVarT
instance Applicative (RVarT n)
instance Monad (RVarT n)
instance Functor (RVarT n)

module Data.Random.Source.DevRandom

-- | On systems that have it, /dev/random is a handy-dandy ready-to-use
--   source of nonsense. Keep in mind that on some systems, Linux included,
--   /dev/random collects "real" entropy, and if you don't have a good
--   source of it, such as special hardware for the purpose or a *lot* of
--   network traffic, it's pretty easy to suck the entropy pool dry with
--   entropy-intensive applications. For many purposes other than
--   cryptography, /dev/urandom is preferable because when it runs out of
--   real entropy it'll still churn out pseudorandom data.
data DevRandom
DevRandom :: DevRandom
DevURandom :: DevRandom
instance RandomSource IO DevRandom

module Data.Random.Source.Std

-- | A token representing the "standard" entropy source in a
--   <a>MonadRandom</a> monad. Its sole purpose is to make the following
--   true (when the types check):
--   
--   <pre>
--   sampleFrom StdRandom === sample
--   </pre>
data StdRandom
StdRandom :: StdRandom
instance (MonadRandom m) => RandomSource m StdRandom

module Data.Random.Source.PureMT

-- | Given a mutable reference to a <a>PureMT</a> generator, we can make a
--   <a>RandomSource</a> usable in any monad in which the reference can be
--   modified.
--   
--   For example, if <tt>x :: TVar PureMT</tt>, <tt>getRandomWordFromMTRef
--   x</tt> can be used as a <a>RandomSource</a> in <a>IO</a>, <a>STM</a>,
--   or any monad which is an instance of <a>MonadIO</a>. These functions
--   can also be used to implement additional <a>RandomSource</a> instances
--   for mutable references to <a>PureMT</a> states.
getRandomWordFromMTRef :: (ModifyRef sr m PureMT) => sr -> m Word64
getRandomByteFromMTRef :: (Monad m, ModifyRef sr m PureMT) => sr -> m Word8
getRandomDoubleFromMTRef :: (Monad m, ModifyRef sr m PureMT) => sr -> m Double

-- | Similarly, <tt>getRandomWordFromMTState x</tt> can be used in any
--   "state" monad in the mtl sense whose state is a <a>PureMT</a>
--   generator. Additionally, the standard mtl state monads have
--   <a>MonadRandom</a> instances which do precisely that, allowing an easy
--   conversion of RVars and other Distribution instances to "pure" random
--   variables (e.g., by <tt>runState . sample :: Distribution d t =&gt; d
--   t -&gt; PureMT -&gt; (t, PureMT)</tt>. <a>PureMT</a> in the type there
--   can be replaced by StdGen or anything else satisfying <tt>MonadRandom
--   (State s) =&gt; s</tt>).
getRandomWordFromMTState :: (MonadState PureMT m) => m Word64
getRandomByteFromMTState :: (MonadState PureMT m) => m Word8
getRandomDoubleFromMTState :: (MonadState PureMT m) => m Double
instance (Monad m, ModifyRef (TVar PureMT) m PureMT) => RandomSource m (TVar PureMT)
instance (Monad m, ModifyRef (STRef s PureMT) m PureMT) => RandomSource m (STRef s PureMT)
instance (Monad m, ModifyRef (IORef PureMT) m PureMT) => RandomSource m (IORef PureMT)
instance (Monad m) => MonadRandom (StateT PureMT m)
instance (Monad m) => MonadRandom (StateT PureMT m)
instance (Monad m1, ModifyRef (Ref m2 PureMT) m1 PureMT) => RandomSource m1 (Ref m2 PureMT)
instance MonadRandom (State PureMT)
instance MonadRandom (State PureMT)

module Data.Random.Source.StdGen
getRandomByteFromStdGenIO :: IO Word8
getRandomWordFromStdGenIO :: IO Word64
getRandomDoubleFromStdGenIO :: IO Double

-- | Given a mutable reference to a <a>RandomGen</a> generator, we can make
--   a <a>RandomSource</a> usable in any monad in which the reference can
--   be modified.
--   
--   For example, if <tt>x :: TVar StdGen</tt>,
--   <tt>getRandomByteFromRandomGenRef x</tt> can be used as a
--   <a>RandomSource</a> in <a>IO</a>, <a>STM</a>, or any monad which is an
--   instance of <a>MonadIO</a>. It's generally probably better to use
--   <a>getRandomWordFromRandomGenRef</a> though, as this one is likely to
--   throw away a lot of perfectly good entropy. Better still is to use
--   these 3 functions together to create a <a>RandomSource</a> instance
--   for the reference you're using, if one does not already exist.
getRandomByteFromRandomGenRef :: (Monad m, ModifyRef sr m g, RandomGen g) => sr -> m Word8
getRandomWordFromRandomGenRef :: (Monad m, ModifyRef sr m g, RandomGen g) => sr -> m Word64
getRandomDoubleFromRandomGenRef :: (Monad m, ModifyRef sr m g, RandomGen g) => sr -> m Double

-- | Similarly, <tt>getRandomWordFromRandomGenState x</tt> can be used in
--   any "state" monad in the mtl sense whose state is a <a>RandomGen</a>
--   generator. Additionally, the standard mtl state monads have
--   <a>MonadRandom</a> instances which do precisely that, allowing an easy
--   conversion of RVars and other Distribution instances to "pure" random
--   variables.
getRandomByteFromRandomGenState :: (RandomGen g, MonadState g m) => m Word8
getRandomWordFromRandomGenState :: (RandomGen g, MonadState g m) => m Word64
getRandomDoubleFromRandomGenState :: (RandomGen g, MonadState g m) => m Double
instance (Monad m) => MonadRandom (StateT StdGen m)
instance MonadRandom (State StdGen)
instance (Monad m) => MonadRandom (StateT StdGen m)
instance MonadRandom (State StdGen)
instance (Monad m, ModifyRef (STRef s StdGen) m StdGen) => RandomSource m (STRef s StdGen)
instance (Monad m, ModifyRef (TVar StdGen) m StdGen) => RandomSource m (TVar StdGen)
instance (Monad m, ModifyRef (IORef StdGen) m StdGen) => RandomSource m (IORef StdGen)
instance (Monad m1, ModifyRef (Ref m2 StdGen) m1 StdGen) => RandomSource m1 (Ref m2 StdGen)

module Data.Random.Internal.TH
replaceName :: Name -> Name -> Name -> Name

module Data.Random.Internal.Fixed
resolutionOf :: (HasResolution r) => f r -> Integer
resolutionOf2 :: (HasResolution r) => f (g r) -> Integer
mkFixed :: Integer -> Fixed r
unMkFixed :: Fixed r -> Integer

module Data.Random.Internal.Find
findMax :: (Fractional a, Ord a) => (a -> Bool) -> a
findMaxFrom :: (Fractional a, Ord a) => a -> a -> (a -> Bool) -> a

-- | Given an upward-closed predicate on an ordered Fractional type, find
--   the smallest value satisfying the predicate.
findMin :: (Fractional a, Ord a) => (a -> Bool) -> a
findMinFrom :: (Fractional a, Ord a) => a -> a -> (a -> Bool) -> a

module Data.Random.Distribution

-- | A definition of a random variable's distribution. From the
--   distribution an <a>RVar</a> can be created, or the distribution can be
--   directly sampled using sampleFrom or sample.
class Distribution d t
rvar :: (Distribution d t) => d t -> RVar t
class (Distribution d t) => CDF d t
cdf :: (CDF d t) => d t -> t -> Double

-- | Return a random variable with the given distribution, pre-lifted to an
--   arbitrary <a>RVarT</a>. Any arbitrary <a>RVar</a> can also be
--   converted to an 'RVarT m' for an arbitrary m, using either <a>lift</a>
--   or sample.
rvarT :: (Distribution d t) => d t -> RVarT n t

module Data.Random.Distribution.Uniform
data Uniform t
Uniform :: !t -> !t -> Uniform t
uniform :: (Distribution Uniform a) => a -> a -> RVar a
data StdUniform t
StdUniform :: StdUniform t

-- | Get a "standard" uniformly distributed value. For integral types, this
--   means uniformly distributed over the full range of the type (and hence
--   there is no support for Integer). For fractional types, this means
--   uniformly distributed on the interval [0,1).
stdUniform :: (Distribution StdUniform a) => RVar a
integralUniform :: (Integral a) => a -> a -> RVar a
realFloatUniform :: (RealFloat a) => a -> a -> RVar a
floatUniform :: Float -> Float -> RVar Float
doubleUniform :: Double -> Double -> RVar Double
fixedUniform :: (HasResolution r) => Fixed r -> Fixed r -> RVar (Fixed r)
boundedStdUniform :: (Distribution Uniform a, Bounded a) => RVar a
boundedEnumStdUniform :: (Enum a, Bounded a) => RVar a
realFloatStdUniform :: (RealFloat a) => RVar a
fixedStdUniform :: (HasResolution r) => RVar (Fixed r)
floatStdUniform :: RVar Float
doubleStdUniform :: RVar Double
realStdUniformCDF :: (Real a) => a -> Double
realUniformCDF :: (Real a) => a -> a -> a -> Double
instance CDF StdUniform Ordering
instance Distribution StdUniform Ordering
instance CDF StdUniform Char
instance Distribution StdUniform Char
instance CDF StdUniform Bool
instance Distribution StdUniform Bool
instance CDF StdUniform ()
instance Distribution StdUniform ()
instance CDF Uniform Ordering
instance Distribution Uniform Ordering
instance CDF Uniform Bool
instance Distribution Uniform Bool
instance CDF Uniform Char
instance Distribution Uniform Char
instance CDF Uniform ()
instance Distribution Uniform ()
instance (HasResolution r) => CDF StdUniform (Fixed r)
instance (HasResolution r) => Distribution StdUniform (Fixed r)
instance (HasResolution r) => CDF Uniform (Fixed r)
instance (HasResolution r) => Distribution Uniform (Fixed r)
instance CDF StdUniform Double
instance CDF StdUniform Float
instance Distribution StdUniform Double
instance Distribution StdUniform Float
instance CDF Uniform Double
instance CDF Uniform Float
instance Distribution Uniform Double
instance Distribution Uniform Float
instance CDF StdUniform Word64
instance CDF StdUniform Word32
instance CDF StdUniform Word16
instance CDF StdUniform Word8
instance CDF StdUniform Int64
instance CDF StdUniform Int32
instance CDF StdUniform Int16
instance CDF StdUniform Int8
instance CDF StdUniform Int
instance Distribution StdUniform Word32
instance Distribution StdUniform Word16
instance Distribution StdUniform Int64
instance Distribution StdUniform Int32
instance Distribution StdUniform Int16
instance Distribution StdUniform Int
instance Distribution StdUniform Word64
instance Distribution StdUniform Word8
instance Distribution StdUniform Int8
instance CDF Uniform Word64
instance Distribution Uniform Word64
instance CDF Uniform Word32
instance Distribution Uniform Word32
instance CDF Uniform Word16
instance Distribution Uniform Word16
instance CDF Uniform Word8
instance Distribution Uniform Word8
instance CDF Uniform Int64
instance Distribution Uniform Int64
instance CDF Uniform Int32
instance Distribution Uniform Int32
instance CDF Uniform Int16
instance Distribution Uniform Int16
instance CDF Uniform Int8
instance Distribution Uniform Int8
instance CDF Uniform Integer
instance Distribution Uniform Integer
instance CDF Uniform Int
instance Distribution Uniform Int

module Data.Random.Distribution.Bernoulli

-- | Generate a Bernoulli variate with the given probability. For
--   <tt>Bool</tt> results, <tt>bernoulli p</tt> will return True (p*100)%
--   of the time and False otherwise. For numerical types, True is replaced
--   by 1 and False by 0.
bernoulli :: (Distribution (Bernoulli b) a) => b -> RVar a

-- | A random variable whose value is <a>True</a> the given fraction of the
--   time and <a>False</a> the rest.
boolBernoulli :: (Fractional a, Ord a, Distribution StdUniform a) => a -> RVar Bool
boolBernoulliCDF :: (Real a) => a -> Bool -> Double

-- | <tt>generalBernoulli t f p</tt> generates a random variable whose
--   value is <tt>t</tt> with probability <tt>p</tt> and <tt>f</tt> with
--   probability <tt>1-p</tt>.
generalBernoulli :: (Distribution (Bernoulli b) Bool) => a -> a -> b -> RVar a
generalBernoulliCDF :: (CDF (Bernoulli b) Bool) => (a -> a -> Bool) -> a -> a -> b -> a -> Double
data Bernoulli b a
Bernoulli :: b -> Bernoulli b a
instance (CDF (Bernoulli b) Bool, RealFloat a) => CDF (Bernoulli b) (Complex a)
instance (Distribution (Bernoulli b) Bool, RealFloat a) => Distribution (Bernoulli b) (Complex a)
instance (CDF (Bernoulli b) Bool, Integral a) => CDF (Bernoulli b) (Ratio a)
instance (Distribution (Bernoulli b) Bool, Integral a) => Distribution (Bernoulli b) (Ratio a)
instance (CDF (Bernoulli b[akQG]) Bool) => CDF (Bernoulli b[akQG]) Double
instance (Distribution (Bernoulli b[akQE]) Bool) => Distribution (Bernoulli b[akQE]) Double
instance (CDF (Bernoulli b[akQG]) Bool) => CDF (Bernoulli b[akQG]) Float
instance (Distribution (Bernoulli b[akQE]) Bool) => Distribution (Bernoulli b[akQE]) Float
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Word64
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Word64
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Word32
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Word32
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Word16
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Word16
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Word8
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Word8
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Int64
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Int64
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Int32
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Int32
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Int16
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Int16
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Int8
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Int8
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Integer
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Integer
instance (CDF (Bernoulli b[akz4]) Bool) => CDF (Bernoulli b[akz4]) Int
instance (Distribution (Bernoulli b[akz2]) Bool) => Distribution (Bernoulli b[akz2]) Int
instance (Distribution (Bernoulli b) Bool, Real b) => CDF (Bernoulli b) Bool
instance (Fractional b, Ord b, Distribution StdUniform b) => Distribution (Bernoulli b) Bool

module Data.Random.Distribution.Exponential
data Exponential a
Exp :: a -> Exponential a
floatingExponential :: (Floating a, Distribution StdUniform a) => a -> RVar a
floatingExponentialCDF :: (Real a) => a -> a -> Double
exponential :: (Distribution Exponential a) => a -> RVar a
instance (Real a, Distribution Exponential a) => CDF Exponential a
instance (Floating a, Distribution StdUniform a) => Distribution Exponential a

module Data.Random.Distribution.Rayleigh
floatingRayleigh :: (Floating a, Distribution StdUniform a) => a -> RVar a
newtype Rayleigh a
Rayleigh :: a -> Rayleigh a
rayleigh :: (Distribution Rayleigh a) => a -> RVar a
rayleighCDF :: (Real a) => a -> a -> Double
instance (Real a, Distribution Rayleigh a) => CDF Rayleigh a
instance (RealFloat a, Distribution StdUniform a) => Distribution Rayleigh a

module Data.Random.Distribution.Triangular
data Triangular a
Triangular :: a -> a -> a -> Triangular a
triLower :: Triangular a -> a
triMid :: Triangular a -> a
triUpper :: Triangular a -> a
realFloatTriangular :: (Floating a, Ord a, Distribution StdUniform a) => a -> a -> a -> RVar a
realFloatTriangularCDF :: (RealFrac a) => a -> a -> a -> a -> Double
instance (Eq a) => Eq (Triangular a)
instance (Show a) => Show (Triangular a)
instance (RealFrac a, Distribution Triangular a) => CDF Triangular a
instance (RealFloat a, Ord a, Distribution StdUniform a) => Distribution Triangular a

module Data.Random.List
randomElement :: [a] -> RVar a
shuffle :: [a] -> RVar [a]
shuffleN :: Int -> [a] -> RVar [a]

module Data.Random.Distribution.Discrete
discrete :: (Distribution (Discrete p) a) => [(p, a)] -> RVar a
empirical :: (Num p, Ord a) => [a] -> Discrete p a
newtype Discrete p a
Discrete :: [(p, a)] -> Discrete p a

-- | Like <a>fmap</a>, but for the weights of a discrete distribution.
mapDiscreteWeights :: (p -> q) -> Discrete p e -> Discrete q e

-- | Adjust all the weights of a discrete distribution so that they sum to
--   unity. If not possible, returns the original distribution unchanged.
normalizeDiscreteWeights :: (Fractional p) => Discrete p e -> Discrete p e

-- | Simplify a discrete distribution by combining equivalent events (the
--   new event will have a weight equal to the sum of all the originals).
collectDiscreteEvents :: (Ord e, Num p, Ord p) => Discrete p e -> Discrete p e

-- | Simplify a discrete distribution by combining equivalent events (the
--   new event will have a weight equal to the sum of all the originals).
--   The comparator function is used to identify events to combine. Once
--   chosen, the events and their weights are combined (independently) by
--   the provided weight and event aggregation functions.
collectDiscreteEventsBy :: (e -> e -> Ordering) -> ([p] -> p) -> ([e] -> e) -> Discrete p e -> Discrete p e
instance (Eq p, Eq a) => Eq (Discrete p a)
instance (Show p, Show a) => Show (Discrete p a)
instance (Num p) => Applicative (Discrete p)
instance (Num p) => Monad (Discrete p)
instance Traversable (Discrete p)
instance Foldable (Discrete p)
instance Functor (Discrete p)
instance (Num p, Ord p, Distribution Uniform p) => Distribution (Discrete p) a

module Data.Random.Distribution.Ziggurat
data Ziggurat t
Ziggurat :: Vector t -> Vector t -> Vector t -> RVar (Int, t) -> RVar t -> (t -> t -> RVar t) -> (t -> t) -> Bool -> Ziggurat t
zTable_xs :: Ziggurat t -> Vector t
zTable_x_ratios :: Ziggurat t -> Vector t
zTable_ys :: Ziggurat t -> Vector t
zGetIU :: Ziggurat t -> RVar (Int, t)
zTailDist :: Ziggurat t -> RVar t
zUniform :: Ziggurat t -> t -> t -> RVar t
zFunc :: Ziggurat t -> t -> t
zMirror :: Ziggurat t -> Bool

-- | Build the tables to implement the <a>ziggurat algorithm</a> devised by
--   Marsaglia &amp; Tang, attempting to automatically compute the R and V
--   values.
--   
--   Arguments are the same as for |mkZigguratRec|, with an additional
--   argument for the tail distribution as a function of the selected R
--   value.
mkZiggurat :: (RealFloat t, Storable t, Distribution Uniform t) => Bool -> (t -> t) -> (t -> t) -> (t -> t) -> t -> Int -> RVar (Int, t) -> (t -> RVar t) -> Ziggurat t

-- | Build the tables to implement the <a>ziggurat algorithm</a> devised by
--   Marsaglia &amp; Tang, attempting to automatically compute the R and V
--   values.
--   
--   Arguments:
--   
--   <ul>
--   <li>flag indicating whether to mirror the distribution * the
--   (one-sided antitone) CDF * the inverse of the CDF * the number of bins
--   * R, the x value of the first bin * V, the volume of each bin * an
--   RVar providing a random tuple consisting of: - a bin index, uniform
--   over [0,c) :: Int - a uniformly distributed fractional value, from -1
--   to 1 if not mirrored, from 0 to 1 otherwise. * an RVar sampling from
--   the tail (the region where x &gt; R)</li>
--   </ul>
mkZiggurat_ :: (RealFloat t, Storable t, Distribution Uniform t) => Bool -> (t -> t) -> (t -> t) -> Int -> t -> t -> RVar (Int, t) -> RVar t -> Ziggurat t
runZiggurat :: (Num a, Ord a, Storable a) => Ziggurat a -> RVar a
instance (Num t, Ord t, Storable t) => Distribution Ziggurat t

module Data.Random.Distribution.Normal
data Normal a
StdNormal :: Normal a
Normal :: a -> a -> Normal a
normal :: (Distribution Normal a) => a -> a -> RVar a
stdNormal :: (Distribution Normal a) => RVar a
doubleStdNormal :: RVar Double
floatStdNormal :: RVar Float
realFloatStdNormal :: (RealFloat a, Erf a, Storable a, Distribution Uniform a) => RVar a

-- | Draw from the tail of a normal distribution (the region beyond the
--   provided value), returning a negative value if the Bool parameter is
--   True.
normalTail :: (Distribution StdUniform a, Floating a, Ord a) => a -> RVar a
normalPair :: (Floating a, Distribution StdUniform a) => RVar (a, a)
boxMullerNormalPair :: (Floating a, Distribution StdUniform a) => RVar (a, a)
knuthPolarNormalPair :: (Floating a, Ord a, Distribution Uniform a) => RVar (a, a)
instance (Real a, Distribution Normal a) => CDF Normal a
instance Distribution Normal Float
instance Distribution Normal Double

module Data.Random.Distribution.Gamma
realFloatGamma :: (Floating a, Ord a, Distribution Normal a, Distribution StdUniform a) => a -> a -> RVar a
realFloatErlang :: (Integral a, Floating b, Ord b, Distribution Normal b, Distribution StdUniform b) => a -> RVar b
gamma :: (Distribution Gamma a) => a -> a -> RVar a
erlang :: (Distribution (Erlang a) b) => a -> RVar b
data Gamma a
Gamma :: a -> a -> Gamma a
data Erlang a b
Erlang :: a -> Erlang a b
instance (Integral a, Floating b, Ord b, Distribution Normal b, Distribution StdUniform b) => Distribution (Erlang a) b
instance (Floating a, Ord a, Distribution Normal a, Distribution StdUniform a) => Distribution Gamma a

module Data.Random.Distribution.Beta
fractionalBeta :: (Fractional a, Distribution Gamma a, Distribution StdUniform a) => a -> a -> RVar a
fractionalBetaFromIntegral :: (Fractional c, Distribution (Erlang a) c, Distribution (Erlang b) c) => a -> b -> RVar c
beta :: (Distribution Beta a) => a -> a -> RVar a
data Beta a
Beta :: a -> a -> Beta a
instance (Fractional a, Distribution Gamma a, Distribution StdUniform a) => Distribution Beta a

module Data.Random.Distribution.Binomial
integralBinomial :: (Integral a, Floating b, Ord b, Distribution Beta b, Distribution StdUniform b) => a -> b -> RVar a
integralBinomialCDF :: (Integral a, Real b) => a -> b -> a -> Double
floatingBinomial :: (RealFrac a, Distribution (Binomial b) Integer) => a -> b -> RVar a
floatingBinomialCDF :: (CDF (Binomial b) Integer, RealFrac a) => a -> b -> a -> Double
binomial :: (Distribution (Binomial b) a) => a -> b -> RVar a
data Binomial b a
Binomial :: a -> b -> Binomial b a
instance (CDF (Binomial b[ayug]) Integer) => CDF (Binomial b[ayug]) Double
instance (Distribution (Binomial b[ayud]) Integer) => Distribution (Binomial b[ayud]) Double
instance (CDF (Binomial b[ayug]) Integer) => CDF (Binomial b[ayug]) Float
instance (Distribution (Binomial b[ayud]) Integer) => Distribution (Binomial b[ayud]) Float
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Word64) => CDF (Binomial b[ay8N]) Word64
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Word64
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Word32) => CDF (Binomial b[ay8N]) Word32
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Word32
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Word16) => CDF (Binomial b[ay8N]) Word16
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Word16
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Word8) => CDF (Binomial b[ay8N]) Word8
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Word8
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Int64) => CDF (Binomial b[ay8N]) Int64
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Int64
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Int32) => CDF (Binomial b[ay8N]) Int32
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Int32
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Int16) => CDF (Binomial b[ay8N]) Int16
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Int16
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Int8) => CDF (Binomial b[ay8N]) Int8
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Int8
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Integer) => CDF (Binomial b[ay8N]) Integer
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Integer
instance (Real b[ay8N], Distribution (Binomial b[ay8N]) Int) => CDF (Binomial b[ay8N]) Int
instance (Floating b[ay8K], Ord b[ay8K], Distribution Beta b[ay8K], Distribution StdUniform b[ay8K]) => Distribution (Binomial b[ay8K]) Int

module Data.Random.Distribution.Poisson
integralPoisson :: (Integral a, RealFloat b, Distribution StdUniform b, Distribution (Erlang a) b, Distribution (Binomial b) a) => b -> RVar a
integralPoissonCDF :: (Integral a, Real b) => b -> a -> Double
fractionalPoisson :: (Num a, Distribution (Poisson b) Integer) => b -> RVar a
fractionalPoissonCDF :: (CDF (Poisson b) Integer, RealFrac a) => b -> a -> Double
poisson :: (Distribution (Poisson b) a) => b -> RVar a
data Poisson b a
Poisson :: b -> Poisson b a
instance (CDF (Poisson b[aAWg]) Integer) => CDF (Poisson b[aAWg]) Double
instance (Distribution (Poisson b[aAWe]) Integer) => Distribution (Poisson b[aAWe]) Double
instance (CDF (Poisson b[aAWg]) Integer) => CDF (Poisson b[aAWg]) Float
instance (Distribution (Poisson b[aAWe]) Integer) => Distribution (Poisson b[aAWe]) Float
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Word64) => CDF (Poisson b[aAwT]) Word64
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Word64) b[aAwR], Distribution (Binomial b[aAwR]) Word64) => Distribution (Poisson b[aAwR]) Word64
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Word32) => CDF (Poisson b[aAwT]) Word32
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Word32) b[aAwR], Distribution (Binomial b[aAwR]) Word32) => Distribution (Poisson b[aAwR]) Word32
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Word16) => CDF (Poisson b[aAwT]) Word16
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Word16) b[aAwR], Distribution (Binomial b[aAwR]) Word16) => Distribution (Poisson b[aAwR]) Word16
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Word8) => CDF (Poisson b[aAwT]) Word8
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Word8) b[aAwR], Distribution (Binomial b[aAwR]) Word8) => Distribution (Poisson b[aAwR]) Word8
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Int64) => CDF (Poisson b[aAwT]) Int64
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Int64) b[aAwR], Distribution (Binomial b[aAwR]) Int64) => Distribution (Poisson b[aAwR]) Int64
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Int32) => CDF (Poisson b[aAwT]) Int32
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Int32) b[aAwR], Distribution (Binomial b[aAwR]) Int32) => Distribution (Poisson b[aAwR]) Int32
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Int16) => CDF (Poisson b[aAwT]) Int16
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Int16) b[aAwR], Distribution (Binomial b[aAwR]) Int16) => Distribution (Poisson b[aAwR]) Int16
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Int8) => CDF (Poisson b[aAwT]) Int8
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Int8) b[aAwR], Distribution (Binomial b[aAwR]) Int8) => Distribution (Poisson b[aAwR]) Int8
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Integer) => CDF (Poisson b[aAwT]) Integer
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Integer) b[aAwR], Distribution (Binomial b[aAwR]) Integer) => Distribution (Poisson b[aAwR]) Integer
instance (Real b[aAwT], Distribution (Poisson b[aAwT]) Int) => CDF (Poisson b[aAwT]) Int
instance (RealFloat b[aAwR], Distribution StdUniform b[aAwR], Distribution (Erlang Int) b[aAwR], Distribution (Binomial b[aAwR]) Int) => Distribution (Poisson b[aAwR]) Int

module Data.Random.Sample

-- | A typeclass allowing <a>Distribution</a>s and <a>RVar</a>s to be
--   sampled. Both may also be sampled via <a>runRVar</a> or
--   <a>runRVarT</a>, but I find it psychologically pleasing to be able to
--   sample both using this function.
class Sampleable d m t
sampleFrom :: (Sampleable d m t, RandomSource m s) => s -> d t -> m t

-- | Sample a distribution using the default source of entropy for the
--   monad in which the sampling occurs.
sample :: (Sampleable d m t, MonadRandom m) => d t -> m t
instance [incoherent] (Lift m n) => Sampleable (RVarT m) n t
instance [incoherent] (Distribution d t) => Sampleable d m t


-- | Random numbers and stuff...
--   
--   Data.Random.Source exports the typeclasses for entropy sources, and
--   Data.Random.Source.* export various instances and/or functions with
--   which instances can be defined.
--   
--   Data.Random.Distribution exports the typeclasses for sampling
--   distributions, and Data.Random.Distribution.* export various specific
--   distributions.
--   
--   Data.Random.RVar exports the <a>RVar</a> type, which is a probability
--   distribution monad that allows for concise definitions of random
--   variables, as well as a couple handy <a>RVar</a>s.
module Data.Random