module Data.Stochastic (
certain
, uniform
, discrete
, bernoulli
, normal
, sample
, sample_
, sampleN
, sampleIO
, sampleIO_
, sampleION
, certainProcess
, uniformProcess
, discreteProcess
, normalProcess
, runProcess
, runProcess_
, runProcessN
, sampleProcess
, sampleProcess_
, sampleProcessN
, sampleProcessIO
, sampleProcessION
, module Data.Stochastic.Types
, module Data.Stochastic.Internal
) where
import Control.Monad.Trans
import Control.Monad.Writer
import Data.Stochastic.Internal
import Data.Stochastic.Types
import qualified Data.Sequence as S
import System.Random
composeProcess :: Integral i => i -> StochProcess -> (Double -> StochProcess) -> StochProcess
composeProcess i pr f = if i <= 0 then pr
else (composeProcess (i1) pr f) >>= f
sampleProcess_ :: StochProcess -> StdGen -> Double
sampleProcess_ ma g = flip sample_ g $ liftM fst $ runWriterT ma
sampleProcess :: StochProcess -> StdGen -> (Double, StdGen)
sampleProcess ma g = flip sample g $ liftM fst $ runWriterT ma
sampleProcessIO :: StochProcess -> IO (Double, StdGen)
sampleProcessIO ma = do
gen <- newStdGen
return $ sampleProcess ma gen
sampleProcessIO_ :: StochProcess -> IO Double
sampleProcessIO_ ma = fst <$> sampleProcessIO ma
sampleProcessION :: (Integral i) => i -> StochProcess -> IO (S.Seq Double)
sampleProcessION i ma = do
gen <- newStdGen
return $ sampleProcessN i ma gen
sampleProcessN :: (Integral i) => i -> StochProcess -> StdGen -> S.Seq Double
sampleProcessN i ma g = if i <= 0 then S.empty
else let (a, gen) = sampleProcess ma g
in a S.<| sampleProcessN (i1) ma gen
runProcess :: StochProcess -> StdGen -> (S.Seq Double, StdGen)
runProcess ma g = flip sample g $ execWriterT ma
runProcess_ :: StochProcess -> StdGen -> S.Seq Double
runProcess_ ma g = fst $ runProcess ma g
runProcessN :: (Integral i) => i -> StochProcess -> StdGen -> S.Seq (S.Seq Double)
runProcessN n pr gen = if n <= 0 then S.empty
else let (seq, gen') = runProcess pr gen
in seq S.<| runProcessN (n1) pr gen'
normalProcess :: Mean -> StDev -> StochProcess
normalProcess mean std = do
sample <- lift $ normal mean std
tell $ S.singleton sample
return sample
certainProcess :: Double -> StochProcess
certainProcess a = do
sample <- lift $ certain a
tell $ S.singleton sample
return sample
discreteProcess :: [(Double, Double)] -> StochProcess
discreteProcess a = do
sample <- lift $ discrete a
tell $ S.singleton sample
return sample
uniformProcess :: [Double] -> StochProcess
uniformProcess l = do
sample <- lift $ uniform l
tell $ S.singleton sample
return sample
normal :: RandomGen g => Mean -> StDev -> Sample g Distribution Double
normal m s = mkSample $ Normal m $ abs s
bernoulli :: RandomGen g => Double -> Sample g Distribution Bool
bernoulli f = mkSample $ Bernoulli f
discrete :: RandomGen g => [(a, Double)] -> Sample g Distribution a
discrete [] = error "do not construct empty discrete distributions"
discrete l = mkSample $ Discrete l
uniform :: (RandomGen g) => [a] -> Sample g Distribution a
uniform l = mkSample $ Uniform l
certain :: (RandomGen g, Sampleable d) => a -> Sample g d a
certain = mkSample . certainDist
sample :: (RandomGen g, Sampleable d) => Sample g d a -> g -> (a, g)
sample s g = let (dist, g') = runSample s g
(a, g'') = sampleFrom dist g'
in (a, snd $ next g'')
sample_ :: (RandomGen g, Sampleable d) => Sample g d a -> g -> a
sample_ s g = fst $ sample s g
sampleN :: (RandomGen g, Sampleable d, Integral i) => i -> Sample g d a -> g -> S.Seq a
sampleN i s g = if i <= 0 then S.empty
else let (a, g') = sample s g
in a S.<| sampleN (i 1) s g'
sampleIO :: Sampleable d => Sample StdGen d a -> IO (a, StdGen)
sampleIO s = sample s <$> newStdGen
sampleIO_ :: Sampleable d => Sample StdGen d a -> IO a
sampleIO_ s = fst <$> (sample s <$> newStdGen)
sampleION :: (Sampleable d, Integral i) => i -> Sample StdGen d a -> IO (S.Seq a)
sampleION i s = sampleN i s <$> newStdGen
mkSample :: (RandomGen g, Sampleable d) => d a -> Sample g d a
mkSample d = Sample $ \g -> (d, snd $ next g)