Probability

Auxiliary definitions

Events

type Event a = a -> Bool

oneOf :: Eq a => [a] -> Event a

just :: Eq a => a -> Event a

Probabilities

newtype Probability

Constructors

P ProbRep

Instances

Show Probability

type ProbRep = Float

precision :: Int

showPfix :: ProbRep -> String

roundRel :: RealFrac a => Int -> a -> a

showP :: ProbRep -> String

errorMargin :: ProbRep

Monad composition

(>@>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c

binary composition

sequ :: Monad m => [a -> m a] -> a -> m a

composition of a list of monadic functions

Deterministic and probabilistic values

Distributions

newtype Dist a

probability disribution

Constructors

D

Fields

unD :: [(a, ProbRep)]

Instances

Monad Dist

Functor Dist

MonadPlus Dist

Sim Dist

Iterate Dist

(Ord a, Eq a) => Eq (Dist a)

(Ord a, Show a) => Show (Dist a)

Expected a => Expected (Dist a)

isZero :: Dist a -> Bool

Auxiliary functions for constructing and working with distributions

onD :: ([(a, ProbRep)] -> [(a, ProbRep)]) -> Dist a -> Dist a

sizeD :: Dist a -> Int

checkD :: Dist a -> Dist a

mkD :: [(a, ProbRep)] -> Dist a

sumP :: [(a, ProbRep)] -> ProbRep

sortP :: [(a, ProbRep)] -> [(a, ProbRep)]

Normalization = grouping

normBy :: Ord a => (a -> a -> Bool) -> Dist a -> Dist a

accumBy :: Num b => (a -> a -> Bool) -> [(a, b)] -> [(a, b)]

norm :: Ord a => Dist a -> Dist a

norm' :: Ord a => [(a, ProbRep)] -> [(a, ProbRep)]

Operations on distributions

joinWith :: (a -> b -> c) -> Dist a -> Dist b -> Dist c

product of independent distributions, identical to Monad.liftM2

prod :: Dist a -> Dist b -> Dist (a, b)

Spread: functions to convert a list of values into a distribution

type Spread a = [a] -> Dist a

distribution generators

certainly :: Trans a

impossible :: Dist a

choose :: ProbRep -> a -> a -> Dist a

enum :: [ProbRep] -> Spread a

enumPC :: [ProbRep] -> Spread a

relative :: [Int] -> Spread a

shape :: (Float -> Float) -> Spread a

linear :: Float -> Spread a

uniform :: Spread a

negexp :: Spread a

normal :: Spread a

normalCurve :: Float -> Float -> Float -> Float

extract :: Dist a -> [a]

extracting and mapping the domain of a distribution

mapD :: (a -> b) -> Dist a -> Dist b

unfoldD :: Dist (Dist a) -> Dist a

unfold a distribution of distributions into one distribution

cond :: Dist Bool -> Dist a -> Dist a -> Dist a

conditional distribution

truth :: Dist Bool -> Probability

(|||) :: Dist a -> Event a -> Dist a

conditional probability

data Select a

filtering distributions

Constructors

Case a

Other

Instances

Eq a => Eq (Select a)

Ord a => Ord (Select a)

Show a => Show (Select a)

above :: Ord a => ProbRep -> Dist a -> Dist (Select a)

scale :: [(a, ProbRep)] -> Dist a

filterD :: (a -> Bool) -> Dist a -> Dist a

selectP :: Dist a -> ProbRep -> a

selecting from distributions

scanP :: ProbRep -> [(a, ProbRep)] -> a

(??) :: Event a -> Dist a -> Probability

class ToFloat a where

Methods

toFloat :: a -> Float

Instances

ToFloat Float

ToFloat Int

ToFloat Integer

class FromFloat a where

Methods

fromFloat :: Float -> a

Instances

FromFloat Float

FromFloat Int

FromFloat Integer

class Expected a where

Methods

expected :: a -> Float

Instances

Expected Float

Expected Int

Expected Integer

Expected a => Expected [a]

Expected a => Expected (Dist a)

variance :: Expected a => Dist a -> Float

statistical analyses

stddev :: Expected a => Dist a -> Float

Randomized values

R random value

type R a = IO a

Random values

printR :: Show a => R a -> R ()

pick :: Dist a -> R a

RDist random distribution

type RDist a = R (Dist a)

Randomized distributions

rAbove :: Ord a => ProbRep -> RDist a -> RDist (Select a)

Deterministic and probabilistic generators

Transitions

type Change a = a -> a

deterministic generator

type Trans a = a -> Dist a

probabilistic generator

idT :: Trans a

mapT :: Change a -> Trans a -> Trans a

unfoldT :: Dist (Trans a) -> Trans a

Spreading changes into transitions

type SpreadC a = [Change a] -> Trans a

functions to convert a list of changes into a transition

certainlyT :: Change a -> Trans a

maybeT :: ProbRep -> Change a -> Trans a

liftC :: Spread a -> [Change a] -> Trans a

uniformT :: [Change a] -> Trans a

normalT :: [Change a] -> Trans a

linearT :: Float -> [Change a] -> Trans a

enumT :: [ProbRep] -> [Change a] -> Trans a

Spreading transitions into transitions

type SpreadT a = [Trans a] -> Trans a

functions to convert a list of transitions into a transition

liftT :: Spread (Trans a) -> [Trans a] -> Trans a

uniformTT :: [Trans a] -> Trans a

normalTT :: [Trans a] -> Trans a

linearTT :: Float -> [Trans a] -> Trans a

enumTT :: [ProbRep] -> [Trans a] -> Trans a

Randomized generators

Randomized changes

type RChange a = a -> R a

random change

random :: Trans a -> RChange a

Randomized transitions

type RTrans a = a -> RDist a

random transition

type ApproxDist a = R [a]

rDist :: Ord a => [R a] -> RDist a

rDist converts a list of randomly generated values into a distribution by taking equal weights for all values

Iteration and simulation

class Iterate c where

Naming convention:

• * takes n :: Int and a generator and iterates the generator n times
• . produces a single result
• .. produces a trace
• ~ takes k :: Int [and n :: Int] and a generator and simulates the [n-fold repetition of the] generator k times

There are the following functions:

• n *. t iterates t and produces a distribution
• n *.. t iterates t and produces a trace
• k ~. t simulates t and produces a distribution
• (k,n) ~*. t simulates the n-fold repetition of t and produces a distribution
• (k,n) ~.. t simulates the n-fold repetition of t and produces a trace

Iteration captures three iteration strategies: iter builds an n-fold composition of a (randomized) transition while and until implement conditional repetitions

The class Iterate allows the overloading of iteration for different kinds of generators, namely transitions and random changes:

• Trans   a = a -> Dist a    ==>   c = Dist

• RChange a = a -> R a       ==>   c = R = IO

Methods

(*.) :: Int -> (a -> c a) -> a -> c a

while :: (a -> Bool) -> (a -> c a) -> a -> c a

until :: (a -> Bool) -> (a -> c a) -> a -> c a

Instances

Iterate IO

Iterate Dist

class Sim c where

Simulation means to repeat a random chage many times and to accumulate all results into a distribution. Therefore, simulation can be regarded as an approximation of distributions through randomization.

The Sim class allows the overloading of simulation for different kinds of generators, namely transitions and random changes:

• Trans   a = a -> Dist a   ==>   c = Dist

• RChange a = a -> R a      ==>   c = R = IO

Methods

(~.) :: Ord a => Int -> (a -> c a) -> RTrans a

returns the final randomized transition

(~..) :: Ord a => (Int, Int) -> (a -> c a) -> RExpand a

returns the whole trace

(~*.) :: Ord a => (Int, Int) -> (a -> c a) -> RTrans a

Instances

Sim IO

Sim Dist

Tracing

type Trace a = [a]

type Space a = Trace (Dist a)

type Walk a = a -> Trace a

type Expand a = a -> Space a

(>>:) :: Trans a -> Expand a -> Expand a

(>>:) composes the result of a transition with a space (transition is composed on the left)

(a -> m a) -> (a -> [m a]) -> (a -> [m a])

walk :: Int -> Change a -> Walk a

walk is a bounded version of the predefined function iterate

(*..) :: Int -> Trans a -> Expand a

(*..) is identical to (*.), but returns the list of all intermediate distributions

type RTrace a = R (Trace a)

type RSpace a = R (Space a)

type RWalk a = a -> RTrace a

type RExpand a = a -> RSpace a

composelR :: RChange a -> RWalk a -> RWalk a

rWalk :: Int -> RChange a -> RWalk a

rWalk computes a list of values by randomly selecting one value from a distribution in each step.

mergeTraces :: Ord a => [RTrace a] -> RSpace a

mergeTraces converts a list of RTraces into a list of randomized distributions, i.e., an RSpace, by creating a randomized distribution for each list position across all traces