-- | Randomized values
module Numeric.Probability.Random where

import qualified Numeric.Probability.Distribution as Dist
import qualified Numeric.Probability.Transition   as Trans

import qualified System.Random as Random
import System.Random (Random, )

import Control.Applicative (Applicative(..))
import Control.Monad.Trans.State (State, state, evalState, runState, )

import qualified System.IO as IO
import Prelude hiding (print)


-- *  random generator

-- | Random values
newtype T a = Cons {forall a. T a -> State StdGen a
decons :: State Random.StdGen a}

instance Monad T where
   return :: forall a. a -> T a
return a
x = forall a. State StdGen a -> T a
Cons (forall (m :: * -> *) a. Monad m => a -> m a
return a
x)
   Cons State StdGen a
x >>= :: forall a b. T a -> (a -> T b) -> T b
>>= a -> T b
y =
      forall a. State StdGen a -> T a
Cons (forall a. T a -> State StdGen a
decons forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> T b
y forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< State StdGen a
x)

instance Functor T where
   fmap :: forall a b. (a -> b) -> T a -> T b
fmap a -> b
f = forall a. State StdGen a -> T a
Cons forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. T a -> State StdGen a
decons

instance Applicative T where
   pure :: forall a. a -> T a
pure a
x = forall a. State StdGen a -> T a
Cons (forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x)
   T (a -> b)
fm <*> :: forall a b. T (a -> b) -> T a -> T b
<*> T a
m = forall a. State StdGen a -> T a
Cons (forall a. T a -> State StdGen a
decons T (a -> b)
fm forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. T a -> State StdGen a
decons T a
m)

randomR :: Random.Random a => (a, a) -> T a
randomR :: forall a. Random a => (a, a) -> T a
randomR (a, a)
rng =
   forall a. State StdGen a -> T a
Cons (forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
state (forall a g. (Random a, RandomGen g) => (a, a) -> g -> (a, g)
Random.randomR (a, a)
rng))

{- |
Run random action in 'IO' monad.
-}
run :: T a -> IO a
run :: forall a. T a -> IO a
run = forall (m :: * -> *) a. MonadIO m => (StdGen -> (a, StdGen)) -> m a
Random.getStdRandom forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall s a. State s a -> s -> (a, s)
runState forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. T a -> State StdGen a
decons

{- |
Run random action without 'IO' using a seed.
-}
runSeed :: Random.StdGen -> T a -> a
runSeed :: forall a. StdGen -> T a -> a
runSeed StdGen
g T a
r = forall s a. State s a -> s -> a
evalState (forall a. T a -> State StdGen a
decons T a
r) StdGen
g


print :: Show a => T a -> IO ()
print :: forall a. Show a => T a -> IO ()
print T a
r  =  forall a. Show a => a -> IO ()
IO.print forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a. T a -> IO a
run T a
r

-- instance Show (IO a) where
--   show _ = ""

pick :: (Num prob, Ord prob, Random prob) =>
   Dist.T prob a -> T a
pick :: forall prob a. (Num prob, Ord prob, Random prob) => T prob a -> T a
pick T prob a
d = forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall prob a. (Num prob, Ord prob) => T prob a -> prob -> a
Dist.selectP T prob a
d forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall a. Random a => (a, a) -> T a
randomR (prob
0,prob
1)


-- *  random distribution

-- | Randomized distribution
type Distribution prob a = T (Dist.T prob a)

above, below :: (Num prob, Ord prob, Ord a) =>
   prob -> Distribution prob a -> Distribution prob (Dist.Select a)
above :: forall prob a.
(Num prob, Ord prob, Ord a) =>
prob -> Distribution prob a -> Distribution prob (Select a)
above prob
p = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall prob a.
(Num prob, Ord prob, Ord a) =>
prob -> T prob a -> T prob (Select a)
Dist.above prob
p)
below :: forall prob a.
(Num prob, Ord prob, Ord a) =>
prob -> Distribution prob a -> Distribution prob (Select a)
below prob
p = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall prob a.
(Num prob, Ord prob, Ord a) =>
prob -> T prob a -> T prob (Select a)
Dist.below prob
p)

{- |
'dist' converts a list of randomly generated values into
a distribution by taking equal weights for all values.
Thus @dist (replicate n rnd)@ simulates @rnd@ @n@ times
and returns an estimation of the distribution represented by @rnd@.
-}
dist :: (Fractional prob, Ord a) => [T a] -> Distribution prob a
dist :: forall prob a.
(Fractional prob, Ord a) =>
[T a] -> Distribution prob a
dist = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall prob a. (Num prob, Ord a) => T prob a -> T prob a
Dist.norm forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall prob a. Fractional prob => Spread prob a
Dist.uniform) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence


-- * Randomized changes

-- | random change
type Change a = a -> T a

change :: (Num prob, Ord prob, Random prob) =>
   Trans.T prob a -> Change a
change :: forall prob a.
(Num prob, Ord prob, Random prob) =>
T prob a -> Change a
change T prob a
t = forall prob a. (Num prob, Ord prob, Random prob) => T prob a -> T a
pick forall b c a. (b -> c) -> (a -> b) -> a -> c
. T prob a
t


-- * Randomized transitions

-- | random transition
type Transition prob a = a -> Distribution prob a

type ApproxDist a = T [a]




{-
for quickCheck

LAWS

  const . pick = random . const

-}