{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
module Synthesizer.Plain.Filter.Recursive.SecondOrderCascade (
Parameter (Parameter),
State,
step,
modifierInit,
modifier,
causal,
) where
import qualified Synthesizer.Plain.Filter.Recursive.SecondOrder as Filt2
import qualified Synthesizer.Plain.Signal as Sig
import qualified Synthesizer.Plain.Modifier as Modifier
import qualified Synthesizer.Interpolation.Class as Interpol
import qualified Synthesizer.Causal.Process as Causal
import qualified Algebra.Module as Module
import qualified Algebra.Ring as Ring
import qualified Control.Monad.Trans.State as MS
import qualified Data.StorableVector as SV
import Foreign.Storable (Storable(..))
import NumericPrelude.Numeric
import NumericPrelude.Base
newtype Parameter a =
Parameter (SV.Vector (Filt2.Parameter a))
type State a =
SV.Vector (Filt2.State a)
{-# INLINE checkSizes #-}
checkSizes :: String -> SV.Vector a -> SV.Vector b -> c -> c
checkSizes :: forall a b c. String -> Vector a -> Vector b -> c -> c
checkSizes String
opName Vector a
x Vector b
y c
act =
if forall a. Vector a -> Int
SV.length Vector a
x forall a. Eq a => a -> a -> Bool
== forall a. Vector a -> Int
SV.length Vector b
y
then c
act
else forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
opName forall a. [a] -> [a] -> [a]
++ String
": incompatible sizes of cascades of second order filters"
{-# INLINE withSizeCheck #-}
withSizeCheck ::
String ->
(SV.Vector a -> SV.Vector b -> c) ->
(SV.Vector a -> SV.Vector b -> c)
withSizeCheck :: forall a b c.
String -> (Vector a -> Vector b -> c) -> Vector a -> Vector b -> c
withSizeCheck String
opName Vector a -> Vector b -> c
f Vector a
x Vector b
y =
forall a b c. String -> Vector a -> Vector b -> c -> c
checkSizes String
opName Vector a
x Vector b
y (Vector a -> Vector b -> c
f Vector a
x Vector b
y)
instance (Interpol.C a v, Storable v) => Interpol.C a (Parameter v) where
{-# INLINE scaleAndAccumulate #-}
scaleAndAccumulate :: (a, Parameter v) -> (Parameter v, Parameter v -> Parameter v)
scaleAndAccumulate (a
a, Parameter Vector (Parameter v)
x) =
(forall a. Vector (Parameter a) -> Parameter a
Parameter forall a b. (a -> b) -> a -> b
$ forall a b.
(Storable a, Storable b) =>
(a -> b) -> Vector a -> Vector b
SV.map (forall a b c. ((a, b) -> c) -> a -> b -> c
curry forall a v. C a v => (a, v) -> v
Interpol.scale a
a) Vector (Parameter v)
x,
\ (Parameter Vector (Parameter v)
y) ->
forall a. Vector (Parameter a) -> Parameter a
Parameter forall a b. (a -> b) -> a -> b
$ forall a b c.
String -> (Vector a -> Vector b -> c) -> Vector a -> Vector b -> c
withSizeCheck String
"mac"
(forall a b c.
(Storable a, Storable b, Storable c) =>
(a -> b -> c) -> Vector a -> Vector b -> Vector c
SV.zipWith (forall a b c. ((a, b) -> c) -> a -> b -> c
curry forall a v. C a v => (a, v) -> v -> v
Interpol.scaleAccumulate a
a)) Vector (Parameter v)
x Vector (Parameter v)
y)
{-# INLINE step #-}
step ::
(Ring.C a, Module.C a v, Storable a, Storable v) =>
Parameter a -> v -> MS.State (State v) v
step :: forall a v.
(C a, C a v, Storable a, Storable v) =>
Parameter a -> v -> State (State v) v
step (Parameter Vector (Parameter a)
p) =
forall s c a.
(Storable s, Storable c) =>
(c -> a -> State s a) -> Vector c -> a -> State (Vector s) a
Modifier.stackStatesStorableVaryL forall a v. (C a, C a v) => Parameter a -> v -> State (State v) v
Filt2.step Vector (Parameter a)
p
{-# INLINE modifierInit #-}
modifierInit ::
(Ring.C a, Module.C a v, Storable a, Storable v) =>
Modifier.Initialized (State v) (State v) (Parameter a) v v
modifierInit :: forall a v.
(C a, C a v, Storable a, Storable v) =>
Initialized (State v) (State v) (Parameter a) v v
modifierInit =
forall s init ctrl a b.
(init -> s)
-> (ctrl -> a -> State s b) -> Initialized s init ctrl a b
Modifier.Initialized forall a. a -> a
id forall a v.
(C a, C a v, Storable a, Storable v) =>
Parameter a -> v -> State (State v) v
step
{-# INLINE modifier #-}
modifier ::
(Ring.C a, Module.C a v, Storable a, Storable v) =>
Int ->
Modifier.Simple (State v) (Parameter a) v v
modifier :: forall a v.
(C a, C a v, Storable a, Storable v) =>
Int -> Simple (State v) (Parameter a) v v
modifier Int
order =
forall s init ctrl a b.
ModifierInit s init ctrl a b -> init -> Modifier s ctrl a b
Sig.modifierInitialize forall a v.
(C a, C a v, Storable a, Storable v) =>
Initialized (State v) (State v) (Parameter a) v v
modifierInit
(forall a. Storable a => Int -> a -> Vector a
SV.replicate Int
order forall a. C a => State a
Filt2.zeroState)
{-# INLINE causal #-}
causal :: (Ring.C a, Module.C a v, Storable a, Storable v) =>
Int ->
Causal.T (Parameter a, v) v
causal :: forall a v.
(C a, C a v, Storable a, Storable v) =>
Int -> T (Parameter a, v) v
causal Int
order =
forall s ctrl a b. Simple s ctrl a b -> T (ctrl, a) b
Causal.fromSimpleModifier (forall a v.
(C a, C a v, Storable a, Storable v) =>
Int -> Simple (State v) (Parameter a) v v
modifier Int
order)