{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{- |
Copyright   :  (c) Henning Thielemann 2008
License     :  GPL

Maintainer  :  synthesizer@henning-thielemann.de
Stability   :  provisional
Portability :  requires multi-parameter type classes

All recursive filters with real coefficients
can be decomposed into first order and second order filters with real coefficients.
This follows from the Fundamental theorem of algebra.
-}
module Synthesizer.Plain.Filter.Recursive.SecondOrder (
   Parameter (Parameter, c0, c1, c2, d1, d2),
   State (State, u1, u2, y1, y2),
   adjustPassband,
   amplify,
   causal,
   modifier,
   modifierInit,
   run,
   runInit,
   step,
   zeroState,
   ) where

import qualified Synthesizer.Plain.Signal   as Sig
import qualified Synthesizer.Plain.Modifier as Modifier
import Synthesizer.Plain.Filter.Recursive (Passband(Lowpass,Highpass))

import qualified Synthesizer.Interpolation.Class as Interpol

import qualified Control.Applicative.HT as App
import Control.Applicative (Applicative, pure, (<*>), )

import qualified Data.Foldable as Fold
import qualified Data.Traversable as Trav

import qualified Synthesizer.Causal.Process as Causal

import qualified Algebra.Module                as Module
import qualified Algebra.Field                 as Field
import qualified Algebra.Ring                  as Ring
import qualified Algebra.Additive              as Additive

import Data.List (zipWith6)

import qualified Control.Monad.Trans.State as MS

import qualified Foreign.Storable.Record as Store
import Foreign.Storable (Storable(..))

import NumericPrelude.Numeric
import NumericPrelude.Base


{- | Parameters for a general recursive filter of 2nd order. -}
data Parameter a =
   Parameter {forall a. Parameter a -> a
c0, forall a. Parameter a -> a
c1, forall a. Parameter a -> a
c2, forall a. Parameter a -> a
d1, forall a. Parameter a -> a
d2 :: !a}
       deriving Int -> Parameter a -> ShowS
[Parameter a] -> ShowS
Parameter a -> String
(Int -> Parameter a -> ShowS)
-> (Parameter a -> String)
-> ([Parameter a] -> ShowS)
-> Show (Parameter a)
forall a. Show a => Int -> Parameter a -> ShowS
forall a. Show a => [Parameter a] -> ShowS
forall a. Show a => Parameter a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Parameter a -> ShowS
showsPrec :: Int -> Parameter a -> ShowS
$cshow :: forall a. Show a => Parameter a -> String
show :: Parameter a -> String
$cshowList :: forall a. Show a => [Parameter a] -> ShowS
showList :: [Parameter a] -> ShowS
Show


instance Functor Parameter where
   {-# INLINE fmap #-}
   fmap :: forall a b. (a -> b) -> Parameter a -> Parameter b
fmap a -> b
f Parameter a
p = b -> b -> b -> b -> b -> Parameter b
forall a. a -> a -> a -> a -> a -> Parameter a
Parameter
      (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
c0 Parameter a
p) (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
c1 Parameter a
p) (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
c2 Parameter a
p) (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
d1 Parameter a
p) (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
d2 Parameter a
p)

instance Applicative Parameter where
   {-# INLINE pure #-}
   pure :: forall a. a -> Parameter a
pure a
x = a -> a -> a -> a -> a -> Parameter a
forall a. a -> a -> a -> a -> a -> Parameter a
Parameter a
x a
x a
x a
x a
x
   {-# INLINE (<*>) #-}
   Parameter (a -> b)
f <*> :: forall a b. Parameter (a -> b) -> Parameter a -> Parameter b
<*> Parameter a
p = b -> b -> b -> b -> b -> Parameter b
forall a. a -> a -> a -> a -> a -> Parameter a
Parameter
      (Parameter (a -> b) -> a -> b
forall a. Parameter a -> a
c0 Parameter (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
c0 Parameter a
p) (Parameter (a -> b) -> a -> b
forall a. Parameter a -> a
c1 Parameter (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
c1 Parameter a
p) (Parameter (a -> b) -> a -> b
forall a. Parameter a -> a
c2 Parameter (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
c2 Parameter a
p) (Parameter (a -> b) -> a -> b
forall a. Parameter a -> a
d1 Parameter (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
d1 Parameter a
p) (Parameter (a -> b) -> a -> b
forall a. Parameter a -> a
d2 Parameter (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ Parameter a -> a
forall a. Parameter a -> a
d2 Parameter a
p)

instance Fold.Foldable Parameter where
   {-# INLINE foldMap #-}
   foldMap :: forall m a. Monoid m => (a -> m) -> Parameter a -> m
foldMap = (a -> m) -> Parameter a -> m
forall (t :: * -> *) m a.
(Traversable t, Monoid m) =>
(a -> m) -> t a -> m
Trav.foldMapDefault

instance Trav.Traversable Parameter where
   {-# INLINE sequenceA #-}
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Parameter (f a) -> f (Parameter a)
sequenceA Parameter (f a)
p =
      (a -> a -> a -> a -> a -> Parameter a)
-> f a -> f a -> f a -> f a -> f a -> f (Parameter a)
forall (m :: * -> *) a b c d e r.
Applicative m =>
(a -> b -> c -> d -> e -> r)
-> m a -> m b -> m c -> m d -> m e -> m r
App.lift5 a -> a -> a -> a -> a -> Parameter a
forall a. a -> a -> a -> a -> a -> Parameter a
Parameter
         (Parameter (f a) -> f a
forall a. Parameter a -> a
c0 Parameter (f a)
p) (Parameter (f a) -> f a
forall a. Parameter a -> a
c1 Parameter (f a)
p) (Parameter (f a) -> f a
forall a. Parameter a -> a
c2 Parameter (f a)
p) (Parameter (f a) -> f a
forall a. Parameter a -> a
d1 Parameter (f a)
p) (Parameter (f a) -> f a
forall a. Parameter a -> a
d2 Parameter (f a)
p)

instance Interpol.C a v => Interpol.C a (Parameter v) where
   {-# INLINE scaleAndAccumulate #-}
   scaleAndAccumulate :: (a, Parameter v) -> (Parameter v, Parameter v -> Parameter v)
scaleAndAccumulate =
      MAC a (Parameter v) (Parameter v)
-> (a, Parameter v) -> (Parameter v, Parameter v -> Parameter v)
forall a v x. MAC a v x -> (a, v) -> (x, v -> x)
Interpol.runMac (MAC a (Parameter v) (Parameter v)
 -> (a, Parameter v) -> (Parameter v, Parameter v -> Parameter v))
-> MAC a (Parameter v) (Parameter v)
-> (a, Parameter v)
-> (Parameter v, Parameter v -> Parameter v)
forall a b. (a -> b) -> a -> b
$
         (v -> v -> v -> v -> v -> Parameter v)
-> MAC a (Parameter v) v
-> MAC a (Parameter v) v
-> MAC a (Parameter v) v
-> MAC a (Parameter v) v
-> MAC a (Parameter v) v
-> MAC a (Parameter v) (Parameter v)
forall (m :: * -> *) a b c d e r.
Applicative m =>
(a -> b -> c -> d -> e -> r)
-> m a -> m b -> m c -> m d -> m e -> m r
App.lift5 v -> v -> v -> v -> v -> Parameter v
forall a. a -> a -> a -> a -> a -> Parameter a
Parameter
            ((Parameter v -> v) -> MAC a (Parameter v) v
forall a x v. C a x => (v -> x) -> MAC a v x
Interpol.element Parameter v -> v
forall a. Parameter a -> a
c0)
            ((Parameter v -> v) -> MAC a (Parameter v) v
forall a x v. C a x => (v -> x) -> MAC a v x
Interpol.element Parameter v -> v
forall a. Parameter a -> a
c1)
            ((Parameter v -> v) -> MAC a (Parameter v) v
forall a x v. C a x => (v -> x) -> MAC a v x
Interpol.element Parameter v -> v
forall a. Parameter a -> a
c2)
            ((Parameter v -> v) -> MAC a (Parameter v) v
forall a x v. C a x => (v -> x) -> MAC a v x
Interpol.element Parameter v -> v
forall a. Parameter a -> a
d1)
            ((Parameter v -> v) -> MAC a (Parameter v) v
forall a x v. C a x => (v -> x) -> MAC a v x
Interpol.element Parameter v -> v
forall a. Parameter a -> a
d2)



data State a =
   State {forall a. State a -> a
u1, forall a. State a -> a
u2, forall a. State a -> a
y1, forall a. State a -> a
y2 :: !a}
       deriving Int -> State a -> ShowS
[State a] -> ShowS
State a -> String
(Int -> State a -> ShowS)
-> (State a -> String) -> ([State a] -> ShowS) -> Show (State a)
forall a. Show a => Int -> State a -> ShowS
forall a. Show a => [State a] -> ShowS
forall a. Show a => State a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> State a -> ShowS
showsPrec :: Int -> State a -> ShowS
$cshow :: forall a. Show a => State a -> String
show :: State a -> String
$cshowList :: forall a. Show a => [State a] -> ShowS
showList :: [State a] -> ShowS
Show

zeroState :: Additive.C a => State a
zeroState :: forall a. C a => State a
zeroState =
   State
      {u1 :: a
u1 = a
forall a. C a => a
zero, u2 :: a
u2 = a
forall a. C a => a
zero,
       y1 :: a
y1 = a
forall a. C a => a
zero, y2 :: a
y2 = a
forall a. C a => a
zero}


instance Functor State where
   {-# INLINE fmap #-}
   fmap :: forall a b. (a -> b) -> State a -> State b
fmap a -> b
f State a
p = b -> b -> b -> b -> State b
forall a. a -> a -> a -> a -> State a
State
      (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ State a -> a
forall a. State a -> a
u1 State a
p) (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ State a -> a
forall a. State a -> a
u2 State a
p) (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ State a -> a
forall a. State a -> a
y1 State a
p) (a -> b
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ State a -> a
forall a. State a -> a
y2 State a
p)

instance Applicative State where
   {-# INLINE pure #-}
   pure :: forall a. a -> State a
pure a
x = a -> a -> a -> a -> State a
forall a. a -> a -> a -> a -> State a
State a
x a
x a
x a
x
   {-# INLINE (<*>) #-}
   State (a -> b)
f <*> :: forall a b. State (a -> b) -> State a -> State b
<*> State a
p = b -> b -> b -> b -> State b
forall a. a -> a -> a -> a -> State a
State
      (State (a -> b) -> a -> b
forall a. State a -> a
u1 State (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ State a -> a
forall a. State a -> a
u1 State a
p) (State (a -> b) -> a -> b
forall a. State a -> a
u2 State (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ State a -> a
forall a. State a -> a
u2 State a
p) (State (a -> b) -> a -> b
forall a. State a -> a
y1 State (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ State a -> a
forall a. State a -> a
y1 State a
p) (State (a -> b) -> a -> b
forall a. State a -> a
y2 State (a -> b)
f (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ State a -> a
forall a. State a -> a
y2 State a
p)

instance Fold.Foldable State where
   {-# INLINE foldMap #-}
   foldMap :: forall m a. Monoid m => (a -> m) -> State a -> m
foldMap = (a -> m) -> State a -> m
forall (t :: * -> *) m a.
(Traversable t, Monoid m) =>
(a -> m) -> t a -> m
Trav.foldMapDefault

instance Trav.Traversable State where
   {-# INLINE sequenceA #-}
   sequenceA :: forall (f :: * -> *) a. Applicative f => State (f a) -> f (State a)
sequenceA State (f a)
p =
      (a -> a -> a -> a -> State a)
-> f a -> f a -> f a -> f a -> f (State a)
forall (m :: * -> *) a b c d r.
Applicative m =>
(a -> b -> c -> d -> r) -> m a -> m b -> m c -> m d -> m r
App.lift4 a -> a -> a -> a -> State a
forall a. a -> a -> a -> a -> State a
State
         (State (f a) -> f a
forall a. State a -> a
u1 State (f a)
p) (State (f a) -> f a
forall a. State a -> a
u2 State (f a)
p) (State (f a) -> f a
forall a. State a -> a
y1 State (f a)
p) (State (f a) -> f a
forall a. State a -> a
y2 State (f a)
p)



instance Storable a => Storable (Parameter a) where
   sizeOf :: Parameter a -> Int
sizeOf    = Dictionary (Parameter a) -> Parameter a -> Int
forall r. Dictionary r -> r -> Int
Store.sizeOf Dictionary (Parameter a)
forall a. Storable a => Dictionary (Parameter a)
storeParameter
   alignment :: Parameter a -> Int
alignment = Dictionary (Parameter a) -> Parameter a -> Int
forall r. Dictionary r -> r -> Int
Store.alignment Dictionary (Parameter a)
forall a. Storable a => Dictionary (Parameter a)
storeParameter
   peek :: Ptr (Parameter a) -> IO (Parameter a)
peek      = Dictionary (Parameter a) -> Ptr (Parameter a) -> IO (Parameter a)
forall r. Dictionary r -> Ptr r -> IO r
Store.peek Dictionary (Parameter a)
forall a. Storable a => Dictionary (Parameter a)
storeParameter
   poke :: Ptr (Parameter a) -> Parameter a -> IO ()
poke      = Dictionary (Parameter a)
-> Ptr (Parameter a) -> Parameter a -> IO ()
forall r. Dictionary r -> Ptr r -> r -> IO ()
Store.poke Dictionary (Parameter a)
forall a. Storable a => Dictionary (Parameter a)
storeParameter

storeParameter ::
   Storable a => Store.Dictionary (Parameter a)
storeParameter :: forall a. Storable a => Dictionary (Parameter a)
storeParameter =
   Access (Parameter a) (Parameter a) -> Dictionary (Parameter a)
forall r. Access r r -> Dictionary r
Store.run (Access (Parameter a) (Parameter a) -> Dictionary (Parameter a))
-> Access (Parameter a) (Parameter a) -> Dictionary (Parameter a)
forall a b. (a -> b) -> a -> b
$
   (a -> a -> a -> a -> a -> Parameter a)
-> Access (Parameter a) a
-> Access (Parameter a) a
-> Access (Parameter a) a
-> Access (Parameter a) a
-> Access (Parameter a) a
-> Access (Parameter a) (Parameter a)
forall (m :: * -> *) a b c d e r.
Applicative m =>
(a -> b -> c -> d -> e -> r)
-> m a -> m b -> m c -> m d -> m e -> m r
App.lift5 a -> a -> a -> a -> a -> Parameter a
forall a. a -> a -> a -> a -> a -> Parameter a
Parameter
      ((Parameter a -> a) -> Access (Parameter a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element Parameter a -> a
forall a. Parameter a -> a
c0)
      ((Parameter a -> a) -> Access (Parameter a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element Parameter a -> a
forall a. Parameter a -> a
c1)
      ((Parameter a -> a) -> Access (Parameter a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element Parameter a -> a
forall a. Parameter a -> a
c2)
      ((Parameter a -> a) -> Access (Parameter a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element Parameter a -> a
forall a. Parameter a -> a
d1)
      ((Parameter a -> a) -> Access (Parameter a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element Parameter a -> a
forall a. Parameter a -> a
d2)


instance Storable a => Storable (State a) where
   sizeOf :: State a -> Int
sizeOf    = Dictionary (State a) -> State a -> Int
forall r. Dictionary r -> r -> Int
Store.sizeOf Dictionary (State a)
forall a. Storable a => Dictionary (State a)
storeState
   alignment :: State a -> Int
alignment = Dictionary (State a) -> State a -> Int
forall r. Dictionary r -> r -> Int
Store.alignment Dictionary (State a)
forall a. Storable a => Dictionary (State a)
storeState
   peek :: Ptr (State a) -> IO (State a)
peek      = Dictionary (State a) -> Ptr (State a) -> IO (State a)
forall r. Dictionary r -> Ptr r -> IO r
Store.peek Dictionary (State a)
forall a. Storable a => Dictionary (State a)
storeState
   poke :: Ptr (State a) -> State a -> IO ()
poke      = Dictionary (State a) -> Ptr (State a) -> State a -> IO ()
forall r. Dictionary r -> Ptr r -> r -> IO ()
Store.poke Dictionary (State a)
forall a. Storable a => Dictionary (State a)
storeState

storeState ::
   Storable a => Store.Dictionary (State a)
storeState :: forall a. Storable a => Dictionary (State a)
storeState =
   Access (State a) (State a) -> Dictionary (State a)
forall r. Access r r -> Dictionary r
Store.run (Access (State a) (State a) -> Dictionary (State a))
-> Access (State a) (State a) -> Dictionary (State a)
forall a b. (a -> b) -> a -> b
$
   (a -> a -> a -> a -> State a)
-> Access (State a) a
-> Access (State a) a
-> Access (State a) a
-> Access (State a) a
-> Access (State a) (State a)
forall (m :: * -> *) a b c d r.
Applicative m =>
(a -> b -> c -> d -> r) -> m a -> m b -> m c -> m d -> m r
App.lift4 a -> a -> a -> a -> State a
forall a. a -> a -> a -> a -> State a
State
      ((State a -> a) -> Access (State a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element State a -> a
forall a. State a -> a
u1)
      ((State a -> a) -> Access (State a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element State a -> a
forall a. State a -> a
u2)
      ((State a -> a) -> Access (State a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element State a -> a
forall a. State a -> a
y1)
      ((State a -> a) -> Access (State a) a
forall a r. Storable a => (r -> a) -> Access r a
Store.element State a -> a
forall a. State a -> a
y2)


{- |
Given a function which computes the filter parameters of a lowpass filter
for a given frequency,
turn that into a function which generates highpass parameters,
if requested filter type is Highpass.
-}
{-# INLINE adjustPassband #-}
adjustPassband :: (Field.C a) =>
   Passband -> (a -> Parameter a) -> (a -> Parameter a)
adjustPassband :: forall a. C a => Passband -> (a -> Parameter a) -> a -> Parameter a
adjustPassband Passband
kind a -> Parameter a
comp a
f =
   case Passband
kind of
      Passband
Lowpass  -> a -> Parameter a
comp a
f
      Passband
Highpass ->
         let p :: Parameter a
p = a -> Parameter a
comp (a
0.5a -> a -> a
forall a. C a => a -> a -> a
-a
f)
         in  a -> a -> a -> a -> a -> Parameter a
forall a. a -> a -> a -> a -> a -> Parameter a
Parameter (Parameter a -> a
forall a. Parameter a -> a
c0 Parameter a
p) (- Parameter a -> a
forall a. Parameter a -> a
c1 Parameter a
p) (Parameter a -> a
forall a. Parameter a -> a
c2 Parameter a
p) (- Parameter a -> a
forall a. Parameter a -> a
d1 Parameter a
p) (Parameter a -> a
forall a. Parameter a -> a
d2 Parameter a
p)

{- |
Change filter parameter such that result is amplified by a given factor.
-}
{-# INLINE amplify #-}
amplify :: (Ring.C a) =>
   a -> Parameter a -> Parameter a
amplify :: forall a. C a => a -> Parameter a -> Parameter a
amplify a
a Parameter a
p =
   Parameter a
p{c0 = a * c0 p,
     c1 = a * c1 p,
     c2 = a * c2 p}

{-# INLINE step #-}
step :: (Ring.C a, Module.C a v) =>
   Parameter a -> v -> MS.State (State v) v
step :: forall a v. (C a, C a v) => Parameter a -> v -> State (State v) v
step Parameter a
c v
u0 = (State v -> (v, State v)) -> StateT (State v) Identity v
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
MS.state ((State v -> (v, State v)) -> StateT (State v) Identity v)
-> (State v -> (v, State v)) -> StateT (State v) Identity v
forall a b. (a -> b) -> a -> b
$ \State v
s ->
   let y0 :: v
y0 =
          Parameter a -> a
forall a. Parameter a -> a
c0 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> v
u0   v -> v -> v
forall a. C a => a -> a -> a
+
          Parameter a -> a
forall a. Parameter a -> a
c1 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> State v -> v
forall a. State a -> a
u1 State v
s v -> v -> v
forall a. C a => a -> a -> a
+ Parameter a -> a
forall a. Parameter a -> a
d1 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> State v -> v
forall a. State a -> a
y1 State v
s v -> v -> v
forall a. C a => a -> a -> a
+
          Parameter a -> a
forall a. Parameter a -> a
c2 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> State v -> v
forall a. State a -> a
u2 State v
s v -> v -> v
forall a. C a => a -> a -> a
+ Parameter a -> a
forall a. Parameter a -> a
d2 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> State v -> v
forall a. State a -> a
y2 State v
s
   in  (v
y0, State
               {u1 :: v
u1 = v
u0, u2 :: v
u2 = State v -> v
forall a. State a -> a
u1 State v
s,
                y1 :: v
y1 = v
y0, y2 :: v
y2 = State v -> v
forall a. State a -> a
y1 State v
s})


{-# INLINE modifierInit #-}
modifierInit :: (Ring.C a, Module.C a v) =>
   Modifier.Initialized (State v) (State v) (Parameter a) v v
modifierInit :: forall a v.
(C a, C a v) =>
Initialized (State v) (State v) (Parameter a) v v
modifierInit =
   (State v -> State v)
-> (Parameter a -> v -> State (State v) v)
-> Initialized (State v) (State v) (Parameter a) v v
forall s init ctrl a b.
(init -> s)
-> (ctrl -> a -> State s b) -> Initialized s init ctrl a b
Modifier.Initialized State v -> State v
forall a. a -> a
id Parameter a -> v -> State (State v) v
forall a v. (C a, C a v) => Parameter a -> v -> State (State v) v
step

{-# INLINE modifier #-}
modifier :: (Ring.C a, Module.C a v) =>
   Modifier.Simple (State v) (Parameter a) v v
modifier :: forall a v. (C a, C a v) => Simple (State v) (Parameter a) v v
modifier =
   ModifierInit (State v) (State v) (Parameter a) v v
-> State v -> Modifier (State v) (Parameter a) v v
forall s init ctrl a b.
ModifierInit s init ctrl a b -> init -> Modifier s ctrl a b
Sig.modifierInitialize ModifierInit (State v) (State v) (Parameter a) v v
forall a v.
(C a, C a v) =>
Initialized (State v) (State v) (Parameter a) v v
modifierInit State v
forall a. C a => State a
zeroState

{-# INLINE causal #-}
causal :: (Ring.C a, Module.C a v) =>
   Causal.T (Parameter a, v) v
causal :: forall a v. (C a, C a v) => T (Parameter a, v) v
causal =
   Simple (State v) (Parameter a) v v -> T (Parameter a, v) v
forall s ctrl a b. Simple s ctrl a b -> T (ctrl, a) b
Causal.fromSimpleModifier Simple (State v) (Parameter a) v v
forall a v. (C a, C a v) => Simple (State v) (Parameter a) v v
modifier


{-# INLINE runInit #-}
runInit :: (Ring.C a, Module.C a v) =>
   State v -> Sig.T (Parameter a) -> Sig.T v -> Sig.T v
runInit :: forall a v.
(C a, C a v) =>
State v -> T (Parameter a) -> T v -> T v
runInit State v
sInit T (Parameter a)
control T v
input =
   let u0s :: T v
u0s = T v
input
       u1s :: T v
u1s = State v -> v
forall a. State a -> a
u1 State v
sInit v -> T v -> T v
forall a. a -> [a] -> [a]
: T v
u0s
       u2s :: T v
u2s = State v -> v
forall a. State a -> a
u2 State v
sInit v -> T v -> T v
forall a. a -> [a] -> [a]
: T v
u1s
       y1s :: T v
y1s = State v -> v
forall a. State a -> a
y1 State v
sInit v -> T v -> T v
forall a. a -> [a] -> [a]
: T v
y0s
       y2s :: T v
y2s = State v -> v
forall a. State a -> a
y2 State v
sInit v -> T v -> T v
forall a. a -> [a] -> [a]
: T v
y1s
       y0s :: T v
y0s = (Parameter a -> v -> v -> v -> v -> v -> v)
-> T (Parameter a) -> T v -> T v -> T v -> T v -> T v -> T v
forall a b c d e f g.
(a -> b -> c -> d -> e -> f -> g)
-> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
zipWith6
          (\Parameter a
c v
u0_ v
u1_ v
u2_ v
y1_ v
y2_ ->
              Parameter a -> a
forall a. Parameter a -> a
c0 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> v
u0_ v -> v -> v
forall a. C a => a -> a -> a
+
              Parameter a -> a
forall a. Parameter a -> a
c1 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> v
u1_ v -> v -> v
forall a. C a => a -> a -> a
+ Parameter a -> a
forall a. Parameter a -> a
d1 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> v
y1_ v -> v -> v
forall a. C a => a -> a -> a
+
              Parameter a -> a
forall a. Parameter a -> a
c2 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> v
u2_ v -> v -> v
forall a. C a => a -> a -> a
+ Parameter a -> a
forall a. Parameter a -> a
d2 Parameter a
c a -> v -> v
forall a v. C a v => a -> v -> v
*> v
y2_)
          T (Parameter a)
control T v
u0s T v
u1s T v
u2s T v
y1s T v
y2s
   in  T v
y0s

{-# INLINE run #-}
run :: (Ring.C a, Module.C a v) =>
   Sig.T (Parameter a) -> Sig.T v -> Sig.T v
run :: forall a v. (C a, C a v) => T (Parameter a) -> T v -> T v
run =
   State v -> T (Parameter a) -> T v -> T v
forall a v.
(C a, C a v) =>
State v -> T (Parameter a) -> T v -> T v
runInit State v
forall a. C a => State a
zeroState