Simulation.Aivika.Dynamics

Tested with: GHC 6.12.1

Aivika is a multi-paradigm simulation library. It allows us to integrate a system of ordinary differential equations. Also it can be applied to the Discrete Event Simulation. It supports the event-oriented, process-oriented and activity-oriented paradigms. Aivika also supports the Agent-based Modeling. Finally, it can be applied to System Dynamics.

Dynamics

data Dynamics a

A value in the Dynamics monad represents a dynamic process, i.e. a polymorphic time varying function.

Instances

Monad Dynamics

Functor Dynamics

MonadIO Dynamics

Eq (Dynamics a)

Floating a => Floating (Dynamics a)

Fractional a => Fractional (Dynamics a)

Num a => Num (Dynamics a)

Show (Dynamics a)

class DynamicsTrans m where

The DynamicsTrans class defines a type which the Dynamics computation can be lifted to.

Methods

liftD :: Dynamics a -> m a

Lift the computation.

Instances

DynamicsTrans DynamicsProc

DynamicsTrans DynamicsCont

data Specs

It defines the simulation specs.

Constructors

Specs

Fields

spcStartTime :: Double

the start time

spcStopTime :: Double

the stop time

spcDT :: Double

the integration time step

spcMethod :: Method

the integration method

Instances

Eq Specs

Ord Specs

Show Specs

data Method

It defines the integration method.

Constructors

Euler

Euler's method

RungeKutta2

the 2nd order Runge-Kutta method

RungeKutta4

the 4th order Runge-Kutta method

Instances

Eq Method

Ord Method

Show Method

runDynamics1 :: Dynamics (Dynamics a) -> Specs -> IO a

Run the simulation and return the result in the last time point using the specified simulation specs.

runDynamics :: Dynamics (Dynamics a) -> Specs -> IO [a]

Run the simulation and return the results in all integration time points using the specified simulation specs.

runDynamicsIO :: Dynamics (Dynamics a) -> Specs -> IO [IO a]

Run the simulation and return the results in all integration time points using the specified simulation specs.

Time parameters

starttime :: Dynamics Double

Return the start simulation time.

stoptime :: Dynamics Double

Return the stop simulation time.

dt :: Dynamics Double

Return the integration time step.

time :: Dynamics Double

Return the current simulation time.

Maximum and Minimum

maxD :: Ord a => Dynamics a -> Dynamics a -> Dynamics a

Return the maximum.

minD :: Ord a => Dynamics a -> Dynamics a -> Dynamics a

Return the minimum.

Integrals

data Integ

The Integ type represents an integral.

newInteg :: Dynamics Double -> Dynamics Integ

Create a new integral with the specified initial value.

integInit :: Integ -> Dynamics Double

The initial value.

integValue :: Integ -> Dynamics Double

Return the integral's value.

integDiff :: Integ -> Dynamics Double -> Dynamics ()

Set the derivative for the integral.

Table Functions

lookupD :: Dynamics Double -> Array Int (Double, Double) -> Dynamics Double

Lookup x in a table of pairs (x, y) using linear interpolation.

lookupStepwiseD :: Dynamics Double -> Array Int (Double, Double) -> Dynamics Double

Lookup x in a table of pairs (x, y) using stepwise function.

Interpolation

initD :: Dynamics a -> Dynamics a

Return the initial value.

discrete :: Dynamics a -> Dynamics a

Discretize the computation in the integration time points.

interpolate :: Dynamics Double -> Dynamics Double

Interpolate the computation based on the integration time points only.

Memoization and Sequential Calculations

class MArray IOArray e IO => Memo e

The Memo class specifies a type for which an array can be created.

Instances

Memo e

class MArray IOUArray e IO => UMemo e

The UMemo class specifies a type for which an unboxed array exists.

Instances

MArray IOUArray e IO => UMemo e

memo :: Memo e => (Dynamics e -> Dynamics e) -> Dynamics e -> Dynamics (Dynamics e)

Memoize and order the computation in the integration time points using the specified interpolation and being aware of the Runge-Kutta method.

umemo :: UMemo e => (Dynamics e -> Dynamics e) -> Dynamics e -> Dynamics (Dynamics e)

Memoize and order the computation in the integration time points using the specified interpolation and being aware of the Runge-Kutta method.

memo0 :: Memo e => (Dynamics e -> Dynamics e) -> Dynamics e -> Dynamics (Dynamics e)

Memoize and order the computation in the integration time points using the specified interpolation and without knowledge of the Runge-Kutta method.

umemo0 :: UMemo e => (Dynamics e -> Dynamics e) -> Dynamics e -> Dynamics (Dynamics e)

Memoize and order the computation in the integration time points using the specified interpolation and without knowledge of the Runge-Kutta method.

Utility

once :: Dynamics a -> Dynamics (Dynamics a)

Call the computation only once.

Event Queue

data DynamicsQueue

The DynamicsQueue type represents the event queue.

newQueue :: Dynamics DynamicsQueue

Create a new event queue.

enqueueDC :: DynamicsQueue -> Dynamics Double -> Dynamics (() -> IO ()) -> Dynamics ()

Enqueue the event which must be actuated at the specified time.

enqueueD :: DynamicsQueue -> Dynamics Double -> Dynamics () -> Dynamics ()

Enqueue the event which must be actuated at the specified time.

runQueue :: DynamicsQueue -> Dynamics ()

Run the event queue processing its events.

References

data DynamicsRef a

The DynamicsRef type represents a mutable variable similar to the IORef variable but only bound to some event queue, which makes the variable coordinated with that queue.

newRef :: DynamicsQueue -> a -> Dynamics (DynamicsRef a)

Create a new reference bound to the specified event queue.

refQueue :: DynamicsRef a -> DynamicsQueue

Return the bound event queue.

readRef :: DynamicsRef a -> Dynamics a

Read the value of a reference, forcing the bound event queue to raise the events in case of need.

writeRef :: DynamicsRef a -> a -> Dynamics ()

Write a new value into the reference.

writeRef' :: DynamicsRef a -> a -> Dynamics ()

A strict version of the writeRef function.

modifyRef :: DynamicsRef a -> (a -> a) -> Dynamics ()

Mutate the contents of the reference, forcing the bound event queue to raise all pending events in case of need.

modifyRef' :: DynamicsRef a -> (a -> a) -> Dynamics ()

A strict version of the modifyRef function.

Discontinuous Processes

data DynamicsPID

Represents a process handler, its PID.

Instances

Eq DynamicsPID

data DynamicsProc a

Specifies a discontinuous process that can be suspended at any time and then resumed later.

Instances

Monad DynamicsProc

Functor DynamicsProc

MonadIO DynamicsProc

DynamicsTrans DynamicsProc

newPID :: DynamicsQueue -> Dynamics DynamicsPID

Create a new process PID.

pidQueue :: DynamicsPID -> DynamicsQueue

Return the bound event queue.

holdProcD :: Dynamics Double -> DynamicsProc ()

Hold the process for the specified time period.

holdProc :: Double -> DynamicsProc ()

Hold the process for the specified time period.

passivateProc :: DynamicsProc ()

Passivate the process.

procPassive :: DynamicsPID -> DynamicsProc Bool

Test whether the process with the specified PID is passivated.

reactivateProc :: DynamicsPID -> DynamicsProc ()

Reactivate a process with the specified PID.

procPID :: DynamicsProc DynamicsPID

Return the current process PID.

runProc :: DynamicsProc () -> DynamicsPID -> Dynamics Double -> Dynamics ()

Start the process with the specified PID at the desired time.

Resources

data DynamicsResource

Represents a limited resource.

Instances

Eq DynamicsResource

newResource :: DynamicsQueue -> Int -> Dynamics DynamicsResource

Create a new resource with the specified initial count.

resourceQueue :: DynamicsResource -> DynamicsQueue

Return the bound event queue.

resourceInitCount :: DynamicsResource -> Int

Return the initial count of the resource.

resourceCount :: DynamicsResource -> DynamicsProc Int

Return the current count of the resource.

requestResource :: DynamicsResource -> DynamicsProc ()

Request for the resource decreasing its count in case of success, otherwise suspending the discontinuous process until some other process releases the resource.

releaseResource :: DynamicsResource -> DynamicsProc ()

Release the resource increasing its count and resuming one of the previously suspended processes as possible.

Agent-based Modeling

data Agent

Represents an agent.

Instances

Eq Agent

data AgentState

Represents the agent state.

Instances

Eq AgentState

newAgent :: DynamicsQueue -> Dynamics Agent

Create an agent bound with the specified event queue.

newState :: Agent -> Dynamics AgentState

Create a new state.

newSubstate :: AgentState -> Dynamics AgentState

Create a child state.

agentQueue :: Agent -> DynamicsQueue

Return the bound event queue.

agentState :: Agent -> Dynamics (Maybe AgentState)

Return the selected downmost active state.

activateState :: AgentState -> Dynamics ()

Select the next downmost active state.

initState :: AgentState -> Dynamics ()

Activate the child state during the direct activation of the parent state. This call is ignored in other cases.

stateAgent :: AgentState -> Agent

Return the corresponded agent.

stateParent :: AgentState -> Maybe AgentState

Return the parent state or Nothing.

addTimeoutD :: AgentState -> Dynamics Double -> Dynamics () -> Dynamics ()

Add to the state a timeout handler that will be actuated in the specified time period, while the state remains active.

addTimeout :: AgentState -> Double -> Dynamics () -> Dynamics ()

Add to the state a timeout handler that will be actuated in the specified time period, while the state remains active.

addTimerD :: AgentState -> Dynamics Double -> Dynamics () -> Dynamics ()

Add to the state a timer handler that will be actuated in the specified time period and then repeated again many times, while the state remains active.

addTimer :: AgentState -> Double -> Dynamics () -> Dynamics ()

Add to the state a timer handler that will be actuated in the specified time period and then repeated again many times, while the state remains active.

stateActivation :: AgentState -> Dynamics () -> Dynamics ()

Set the activation computation for the specified state.

stateDeactivation :: AgentState -> Dynamics () -> Dynamics ()

Set the deactivation computation for the specified state.