probable: Easy and reasonably efficient probabilistic programming and random generation

This is a package candidate release! Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

[maintain] [Publish]

Warnings:

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.


[Skip to Readme]

Properties

Versions 0.1.0.0, 0.1.1, 0.1.2, 0.1.3, 0.1.3
Change log None available
Dependencies base (>=4.5 && <5), mtl, mwc-random (>=0.10), primitive (>=0.6), statistics (>=0.14), transformers (>=0.3), vector (>=0.10) [details]
License BSD-3-Clause
Copyright 2014-2016 Alp Mestanogullari
Author Alp Mestanogullari
Maintainer alpmestan@gmail.com
Category Math, Statistics
Home page http://github.com/alpmestan/probable
Bug tracker http://github.com/alpmestan/probable/issues
Source repo head: git clone https://github.com/alpmestan/probable.git
Uploaded by AlpMestanogullari at 2018-02-11T11:44:34Z

Modules

[Index]

Downloads

Maintainer's Corner

Package maintainers

For package maintainers and hackage trustees


Readme for probable-0.1.3

[back to package description]

probable

Build Status

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.