{-# LANGUAGE NoImplicitPrelude #-}
module Synthesizer.Causal.Filter.Recursive.Integration where
import qualified Synthesizer.Causal.Process as Causal
import qualified Control.Monad.Trans.State as State
import qualified Algebra.Additive as Additive
import NumericPrelude.Numeric
import NumericPrelude.Base
{-# INLINE run #-}
run :: Additive.C v => Causal.T v v
run :: forall v. C v => T v v
run = (v -> State v v) -> v -> T v v
forall a s b. (a -> State s b) -> s -> T a b
Causal.fromState (\v
x -> (v -> v) -> StateT v Identity ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
State.modify (v
xv -> v -> v
forall a. C a => a -> a -> a
+) StateT v Identity () -> State v v -> State v v
forall a b.
StateT v Identity a -> StateT v Identity b -> StateT v Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> State v v
forall (m :: * -> *) s. Monad m => StateT s m s
State.get) v
forall a. C a => a
zero
{-# INLINE runInit #-}
runInit :: Additive.C v => v -> Causal.T v v
runInit :: forall v. C v => v -> T v v
runInit = (v -> State v v) -> v -> T v v
forall a s b. (a -> State s b) -> s -> T a b
Causal.fromState (\v
x -> (v -> (v, v)) -> State v v
forall (m :: * -> *) s a. Monad m => (s -> (a, s)) -> StateT s m a
State.state (\v
s -> (v
s, v
sv -> v -> v
forall a. C a => a -> a -> a
+v
x)))