module Synthesizer.Plain.Filter.Recursive.FirstOrder where
import qualified Synthesizer.Plain.Signal as Sig
import qualified Synthesizer.Plain.Modifier as Modifier
import qualified Synthesizer.Causal.Process as Causal
import qualified Synthesizer.Interpolation.Class as Interpol
import qualified Algebra.Module as Module
import qualified Algebra.Transcendental as Trans
import qualified Algebra.Ring as Ring
import qualified Algebra.Additive as Additive
import Algebra.Module((*>))
import Control.Monad.Trans.State (State, state, )
import PreludeBase
import NumericPrelude
newtype Parameter a = Parameter {getParameter :: a}
deriving Show
instance Interpol.C a v => Interpol.C a (Parameter v) where
scaleAndAccumulate = Interpol.makeMac Parameter getParameter
parameter :: Trans.C a => a -> Parameter a
parameter freq = Parameter (exp (2*pi*freq))
lowpassStep :: (Ring.C a, Module.C a v) =>
Parameter a -> v -> State v v
lowpassStep (Parameter c) x =
state (\s -> let y = x + c *> (sx) in (y,y))
lowpassModifierInit :: (Ring.C a, Module.C a v) =>
Modifier.Initialized v v (Parameter a) v v
lowpassModifierInit =
Modifier.Initialized id lowpassStep
lowpassModifier :: (Ring.C a, Module.C a v) =>
Modifier.Simple v (Parameter a) v v
lowpassModifier =
Sig.modifierInitialize lowpassModifierInit zero
lowpassCausal ::
(Ring.C a, Module.C a v) =>
Causal.T (Parameter a, v) v
lowpassCausal =
Causal.fromSimpleModifier lowpassModifier
lowpassInit :: (Ring.C a, Module.C a v) =>
v -> Sig.T (Parameter a) -> Sig.T v -> Sig.T v
lowpassInit =
Sig.modifyModulatedInit lowpassModifierInit
lowpass :: (Ring.C a, Module.C a v) =>
Sig.T (Parameter a) -> Sig.T v -> Sig.T v
lowpass = lowpassInit zero
highpassStep :: (Ring.C a, Module.C a v) =>
Parameter a -> v -> State v v
highpassStep c x =
fmap (x) (lowpassStep c x)
highpassModifierInit :: (Ring.C a, Module.C a v) =>
Modifier.Initialized v v (Parameter a) v v
highpassModifierInit =
Modifier.Initialized negate highpassStep
highpassModifier :: (Ring.C a, Module.C a v) =>
Modifier.Simple v (Parameter a) v v
highpassModifier =
Sig.modifierInitialize highpassModifierInit zero
highpassInit :: (Ring.C a, Module.C a v) =>
v -> Sig.T (Parameter a) -> Sig.T v -> Sig.T v
highpassInit =
Sig.modifyModulatedInit highpassModifierInit
highpassInitAlt :: (Ring.C a, Module.C a v) =>
v -> Sig.T (Parameter a) -> Sig.T v -> Sig.T v
highpassInitAlt y0 control x =
x lowpassInit (y0) control x
highpass :: (Ring.C a, Module.C a v) =>
Sig.T (Parameter a) -> Sig.T v -> Sig.T v
highpass = highpassInit zero
data Result a =
Result {highpass_, lowpass_ :: !a}
instance Additive.C v => Additive.C (Result v) where
zero = Result zero zero
(+) (Result xhp xlp) (Result yhp ylp) = Result (xhp + yhp) (xlp + ylp)
() (Result xhp xlp) (Result yhp ylp) = Result (xhp yhp) (xlp ylp)
negate (Result xhp xlp) = Result (negate xhp) (negate xlp)
instance Module.C a v => Module.C a (Result v) where
s *> (Result hp lp) = Result (s *> hp) (s *> lp)
step :: (Ring.C a, Module.C a v) =>
Parameter a -> v -> State v (Result v)
step c x =
fmap (\lp -> Result (xlp) lp) (lowpassStep c x)