random-fu-0.2: Random number generation




Flexible modeling and sampling of random variables.

The central abstraction in this library is the concept of a random variable. It is not fully formalized in the standard measure-theoretic language, but rather is informally defined as a "thing you can get random values out of". Different random variables may have different types of values they can return or the same types but different probabilities for each value they can return. The random values you get out of them are traditionally called "random variates".

Most imperative-language random number libraries are all about obtaining and manipulating random variates. This one is about defining, manipulating and sampling random variables. Computationally, the distinction is small and mostly just a matter of perspective, but from a program design perspective it provides both a powerfully composable abstraction and a very useful separation of concerns.

Abstract random variables as implemented by RVar are composable. They can be defined in a monadic / "imperative" style that amounts to manipulating variates, but with strict type-level isolation. Concrete random variables are also provided, but they do not compose as generically. The Distribution type class allows concrete random variables to "forget" their concreteness so that they can be composed. For examples of both, see the documentation for RVar and Distribution, as well as the code for any of the concrete distributions such as Uniform, Gamma, etc.

Both abstract and concrete random variables can be sampled (despite the types GHCi may list for the functions) by the functions in Data.Random.Sample.

Random variable sampling is done with regard to a generic basis of primitive random variables defined in Data.Random.Internal.Primitives. This basis is very low-level and the actual set of primitives is still fairly experimental, which is why it is in the "Internal" sub-heirarchy. User-defined variables should use the existing high-level variables such as Uniform and Normal rather than these basis variables. Data.Random.Source defines classes for entropy sources that provide implementations of these primitive variables. Several implementations are available in the Data.Random.Source.* modules.


Random variables

Abstract (RVar)

type RVar = RVarT Identity

An opaque type modeling a "random variable" - a value which depends on the outcome of some random event. RVars can be conveniently defined by an imperative-looking style:

 normalPair =  do
     u <- stdUniform
     t <- stdUniform
     let r = sqrt (-2 * log u)
         theta = (2 * pi) * t
         x = r * cos theta
         y = r * sin theta
     return (x,y)

OR by a more applicative style:

 logNormal = exp <$> stdNormal

Once defined (in any style), there are several ways to sample RVars:

 runRVar (uniform 1 100) DevRandom :: IO Int
 sampleRVar (uniform 1 100) :: State PureMT Int
  • As a pure function transforming a functional RNG:
 sampleState (uniform 1 100) :: StdGen -> (Int, StdGen)

(where sampleState = runState . sampleRVar)

data RVarT 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.

For example, a simple random walk can be implemented as an RVarT IO value:

 rwalkIO :: IO (RVarT IO Double)
 rwalkIO d = do
     lastVal <- newIORef 0
     let x = do
             prev    <- lift (readIORef lastVal)
             change  <- rvarT StdNormal
             let new = prev + change
             lift (writeIORef lastVal new)
             return new
     return x

To run the random walk it must first be initialized, after which it can be sampled as usual:

     rw <- rwalkIO
     x <- sampleRVarT rw
     y <- sampleRVarT rw

The same random-walk process as above can be implemented using MTL types as follows (using import Control.Monad.Trans as MTL):

 rwalkState :: RVarT (State Double) Double
 rwalkState = do
     prev <- MTL.lift get
     change  <- rvarT StdNormal
     let new = prev + change
     MTL.lift (put new)
     return new

Invocation is straightforward (although a bit noisy) if you're used to MTL:

 rwalk :: Int -> Double -> StdGen -> ([Double], StdGen)
 rwalk count start gen = 
     flip evalState start .
         flip runStateT gen .
             sampleRVarTWith MTL.lift $
                 replicateM count rwalkState

runRVar :: RandomSource m s => RVar a -> s -> m a

"Run" an RVar - samples the random variable from the provided source of entropy.

runRVarT :: (Lift n m, RandomSource m s) => RVarT n a -> s -> m aSource

Like runRVarTWith, but using an implicit lifting (provided by the Lift class)

runRVarTWith :: RandomSource m s => (forall t. n t -> m t) -> RVarT n a -> s -> m a

"Runs" an RVarT, sampling the random variable it defines.

The first argument lifts the base monad into the sampling monad. This operation must obey the "monad transformer" laws:

 lift . return = return
 lift (x >>= f) = (lift x) >>= (lift . f)

One example of a useful non-standard lifting would be one that takes State s to another monad with a different state representation (such as IO with the state mapped to an IORef):

 embedState :: (Monad m) => m s -> (s -> m ()) -> State s a -> m a
 embedState get put = \m -> do
     s <- get
     (res,s) <- return (runState m s)
     put s
     return res

The ability to lift is very important - without it, every RVar would have to either be given access to the full capability of the monad in which it will eventually be sampled (which, incidentally, would also have to be monomorphic so you couldn't sample one RVar in more than one monad) or functions manipulating RVars would have to use higher-ranked types to enforce the same kind of isolation and polymorphism.

Concrete (Distribution)

class Distribution d t whereSource

A Distribution is a data representation of a random variable's probability structure. For example, in Data.Random.Distribution.Normal, the Normal distribution is defined as:

 data Normal a
     = StdNormal
     | Normal a a

Where the two parameters of the Normal data constructor are the mean and standard deviation of the random variable, respectively. To make use of the Normal type, one can convert it to an rvar and manipulate it or sample it directly:

 x <- sample (rvar (Normal 10 2))
 x <- sample (Normal 10 2)

A Distribution is typically more transparent than an RVar but less composable (precisely because of that transparency). There are several practical uses for types implementing Distribution:

  • Typically, a Distribution will expose several parameters of a standard mathematical model of a probability distribution, such as mean and std deviation for the normal distribution. Thus, they can be manipulated analytically using mathematical insights about the distributions they represent. For example, a collection of bernoulli variables could be simplified into a (hopefully) smaller collection of binomial variables.
  • Because they are generally just containers for parameters, they can be easily serialized to persistent storage or read from user-supplied configurations (eg, initialization data for a simulation).
  • If a type additionally implements the CDF subclass, which extends Distribution with a cumulative density function, an arbitrary random variable x can be tested against the distribution by testing fmap (cdf dist) x for uniformity.

On the other hand, most Distributions will not be closed under all the same operations as RVar (which, being a monad, has a fully turing-complete internal computational model). The sum of two uniformly-distributed variables, for example, is not uniformly distributed. To support general composition, the Distribution class defines a function rvar to construct the more-abstract and more-composable RVar representation of a random variable.


rvar :: d t -> RVar tSource

Return a random variable with this distribution.

rvarT :: d t -> RVarT n tSource

Return a random variable with the given distribution, pre-lifted to an arbitrary RVarT. Any arbitrary RVar can also be converted to an 'RVarT m' for an arbitrary m, using either lift or sample.


Distribution StdUniform Bool 
Distribution StdUniform Char 
Distribution StdUniform Double 
Distribution StdUniform Float 
Distribution StdUniform Int 
Distribution StdUniform Int8 
Distribution StdUniform Int16 
Distribution StdUniform Int32 
Distribution StdUniform Int64 
Distribution StdUniform Ordering 
Distribution StdUniform Word 
Distribution StdUniform Word8 
Distribution StdUniform Word16 
Distribution StdUniform Word32 
Distribution StdUniform Word64 
Distribution StdUniform () 
Distribution Uniform Bool 
Distribution Uniform Char 
Distribution Uniform Double 
Distribution Uniform Float 
Distribution Uniform Int 
Distribution Uniform Int8 
Distribution Uniform Int16 
Distribution Uniform Int32 
Distribution Uniform Int64 
Distribution Uniform Integer 
Distribution Uniform Ordering 
Distribution Uniform Word 
Distribution Uniform Word8 
Distribution Uniform Word16 
Distribution Uniform Word32 
Distribution Uniform Word64 
Distribution Uniform () 
(Floating a, Distribution StdUniform a) => Distribution Exponential a 
Distribution Normal Double 
Distribution Normal Float 
(Floating a, Ord a, Distribution Normal a, Distribution StdUniform a) => Distribution Gamma a 
(Fractional t, Distribution Gamma t) => Distribution ChiSquare t 
(RealFloat a, Distribution StdUniform a) => Distribution Rayleigh a 
(RealFloat a, Ord a, Distribution StdUniform a) => Distribution Triangular a 
(Floating a, Distribution StdUniform a) => Distribution Weibull a 
Distribution Beta Double 
Distribution Beta Float 
HasResolution r => Distribution StdUniform (Fixed r) 
HasResolution r => Distribution Uniform (Fixed r) 
(Fractional a, Distribution Gamma a) => Distribution Dirichlet [a] 
(Fractional p, Ord p, Distribution Uniform p) => Distribution (Categorical p) a 
(Num t, Ord t, Vector v t) => Distribution (Ziggurat v) t 
(Integral a, Floating b, Ord b, Distribution Normal b, Distribution StdUniform b) => Distribution (Erlang a) b 
(Fractional b, Ord b, Distribution StdUniform b) => Distribution (Bernoulli b) Bool 
Distribution (Bernoulli b[aETu]) Bool => Distribution (Bernoulli b[aETu]) Word64 
Distribution (Bernoulli b[aETq]) Bool => Distribution (Bernoulli b[aETq]) Word32 
Distribution (Bernoulli b[aETm]) Bool => Distribution (Bernoulli b[aETm]) Word16 
Distribution (Bernoulli b[aETi]) Bool => Distribution (Bernoulli b[aETi]) Word8 
Distribution (Bernoulli b[aETe]) Bool => Distribution (Bernoulli b[aETe]) Word 
Distribution (Bernoulli b[aETa]) Bool => Distribution (Bernoulli b[aETa]) Int64 
Distribution (Bernoulli b[aET6]) Bool => Distribution (Bernoulli b[aET6]) Int32 
Distribution (Bernoulli b[aET2]) Bool => Distribution (Bernoulli b[aET2]) Int16 
Distribution (Bernoulli b[aESY]) Bool => Distribution (Bernoulli b[aESY]) Int8 
Distribution (Bernoulli b[aESU]) Bool => Distribution (Bernoulli b[aESU]) Int 
Distribution (Bernoulli b[aESN]) Bool => Distribution (Bernoulli b[aESN]) Integer 
Distribution (Bernoulli b[aF6J]) Bool => Distribution (Bernoulli b[aF6J]) Double 
Distribution (Bernoulli b[aF6F]) Bool => Distribution (Bernoulli b[aF6F]) Float 
(Floating b[aImY], Ord b[aImY], Distribution Beta b[aImY], Distribution StdUniform b[aImY]) => Distribution (Binomial b[aImY]) Word64 
(Floating b[aImS], Ord b[aImS], Distribution Beta b[aImS], Distribution StdUniform b[aImS]) => Distribution (Binomial b[aImS]) Word32 
(Floating b[aImM], Ord b[aImM], Distribution Beta b[aImM], Distribution StdUniform b[aImM]) => Distribution (Binomial b[aImM]) Word16 
(Floating b[aImG], Ord b[aImG], Distribution Beta b[aImG], Distribution StdUniform b[aImG]) => Distribution (Binomial b[aImG]) Word8 
(Floating b[aImA], Ord b[aImA], Distribution Beta b[aImA], Distribution StdUniform b[aImA]) => Distribution (Binomial b[aImA]) Word 
(Floating b[aImu], Ord b[aImu], Distribution Beta b[aImu], Distribution StdUniform b[aImu]) => Distribution (Binomial b[aImu]) Int64 
(Floating b[aImo], Ord b[aImo], Distribution Beta b[aImo], Distribution StdUniform b[aImo]) => Distribution (Binomial b[aImo]) Int32 
(Floating b[aImi], Ord b[aImi], Distribution Beta b[aImi], Distribution StdUniform b[aImi]) => Distribution (Binomial b[aImi]) Int16 
(Floating b[aImc], Ord b[aImc], Distribution Beta b[aImc], Distribution StdUniform b[aImc]) => Distribution (Binomial b[aImc]) Int8 
(Floating b[aIm6], Ord b[aIm6], Distribution Beta b[aIm6], Distribution StdUniform b[aIm6]) => Distribution (Binomial b[aIm6]) Int 
(Floating b[aIm0], Ord b[aIm0], Distribution Beta b[aIm0], Distribution StdUniform b[aIm0]) => Distribution (Binomial b[aIm0]) Integer 
Distribution (Binomial b[aIAC]) Integer => Distribution (Binomial b[aIAC]) Double 
Distribution (Binomial b[aIAw]) Integer => Distribution (Binomial b[aIAw]) Float 
(RealFloat b[aNMc], Distribution StdUniform b[aNMc], Distribution (Erlang Word64) b[aNMc], Distribution (Binomial b[aNMc]) Word64) => Distribution (Poisson b[aNMc]) Word64 
(RealFloat b[aNM8], Distribution StdUniform b[aNM8], Distribution (Erlang Word32) b[aNM8], Distribution (Binomial b[aNM8]) Word32) => Distribution (Poisson b[aNM8]) Word32 
(RealFloat b[aNM4], Distribution StdUniform b[aNM4], Distribution (Erlang Word16) b[aNM4], Distribution (Binomial b[aNM4]) Word16) => Distribution (Poisson b[aNM4]) Word16 
(RealFloat b[aNM0], Distribution StdUniform b[aNM0], Distribution (Erlang Word8) b[aNM0], Distribution (Binomial b[aNM0]) Word8) => Distribution (Poisson b[aNM0]) Word8 
(RealFloat b[aNLW], Distribution StdUniform b[aNLW], Distribution (Erlang Word) b[aNLW], Distribution (Binomial b[aNLW]) Word) => Distribution (Poisson b[aNLW]) Word 
(RealFloat b[aNLS], Distribution StdUniform b[aNLS], Distribution (Erlang Int64) b[aNLS], Distribution (Binomial b[aNLS]) Int64) => Distribution (Poisson b[aNLS]) Int64 
(RealFloat b[aNLO], Distribution StdUniform b[aNLO], Distribution (Erlang Int32) b[aNLO], Distribution (Binomial b[aNLO]) Int32) => Distribution (Poisson b[aNLO]) Int32 
(RealFloat b[aNLK], Distribution StdUniform b[aNLK], Distribution (Erlang Int16) b[aNLK], Distribution (Binomial b[aNLK]) Int16) => Distribution (Poisson b[aNLK]) Int16 
(RealFloat b[aNLG], Distribution StdUniform b[aNLG], Distribution (Erlang Int8) b[aNLG], Distribution (Binomial b[aNLG]) Int8) => Distribution (Poisson b[aNLG]) Int8 
(RealFloat b[aNLC], Distribution StdUniform b[aNLC], Distribution (Erlang Int) b[aNLC], Distribution (Binomial b[aNLC]) Int) => Distribution (Poisson b[aNLC]) Int 
(RealFloat b[aNLy], Distribution StdUniform b[aNLy], Distribution (Erlang Integer) b[aNLy], Distribution (Binomial b[aNLy]) Integer) => Distribution (Poisson b[aNLy]) Integer 
Distribution (Poisson b[aNYN]) Integer => Distribution (Poisson b[aNYN]) Double 
Distribution (Poisson b[aNYJ]) Integer => Distribution (Poisson b[aNYJ]) Float 
(Distribution (Bernoulli b) Bool, RealFloat a) => Distribution (Bernoulli b) (Complex a) 
(Distribution (Bernoulli b) Bool, Integral a) => Distribution (Bernoulli b) (Ratio a) 
(Num a, Fractional p, Distribution (Binomial p) a) => Distribution (Multinomial p) [a] 

class Distribution d t => CDF d t whereSource


cdf :: d t -> t -> DoubleSource

Return the cumulative distribution function of this distribution. That is, a function taking x :: t to the probability that the next sample will return a value less than or equal to x, according to some order or partial order (not necessarily an obvious one).

In the case where t is an instance of Ord, cdf should correspond to the CDF with respect to that order.

In other cases, cdf is only required to satisfy the following law: fmap (cdf d) (rvar d) must be uniformly distributed over (0,1). Inclusion of either endpoint is optional, though the preferred range is (0,1].

Note that this definition requires that cdf for a product type should _not_ be a joint CDF as commonly defined, as that definition violates both conditions. Instead, it should be a univariate CDF over the product type. That is, it should represent the CDF with respect to the lexicographic order of the product.

The present specification is probably only really useful for testing conformance of a variable to its target distribution, and I am open to suggestions for more-useful specifications (especially with regard to the interaction with product types).


CDF StdUniform Bool 
CDF StdUniform Char 
CDF StdUniform Double 
CDF StdUniform Float 
CDF StdUniform Int 
CDF StdUniform Int8 
CDF StdUniform Int16 
CDF StdUniform Int32 
CDF StdUniform Int64 
CDF StdUniform Ordering 
CDF StdUniform Word 
CDF StdUniform Word8 
CDF StdUniform Word16 
CDF StdUniform Word32 
CDF StdUniform Word64 
CDF StdUniform () 
CDF Uniform Bool 
CDF Uniform Char 
CDF Uniform Double 
CDF Uniform Float 
CDF Uniform Int 
CDF Uniform Int8 
CDF Uniform Int16 
CDF Uniform Int32 
CDF Uniform Int64 
CDF Uniform Integer 
CDF Uniform Ordering 
CDF Uniform Word 
CDF Uniform Word8 
CDF Uniform Word16 
CDF Uniform Word32 
CDF Uniform Word64 
CDF Uniform () 
(Real a, Distribution Exponential a) => CDF Exponential a 
(Real a, Distribution Normal a) => CDF Normal a 
(Real a, Distribution Gamma a) => CDF Gamma a 
(Real t, Distribution ChiSquare t) => CDF ChiSquare t 
(Real a, Distribution Rayleigh a) => CDF Rayleigh a 
(RealFrac a, Distribution Triangular a) => CDF Triangular a 
(Real a, Distribution Weibull a) => CDF Weibull a 
HasResolution r => CDF StdUniform (Fixed r) 
HasResolution r => CDF Uniform (Fixed r) 
(Integral a, Real b, Distribution (Erlang a) b) => CDF (Erlang a) b 
(Distribution (Bernoulli b) Bool, Real b) => CDF (Bernoulli b) Bool 
CDF (Bernoulli b[aETw]) Bool => CDF (Bernoulli b[aETw]) Word64 
CDF (Bernoulli b[aETs]) Bool => CDF (Bernoulli b[aETs]) Word32 
CDF (Bernoulli b[aETo]) Bool => CDF (Bernoulli b[aETo]) Word16 
CDF (Bernoulli b[aETk]) Bool => CDF (Bernoulli b[aETk]) Word8 
CDF (Bernoulli b[aETg]) Bool => CDF (Bernoulli b[aETg]) Word 
CDF (Bernoulli b[aETc]) Bool => CDF (Bernoulli b[aETc]) Int64 
CDF (Bernoulli b[aET8]) Bool => CDF (Bernoulli b[aET8]) Int32 
CDF (Bernoulli b[aET4]) Bool => CDF (Bernoulli b[aET4]) Int16 
CDF (Bernoulli b[aET0]) Bool => CDF (Bernoulli b[aET0]) Int8 
CDF (Bernoulli b[aESW]) Bool => CDF (Bernoulli b[aESW]) Int 
CDF (Bernoulli b[aESP]) Bool => CDF (Bernoulli b[aESP]) Integer 
CDF (Bernoulli b[aF6L]) Bool => CDF (Bernoulli b[aF6L]) Double 
CDF (Bernoulli b[aF6H]) Bool => CDF (Bernoulli b[aF6H]) Float 
(Real b[aIn1], Distribution (Binomial b[aIn1]) Word64) => CDF (Binomial b[aIn1]) Word64 
(Real b[aImV], Distribution (Binomial b[aImV]) Word32) => CDF (Binomial b[aImV]) Word32 
(Real b[aImP], Distribution (Binomial b[aImP]) Word16) => CDF (Binomial b[aImP]) Word16 
(Real b[aImJ], Distribution (Binomial b[aImJ]) Word8) => CDF (Binomial b[aImJ]) Word8 
(Real b[aImD], Distribution (Binomial b[aImD]) Word) => CDF (Binomial b[aImD]) Word 
(Real b[aImx], Distribution (Binomial b[aImx]) Int64) => CDF (Binomial b[aImx]) Int64 
(Real b[aImr], Distribution (Binomial b[aImr]) Int32) => CDF (Binomial b[aImr]) Int32 
(Real b[aIml], Distribution (Binomial b[aIml]) Int16) => CDF (Binomial b[aIml]) Int16 
(Real b[aImf], Distribution (Binomial b[aImf]) Int8) => CDF (Binomial b[aImf]) Int8 
(Real b[aIm9], Distribution (Binomial b[aIm9]) Int) => CDF (Binomial b[aIm9]) Int 
(Real b[aIm3], Distribution (Binomial b[aIm3]) Integer) => CDF (Binomial b[aIm3]) Integer 
CDF (Binomial b[aIAF]) Integer => CDF (Binomial b[aIAF]) Double 
CDF (Binomial b[aIAz]) Integer => CDF (Binomial b[aIAz]) Float 
(Real b[aNMe], Distribution (Poisson b[aNMe]) Word64) => CDF (Poisson b[aNMe]) Word64 
(Real b[aNMa], Distribution (Poisson b[aNMa]) Word32) => CDF (Poisson b[aNMa]) Word32 
(Real b[aNM6], Distribution (Poisson b[aNM6]) Word16) => CDF (Poisson b[aNM6]) Word16 
(Real b[aNM2], Distribution (Poisson b[aNM2]) Word8) => CDF (Poisson b[aNM2]) Word8 
(Real b[aNLY], Distribution (Poisson b[aNLY]) Word) => CDF (Poisson b[aNLY]) Word 
(Real b[aNLU], Distribution (Poisson b[aNLU]) Int64) => CDF (Poisson b[aNLU]) Int64 
(Real b[aNLQ], Distribution (Poisson b[aNLQ]) Int32) => CDF (Poisson b[aNLQ]) Int32 
(Real b[aNLM], Distribution (Poisson b[aNLM]) Int16) => CDF (Poisson b[aNLM]) Int16 
(Real b[aNLI], Distribution (Poisson b[aNLI]) Int8) => CDF (Poisson b[aNLI]) Int8 
(Real b[aNLE], Distribution (Poisson b[aNLE]) Int) => CDF (Poisson b[aNLE]) Int 
(Real b[aNLA], Distribution (Poisson b[aNLA]) Integer) => CDF (Poisson b[aNLA]) Integer 
CDF (Poisson b[aNYP]) Integer => CDF (Poisson b[aNYP]) Double 
CDF (Poisson b[aNYL]) Integer => CDF (Poisson b[aNYL]) Float 
(CDF (Bernoulli b) Bool, RealFloat a) => CDF (Bernoulli b) (Complex a) 
(CDF (Bernoulli b) Bool, Integral a) => CDF (Bernoulli b) (Ratio a) 

Sampling random variables

class Sampleable d m t whereSource

A typeclass allowing Distributions and RVars to be sampled. Both may also be sampled via runRVar or runRVarT, but I find it psychologically pleasing to be able to sample both using this function, as they are two separate abstractions for one base concept: a random variable.


sampleFrom :: RandomSource m s => s -> d t -> m tSource

Directly sample from a distribution or random variable, using the given source of entropy.


Distribution d t => Sampleable d m t 
Lift m n => Sampleable (RVarT m) n t 

sample :: (Sampleable d m t, MonadRandom m) => d t -> m tSource

Sample a random variable using the default source of entropy for the monad in which the sampling occurs.

sampleState :: (Sampleable d (State s) t, MonadRandom (State s)) => d t -> s -> (t, s)Source

Sample a random variable in a "functional" style. Typical instantiations of s are System.Random.StdGen or System.Random.Mersenne.Pure64.PureMT.

sampleStateT :: (Sampleable d (StateT s m) t, MonadRandom (StateT s m)) => d t -> s -> m (t, s)Source

Sample a random variable in a "semi-functional" style. Typical instantiations of s are System.Random.StdGen or System.Random.Mersenne.Pure64.PureMT.

A few very common distributions

stdUniform :: Distribution StdUniform a => RVar aSource

Get a "standard" uniformly distributed variable. For integral types, this means uniformly distributed over the full range of the type (there is no support for Integer). For fractional types, this means uniformly distributed on the interval [0,1).

stdUniformT :: Distribution StdUniform a => RVarT m aSource

Get a "standard" uniformly distributed process. For integral types, this means uniformly distributed over the full range of the type (there is no support for Integer). For fractional types, this means uniformly distributed on the interval [0,1).

data Normal a Source

A specification of a normal distribution over the type a.



The "standard" normal distribution - mean 0, stddev 1

Normal a a

Normal m s is a normal distribution with mean m and stddev sd.

normal :: Distribution Normal a => a -> a -> RVar aSource

normal m s is a random variable with distribution Normal m s.

stdNormal :: Distribution Normal a => RVar aSource

stdNormal is a normal variable with distribution StdNormal.

normalT :: Distribution Normal a => a -> a -> RVarT m aSource

normalT m s is a random process with distribution Normal m s.

stdNormalT :: Distribution Normal a => RVarT m aSource

stdNormalT is a normal process with distribution StdNormal.

data Gamma a Source


Gamma a a 

gamma :: Distribution Gamma a => a -> a -> RVar aSource

gammaT :: Distribution Gamma a => a -> a -> RVarT m aSource

Entropy Sources

class Monad m => MonadRandom m

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.

Minimum implementation is either the internal getRandomPrim or all other functions. Additionally, this class's interface is subject to extension at any time, so it is very, very strongly recommended that the monadRandom Template Haskell function be used to implement this function rather than directly implementing it. That function takes care of choosing default implementations for any missing functions; as long as at least one function is implemented, it will derive sensible implementations of all others.

To use monadRandom, just wrap your instance declaration as follows (and enable the TemplateHaskell and GADTs language extensions):

 $(monadRandom [d|
         instance MonadRandom FooM where
             getRandomDouble = return pi
             getRandomWord16 = return 4
             {- etc... -}


class Monad m => RandomSource m s

A source of entropy which can be used in the given monad.

See also MonadRandom.

Minimum implementation is either the internal getRandomPrimFrom or all other functions. Additionally, this class's interface is subject to extension at any time, so it is very, very strongly recommended that the randomSource Template Haskell function be used to implement this function rather than directly implementing it. That function takes care of choosing default implementations for any missing functions; as long as at least one function is implemented, it will derive sensible implementations of all others.

To use randomSource, just wrap your instance declaration as follows (and enable the TemplateHaskell, MultiParamTypeClasses and GADTs language extensions, as well as any others required by your instances, such as FlexibleInstances):

 $(randomSource [d|
         instance RandomSource FooM Bar where
             {- at least one RandomSource function... -}


MonadRandom m => RandomSource m StdRandom 
RandomSource IO (Gen RealWorld) 
Monad m => RandomSource m (GetPrim m) 
Monad m[awxK] => RandomSource m[awxK] (m[awxK] Word32) 
Monad m[awsL] => RandomSource m[awsL] (m[awsL] Word16) 
Monad m[awnE] => RandomSource m[awnE] (m[awnE] Word8) 
Monad m[awHk] => RandomSource m[awHk] (m[awHk] Double) 
Monad m[awCB] => RandomSource m[awCB] (m[awCB] Word64) 
MonadIO m[art5] => RandomSource m[art5] (IORef PureMT) 
(Monad m, ModifyRef (IORef StdGen) m StdGen) => RandomSource m (IORef StdGen) 
(Monad m[arA0], ModifyRef (STRef s[arA1] PureMT) m[arA0] PureMT) => RandomSource m[arA0] (STRef s[arA1] PureMT) 
(Monad m1[arbD], ModifyRef (Ref m2[arbE] PureMT) m1[arbD] PureMT) => RandomSource m1[arbD] (Ref m2[arbE] PureMT) 
(Monad m, ModifyRef (STRef s StdGen) m StdGen) => RandomSource m (STRef s StdGen) 
(Monad m1, ModifyRef (Ref m2 StdGen) m1 StdGen) => RandomSource m1 (Ref m2 StdGen) 
RandomSource (ST s[aCxb]) (Gen s[aCxb]) 

data StdRandom

A token representing the "standard" entropy source in a MonadRandom monad. Its sole purpose is to make the following true (when the types check):

 runRVar x StdRandom === sampleRVar



Useful list-based operations

randomElement :: [a] -> RVar aSource

A random variable returning an arbitrary element of the given list. Every element has equal probability of being chosen. Because it is a pure RVar it has no memory - that is, it "draws with replacement."

shuffle :: [a] -> RVar [a]Source

A random variable that returns the given list in an arbitrary shuffled order. Every ordering of the list has equal probability.

shuffleN :: Int -> [a] -> RVar [a]Source

A random variable that shuffles a list of a known length (or a list prefix of the specified length). Useful for shuffling large lists when the length is known in advance. Avoids needing to traverse the list to discover its length. Each ordering has equal probability.

shuffleNofM :: Int -> Int -> [a] -> RVar [a]Source

A random variable that selects N arbitrary elements of a list of known length M.