module Synthesizer.Dimensional.Amplitude.Displacement (
mix, mixVolume,
mixMulti, mixMultiVolume,
raise, distort,
) where
import qualified Synthesizer.Dimensional.Abstraction.RateIndependent as Ind
import qualified Synthesizer.Dimensional.Amplitude.Signal as SigA
import Synthesizer.Dimensional.Amplitude.Signal (toAmplitudeScalar)
import qualified Number.DimensionTerm as DN
import qualified Algebra.DimensionTerm as Dim
import qualified Synthesizer.State.Displacement as Disp
import qualified Synthesizer.State.Signal as Sig
import qualified Algebra.Module as Module
import qualified Algebra.Field as Field
import qualified Algebra.Real as Real
import qualified Algebra.Additive as Additive
import Algebra.Module ((*>))
import PreludeBase
import NumericPrelude
import Prelude ()
mix ::
(Real.C y, Field.C y, Module.C y yv, Dim.C u) =>
SigA.R s u y yv
-> SigA.R s u y yv
-> SigA.R s u y yv
mix x y =
mixVolume (DN.abs (SigA.amplitude x) + DN.abs (SigA.amplitude y)) x y
mixVolume ::
(Real.C y, Field.C y, Module.C y yv, Dim.C u) =>
DN.T u y
-> SigA.R s u y yv
-> SigA.R s u y yv
-> SigA.R s u y yv
mixVolume v x y =
let z = SigA.fromSamples v
(SigA.vectorSamples (toAmplitudeScalar z) x +
SigA.vectorSamples (toAmplitudeScalar z) y)
in z
mixMulti ::
(Real.C y, Field.C y, Module.C y yv, Dim.C u) =>
[SigA.R s u y yv]
-> SigA.R s u y yv
mixMulti x =
mixMultiVolume (sum (map (DN.abs . SigA.amplitude) x)) x
mixMultiVolume ::
(Real.C y, Field.C y, Module.C y yv, Dim.C u) =>
DN.T u y
-> [SigA.R s u y yv]
-> SigA.R s u y yv
mixMultiVolume v x =
let z = SigA.fromSamples v
(foldr (\y -> (SigA.vectorSamples (toAmplitudeScalar z) y +)) Sig.empty x)
in z
raise :: (Ind.C w, Field.C y, Module.C y yv, Dim.C u) =>
DN.T u y
-> yv
-> w (SigA.S u y) yv
-> w (SigA.S u y) yv
raise y' yv x =
SigA.processSamples
(Disp.raise (toAmplitudeScalar x y' *> yv)) x
distort :: (Field.C y, Module.C y yv, Dim.C u) =>
(yv -> yv)
-> SigA.R s u y y
-> SigA.R s u y yv
-> SigA.R s u y yv
distort f cs xs =
SigA.processSamples
(Sig.zipWith
(\c y -> c *> f (recip c *> y))
(SigA.scalarSamples (toAmplitudeScalar xs) cs)) xs