-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Easy and reasonably efficient probabilistic programming and random generation -- -- Easy and reasonably efficient probabilistic programming and random -- generation -- -- This library gives a common language to speak about probability -- distributions and random generation, by wrapping both, when necessary, -- in a RandT monad defined in Math.Probable.Random. This -- module also provides a lot of useful little combinators for easily -- describing how random values for your types should be generated. -- -- In Math.Probable.Distribution, you'll find functions for -- generating random values that follow any distribution supported by -- mwc-random. -- -- In Math.Probable.Distribution.Finite, you'll find an -- adaptation of Eric Kidd's work on probability monads (from -- here). -- -- You may want to check the examples bundled with this package, viewable -- online at -- https://github.com/alpmestan/probable/tree/master/examples. One -- of these examples is simple enough to be worth reproducing here. -- -- 
--   module Main where
--   
--   import Control.Applicative
--   import Control.Monad
--   import Math.Probable
--   
--   import qualified Data.Vector.Unboxed as VU
--   
--   data Person = Person Int    -- ^ age
--                        Double -- ^ weight (kgs)
--                        Double -- ^ salary (e.g euros)
--       deriving (Eq, Show)
--   
--   person :: RandT IO Person
--   person =
--       Person <$> uniformIn (1, 100)
--              <*> uniformIn (2, 130)
--              <*> uniformIn (500, 10000)
--   
--   randomPersons :: Int -> IO [Person]
--   randomPersons n = mwc $ listOf n person
--   
--   randomDoubles :: Int -> IO (VU.Vector Double)
--   randomDoubles n = mwc $ vectorOf n double
--   
--   main :: IO ()
--   main = do
--       randomPersons 10 >>= mapM_ print
--       randomDoubles 10 >>= VU.mapM_ print
--
-- -- Please report any feature request or problem, either by email or -- through github's issues/feature requests. @package probable @version 0.1.2 -- | Random number generation based on Gen, defined as a Monad -- transformer. -- -- Quickstart, in ghci: -- -- 
--   λ> import Math.Probable
--   λ> import Control.Applicative
--   λ> mwc double
--   0.2756820707828763
--   λ> mwc word64
--   12175918187293541909
--   λ> mwc $ (,) <$> bool <*> intIn (0, 10)
--   (True,7)
--   λ> mwc $ do { n <- intIn (1, 10) ; listOf n (listOf 2 bool) }
--   [ [False,True],[True,False],[False,True],[False,False],[False,False],
--     [False,True],[True,False],[True,False],[True,True],[False,False]
--   ]
--
-- -- This module features a bunch of combinators that can help you create -- some random generation descriptions easily, and in a very familiar -- style. -- -- You can easily combine them through the Monad instance for -- RandT which really just make sure everyone gets a Gen -- (from mwc-random) eventually. This of course makes RandT a -- Functor and an Applicative. -- -- 
--   import Math.Probable
--   
--   data Person = 
--     Person { name   :: String
--            , age    :: Int
--            , salary :: Double
--            }
--       deriving (Eq, Show)
--   
--   randomPerson :: PrimMonad m 
--                => RandT m Person
--   randomPerson = do
--       -- we pick a random length
--       -- for the person's name
--       nameLen <- intIn (3, 10) 
--                              
--       -- and just express what a random Person
--       -- should be, Applicative-style
--       Person <$> pickName nameLen    -- pick a name
--              <*> intIn (0, 100)      -- an Int between 0 and 100
--              <*> doubleIn (0, 10000) -- a Double between 0 and 10000
--   
--       where pickName nameLen = do
--                 -- the initial, between 'A' and 'Z'
--                 initial <- chr `fmap` intIn (65, 90)
--    
--                 (initial:) `fmap` 
--                 -- the rest, between 'a' and 'z'
--                     listOf (nameLen - 1)
--                            (chr `fmap` intIn (97, 122))
--
-- -- This is all nice, but how do we actually sample such a Person? You -- just have to call mwc: -- -- 
--   λ> mwc randomPerson
--   Person {name = "Ojeesra", age = 83, salary = 3075.9945184521885}
--
-- -- So any value of type 'RandT m a' is something that you'll eventually -- run in m (hence IO or ST s) for -- generating a random value of type a. Note that -- mwc forces the execution using withSystemRandom and -- gets you back in IO, whereas mwcST gets you back in -- ST s. -- -- My simple name generation routine can help you pick a name for your -- baby, if you are having one soon. -- -- 
--   λ> map name `fmap` mwc (listOf 10 randomPerson)
--   ["Npujbc","Faidx","Zusha","Ghbipic","Ljaestei","Fktcfonnxe","Hlvkolds","Zpws","Zgmrkrdv","Rhcd"]
--
-- -- If we were to make a generator that could generate more familiar and -- creativity-free names, we wouldn't sample uniformly from the alphabet. module Math.Probable.Random -- | RandT type, equivalent to a ReaderT (Gen -- (PrimState m)) -- -- This lets you build simple or complex random generation routines -- without having the generator passed all around and just run the whole -- thing in the end, most likely by using mwc. newtype RandT m a RandT :: (Gen (PrimState m) -> m a) -> RandT m a [runRandT] :: RandT m a -> Gen (PrimState m) -> m a -- | Take a RandT value and run it in IO, generating all the -- random values described by the RandT. It just uses -- withSystemRandom so you really should try hard to put your -- whole random generation logic in RandT and call mwc in -- the end, thus initialising the generator only once and generating -- everything with it. -- -- See the documentation for withSystemRandom for more about this. -- -- 
--   λ> mwc $ (+2) `fmap` int8
--   34
--
mwc :: RandT IO a -> IO a -- | If for some reason you have a RandT (ST s) you -- can run it from IO just like we do with mwc. -- -- 
--   λ> mwcST $ listOf 4 bool
--   [False,False,True,True]
--
mwcST :: RandT (ST s) a -> IO a -- | A generic function for sampling uniformly any type that implements -- Variate. -- -- All the xxxIn functions from this module just call -- uniformR. uniformIn :: (Variate a, PrimMonad m) => (a, a) -> RandT m a -- | Generate a random Int. The whole Int range is used. -- -- 
--   λ> mwc int
--   8354496680947360541
--
int :: PrimMonad m => RandT m Int -- | Generate a random Int8. The whole Int8 range is used. -- -- 
--   λ> mwc int8
--   -65
--
int8 :: PrimMonad m => RandT m Int8 -- | Generate a random Int16. The whole Int16 range is used. -- -- 
--   λ> mwc int16
--   15413
--
int16 :: PrimMonad m => RandT m Int16 -- | Generate a random Int32. The whole Int32 range is used. -- -- 
--   λ> mwc int32
--   1774441747
--
int32 :: PrimMonad m => RandT m Int32 -- | Generate a random Int64. The whole Int64 range is used. -- -- 
--   λ> mwc int64
--   -2596387699802756017
--
int64 :: PrimMonad m => RandT m Int64 -- | Generate a random Int in the given range. -- -- 
--   λ> mwc $ intIn (0, 10)
--   7
--
intIn :: PrimMonad m => (Int, Int) -> RandT m Int -- | Generate a random Int8 in the given range -- -- 
--   λ> mwc $ int8In (-10, 10)
--   -3
--
int8In :: PrimMonad m => (Int8, Int8) -> RandT m Int8 -- | Generate a random Int16 in the given range -- -- 
--   λ> mwc $ int16In (-500, 30129)
--   9501
--
int16In :: PrimMonad m => (Int16, Int16) -> RandT m Int16 -- | Generate a random Int32 in the given range. -- -- 
--   λ> mwc $ int32In (-500, 30129)
--   8012
--
int32In :: PrimMonad m => (Int32, Int32) -> RandT m Int32 -- | Generate a random Int64 in the given range. -- -- 
--   λ> mwc $ int64In (-2^30, 30)
--   -630614786
--
int64In :: PrimMonad m => (Int64, Int64) -> RandT m Int64 -- | Generate a random Word. The whole Word range is used. -- -- 
--   λ> mwc word
--   3106215968599504888
--
word :: PrimMonad m => RandT m Word -- | Generate a random Word8. The whole Word8 range is used. -- -- 
--   λ> mwc word8
--   231
--
word8 :: PrimMonad m => RandT m Word8 -- | Generate a random Word16. The whole Word16 range is -- used. -- -- 
--   λ> mwc word16
--   31127
--
word16 :: PrimMonad m => RandT m Word16 -- | Generate a random Word32. The whole Word32 range is -- used. -- -- 
--   λ> mwc word32
--   3917666696
--
word32 :: PrimMonad m => RandT m Word32 -- | Generate a random Word64. The whole Word64 range is -- used. -- -- 
--   λ> mwc word64
--   12496697905424132339
--
word64 :: PrimMonad m => RandT m Word64 -- | Generate a random Word in the given range. -- -- 
--   λ> mwc $ wordIn (1, 64)
--   28
--
wordIn :: PrimMonad m => (Word, Word) -> RandT m Word -- | Generate a random Word8 in the given range -- -- 
--   λ> mwc $ word8In (2, 15)
--   3
--
word8In :: PrimMonad m => (Word8, Word8) -> RandT m Word8 -- | Generate a random Word16 in the given range. -- -- 
--   λ> mwc $ word16In (2^13, 2^14)
--   8885
--
word16In :: PrimMonad m => (Word16, Word16) -> RandT m Word16 -- | Generate a random Word32 in the given range. -- -- 
--   λ> mwc $ word32In (100, 330)
--   125
--
word32In :: PrimMonad m => (Word32, Word32) -> RandT m Word32 -- | Generate a random Word64 in the given range. -- -- 
--   λ> mwc $ word64In (2^45, 2^46)
--   59226619151303
--
word64In :: PrimMonad m => (Word64, Word64) -> RandT m Word64 -- | Generate a random Float between 0 (excluded) and 1 (included) -- -- 
--   λ> mwc float
--   0.11831179
--
float :: PrimMonad m => RandT m Float -- | Generate a random Double between 0 (excluded) and 1 (included) -- -- 
--   λ> mwc double
--   0.7689412928620208
--
double :: PrimMonad m => RandT m Double -- | Generate a random Float in the given range -- -- 
--   λ> mwc $ floatIn (0.20, 3.14)
--   1.3784513
--
floatIn :: PrimMonad m => (Float, Float) -> RandT m Float -- | Generate a random Double in the given range -- -- 
--   λ> mwc $ doubleIn (-30.121121445, 0.129898878612)
--   -13.612464813256999
--
doubleIn :: PrimMonad m => (Double, Double) -> RandT m Double -- | Generate a random Bool -- -- 
--   λ> mwc bool
--   False
--
bool :: PrimMonad m => RandT m Bool -- | Repeatedly run a random computation yielding a value of type -- a to get a list of random values of type a. -- -- 
--   λ> mwc (listOf 30 float)
--   [ 5.438623e-2,0.78114086,0.4954672,0.5958733,0.47243807,5.883485e-2
--   , 5.500287e-2,0.79262286,0.5528683,0.7628807,0.80705905,0.15368962
--   , 0.8654971,0.4560417,0.23922172,0.5069659,0.8130155,0.6559351
--   , 1.31405e-2,0.25705606,0.7134138,0.79111993,0.7529769,0.10573909
--   , 0.37731406,0.6289338,0.85156864,0.15691182,0.9910314,8.133593e-2
--   ]
--
-- -- 
--   λ> mwc (sum `fmap` listOf 30 float)
--   15.037931
--
listOf :: Monad m => Int -> RandT m a -> RandT m [a] -- | A function for generating a vector of the given length with random -- values of any type (in contrast to vectorOfVariate). -- -- It is generic in the Vector instance it hands you back. It's -- implemented in terms of replicateM and has been benchmarked to -- perform as well as uniformVector on simple types -- (uniformVector can't generate values for types that don't have -- a Variate instance). -- -- 
--   λ> import qualified Data.Vector.Unboxed as V
--   λ> :set -XScopedTypeVariables
--   λ> v :: V.Vector Int <- mwc $ vectorOf 10 int
--   λ> V.mapM_ print v
--   -3920053790769159788
--   3983393642052845448
--   1528310798822685910
--   3522283620461337684
--   6451017362937898910
--   1929485210691770214
--   8547527164583329795
--   3298785082692387491
--   4019024417224980311
--   -5216301990322376953
--
vectorOf :: (Monad m, Vector v a) => Int -> RandT m a -> RandT m (v a) -- | A function for generating a vector of the given length for values -- whose types are instances of Variate. -- -- This function is generic in the type of vector it returns, any -- instance of Vector will do. -- -- It's just a wrapper arround uniformVector and doesn't really -- use the Monad instance of RandT. -- -- But if you want to have a vector of Persons, you have to use -- vectorOf. -- -- 
--   λ> import qualified Data.Vector.Unboxed as V
--   λ> :set -XScopedTypeVariables
--   λ> v :: V.Vector Double <- mwc $ vectorOfVariate 10
--   λ> V.mapM_ print v
--   3.8565084196117705e-2
--   0.575103826646098
--   0.379710162825715
--   0.4066991135077237
--   0.9778431248247549
--   0.3786223745680838
--   0.4361789615081698
--   0.9904407826187301
--   0.2951087330670904
--   0.1533350329892028
--
vectorOfVariate :: (PrimMonad m, Variate a, Vector v a) => Int -> RandT m (v a) instance GHC.Base.Monad m => GHC.Base.Monad (Math.Probable.Random.RandT m) instance GHC.Base.Monad m => GHC.Base.Functor (Math.Probable.Random.RandT m) instance GHC.Base.Monad m => GHC.Base.Applicative (Math.Probable.Random.RandT m) -- | Fun with finite distributions! -- -- This all pretty much comes from Eric Kidd's series of blog posts at -- http://www.randomhacks.net/probability-monads/. -- -- I have adapted it a bit by making it fit into my own random -- generation/sampling scheme. -- -- The idea and purpose of this module should be clear after going -- through an example. First, let's import the library and -- vector. -- -- 
--   import Math.Probable
--   import qualified Data.Vector as V
--
-- -- We are going to talk about Books, and particularly about whether a -- given book is interesting or not. -- -- 
--   data Book = Interesting 
--             | Boring
--       deriving (Eq, Show)
--
-- -- Let's say we have very particular tastes, and that we think that only -- 20% of all books are interesting (that's not so small actually. oh -- well). -- -- 
--   bookPrior :: Finite d => d Book
--   bookPrior = weighted [ (Interesting, 0.2) 
--                        , (Boring, 0.8) 
--                        ]
--
-- -- weighted belongs to the Finite class, which represents -- types that can somehow represent a distribution over a finite set. -- That makes our distribution polymorphic in how we will use it. -- Awesome! -- -- So how does it look? -- -- 
--   λ> exact bookPrior -- in ghci
--   [Event Interesting 20.0%,Event Boring 80.0%]
--
-- -- exact takes Fin a and gives you the inner list -- that Fin uses to represent the distribution. -- -- Now, what if we pick two books? First, how do we even do that? Well, -- any instance of Finite must be a Monad, so you have your -- good old do notation. The ones provided by this package also -- provide Functor and Applicative instances, but let's use -- do. -- -- 
--   twoBooks :: Finite d => d (Book, Book)
--   twoBooks = do
--       book1 <- bookPrior
--       book2 <- bookPrior
--       return (book1, book2)
--
-- -- Nothing impressive. We pick a book with the prior we defined above, -- then another, pair them together and hand the pair back. What this -- will actually do is behave just like in the list monad, but in -- addition to this it will combine the probabilities of the various -- events we could be dealing with in the appropriate way. -- -- So, how about we verify what I just said: -- -- 
--   λ> exact twoBooks
--   [ Event (Interesting,Interesting) 4.0%
--   , Event (Interesting,Boring) 16.0%
--   , Event (Boring,Interesting) 16.0%
--   , Event (Boring,Boring) 64.0%
--   ]
--
-- -- Nice! Let's take a look at a more complicated scenario now. -- -- What if we wanted to take a look at the same distribution, with just a -- difference: we want at least one of the books to be an Interesting -- one. -- -- 
--   oneInteresting :: Fin (Book, Book)
--   oneInteresting = bayes $ do -- notice the call to bayes
--       (b1, b2) <- twoBooks
--       condition (b1 == Interesting || b2 == Interesting)
--       return (b1, b2)
--
-- -- We get two books from the previous distribution, and use -- condition to restrict the current distribution to the values of -- b1 and b2 that verify our condition. This lifts us in the -- FinBayes type, where our probabilistic computations can "fail" -- in some sense. If you want to discard values and restrict the ones on -- which you'll run further computations, use condition. -- -- However, how do we view the distribution now, without having all those -- Maybes in the middle? That's what bayes is for. It runs -- the computations for the distribution and discards all the ones where -- any condition wasn't satisfied. In particular, it means it -- hands you back a normal Fin distribution. -- -- If we run this one: -- -- 
--   λ> exact oneInteresting
--   [ Event (Interesting,Interesting) 11.1%
--   , Event (Interesting,Boring) 44.4%
--   , Event (Boring,Interesting) 44.4%
--   ]
--
-- -- Note that these finite distribution types support random sampling too: -- -- -- -- 
--   -- example of the former
--   sampleBooks :: RandT IO (V.Vector Book)
--   sampleBooks = vectorOf 10 bookPrior
--
-- -- 
--   λ> mwc sampleBooks
--   fromList [Interesting,Boring,Boring,Boring,Boring
--            ,Boring,Boring,Interesting,Boring,Boring]
--
-- -- 
--   λ> mwc $ listOf 4 (liftF oneInteresting) -- example of the latter
--   [ (Boring,Interesting)
--   , (Boring,Interesting)
--   , (Boring,Interesting)
--   , (Interesting,Boring)
--   ]
--
module Math.Probable.Distribution.Finite -- | Probability type: wrapper around Double for a nicer Show instance and -- for more easily enforcing normalization of weights newtype P P :: Double -> P -- | Get the underlying probability -- -- 
--   λ> prob (P 0.1)
--   0.1
--
prob :: P -> Double -- | An event, and its probability data Event a Event :: a -> {-# UNPACK #-} !P -> Event a -- | This event never happens (probability of 0) -- -- 
--   never = Event undefined 0
--
never :: Event a -- | EventT monad transformer -- -- It pairs a value with a probability within the m monad newtype EventT m a EventT :: m (Event a) -> EventT m a [runEventT] :: EventT m a -> m (Event a) -- | T distribution of probabilities over a finite set. class (Functor d, Monad d) => Finite d -- | The only requirement is to somehow be able to represent the -- distribution corresponding to the list given as argument, e.g: -- -- 
--   weighted [(True, 0.8), (False, 0.2)]
--
-- -- It should also be able to handle the normalization for you. -- -- 
--   weighted [(True, 8), (False, 2)]
--
weighted :: Finite d => [(a, Double)] -> d a -- | Fin is just 'EventT []' -- -- You can think of 'Fin a' meaning '[Event a]' i.e a list of the -- possible outcomes of type a with their respective probability type Fin = EventT [] -- | See the outcomes of a finite distribution and their probabilities -- -- 
--   λ> exact $ uniformly [True, False]
--   [Event True 50.0%,Event False 50.0%]
--
-- -- 
--   λ> data Fruit = Apple | Orange deriving (Eq, Show)
--   λ> exact $ uniformly [Apple, Orange]
--   [Event Apple 50.0%,Event Orange 50.0%]
--
-- -- 
--   λ> exact $ weighted [(Apple, 0.8), (Orange, 0.2)]
--   [Event Apple 80.0%,Event Orange 20.0%]
--
exact :: Fin a -> [Event a] -- | Create a Finite distribution over the values in the list, each -- with an equal probability -- -- 
--   λ> exact $ uniformly [True, False]
--   [Event True 50.0%,Event False 50.0%]
--
uniformly :: Finite d => [a] -> d a -- | Make finite distributions (Fin) citizens of RandT by -- simply sampling an element at random while still approximately -- preserving the distribution -- -- 
--   λ> mwc . liftF $ uniformly [True, False]
--   False
--   λ> mwc . liftF $ uniformly [True, False]
--   True
--   λ> mwc . liftF $ weighted [("Haskell", 99), ("PHP", 1)]
--   "Haskell"
--
liftF :: PrimMonad m => Fin a -> RandT m a -- | FinBayes is Fin with a MaybeT layer -- -- What is that for? The MaybeT lets us express the fact that what -- we've drawn from the distribution isn't of interest anymore, using -- condition, and observing the remaining cases, using -- bayes, to get back to a normal finite distribution. Example: -- -- 
--   data Wine = Good | Bad deriving (Eq, Show)
--   
--   wines :: Finite d => d Wine
--   wines = weighted [(Good, 0.2), (Bad, 0.8)]
--   
--   twoWines :: Finite d => d (Wine, Wine)
--   twoWines = (,) <*> wines <$> wines
--   
--   decentMeal :: FinBayes (Wine, Wine)
--   decentMeal = do
--     (wine1, wine2) <- twoWines
--     -- we only consider the outcomes of 'twoWines' 
--     -- where at least one of the two wines is good
--     -- because we're having a nice meal and are looking
--     -- for a decent pair of wine
--     condition (wine1 == Good || wine2 == Good)
--     return (wine1, wine2)
--   
--   -- to view the distribution, applying
--   -- Bayes' rule on our way:
--   exact (bayes decentMeal)
--
type FinBayes = MaybeT Fin -- | This functions discards all the elements of the distribution for which -- the call to condition yielded Nothing. While -- condition does the mapping to Maybe values, this -- function discards all of those values for which the condition was not -- met. bayes :: FinBayes a -> Fin a -- | This is the core of FinBayes. If the Bool is false, the -- current computation is shortcuited (sent to a Nothing in -- MaybeT) and won't be included when running the distribution -- with bayes. See the documentation of FinBayes for an -- example. condition :: Bool -> FinBayes () -- | Keeps only the Justs and remove the Maybe layer in the -- distribution. onlyJust :: Fin (Maybe a) -> Fin a instance GHC.Show.Show a => GHC.Show.Show (Math.Probable.Distribution.Finite.Event a) instance GHC.Classes.Eq a => GHC.Classes.Eq (Math.Probable.Distribution.Finite.Event a) instance GHC.Real.RealFrac Math.Probable.Distribution.Finite.P instance GHC.Real.Real Math.Probable.Distribution.Finite.P instance GHC.Num.Num Math.Probable.Distribution.Finite.P instance GHC.Real.Fractional Math.Probable.Distribution.Finite.P instance GHC.Classes.Ord Math.Probable.Distribution.Finite.P instance GHC.Classes.Eq Math.Probable.Distribution.Finite.P instance GHC.Show.Show Math.Probable.Distribution.Finite.P instance GHC.Base.Functor Math.Probable.Distribution.Finite.Event instance GHC.Base.Applicative Math.Probable.Distribution.Finite.Event instance GHC.Base.Monad Math.Probable.Distribution.Finite.Event instance GHC.Base.Monad m => GHC.Base.Functor (Math.Probable.Distribution.Finite.EventT m) instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Math.Probable.Distribution.Finite.EventT m) instance GHC.Base.Monad m => GHC.Base.Monad (Math.Probable.Distribution.Finite.EventT m) instance Control.Monad.Trans.Class.MonadTrans Math.Probable.Distribution.Finite.EventT instance Math.Probable.Distribution.Finite.Finite Math.Probable.Distribution.Finite.Fin instance Control.Monad.Primitive.PrimMonad m => Math.Probable.Distribution.Finite.Finite (Math.Probable.Random.RandT m) instance Math.Probable.Distribution.Finite.Finite Math.Probable.Distribution.Finite.FinBayes module Math.Probable.Distribution -- | Beta distribution (from Statistics.Distribution.Beta) -- -- 
--   λ> mwc $ listOf 10 (beta 81 219)
--   [ 0.23238372272745833,0.252972980515086,0.22708315774257903
--   , 0.25807200295967214,0.29794072226119983,0.24534701159196015
--   , 0.24766870269839578,0.2994199351220346,0.2728157476212405,0.2593318159573564
--   ]
--
beta :: PrimMonad m => Double -> Double -> RandT m Double -- | Cauchy distribution (from Statistics.Distribution.Cauchy) -- -- 
--   λ> mwc $ listOf 10 (cauchy 0 0.1)
--   [ -0.3932758718373347,0.490467375093784,4.2620417667423555e-2
--   , 3.370509874905657e-2,-8.186484692937862e-2,9.371858212168262e-2
--   , -1.1095818809115384e-2,3.0353983716155386e-2,0.22759697862410477
--   , -0.1881828277028582 ]
--
cauchy :: PrimMonad m => Double -> Double -> RandT m Double -- | Cauchy distribution around 0, with scale 1 (from -- Statistics.Distribution.Cauchy) -- -- 
--   λ> mwc $ listOf 10 cauchyStd
--   [ 9.409701589649838,-7.361963972107541,0.168746305673769
--   , 5.091825420838711,-0.326080163135388,-1.2989850787629456
--   , -2.685658063444485,0.22671438734899435,-1.602349559644217e-2
--   , -0.6476292643908057 ]
--
cauchyStd :: PrimMonad m => RandT m Double -- | Chi-squared distribution (from -- Statistics.Distribution.ChiSquared) -- -- 
--   λ> mwc $ listOf 10 (chiSquare 4)
--   [ 8.068852054279787,1.861584389294606,6.3049415103095265
--   , 1.0512164068833838,1.6243237867165086,5.284901049954076
--   , 0.4773242487947021,1.1753876666374887,5.21554771873363
--   , 3.477574639460651 ]
--
chiSquared :: PrimMonad m => Int -> RandT m Double -- | Fisher's F-Distribution (from -- Statistics.Distribution.FDistribution) -- -- 
--   λ> mwc $ listOf 10 (fisher 4 3)
--   [ 3.437898578540642,0.844120450719367,1.9907851466347173
--   , 2.0089975147012784,1.3729208790549117,0.9380430357924707
--   , 2.642389323945247,1.0918121624055352,0.45650856735477335
--   , 2.5134537326659196 ]
--
fisher :: PrimMonad m => Int -> Int -> RandT m Double -- | Gamma distribution (from Statistics.Distribution.Gamma) -- -- 
--   λ> mwc $ listOf 10 (gamma 3 0.1)
--   [ 5.683745415884202e-2,0.20726188766138176,0.3150672538487696
--   , 0.4250825346490057,0.5586516230326105,0.46897413151474315
--   , 0.18374916962208182,9.93000480494153e-2,0.6057279704154832
--   , 0.11070190282993911 ]
--
gamma :: PrimMonad m => Double -> Double -> RandT m Double -- | Gamma distribution, without checking whether the parameter are valid -- (from Statistics.Distribution.Gamma) -- -- 
--   λ> mwc $ listOf 10 (improperGamma 3 0.1)
--   [ 0.30431838005485,0.4044380297376584,2.8950141419406657e-2
--   , 0.468271612850147,0.18587792578128381,0.22735854572527045
--   , 0.5168050216325927,5.896911236207261e-2,0.24654560998405564
--   , 0.10557650513145429 ]
--
improperGamma :: PrimMonad m => Double -> Double -> RandT m Double -- | Geometric distribution. -- -- Distribution of the number of trials needed to get one success. See -- Statistics.Distribution.Geometric -- -- 
--   λ> mwc $ listOf 10 (geometric 0.8)
--   [2,1,1,1,1,1,1,2,1,5]
--
geometric :: PrimMonad m => Double -> RandT m Int -- | Geometric distribution. -- -- Distribution of the number of failures before getting one success. See -- Statistics.Distribution.Geometric -- -- 
--   λ> mwc $ listOf 10 (geometric0 0.8)
--   [0,0,0,0,0,1,1,0,0,0]
--
geometric0 :: PrimMonad m => Double -> RandT m Int -- | Student-T distribution (from -- Statistics.Distribution.StudentT) -- -- 
--   λ> mwc $ listOf 10 (student 0.2)
--   [ -14.221373473810829,-29.395749168822267,19.448665112984997
--   , -30.00446058929083,-0.5033202547957609,2.321975597874013
--   , 0.7884787761643617,-0.1895113832448149,-131.12901170537924
--   , 1.371956948317759 ]
--
student :: PrimMonad m => Double -> RandT m Double -- | Uniform distribution between a and b (from -- Statistics.Distribution.Uniform) -- -- 
--   λ> mwc $ listOf 10 (uniform 0.1 0.2)
--   [ 0.1711914559256124,0.1275212181343327,0.15347702635758945
--   , 0.1743662387063698,0.12047749686635312,0.10719840237585587
--   , 0.10543681342025846,0.13482973080648325,0.19779298960413577
--   , 0.1681037592576508 ]
--
uniform :: PrimMonad m => Double -> Double -> RandT m Double -- | Normal distribution (from Statistics.Distribution.Normal) -- -- 
--   λ> mwc $ listOf 10 (normal 4 1)
--   [ 3.6815394812555144,3.5958531529526727,3.775960990625964
--   , 4.413109650155896,4.825826384709198,4.805629590118984
--   , 5.259267547365003,4.45410634165052,4.886537243027636
--   , 3.0409409067356954 ]
--
normal :: PrimMonad m => Double -> Double -> RandT m Double -- | The standard normal distribution (mean = 0, stddev = 1) (from -- Statistics.Distribution.Normal) -- -- 
--   λ> mwc $ listOf 10 standard
--   [ 0.2252627935262769,1.1831885443897947,-0.6577353418647461
--   , 2.1574536855051853,-0.16983072710637676,0.9667954287638821
--   , -1.8758605246293683,-0.8578048838241616,1.9516838769731923
--   , 0.43752574431460434 ]
--
standard :: PrimMonad m => RandT m Double -- | Create a normal distribution using parameters estimated from the -- sample (from Statistics.Distribution.Normal) -- -- 
--   λ> mwc . listOf 10 $ 
--        normalFromSample $ 
--          V.fromList [1,1,1,3,3,3,4
--                     ,4,4,4,4,4,4,4
--                     ,4,4,4,4,4,5,5
--                     ,5,7,7,7]
--   [ 7.1837511677441395,2.388433817342809,5.252282321156134
--   , 4.988163140851522,0.40102386713467864,4.4840751065620665
--   , 2.1471370686776874,2.6591948802201046,3.843667372514598
--   , 1.7650436484843248 ]
--
normalFromSample :: PrimMonad m => Sample -> RandT m Double -- | Exponential distribution (from -- Statistics.Distribution.Exponential) -- -- 
--   λ> mwc $ listOf 10 (exponential 0.2)
--   [ 5.713524665694821,1.7774315204594584,2.434017573227628
--   , 5.463202731505528,0.5403008025455847,14.346316301765576
--   , 7.380393612391503,24.800854500680032,0.8731076703020924
--   , 6.1661076502236645 ]
--
exponential :: PrimMonad m => Double -> RandT m Double -- | Exponential distribution given a sample (from -- Statistics.Distribution.Exponential) -- -- 
--   λ> mwc $ listOf 10 (exponentialFromSample $ V.fromList [1,1,1,0])
--   [ 0.4237050903604833,1.934301502525168,0.7435728843566659
--   , 1.8720263209574293,0.605750265970631,0.24103955067365979
--   , 0.6294952762436511,1.660404952631443,0.6448230847113577
--   , 0.8891555734786789 ]
--
exponentialFromSample :: PrimMonad m => Sample -> RandT m Double -- | Sample from a continuous distribution from the statistics -- package -- -- 
--   λ> import qualified Statistics.Distribution.Normal as Normal
--   λ> mwc $ continuous (Normal.normalDistr 0 1)
--   -0.7266583064693862
--
-- -- This is equivalent to using normal from this module. continuous :: (ContGen d, PrimMonad m) => d -> RandT m Double -- | Sample from a discrete distribution from the statistics -- package -- -- 
--   λ> import qualified Statistics.Distribution.Normal as Normal
--   λ> mwc $ discrete (Geo.geometric 0.6)
--   2
--
-- -- This is equivalent to using geometric from this module. discrete :: (DiscreteGen d, PrimMonad m) => d -> RandT m Int -- | Easy, composable and efficient random number generation, with support -- for distributions over a finite set and your usual probability -- distributions. module Math.Probable