-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Delay differential equations
--   
--   Please see the README on Github at
--   <a>https://github.com/masterdezign/dde#readme</a>
@package dde
@version 0.2.0

module Numeric.DDE.Types

-- | DDE right-hand side.
--   
--   Parameter <tt>state</tt> is and abstraction of a dynamical system's
--   state, i.e. it can be a vector of any length (x(t), y(t), ...).
newtype RHS state
RHS :: ((state, HistorySnapshot state, InputSnapshot) -> state) -> RHS state
[_state] :: RHS state -> (state, HistorySnapshot state, InputSnapshot) -> state

-- | Contains only the required snapshot of history to make steppers (e.g.
--   Heun) work. There could be several delay variables
newtype HistorySnapshot state
Hist :: state -> HistorySnapshot state
[_histsnap] :: HistorySnapshot state -> state

-- | Vector of input data points
newtype Input
Input :: Vector Double -> Input
[_input] :: Input -> Vector Double

-- | Input u(t) is one-dimensional
newtype InputSnapshot
Inp :: Double -> InputSnapshot
[_insnap] :: InputSnapshot -> Double

-- | DDE stepper (all delays are equal).
--   
--   Stepper is a function of the following arguments:
--   
--   <ul>
--   <li>Integration step</li>
--   <li>DDE right-hand side</li>
--   <li>Current state vector <tt>(x(t), y(t), ...)</tt></li>
--   <li>Two subsequent history snapshots</li>
--   <li>Two subsequent inputs</li>
--   </ul>
--   
--   The result (step) is a new state vector.
type Stepper = forall state. (Functor state, VectorSpace (state Double), Num (Scalar (state Double))) => Scalar (state Double) -> RHS (state Double) -> state Double -> (HistorySnapshot (state Double), HistorySnapshot (state Double)) -> (Double, Double) -> state Double


-- | <h1>Example DDE models</h1>
module Numeric.DDE.Model

-- | Bandpass filter (linear) parameters
data BandpassFiltering
BandpassFiltering :: Double -> Double -> BandpassFiltering

-- | System response time, s (epsilon = tau / tau_D)
[_tau] :: BandpassFiltering -> Double

-- | Integration time, s (delta = tau_D / theta)
[_theta] :: BandpassFiltering -> Double
data RC
RC :: (Double -> Double) -> Double -> BandpassFiltering -> RC

-- | Nonlinear transformation
[_fnl] :: RC -> Double -> Double

-- | External forcing weight
[_rho] :: RC -> Double
[_filt] :: RC -> BandpassFiltering

-- | Mackey-Glass model (no external input) parameters
data MackeyGlass
MackeyGlass :: Double -> Double -> MackeyGlass
[_beta] :: MackeyGlass -> Double
[_gamma] :: MackeyGlass -> Double

-- | Mackey-Glass model with no external forcing
mackeyGlassRhs :: MackeyGlass -> RHS (V1 Double)
bandpassRhs :: RC -> RHS (V2 Double)
instance GHC.Show.Show Numeric.DDE.Model.BandpassFiltering


-- | <h1>Delay differential equations (DDE)</h1>
--   
--   <h2>Example: Ikeda DDE</h2>
--   
--   Below is a complete example simulating the Ikeda DDE defined as:
--   <tt>tau * x(t)/dt = -x + beta * sin[x(t - tau_D)]</tt>.
--   
--   <pre>
--   import           Linear ( V1 (..) )
--   import qualified Data.Vector.Storable as V
--   import qualified Numeric.DDE as DDE
--   
--   ikedaRhs beta = DDE.RHS derivative
--     where
--       derivative ((V1 x), (DDE.Hist (V1 x_tauD)), _) = V1 x'
--         where
--           -- Ikeda DDE definition
--           x' = (-x + beta * (sin x_tauD)) / tau
--   
--           -- Constants
--           tau = 0.01
--   
--   model beta hStep len1 totalIter = (state1, V.map (\(V1 x) -&gt; x) trace)
--     where
--       -- Initial conditions:
--       -- dynamical state and delay history.
--       state0 = V1 (pi/2)
--       hist0 = V.replicate len1 state0
--   
--       -- Input is ignored in ikedaRhs
--       inp = DDE.Input $ V.replicate (totalIter + 1) 0
--   
--       (state1, trace) = DDE.integ DDE.rk4 state0 hist0 len1 hStep (ikedaRhs beta) inp
--   
--   -- Control parameter
--   beta = 2.6
--   
--   main = do
--     let hStep = 0.001  -- Integration step
--         tauD = 1.0  -- Delay time
--         samplesPerDelay = round $ tauD / hStep
--         delays = 8
--         total = delays * samplesPerDelay
--   
--     let (state1, trace) = model beta hStep samplesPerDelay total
--   
--     mapM_ print $ V.toList trace
--   </pre>
module Numeric.DDE

-- | Generic integrator that records the whole time trace <tt>x(t)</tt>
--   (single delay time).
integ :: (Functor state, Storable (state Double), VectorSpace (state Double), Num (Scalar (state Double))) => Stepper -> state Double -> Vector (state Double) -> Int -> Scalar (state Double) -> RHS (state Double) -> Input -> (state Double, Vector (state Double))

-- | Generic integrator for DDEs (single delay time). Records all dynamical
--   variables.
integ' :: Storable state => (state -> (HistorySnapshot state, HistorySnapshot state) -> (Double, Double) -> state) -> Int -> Int -> Int -> (state, Vector state, Input) -> (state, Vector state)

-- | RK4 integrator shortcut for 1D DDEs with zero initial conditions
integRk4 :: Int -> Double -> RHS (V1 Double) -> Input -> (V1 Double, Vector (V1 Double))

-- | Shortcut for Heun's 2nd order 1D DDEs with zero initial conditions
integHeun2 :: Int -> Double -> RHS (V1 Double) -> Input -> (V1 Double, Vector (V1 Double))

-- | RK4 integrator shortcut for 2D DDEs with zero initial conditions
integRk4_2D :: Int -> Double -> RHS (V2 Double) -> Input -> (V2 Double, Vector (V2 Double))

-- | Shortcut for Heun's 2nd order 2D DDEs with zero initial conditions
integHeun2_2D :: Int -> Double -> RHS (V2 Double) -> Input -> (V2 Double, Vector (V2 Double))

-- | Vector of input data points
newtype Input
Input :: Vector Double -> Input
[_input] :: Input -> Vector Double

-- | Input u(t) is one-dimensional
newtype InputSnapshot
Inp :: Double -> InputSnapshot
[_insnap] :: InputSnapshot -> Double

-- | Contains only the required snapshot of history to make steppers (e.g.
--   Heun) work. There could be several delay variables
newtype HistorySnapshot state
Hist :: state -> HistorySnapshot state
[_histsnap] :: HistorySnapshot state -> state

-- | DDE right-hand side.
--   
--   Parameter <tt>state</tt> is and abstraction of a dynamical system's
--   state, i.e. it can be a vector of any length (x(t), y(t), ...).
newtype RHS state
RHS :: ((state, HistorySnapshot state, InputSnapshot) -> state) -> RHS state
[_state] :: RHS state -> (state, HistorySnapshot state, InputSnapshot) -> state

-- | DDE stepper (all delays are equal).
--   
--   Stepper is a function of the following arguments:
--   
--   <ul>
--   <li>Integration step</li>
--   <li>DDE right-hand side</li>
--   <li>Current state vector <tt>(x(t), y(t), ...)</tt></li>
--   <li>Two subsequent history snapshots</li>
--   <li>Two subsequent inputs</li>
--   </ul>
--   
--   The result (step) is a new state vector.
type Stepper = forall state. (Functor state, VectorSpace (state Double), Num (Scalar (state Double))) => Scalar (state Double) -> RHS (state Double) -> state Double -> (HistorySnapshot (state Double), HistorySnapshot (state Double)) -> (Double, Double) -> state Double

-- | Fourth order Runge-Kutta stepper
rk4 :: Stepper

-- | Second order Heun's stepper
heun2 :: Stepper