{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
module Synthesizer.State.Filter.Recursive.Comb where
import qualified Synthesizer.State.Signal as Sig
import qualified Synthesizer.Plain.Filter.Recursive.FirstOrder as Filt1
import qualified Synthesizer.State.Filter.Delay as Delay
import qualified Algebra.Module as Module
import qualified Algebra.Ring as Ring
import qualified Algebra.Additive as Additive
import NumericPrelude.Numeric
import NumericPrelude.Base
{-# INLINE karplusStrong #-}
karplusStrong :: (Ring.C a, Module.C a v) =>
Filt1.Parameter a -> Sig.T v -> Sig.T v
karplusStrong :: forall a v. (C a, C a v) => Parameter a -> T v -> T v
karplusStrong Parameter a
c T v
wave =
(T v -> T v) -> T v -> T v
forall y. (T y -> T y) -> T y -> T y
Sig.delayLoop (Simple v (Parameter a) v v -> Parameter a -> T v -> T v
forall s ctrl a b. Simple s ctrl a b -> ctrl -> T a -> T b
Sig.modifyStatic Simple v (Parameter a) v v
forall a v. (C a, C a v) => Simple v (Parameter a) v v
Filt1.lowpassModifier Parameter a
c) T v
wave
{-# INLINE run #-}
run :: (Module.C a v) => Int -> a -> Sig.T v -> Sig.T v
run :: forall a v. C a v => Int -> a -> T v -> T v
run Int
time a
gain = Int -> (T v -> T v) -> T v -> T v
forall y. C y => Int -> (T y -> T y) -> T y -> T y
Sig.delayLoopOverlap Int
time (a
gain a -> T v -> T v
forall a v. C a v => a -> v -> v
*>)
{-# INLINE runMulti #-}
runMulti :: (Ring.C a, Module.C a v) => [Int] -> a -> Sig.T v -> Sig.T v
runMulti :: forall a v. (C a, C a v) => [Int] -> a -> T v -> T v
runMulti [Int]
times a
gain T v
x =
let y :: T v
y = [v] -> T v
forall y. [y] -> T y
Sig.fromList ([v] -> T v) -> [v] -> T v
forall a b. (a -> b) -> a -> b
$ T v -> [v]
forall y. T y -> [y]
Sig.toList (T v -> [v]) -> T v -> [v]
forall a b. (a -> b) -> a -> b
$
(T v -> T v -> T v) -> T v -> [T v] -> T v
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl
((v -> v -> v) -> T v -> T v -> T v
forall a b c. (a -> b -> c) -> T a -> T b -> T c
Sig.zipWith v -> v -> v
forall a. C a => a -> a -> a
(+)) T v
x
((Int -> T v) -> [Int] -> [T v]
forall a b. (a -> b) -> [a] -> [b]
map ((Int -> T v -> T v) -> T v -> Int -> T v
forall a b c. (a -> b -> c) -> b -> a -> c
flip Int -> T v -> T v
forall y. C y => Int -> T y -> T y
Delay.staticPos (a
gain a -> T v -> T v
forall a v. C a v => a -> v -> v
*> T v
y)) [Int]
times)
in T v
y
{-# INLINE runProc #-}
runProc :: Additive.C v => Int -> (Sig.T v -> Sig.T v) -> Sig.T v -> Sig.T v
runProc :: forall y. C y => Int -> (T y -> T y) -> T y -> T y
runProc = Int -> (T v -> T v) -> T v -> T v
forall y. C y => Int -> (T y -> T y) -> T y -> T y
Sig.delayLoopOverlap