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.Transform

Contents

The Transform Arrow
Delaying the Transform
The Time Transform
Differential and Difference Equations

Description

Tested with: GHC 8.0.1

The module defines something which is most close to the notion of analogous circuit as an opposite to the digital one.

Synopsis

newtype Transform m a b = Transform {
- runTransform :: Dynamics m a -> Simulation m (Dynamics m b)
}
delayTransform :: MonadSD m => Dynamics m Double -> Dynamics m a -> Transform m a a
timeTransform :: Monad m => Transform m a Double
integTransform :: (MonadSD m, MonadFix m) => Dynamics m Double -> Transform m Double Double
integTransformEither :: (MonadSD m, MonadFix m) => Dynamics m Double -> Transform m (Either Double Double) Double
sumTransform :: (MonadSD m, MonadFix m, Num a, MonadMemo m a) => Dynamics m a -> Transform m a a
sumTransformEither :: (MonadSD m, MonadFix m, Num a, MonadMemo m a) => Dynamics m a -> Transform m (Either a a) a

The Transform Arrow

newtype Transform m a b Source #

It allows representing an analogous circuit as an opposite to the digital one.

This is a transform of one time varying function to another usually specified in the integration time points and then interpolated in other time points with help of one of the memoization functions like memo0Dynamics.

Constructors

Transform
Fields runTransform :: Dynamics m a -> Simulation m (Dynamics m b) Run the transform.

Instances

Instances details

Monad m => Category (Transform m :: Type -> Type -> Type) Source #
Instance details Defined in Simulation.Aivika.Trans.Transform Methods id :: forall (a :: k). Transform m a a # (.) :: forall (b :: k) (c :: k) (a :: k). Transform m b c -> Transform m a b -> Transform m a c #
MonadSD m => Arrow (Transform m) Source #
Instance details Defined in Simulation.Aivika.Trans.Transform Methods arr :: (b -> c) -> Transform m b c # first :: Transform m b c -> Transform m (b, d) (c, d) # second :: Transform m b c -> Transform m (d, b) (d, c) # (***) :: Transform m b c -> Transform m b' c' -> Transform m (b, b') (c, c') # (&&&) :: Transform m b c -> Transform m b c' -> Transform m b (c, c') #

Delaying the Transform

delayTransform Source #

Arguments

:: MonadSD m
=> Dynamics m Double	the lag time
-> Dynamics m a	the initial value
-> Transform m a a	the delayed transform

Return a delayed transform by the specified lag time and initial value.

This is actually the delayI function wrapped in the Transform type.

The Time Transform

timeTransform :: Monad m => Transform m a Double Source #

A transform that returns the current modeling time.

Differential and Difference Equations

integTransform Source #

Arguments

:: (MonadSD m, MonadFix m)
=> Dynamics m Double	the initial value
-> Transform m Double Double	map the derivative to an integral

Return a transform that maps the derivative to an integral by the specified initial value.

This is actually the integ function wrapped in the Transform type.

integTransformEither Source #

Arguments

:: (MonadSD m, MonadFix m)
=> Dynamics m Double	the initial value
-> Transform m (Either Double Double) Double	map either a new `Left` value or the `Right` derivative to an integral

Like integTransform but allows either setting a new Left value of the integral, or updating it by the specified Right derivative.

sumTransform Source #

Arguments

:: (MonadSD m, MonadFix m, Num a, MonadMemo m a)
=> Dynamics m a	the initial value
-> Transform m a a	map the difference to a sum

Return a transform that maps the difference to a sum by the specified initial value.

This is actually the diffsum function wrapped in the Transform type.

sumTransformEither Source #

Arguments

:: (MonadSD m, MonadFix m, Num a, MonadMemo m a)
=> Dynamics m a	the initial value
-> Transform m (Either a a) a	map either a new `Left` value or the `Right` difference to a sum

Like sumTransform but allows either setting a new Left value of the sum, or updating it by the specified Right difference.