Copyright	Copyright (c) 2009-2017 David Sorokin <david.sorokin@gmail.com>
License	BSD3
Maintainer	David Sorokin <david.sorokin@gmail.com>
Stability	experimental
Safe Haskell	Safe-Inferred
Language	Haskell2010

Simulation.Aivika.Trans.Circuit

Contents

The Circuit Arrow
Circuit Primitives
The Arrival Circuit
Delaying the Circuit
The Time Circuit
Conditional Computation
Converting to Signals and Processors
Integrals and Difference Equations
The Circuit Transform
Debugging

Description

Tested with: GHC 8.0.1

It represents a circuit synchronized with the event queue. Also it allows creating the recursive links with help of the proc-notation.

The implementation is based on the Arrow Tutorial.

Synopsis

newtype Circuit m a b = Circuit {
- runCircuit :: a -> Event m (b, Circuit m a b)
}
iterateCircuitInIntegTimes :: MonadDES m => Circuit m a a -> a -> Event m (Task m a)
iterateCircuitInIntegTimes_ :: MonadDES m => Circuit m a a -> a -> Event m ()
iterateCircuitInIntegTimesMaybe :: MonadDES m => Circuit m a (Maybe a) -> a -> Event m ()
iterateCircuitInIntegTimesEither :: MonadDES m => Circuit m a (Either b a) -> a -> Event m (Task m (Either b a))
iterateCircuitInTimes :: MonadDES m => [Double] -> Circuit m a a -> a -> Event m (Task m a)
iterateCircuitInTimes_ :: MonadDES m => [Double] -> Circuit m a a -> a -> Event m ()
iterateCircuitInTimesMaybe :: MonadDES m => [Double] -> Circuit m a (Maybe a) -> a -> Event m ()
iterateCircuitInTimesEither :: MonadDES m => [Double] -> Circuit m a (Either b a) -> a -> Event m (Task m (Either b a))
arrCircuit :: MonadDES m => (a -> Event m b) -> Circuit m a b
accumCircuit :: MonadDES m => (acc -> a -> Event m (acc, b)) -> acc -> Circuit m a b
arrivalCircuit :: MonadDES m => Circuit m a (Arrival a)
delayCircuit :: MonadDES m => a -> Circuit m a a
timeCircuit :: MonadDES m => Circuit m a Double
(<?<) :: MonadDES m => Circuit m b c -> Circuit m a (Maybe b) -> Circuit m a (Maybe c)
(>?>) :: MonadDES m => Circuit m a (Maybe b) -> Circuit m b c -> Circuit m a (Maybe c)
filterCircuit :: MonadDES m => (a -> Bool) -> Circuit m a b -> Circuit m a (Maybe b)
filterCircuitM :: MonadDES m => (a -> Event m Bool) -> Circuit m a b -> Circuit m a (Maybe b)
neverCircuit :: MonadDES m => Circuit m a (Maybe b)
circuitSignaling :: MonadDES m => Circuit m a b -> Signal m a -> Signal m b
circuitProcessor :: MonadDES m => Circuit m a b -> Processor m a b
integCircuit :: MonadDES m => Double -> Circuit m Double Double
integCircuitEither :: MonadDES m => Double -> Circuit m (Either Double Double) Double
sumCircuit :: (MonadDES m, Num a) => a -> Circuit m a a
sumCircuitEither :: (MonadDES m, Num a) => a -> Circuit m (Either a a) a
circuitTransform :: (MonadSD m, MonadDES m) => Circuit m a b -> Transform m a b
traceCircuit :: MonadDES m => Maybe String -> Maybe String -> Circuit m a b -> Circuit m a b

The Circuit Arrow

newtype Circuit m a b Source #

Represents a circuit synchronized with the event queue. Besides, it allows creating the recursive links with help of the proc-notation.

Constructors

Circuit
Fields runCircuit :: a -> Event m (b, Circuit m a b) Run the circuit.

Instances

Instances details

MonadDES m => Category (Circuit m :: Type -> Type -> Type) Source #
Instance details Defined in Simulation.Aivika.Trans.Circuit Methods id :: forall (a :: k). Circuit m a a # (.) :: forall (b :: k) (c :: k) (a :: k). Circuit m b c -> Circuit m a b -> Circuit m a c #
MonadDES m => Arrow (Circuit m) Source #
Instance details Defined in Simulation.Aivika.Trans.Circuit Methods arr :: (b -> c) -> Circuit m b c # first :: Circuit m b c -> Circuit m (b, d) (c, d) # second :: Circuit m b c -> Circuit m (d, b) (d, c) # (***) :: Circuit m b c -> Circuit m b' c' -> Circuit m (b, b') (c, c') # (&&&) :: Circuit m b c -> Circuit m b c' -> Circuit m b (c, c') #
MonadDES m => ArrowChoice (Circuit m) Source #
Instance details Defined in Simulation.Aivika.Trans.Circuit Methods left :: Circuit m b c -> Circuit m (Either b d) (Either c d) # right :: Circuit m b c -> Circuit m (Either d b) (Either d c) # (+++) :: Circuit m b c -> Circuit m b' c' -> Circuit m (Either b b') (Either c c') # (\|\|\|) :: Circuit m b d -> Circuit m c d -> Circuit m (Either b c) d #
(MonadDES m, MonadFix m) => ArrowLoop (Circuit m) Source #
Instance details Defined in Simulation.Aivika.Trans.Circuit Methods loop :: Circuit m (b, d) (c, d) -> Circuit m b c #

iterateCircuitInIntegTimes :: MonadDES m => Circuit m a a -> a -> Event m (Task m a) Source #

Iterate the circuit in the integration time points returning a task which completes after the final output of the circuit is received.

iterateCircuitInIntegTimes_ :: MonadDES m => Circuit m a a -> a -> Event m () Source #

Iterate the circuit in the integration time points.

iterateCircuitInIntegTimesMaybe :: MonadDES m => Circuit m a (Maybe a) -> a -> Event m () Source #

Iterate the circuit in the integration time points, interrupting the iteration immediately if Nothing is returned within the Circuit computation.

iterateCircuitInIntegTimesEither :: MonadDES m => Circuit m a (Either b a) -> a -> Event m (Task m (Either b a)) Source #

Iterate the circuit in the integration time points returning a task that computes the final output of the circuit either after all points are exhausted, or after the Left result of type b is received, which interrupts the computation immediately.

iterateCircuitInTimes :: MonadDES m => [Double] -> Circuit m a a -> a -> Event m (Task m a) Source #

Iterate the circuit in the specified time points returning a task which completes after the final output of the circuit is received.

iterateCircuitInTimes_ :: MonadDES m => [Double] -> Circuit m a a -> a -> Event m () Source #

Iterate the circuit in the specified time points.

iterateCircuitInTimesMaybe :: MonadDES m => [Double] -> Circuit m a (Maybe a) -> a -> Event m () Source #

Iterate the circuit in the specified time points, interrupting the iteration immediately if Nothing is returned within the Circuit computation.

iterateCircuitInTimesEither :: MonadDES m => [Double] -> Circuit m a (Either b a) -> a -> Event m (Task m (Either b a)) Source #

Iterate the circuit in the specified time points returning a task that computes the final output of the circuit either after all points are exhausted, or after the Left result of type b is received, which interrupts the computation immediately.

Circuit Primitives

arrCircuit :: MonadDES m => (a -> Event m b) -> Circuit m a b Source #

Create a simple circuit by the specified handling function that runs the computation for each input value to get an output.

accumCircuit :: MonadDES m => (acc -> a -> Event m (acc, b)) -> acc -> Circuit m a b Source #

Accumulator that outputs a value determined by the supplied function.

The Arrival Circuit

arrivalCircuit :: MonadDES m => Circuit m a (Arrival a) Source #

A circuit that adds the information about the time points at which the values were received.

Delaying the Circuit

delayCircuit :: MonadDES m => a -> Circuit m a a Source #

Delay the input by one step using the specified initial value.

The Time Circuit

timeCircuit :: MonadDES m => Circuit m a Double Source #

A circuit that returns the current modeling time.

Conditional Computation

(<?<) Source #

Arguments

:: MonadDES m
=> Circuit m b c	process the event if it presents
-> Circuit m a (Maybe b)	whether there is an event
-> Circuit m a (Maybe c)	the resulting circuit that processes only the represented events

Like <<< but processes only the represented events.

(>?>) Source #

Arguments

:: MonadDES m
=> Circuit m a (Maybe b)	whether there is an event
-> Circuit m b c	process the event if it presents
-> Circuit m a (Maybe c)	the resulting circuit that processes only the represented events

Like >>> but processes only the represented events.

filterCircuit :: MonadDES m => (a -> Bool) -> Circuit m a b -> Circuit m a (Maybe b) Source #

Filter the circuit, calculating only those parts of the circuit that satisfy the specified predicate.

filterCircuitM :: MonadDES m => (a -> Event m Bool) -> Circuit m a b -> Circuit m a (Maybe b) Source #

Filter the circuit within the Event computation, calculating only those parts of the circuit that satisfy the specified predicate.

neverCircuit :: MonadDES m => Circuit m a (Maybe b) Source #

The source of events that never occur.

Converting to Signals and Processors

circuitSignaling :: MonadDES m => Circuit m a b -> Signal m a -> Signal m b Source #

Get a signal transform by the specified circuit.

circuitProcessor :: MonadDES m => Circuit m a b -> Processor m a b Source #

Transform the circuit to a processor.

Integrals and Difference Equations

integCircuit Source #

Arguments

:: MonadDES m
=> Double	the initial value
-> Circuit m Double Double	map the derivative to an integral

An approximation of the integral using Euler's method.

This function can be rather inaccurate as it depends on the time points at wich the Circuit computation is actuated. Also Euler's method per se is not most accurate, although simple enough for implementation.

Consider using the integ function whenever possible. That function can integrate with help of the Runge-Kutta method by the specified integration time points that are passed in the simulation specs to every Simulation, when running the model.

At the same time, the integCircuit function has no mutable state unlike the former. The latter consumes less memory but at the cost of inaccuracy and relatively more slow simulation, had we requested the integral in the same time points.

Regarding the recursive equations, the both functions allow defining them but whithin different computations (either with help of the recursive do-notation or the proc-notation).

integCircuitEither Source #

Arguments

:: MonadDES m
=> Double	the initial value
-> Circuit m (Either Double Double) Double	map either a new `Left` value or the `Right` derivative to an integral

Like integCircuit but allows either setting a new Left integral value, or using the Right derivative when integrating by Euler's method.

sumCircuit Source #

Arguments

:: (MonadDES m, Num a)
=> a	the initial value
-> Circuit m a a	map the difference to a sum

A sum of differences starting from the specified initial value.

Consider using the more accurate diffsum function whener possible as it is calculated in every integration time point specified by specs passed in to every Simulation, when running the model.

At the same time, the sumCircuit function has no mutable state and it consumes less memory than the former.

Regarding the recursive equations, the both functions allow defining them but whithin different computations (either with help of the recursive do-notation or the proc-notation).

sumCircuitEither Source #

Arguments

:: (MonadDES m, Num a)
=> a	the initial value
-> Circuit m (Either a a) a	map either a new `Left` value or the `Right` difference to a sum

Like sumCircuit but allows either setting a new Left value for the sum, or updating it by specifying the Right difference.

The Circuit Transform

circuitTransform :: (MonadSD m, MonadDES m) => Circuit m a b -> Transform m a b Source #

Approximate the circuit as a transform of time varying function, calculating the values in the integration time points and then interpolating in all other time points. The resulting transform computation is synchronized with the event queue.

This procedure consumes memory as the underlying memoization allocates an array to store the calculated values.

Debugging

traceCircuit Source #

Arguments

:: MonadDES m
=> Maybe String	the request message
-> Maybe String	the response message
-> Circuit m a b	a circuit
-> Circuit m a b

Show the debug messages with the current simulation time.