# probable: Easy and reasonably efficient probabilistic programming and random generation

[ bsd3, library, math, statistics ] [ Propose Tags ]

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 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. [Skip to Readme] Versions [faq] 0.1.0.0, 0.1.1, 0.1.2, 0.1.3 base (>=4.8 && <5), mtl (==2.2.*), mwc-random (>=0.10 && <0.15), primitive (==0.6.*), statistics (==0.14.*), transformers (>=0.3 && <0.6), vector (>=0.10 && <0.13) [details] BSD-3-Clause 2014-2016 Alp Mestanogullari Alp Mestanogullari alpmestan@gmail.com Revision 3 made by AlpMestanogullari at Sun Mar 3 08:11:17 UTC 2019 Math, Statistics http://github.com/alpmestan/probable http://github.com/alpmestan/probable/issues head: git clone https://github.com/alpmestan/probable.git by AlpMestanogullari at Sun Feb 11 11:45:40 UTC 2018 NixOS:0.1.3 1811 total (72 in the last 30 days) 2.0 (votes: 1) [estimated by rule of succession] λ λ λ Docs available Last success reported on 2018-02-11 ## Modules [Index] ## Downloads Note: This package has metadata revisions in the cabal description newer than included in the tarball. To unpack the package including the revisions, use 'cabal get'. #### Maintainer's Corner For package maintainers and hackage trustees ## Readme for probable-0.1.3 [back to package description] # probable Simple random value generation for haskell, using an efficient random generator and minimizing system calls. But the library also lets you work with distributions over a finite set, adapting code from Eric Kidd's posts, and all the usual distributions covered in the statistics package. You can see how it looks in examples, or below. You can view the documentation for 0.1 here. ## Example Simple example of random generation for your types, using probable. module Main where import Control.Applicative import Control.Monad import Math.Probable import qualified Data.Vector.Unboxed as VU data Person = Person { age :: Int , weight :: Double , salary :: Int } deriving (Eq, Show) person :: RandT IO Person person = Person <$> intIn (1, 100)
<*> doubleIn (2, 130)
<*> intIn (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


Distributions over finite sets, conditional probabilities and random sampling.

module Main where

import Math.Probable

import qualified Data.Vector as V

data Book = Interesting
| Boring
deriving (Eq, Show)

bookPrior :: Finite d => d Book
bookPrior = weighted [ (Interesting, 0.2)
, (Boring, 0.8)
]

twoBooks :: Finite d => d (Book, Book)
twoBooks = do
book1 <- bookPrior
book2 <- bookPrior
return (book1, book2)

sampleBooks :: RandT IO (V.Vector Book)
sampleBooks = vectorOf 10 bookPrior

oneInteresting :: Fin (Book, Book)
oneInteresting = bayes $do (b1, b2) <- twoBooks condition (b1 == Interesting || b2 == Interesting) return (b1, b2) main :: IO () main = do print$ exact bookPrior
mwc sampleBooks >>= print
print $exact twoBooks print$ exact oneInteresting


# Contact

This library is written and maintained by Alp Mestanogullari.

Feel free to contact me for any feedback, comment, suggestion, bug report and what not.