module Synthesizer.Dimensional.Amplitude.Control
(
constant, constantVector,
mapLinear, mapLinearDimension,
mapExponential,
) where
import qualified Synthesizer.Dimensional.Abstraction.RateIndependent as Ind
import qualified Synthesizer.Dimensional.Abstraction.Flat as Flat
import qualified Synthesizer.Dimensional.Straight.Signal as SigS
import qualified Synthesizer.Dimensional.Amplitude.Signal as SigA
import Synthesizer.Dimensional.Amplitude.Signal (toAmplitudeScalar)
import qualified Synthesizer.State.Control as Ctrl
import qualified Synthesizer.State.Signal as Sig
import qualified Number.DimensionTerm as DN
import qualified Algebra.DimensionTerm as Dim
import Number.DimensionTerm ((&*&))
import qualified Algebra.Transcendental as Trans
import qualified Algebra.Field as Field
import qualified Algebra.Real as Real
import qualified Algebra.Ring as Ring
import qualified Algebra.Additive as Additive
import NumericPrelude
import PreludeBase as P
import Prelude ()
constant :: (Real.C y, Dim.C u) =>
DN.T u y
-> SigA.R s u y y
constant =
uncurry constantVector .
DN.absSignum
constantVector ::
DN.T u y
-> yv
-> SigA.R s u y yv
constantVector y yv =
SigA.fromSamples y (Ctrl.constant yv)
mapLinear :: (Ind.C w, Flat.C flat y, Ring.C y, Dim.C u) =>
y ->
DN.T u y ->
w flat y ->
w (SigA.S u y) y
mapLinear depth center =
Ind.processSignal
(SigA.Cons center . SigS.Cons .
Sig.map (\x -> one+x*depth) .
Flat.unwrappedToSamples)
mapExponential :: (Ind.C w, Flat.C flat y, Trans.C y, Dim.C u) =>
y ->
DN.T u q ->
w flat y ->
w (SigA.S u q) y
mapExponential depth center =
Ind.processSignal
(SigA.Cons center . SigS.Cons .
Sig.map (depth**) .
Flat.unwrappedToSamples)
mapLinearDimension ::
(Ind.C w, Field.C y, Real.C y, Dim.C u, Dim.C v) =>
DN.T v y
-> DN.T (Dim.Mul v u) y
-> w (SigA.S u y) y
-> w (SigA.S (Dim.Mul v u) y) y
mapLinearDimension range center x =
let absRange = DN.abs range &*& SigA.amplitude x
absCenter = DN.abs center
rng = toAmplitudeScalar z absRange
cnt = toAmplitudeScalar z absCenter
z =
Ind.processSignal
(SigA.Cons (absRange + absCenter) . SigS.Cons .
Sig.map (\y -> cnt + rng*y) .
SigA.privateSamples) x
in z