Simulation.Aivika.Lattice.Estimate

Tested with: GHC 8.0.1

The module defines the Estimate monad transformer which is destined for estimating computations within lattice nodes. Such computations are separated from the Event computations. An idea is that the forward-traversing Event computations provide with something that can be observed, while the backward-traversing Estimate computations estimate the received information.

Estimate Monad

data Estimate m a

A value in the Estimate monad transformer represents something that can be estimated within lattice nodes.

Instances

MonadTrans Estimate

Methods

lift :: Monad m => m a -> Estimate m a

Monad m => ParameterLift Estimate m

Methods

liftParameter :: Parameter m a -> Estimate m a

Monad m => MonadCompTrans Estimate m

Methods

liftComp :: m a -> Estimate m a

Monad m => EstimateLift Estimate m

Methods

liftEstimate :: Estimate m a -> Estimate m a

Monad m => Monad (Estimate m)

Methods

(>>=) :: Estimate m a -> (a -> Estimate m b) -> Estimate m b

(>>) :: Estimate m a -> Estimate m b -> Estimate m b

return :: a -> Estimate m a

fail :: String -> Estimate m a

Functor m => Functor (Estimate m)

Methods

fmap :: (a -> b) -> Estimate m a -> Estimate m b

(<$) :: a -> Estimate m b -> Estimate m a

MonadFix m => MonadFix (Estimate m)

Methods

mfix :: (a -> Estimate m a) -> Estimate m a

Applicative m => Applicative (Estimate m)

Methods

pure :: a -> Estimate m a

(<*>) :: Estimate m (a -> b) -> Estimate m a -> Estimate m b

(*>) :: Estimate m a -> Estimate m b -> Estimate m b

(<*) :: Estimate m a -> Estimate m b -> Estimate m a

MonadIO m => MonadIO (Estimate m)

Methods

liftIO :: IO a -> Estimate m a

class EstimateLift t m where

A type class to lift the Estimate computations into other computations.

Minimal complete definition

liftEstimate

Methods

liftEstimate :: Estimate m a -> t m a

Lift the specified Estimate computation into another computation.

Instances

Monad m => EstimateLift Estimate m

Methods

liftEstimate :: Estimate m a -> Estimate m a

runEstimateInStartTime :: MonadDES m => Estimate m a -> Simulation m a

Run the Estimate computation in the start time and return the estimate.

estimateTime :: MonadDES m => Estimate m Double

Like time estimates the current modeling time.

latticeTimeStep :: Parameter LIO Double

The time step used when constructing the lattice. Currently, it is equivalent to dt.

Computations within Lattice

foldEstimate

Arguments

:: (a -> a -> Estimate LIO a)

reduce in the intermediate nodes of the lattice

-> Estimate LIO a

estimate the computation in the final time point and beyond it

-> Simulation LIO (Estimate LIO a)

Fold the estimation of the specified computation.

memoEstimate

Arguments

:: (Estimate LIO a -> Estimate LIO a)

estimate in the intermediate time point of the lattice

-> Estimate LIO a

estimate in the final time point of the lattice or beyond it

-> Simulation LIO (Estimate LIO a)

Estimate the computation in the lattice nodes.

estimateUpSide :: Estimate LIO a -> Estimate LIO a

Estimate the computation in the up side node of the lattice, where latticeTimeIndex is increased by 1 but latticeMemberIndex remains the same.

It is merely equivalent to the following definition:

estimateUpSide = estimateFuture 1 0

estimateDownSide :: Estimate LIO a -> Estimate LIO a

Estimate the computation in the down side node of the lattice, where the both latticeTimeIndex and latticeMemberIndex are increased by 1.

It is merely equivalent to the following definition:

estimateDownSide = estimateFuture 1 1

estimateFuture

Arguments

:: Int

a positive shift of the lattice time index

-> Int

a shift of the lattice member index

-> Estimate LIO a

the source computation

-> Estimate LIO a

Estimate the computation in the shifted lattice node, where the first parameter specifies the positive latticeTimeIndex shift, but the second parameter specifies the latticeMemberIndex shift af any sign.

It allows looking into the future computations. The lattice is constructed in such a way that we can define the past Estimate computation in terms of the future Estimate computation. That is the point.

Regarding the Event computation, a quite opposite rule is true. The future Event computation depends on the past Event computation. But we can update Ref references within the corresponding discrete event simulation and then read them within the Estimate computation, because Ref is Observable.

Error Handling

catchEstimate :: (MonadException m, Exception e) => Estimate m a -> (e -> Estimate m a) -> Estimate m a

Exception handling within Estimate computations.

finallyEstimate :: MonadException m => Estimate m a -> Estimate m b -> Estimate m a

A computation with finalization part like the finally function.

throwEstimate :: (MonadException m, Exception e) => e -> Estimate m a

Like the standard throw function.

Debugging

traceEstimate :: String -> Estimate LIO a -> Estimate LIO a

Show the debug message with the current simulation time and lattice node indices.