module Synthesizer.Dimensional.Rate.Oscillator (
static,
staticAntiAlias,
freqMod,
freqModAntiAlias,
phaseMod,
phaseFreqMod,
shapeMod,
shapeFreqMod,
staticSample,
freqModSample,
) where
import qualified Synthesizer.Dimensional.Abstraction.Flat as Flat
import qualified Synthesizer.Dimensional.RatePhantom as RP
import qualified Synthesizer.State.Oscillator as Osci
import qualified Synthesizer.State.Signal as Sig
import qualified Synthesizer.Basic.WaveSmoothed as WaveSmooth
import qualified Synthesizer.Basic.Wave as Wave
import qualified Synthesizer.Basic.Phase as Phase
import qualified Synthesizer.Dimensional.Straight.Signal as SigS
import qualified Synthesizer.Dimensional.Cyclic.Signal as SigC
import qualified Synthesizer.Dimensional.Amplitude.Signal as SigA
import qualified Synthesizer.Dimensional.Process as Proc
import Synthesizer.Dimensional.Process (toFrequencyScalar, )
import qualified Synthesizer.State.Interpolation as Interpolation
import qualified Number.DimensionTerm as DN
import qualified Algebra.DimensionTerm as Dim
import qualified Algebra.RealField as RealField
import qualified Algebra.Field as Field
import PreludeBase as P
static :: (RealField.C t, Dim.C u) =>
Wave.T t y
-> Phase.T t
-> DN.T (Dim.Recip u) t
-> Proc.T s u t (SigS.R s y)
static wave phase =
staticAux (SigS.fromSamples . Osci.static wave phase)
staticAntiAlias :: (RealField.C t, Dim.C u) =>
WaveSmooth.T t y
-> Phase.T t
-> DN.T (Dim.Recip u) t
-> Proc.T s u t (SigS.R s y)
staticAntiAlias wave phase =
staticAux (SigS.fromSamples . Osci.staticAntiAlias wave phase)
freqMod :: (RealField.C t, Dim.C u) =>
Wave.T t y
-> Phase.T t
-> Proc.T s u t (
SigA.R s (Dim.Recip u) t t
-> SigS.R s y)
freqMod wave phase =
freqModAux (SigS.fromSamples . Osci.freqMod wave phase)
freqModAntiAlias :: (RealField.C t, Dim.C u) =>
WaveSmooth.T t y
-> Phase.T t
-> Proc.T s u t (
SigA.R s (Dim.Recip u) t t
-> SigS.R s y)
freqModAntiAlias wave phase =
freqModAux (SigS.fromSamples . Osci.freqModAntiAlias wave phase)
phaseMod :: (Flat.C flat t, RealField.C t, Dim.C u) =>
Wave.T t y
-> DN.T (Dim.Recip u) t
-> Proc.T s u t (
RP.T s flat t
-> SigS.R s y)
phaseMod wave =
staticAux (\freq -> SigS.fromSamples . Osci.phaseMod wave freq . Flat.toSamples)
shapeMod :: (Flat.C flat c, RealField.C t, Dim.C u) =>
(c -> Wave.T t y)
-> Phase.T t
-> DN.T (Dim.Recip u) t
-> Proc.T s u t (
RP.T s flat c
-> SigS.R s y)
shapeMod wave phase =
staticAux (\freq -> SigS.fromSamples . Osci.shapeMod wave phase freq . Flat.toSamples)
phaseFreqMod :: (Flat.C flat t, RealField.C t, Dim.C u) =>
Wave.T t y
-> Proc.T s u t (
RP.T s flat t
-> SigA.R s (Dim.Recip u) t t
-> SigS.R s y)
phaseFreqMod wave =
fmap flip $
freqModAux
(\ freqs phases ->
SigS.fromSamples $ Osci.phaseFreqMod wave (Flat.toSamples phases) freqs)
shapeFreqMod :: (Flat.C flat c, RealField.C t, Dim.C u) =>
(c -> Wave.T t y)
-> Phase.T t
-> Proc.T s u t (
RP.T s flat c
-> SigA.R s (Dim.Recip u) t t
-> SigS.R s y)
shapeFreqMod wave phase =
fmap flip $
freqModAux
(\ freqs parameters ->
SigS.fromSamples $ Osci.shapeFreqMod wave phase (Flat.toSamples parameters) freqs)
staticSample :: (RealField.C t, Dim.C u) =>
Interpolation.T t y
-> SigC.R r y
-> Phase.T t
-> DN.T (Dim.Recip u) t
-> Proc.T s u t (SigS.R s y)
staticSample ip wave phase =
staticAux (SigS.fromSamples . Osci.staticSample ip (SigC.toPeriod wave) phase)
freqModSample :: (RealField.C t, Dim.C u) =>
Interpolation.T t y
-> SigC.R r y
-> Phase.T t
-> Proc.T s u t (
SigA.R s (Dim.Recip u) t t
-> SigS.R s y)
freqModSample ip wave phase =
freqModAux (SigS.fromSamples . Osci.freqModSample ip (SigC.toPeriod wave) phase)
freqModAux :: (Field.C t, Dim.C u) =>
(Sig.T t -> c)
-> Proc.T s u t (
SigA.R s (Dim.Recip u) t t
-> c)
freqModAux f =
do toFreq <- Proc.withParam toFrequencyScalar
return $ f . SigA.scalarSamples toFreq
staticAux :: (Dim.C u, Field.C t) =>
(t -> c)
-> DN.T (Dim.Recip u) t
-> Proc.T s u t c
staticAux f freq =
fmap f (toFrequencyScalar freq)