module Synthesizer.Dimensional.Amplitude.Filter (
amplify,
amplifyDimension,
negate,
envelope,
envelopeVector,
envelopeVectorDimension,
) where
import qualified Synthesizer.Dimensional.Abstraction.RateIndependent as Ind
import qualified Synthesizer.Dimensional.Abstraction.Homogeneous as Hom
import qualified Synthesizer.Dimensional.Abstraction.Flat as Flat
import qualified Synthesizer.Dimensional.RatePhantom as RP
import qualified Synthesizer.Dimensional.Amplitude.Signal as SigA
import qualified Number.DimensionTerm as DN
import qualified Algebra.DimensionTerm as Dim
import Number.DimensionTerm ((&*&))
import qualified Synthesizer.State.Filter.NonRecursive as FiltNR
import qualified Algebra.Ring as Ring
import qualified Algebra.Additive as Additive
import qualified Algebra.Module as Module
import Prelude (($))
amplify :: (Ind.C w, Ring.C y, Dim.C u) =>
y
-> w (SigA.S u y) yv
-> w (SigA.S u y) yv
amplify volume x =
SigA.replaceAmplitude (DN.scale volume $ SigA.amplitude x) x
amplifyDimension :: (Ind.C w, Ring.C y, Dim.C u, Dim.C v) =>
DN.T v y
-> w (SigA.S u y) yv
-> w (SigA.S (Dim.Mul v u) y) yv
amplifyDimension volume x =
SigA.replaceAmplitude (volume &*& SigA.amplitude x) x
negate :: (Ind.C w, Hom.C sig, Additive.C yv) =>
w sig yv
-> w sig yv
negate =
Ind.processSignal (Hom.unwrappedProcessSamples Additive.negate)
envelope :: (Hom.C sig, Flat.C flat y0, Ring.C y0) =>
RP.T s flat y0
-> RP.T s sig y0
-> RP.T s sig y0
envelope y =
Hom.processSamples (FiltNR.envelope (Flat.toSamples y))
envelopeVector :: (Hom.C sig, Flat.C flat y0, Module.C y0 yv) =>
RP.T s flat y0
-> RP.T s sig yv
-> RP.T s sig yv
envelopeVector y =
Hom.processSamples (FiltNR.envelopeVector (Flat.toSamples y))
envelopeVectorDimension :: (Module.C y0 yv, Ring.C y, Dim.C u, Dim.C v) =>
SigA.R s v y y0
-> SigA.R s u y yv
-> SigA.R s (Dim.Mul v u) y yv
envelopeVectorDimension y x =
SigA.fromSamples
(SigA.amplitude y &*& SigA.amplitude x)
(FiltNR.envelopeVector (SigA.samples y) (SigA.samples x))