{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
module Synthesizer.Dimensional.RateAmplitude.Instrument where

import qualified Synthesizer.Dimensional.Rate.Oscillator as Osci
import qualified Synthesizer.Dimensional.Rate.Filter     as Filt
import qualified Synthesizer.Dimensional.RateAmplitude.Displacement as Disp
import qualified Synthesizer.Dimensional.RateAmplitude.Noise      as Noise
-- import qualified Synthesizer.SampleRateDimension.Filter.Recursive    as FiltR
-- import qualified Synthesizer.SampleRateDimension.Filter.NonRecursive as FiltNR
import qualified Synthesizer.Dimensional.RateAmplitude.Filter     as FiltA
import qualified Synthesizer.Dimensional.RateAmplitude.Cut        as Cut
import qualified Synthesizer.Dimensional.Amplitude.Cut            as CutA

import qualified Synthesizer.Dimensional.RateAmplitude.Piece      as Piece
import qualified Synthesizer.Dimensional.RateAmplitude.Control    as Ctrl
import qualified Synthesizer.Dimensional.Rate.Control             as CtrlR

import qualified Synthesizer.Dimensional.Amplitude.Analysis       as Ana

import qualified Synthesizer.Dimensional.Process as Proc
import qualified Synthesizer.Dimensional.Signal as SigA

import Synthesizer.Dimensional.Signal (($-), ($&), (&*^), (&*>^), )
import Synthesizer.Dimensional.RateAmplitude.Piece ((-|#), ( #|-), (|#), ( #|), )
import Synthesizer.Dimensional.Wave ((&*~), )

import Synthesizer.Dimensional.Process (($:), ($::), ($^), (.^), ($#), )
import qualified Synthesizer.Dimensional.Amplitude.Displacement as DispA

import qualified Synthesizer.Dimensional.Amplitude.Flat as Flat
import qualified Synthesizer.Dimensional.Sample as Sample
-- import qualified Synthesizer.Dimensional.Rate as Rate

-- import qualified Synthesizer.Storable.Signal as SigSt
import Foreign.Storable (Storable, )

import qualified Algebra.DimensionTerm as Dim
import qualified Number.DimensionTerm  as DN

import Number.DimensionTerm ((*&), (&*&), )

import qualified Synthesizer.Interpolation.Module as Interpolation
import           Synthesizer.Plain.Instrument (choirWave)
import qualified Synthesizer.Dimensional.Wave.Controlled as WaveCtrl
import qualified Synthesizer.Dimensional.Wave as WaveD
import qualified Synthesizer.Generic.Wave     as WaveG
import qualified Synthesizer.Basic.Wave       as Wave
import qualified Synthesizer.Basic.Phase      as Phase

import qualified Number.NonNegative     as NonNeg

import qualified Algebra.Transcendental as Trans
import qualified Algebra.Module         as Module
import qualified Algebra.RealField      as RealField
import qualified Algebra.Ring           as Ring

import System.Random (Random, randoms, randomRs, mkStdGen, )
import Synthesizer.Utility (randomRsBalanced, balanceLevel, )

import Data.List(zip4)

import NumericPrelude.Base
import NumericPrelude.Numeric



{-| Create a sound of a slightly changed frequency
    just as needed for a simple stereo sound. -}
{-# INLINE stereoPhaser #-}
stereoPhaser :: Ring.C a =>
      (DN.T Dim.Frequency a ->
       Proc.T s Dim.Time a (SigA.R s u b b))
           {- ^ A function mapping a frequency to a signal. -}
   -> a    {- ^ The factor to the frequency, should be close to 1. -}
   -> DN.T Dim.Frequency a
           {- ^ The base (undeviated) frequency of the sound. -}
   -> Proc.T s Dim.Time a (SigA.R s u b b)
stereoPhaser :: forall a s u b.
C a =>
(T Frequency a -> T s Time a (R s u b b))
-> a -> T Frequency a -> T s Time a (R s u b b)
stereoPhaser T Frequency a -> T s Time a (R s u b b)
sound a
dif T Frequency a
freq =
   T Frequency a -> T s Time a (R s u b b)
sound (a
dif forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq)



{-
allpassPlain :: (RealField.C a, Trans.C a, Module.C a a) =>
                   a -> a -> a -> a -> [a]
allpassPlain sampleRate halfLife k freq =
    Filt.allpassCascade 10
        (map Filt.AllpassParam (exponential2 (halfLife*sampleRate) k))
        (simpleSaw sampleRate freq)
-}

{-# INLINE allpassDown #-}
allpassDown ::
   (RealField.C a, Trans.C a, Module.C a a) =>
      NonNeg.Int -> DN.T Dim.Time a ->
      DN.T Dim.Frequency a -> DN.T Dim.Frequency a ->
      Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
allpassDown :: forall a s.
(C a, C a, C a a) =>
Int
-> T Time a
-> T Frequency a
-> T Frequency a
-> T s Time a (R s Voltage a a)
allpassDown Int
order T Time a
halfLife T Frequency a
filterfreq T Frequency a
freq =
   do R s Voltage a a
x <- forall a u v s.
(C a, C u, C v) =>
T (Recip u) v -> T s u v (R s Voltage a v)
simpleSaw T Frequency a
freq
      forall y u v s t yv.
(C y, C u, C v) =>
y -> T s u t (R s v y yv -> R s v y yv)
FiltA.amplify a
0.3 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
         (forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t (R s v y yv -> R s v y yv -> R s v y yv)
Disp.mix
             forall (f :: * -> *) a b. Functor f => f (a -> b) -> a -> f b
$# R s Voltage a a
x
             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall q yv u s amp.
(C q, C q yv, C u) =>
Int
-> q
-> T s
     u
     q
     (R s (Recip u) q q -> Signal s amp yv -> Signal s amp yv)
Filt.allpassCascade Int
order forall a. C a => a
Filt.allpassFlangerPhase
                    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: T Frequency a
filterfreq forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 T Time a
halfLife
                    forall (f :: * -> *) a b. Functor f => f (a -> b) -> a -> f b
$# R s Voltage a a
x))


{-# INLINE moogDown #-}
{-# INLINE moogReso #-}
moogDown, moogReso ::
   (RealField.C a, Trans.C a, Module.C a a) =>
      NonNeg.Int -> DN.T Dim.Time a ->
      DN.T Dim.Frequency a -> DN.T Dim.Frequency a ->
      Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
moogDown :: forall a s.
(C a, C a, C a a) =>
Int
-> T Time a
-> T Frequency a
-> T Frequency a
-> T s Time a (R s Voltage a a)
moogDown Int
order T Time a
halfLife T Frequency a
filterfreq T Frequency a
freq =
   forall q flat yv u s amp.
(C q flat, C q, C q yv, C u) =>
Int
-> T s
     u
     q
     (Signal s flat q
      -> R s (Recip u) q q -> Signal s amp yv -> Signal s amp yv)
Filt.moogLowpass Int
order
      forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- forall a. a -> Scalar a
DN.fromNumber a
10
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: T Frequency a
filterfreq forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 T Time a
halfLife
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a u v s.
(C a, C u, C v) =>
T (Recip u) v -> T s u v (R s Voltage a v)
simpleSaw T Frequency a
freq

moogReso :: forall a s.
(C a, C a, C a a) =>
Int
-> T Time a
-> T Frequency a
-> T Frequency a
-> T s Time a (R s Voltage a a)
moogReso Int
order T Time a
halfLife T Frequency a
filterfreq T Frequency a
freq =
   forall q flat yv u s amp.
(C q flat, C q, C q yv, C u) =>
Int
-> T s
     u
     q
     (Signal s flat q
      -> R s (Recip u) q q -> Signal s amp yv -> Signal s amp yv)
Filt.moogLowpass Int
order
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a. a -> Scalar a
DN.fromNumber a
100 forall amp s u t rate y sig.
amp
-> T s u t (T rate (Flat y) sig)
-> T s u t (T rate (Numeric amp) sig)
&*>^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 T Time a
halfLife
      forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- T Frequency a
filterfreq
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a u v s.
(C a, C u, C v) =>
T (Recip u) v -> T s u v (R s Voltage a v)
simpleSaw T Frequency a
freq


{-# INLINE bell #-}
bell :: (Trans.C a, RealField.C a, Module.C a a) =>
   DN.T Dim.Frequency a ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
bell :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
bell T Frequency a
freq =
   let halfLife :: Time a
halfLife = forall a. a -> Time a
DN.time a
0.5
   in  forall y u v s t yv.
(C y, C u, C v) =>
y -> T s u t (R s v y yv -> R s v y yv)
FiltA.amplify (a
1forall a. C a => a -> a -> a
/a
3) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
       (forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t ([R s v y yv] -> R s v y yv)
Disp.mixMulti forall (f :: * -> *) (t :: * -> *) a b.
(Applicative f, Traversable t) =>
f (t a -> b) -> t (f a) -> f b
$::
          (forall a s.
(C a, C a, C a a) =>
a -> T Time a -> T Frequency a -> T s Time a (R s Voltage a a)
bellHarmonic a
1 Time a
halfLife T Frequency a
freq forall a. a -> [a] -> [a]
:
           forall a s.
(C a, C a, C a a) =>
a -> T Time a -> T Frequency a -> T s Time a (R s Voltage a a)
bellHarmonic a
4 Time a
halfLife T Frequency a
freq forall a. a -> [a] -> [a]
:
           forall a s.
(C a, C a, C a a) =>
a -> T Time a -> T Frequency a -> T s Time a (R s Voltage a a)
bellHarmonic a
7 Time a
halfLife T Frequency a
freq forall a. a -> [a] -> [a]
:
           []))



{-# INLINE bellHarmonic #-}
bellHarmonic :: (Trans.C a, RealField.C a, Module.C a a) =>
   a -> DN.T Dim.Time a -> DN.T Dim.Frequency a ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
bellHarmonic :: forall a s.
(C a, C a, C a a) =>
a -> T Time a -> T Frequency a -> T s Time a (R s Voltage a a)
bellHarmonic a
n T Time a
halfLife T Frequency a
freq =
   forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. C a => a -> a
recip a
n forall u a. (C u, C a) => a -> T u a -> T u a
*& T Time a
halfLife)
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod (forall a. a -> Voltage a
DN.voltage a
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.sine) forall a. C a => a
zero
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapLinear a
0.005 (forall a. a -> Frequency a
DN.frequency a
5) forall a. C a => T a a
Wave.sine)
                  forall a. C a => a
zero (a
n forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq))


{-# INLINE fastBell #-}
{-# INLINE squareBell #-}
{-# INLINE moogGuitar #-}
{-# INLINE moogGuitarSoft #-}
{-# INLINE fatSaw #-}

fastBell, squareBell, moogGuitar, moogGuitarSoft, fatSaw ::
   (RealField.C a, Trans.C a, Module.C a a) =>
   DN.T Dim.Frequency a -> Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
fastBell :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fastBell T Frequency a
freq =
   forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.2)
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall a. a -> Voltage a
DN.voltage a
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.sine) forall a. C a => a
zero T Frequency a
freq

{-# INLINE filterSaw #-}
filterSaw :: (Module.C a a, Trans.C a, RealField.C a) =>
   DN.T Dim.Frequency a -> DN.T Dim.Frequency a ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
filterSaw :: forall a s.
(C a a, C a, C a) =>
T Frequency a -> T Frequency a -> T s Time a (R s Voltage a a)
filterSaw T Frequency a
filterFreq T Frequency a
freq =
   forall y u v s t yv.
(C y, C u, C v) =>
y -> T s u t (R s v y yv -> R s v y yv)
FiltA.amplify a
0.1 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
   (forall s amp yv. Signal s amp (Result yv) -> Signal s amp yv
Filt.lowpassFromUniversal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
$^
     (forall q flat yv u s amp.
(C q flat, C q, C q yv, C u) =>
T s
  u
  q
  (Signal s flat q
   -> R s (Recip u) q q
   -> Signal s amp yv
   -> Signal s amp (Result yv))
Filt.universal
         forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- forall a. a -> Scalar a
DN.fromNumber a
10
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: T Frequency a
filterFreq forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.1)
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall a. a -> Voltage a
DN.voltage a
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero T Frequency a
freq))


squareBell :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
squareBell T Frequency a
freq =
   forall q yv u s amp.
(C q, C q yv, C u) =>
T s u q (R s (Recip u) q q -> Signal s amp yv -> Signal s amp yv)
Filt.firstOrderLowpass
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a. a -> Frequency a
DN.frequency a
4000 forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time (a
1forall a. C a => a -> a -> a
/a
10))
--       (Osci.freqModSample Interpolation.cubic [0, 0.7, -0.3, 0.7, 0, -0.7, 0.3, -0.7] zero
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod
             (forall t y amp. C t => T t y -> amp -> [y] -> T t (Numeric amp y)
sampledWave forall t y. C t y => T t y
Interpolation.linear (forall a. a -> Voltage a
DN.voltage a
1)
                 [a
0, a
0.5, a
0.6, a
0.8, a
0, -a
0.5, -a
0.6, -a
0.8]) forall a. C a => a
zero
             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapLinear a
0.01 T Frequency a
freq forall a. C a => T a a
Wave.sine) forall a. C a => a
zero (forall a. a -> Frequency a
DN.frequency a
5.0)))


{-# INLINE fmBell #-}
fmBell :: (RealField.C a, Trans.C a, Module.C a a) =>
   a -> a -> DN.T Dim.Frequency a ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
fmBell :: forall a s.
(C a, C a, C a a) =>
a -> a -> T Frequency a -> T s Time a (R s Voltage a a)
fmBell a
depth a
freqRatio T Frequency a
freq =
   let modul :: T s Time a (Signal s (Numeric (Scalar a)) a)
modul =
          forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.2)
             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall a. a -> Scalar a
DN.fromNumber a
depth forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.sine)
                   forall a. C a => a
zero (a
freqRatio forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq)
   in  forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.5)
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall t flat u amp y s.
(C t flat, C t, C u) =>
T t (T amp y)
-> T (Recip u) t -> T s u t (Signal s flat t -> Signal s amp y)
Osci.phaseMod (forall a. a -> Voltage a
DN.voltage a
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.sine) T Frequency a
freq forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$& forall {s}. T s Time a (Signal s (Numeric (Scalar a)) a)
modul)


moogGuitar :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
moogGuitar T Frequency a
freq =
   let filterControl :: T s Time a (T (Phantom s) (Numeric (T Frequency a)) (T a))
filterControl =
          forall a. a -> Frequency a
DN.frequency a
4000 forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.5)
       tone :: T s Time a (Signal s (Numeric (Voltage a)) a)
tone =
          forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod (forall a. a -> Voltage a
DN.voltage a
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero
              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapLinear a
0.005 T Frequency a
freq forall a. C a => T a a
Wave.sine)
                    forall a. C a => a
zero (forall a. a -> Frequency a
DN.frequency a
5)
   in  forall q flat yv u s amp.
(C q flat, C q, C q yv, C u) =>
Int
-> T s
     u
     q
     (Signal s flat q
      -> R s (Recip u) q q -> Signal s amp yv -> Signal s amp yv)
Filt.moogLowpass Int
4 forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- forall a. a -> Scalar a
DN.fromNumber a
10 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall {s}.
T s Time a (T (Phantom s) (Numeric (T Frequency a)) (T a))
filterControl forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall {s}. T s Time a (Signal s (Numeric (Voltage a)) a)
tone

moogGuitarSoft :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
moogGuitarSoft T Frequency a
freq =
   forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall amp y0 y1 rate.
Primitive amp =>
(y0 -> y1) -> T rate amp (T y0) -> T rate amp (T y1)
DispA.map (a
1forall a. C a => a -> a -> a
-) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
$^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.003))
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
moogGuitar T Frequency a
freq


{- |
Phase modulation using a ring modulated signal.
May be used as some kind of e-guitar.
-}
fmRing ::
   (RealField.C a, Trans.C a, Module.C a a) =>
   DN.T Dim.Frequency a -> Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
fmRing :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fmRing T Frequency a
freq =
   forall t flat u amp y s.
(C t flat, C t, C u) =>
T t (T amp y)
-> T (Recip u) t -> T s u t (Signal s flat t -> Signal s amp y)
Osci.phaseMod (forall a. a -> Voltage a
DN.voltage a
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => a -> T a a
Wave.sineSawSmooth a
1) T Frequency a
freq
     forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
           forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.2)
           forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y t. C y => T t y -> T t (Flat y)
WaveD.flat forall a b. (a -> b) -> a -> b
$ forall y t. C y => y -> T t y -> T t y
Wave.raise forall a. C a => a
one forall a. C a => T a a
Wave.sine) (forall a. C a => a -> T a
Phase.fromRepresentative a
0.75) T Frequency a
freq
                  forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static
                        (forall a. a -> Scalar a
DN.fromNumber a
0.2 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~  {- 0.2 for no distortion -} forall a. C a => T a a
Wave.sine)
                        forall a. C a => a
zero (a
5.001 forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq)))

fatPad ::
   (RealField.C a, Trans.C a, Module.C a a, Random a) =>
   DN.T Dim.Frequency a -> Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
fatPad :: forall a s.
(C a, C a, C a a, Random a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fatPad T Frequency a
freq =
   let env :: T s Time a (R s Scalar a a)
env =
          forall y v u yv s t.
(Ord y, C y, C v, C u, C y yv) =>
T s u t (R s v y yv -> R s v y yv -> R s v y yv)
Cut.append
             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall t u v s y yv.
(C t, C u, C v) =>
T u t -> T s u t (R s v y yv -> R s v y yv)
Cut.take (forall a. a -> Time a
DN.time a
0.7) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
                  forall q u v s.
(C q, C u, C v) =>
(T u q, (T v q, T (DimensionGradient u v) q))
-> (T u q, (T v q, T (DimensionGradient u v) q))
-> T s u q (R s v q q)
Ctrl.cubicHermite
                   (forall a. a -> Time a
DN.time a
0,   (forall a. a -> Scalar a
DN.fromNumber a
0,   forall a. a -> Frequency a
DN.frequency a
1 forall u v a. (C u, C v, C a) => T u a -> T v a -> T (Mul u v) a
&*& forall a. a -> Scalar a
DN.fromNumber a
5))
                   (forall a. a -> Time a
DN.time a
0.7, (forall a. a -> Scalar a
DN.fromNumber a
0.5, forall a. a -> Frequency a
DN.frequency a
1 forall u v a. (C u, C v, C a) => T u a -> T v a -> T (Mul u v) a
&*& forall a. a -> Scalar a
DN.fromNumber a
0)))
             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall y u v s t. (C y, C u, C v) => T v y -> T s u t (R s v y y)
Ctrl.constant (forall a. a -> Scalar a
DN.fromNumber a
0.5)
       osci :: T Frequency a -> T s Time a (Signal s (Numeric (Voltage a)) a)
osci T Frequency a
f =
          forall t flat u amp y s.
(C t flat, C t, C u) =>
T t (T amp y)
-> T (Recip u) t -> T s u t (Signal s flat t -> Signal s amp y)
Osci.phaseMod (forall a. a -> Voltage a
DN.voltage a
0.3 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.sine) T Frequency a
f
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall {s}. T s Time a (R s Scalar a a)
env
                   forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall a. a -> Scalar a
DN.fromNumber a
2 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => a -> T a a
Wave.sineSawSmooth a
1) forall a. C a => a
zero T Frequency a
f)
       freqs :: [a]
freqs = forall g y.
(RandomGen g, Random y, C y) =>
g -> Int -> y -> y -> [y]
randomRsBalanced (Int -> StdGen
mkStdGen Int
384) Int
3 a
1 a
0.03
   in  forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t ([R s v y yv] -> R s v y yv)
Disp.mixMulti forall (f :: * -> *) (t :: * -> *) a b.
(Applicative f, Traversable t) =>
f (t a -> b) -> t (f a) -> f b
$:: forall a b. (a -> b) -> [a] -> [b]
map (\a
k -> forall {a} {s}.
C a =>
T Frequency a -> T s Time a (Signal s (Numeric (Voltage a)) a)
osci (a
k forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq)) [a]
freqs
{-
renderTimeVoltageMonoDoubleToInt16 (DN.frequency 44100) "fat-pad" (Cut.take (DN.time 1.5) $: fatPad (DN.frequency 220))
-}


brass ::
   (RealField.C a, Trans.C a, Module.C a a, Random a) =>
   DN.T Dim.Frequency a -> Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
brass :: forall a s.
(C a, C a, C a a, Random a) =>
T Frequency a -> T s Time a (R s Voltage a a)
brass T Frequency a
freq =
   let blobEnv :: T s Time a (R s Scalar a a)
blobEnv = forall q u v s.
(C q, C q, C u, C v) =>
Sequence s u v T q -> T s u q (R s v q q)
Piece.runState
          (forall a. a -> Scalar a
DN.fromNumber a
0  forall y t sig. y -> (PieceDist t y sig, T t y sig) -> T t y sig
|# (forall a. a -> Time a
DN.time a
0.05, forall q u v (sig :: * -> *) s.
(C q, C u, C v, Write sig q) =>
T s u v sig q
Piece.cosine) forall t y sig.
(t, Piece t y sig)
-> (PieceRightSingle y, T t y sig)
-> (PieceDist t y sig, T t y sig)
#|-
           forall a. a -> Scalar a
DN.fromNumber a
1 forall y t sig.
y
-> (PieceDist t y sig, T t y sig)
-> (PieceRightSingle y, T t y sig)
-|# (forall a. a -> Time a
DN.time a
0.05, forall q u v (sig :: * -> *) s.
(C q, C u, C v, Write sig q) =>
T s u v sig q
Piece.cosine) forall t y sig.
(t, Piece t y sig) -> y -> (PieceDist t y sig, T t y sig)
#|
           forall a. a -> Scalar a
DN.fromNumber a
0)
       adsr :: T s Time a (R s Scalar a a)
adsr = forall q u v s.
(C q, C q, C u, C v) =>
Sequence s u v T q -> T s u q (R s v q q)
Piece.runState
          (forall a. a -> Scalar a
DN.fromNumber a
0 forall y t sig. y -> (PieceDist t y sig, T t y sig) -> T t y sig
|# (forall a. a -> Time a
DN.time a
0.1, forall q u v (sig :: * -> *) s.
(C q, C u, C v, Write sig q) =>
T (DimensionGradient u v) q
-> T (DimensionGradient u v) q -> T s u v sig q
Piece.cubic (forall a. a -> Frequency a
DN.frequency a
1 forall u v a. (C u, C v, C a) => T u a -> T v a -> T (Mul u v) a
&*& forall a. a -> Scalar a
DN.fromNumber a
10) (forall a. a -> Frequency a
DN.frequency a
1 forall u v a. (C u, C v, C a) => T u a -> T v a -> T (Mul u v) a
&*& forall a. a -> Scalar a
DN.fromNumber a
0)) forall t y sig.
(t, Piece t y sig)
-> (PieceRightSingle y, T t y sig)
-> (PieceDist t y sig, T t y sig)
#|-
           forall a. a -> Scalar a
DN.fromNumber a
0.5 forall y t sig.
y
-> (PieceDist t y sig, T t y sig)
-> (PieceRightSingle y, T t y sig)
-|# (forall a. a -> Time a
DN.time a
1, forall q u v (sig :: * -> *) s.
(C q, C u, C v, Write sig q) =>
T s u v sig q
Piece.step) forall t y sig.
(t, Piece t y sig)
-> (PieceRightSingle y, T t y sig)
-> (PieceDist t y sig, T t y sig)
#|-
           forall a. a -> Scalar a
DN.fromNumber a
0.5 forall y t sig.
y
-> (PieceDist t y sig, T t y sig)
-> (PieceRightSingle y, T t y sig)
-|# (forall a. a -> Time a
DN.time a
0.3, forall q u v (sig :: * -> *) s.
(C q, C u, C v, Write sig q) =>
T v q -> T s u v sig q
Piece.exponential (forall a. a -> Scalar a
DN.fromNumber a
0)) forall t y sig.
(t, Piece t y sig) -> y -> (PieceDist t y sig, T t y sig)
#|
           forall a. a -> Scalar a
DN.fromNumber a
0.01)
       osci :: a -> T Frequency a -> T s Time a (Signal s (Numeric (Voltage a)) a)
osci a
b T Frequency a
f =
          forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod (forall a. a -> Voltage a
DN.voltage a
0.5 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
             (forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t (R s v y yv -> R s v y yv -> R s v y yv)
Disp.mix
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapLinear a
0.01 T Frequency a
f forall a. C a => T a a
Wave.sine)
                        forall a. C a => a
zero (forall a. a -> Frequency a
DN.frequency a
2))
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: ((a
b forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
f) forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall {s}. T s Time a (R s Scalar a a)
blobEnv))
       n :: Int
n = Int
4
       freqs :: [a]
freqs = forall g y.
(RandomGen g, Random y, C y) =>
g -> Int -> y -> y -> [y]
randomRsBalanced (Int -> StdGen
mkStdGen Int
295) Int
n a
1 a
0.03
       blobAmps :: [a]
blobAmps = forall y. C y => y -> [y] -> [y]
balanceLevel a
0 (forall a. Int -> [a] -> [a]
take Int
n (forall a. (a -> a) -> a -> [a]
iterate (a
0.1forall a. C a => a -> a -> a
+) a
0))
   in  forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall {s}. T s Time a (R s Scalar a a)
adsr
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t ([R s v y yv] -> R s v y yv)
Disp.mixMulti forall (f :: * -> *) (t :: * -> *) a b.
(Applicative f, Traversable t) =>
f (t a -> b) -> t (f a) -> f b
$:: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\a
b a
k -> forall {a} {s}.
C a =>
a -> T Frequency a -> T s Time a (Signal s (Numeric (Voltage a)) a)
osci a
b (a
k forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq)) [a]
blobAmps [a]
freqs)
{-
Synthesizer.Dimensional.RateAmplitude.File.renderTimeVoltageMonoDoubleToInt16 (DN.frequency 44100) "brass.aiff" (brass (DN.frequency 440))
-}


{-| low pass with resonance -}
{-# INLINE filterSweep #-}
filterSweep :: (Module.C a v, Trans.C a, RealField.C a) =>
   Phase.T a ->
   Proc.T s Dim.Time a (
      SigA.R s Dim.Voltage a v ->
      SigA.R s Dim.Voltage a v)
filterSweep :: forall a v s.
(C a v, C a, C a) =>
T a -> T s Time a (R s Voltage a v -> R s Voltage a v)
filterSweep T a
phase =
   forall s amp yv. Signal s amp (Result yv) -> Signal s amp yv
Filt.lowpassFromUniversal forall (f :: * -> *) (arrow :: * -> * -> *) b c a.
(Functor f, Arrow arrow) =>
arrow b c -> f (arrow a b) -> f (arrow a c)
.^
    (forall q flat yv u s amp.
(C q flat, C q, C q yv, C u) =>
T s
  u
  q
  (Signal s flat q
   -> R s (Recip u) q q
   -> Signal s amp yv
   -> Signal s amp (Result yv))
Filt.universal
       forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- forall a. a -> Scalar a
DN.fromNumber a
10
       forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapExponential a
2 (forall a. a -> Frequency a
DN.frequency a
1800) forall a. C a => T a a
Wave.sine)
             T a
phase (forall a. a -> Frequency a
DN.frequency (a
1forall a. C a => a -> a -> a
/a
16)))


{-# INLINE fatSawChordFilter #-}
{-# INLINE fatSawChord #-}
fatSawChordFilter, fatSawChord ::
   (RealField.C a, Trans.C a, Module.C a a) =>
   DN.T Dim.Frequency a -> Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)

fatSawChordFilter :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fatSawChordFilter T Frequency a
freq =
   forall y u v s t yv.
(C y, C u, C v) =>
y -> T s u t (R s v y yv -> R s v y yv)
FiltA.amplify (a
1forall a. C a => a -> a -> a
/a
2) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
   (forall s amp yv. Signal s amp (Result yv) -> Signal s amp yv
Filt.lowpassFromUniversal forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
$^
     (forall q flat yv u s amp.
(C q flat, C q, C q yv, C u) =>
T s
  u
  q
  (Signal s flat q
   -> R s (Recip u) q q
   -> Signal s amp yv
   -> Signal s amp (Result yv))
Filt.universal
         forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- forall a. a -> Scalar a
DN.fromNumber a
10
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a s. (C a, C a) => T s Time a (R s Frequency a a)
filterDown
         forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fatSawChord T Frequency a
freq))

fatSawChord :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fatSawChord T Frequency a
freq =
   forall y u v s t yv.
(C y, C u, C v) =>
y -> T s u t (R s v y yv -> R s v y yv)
FiltA.amplify (a
1forall a. C a => a -> a -> a
/a
3) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
   (forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t ([R s v y yv] -> R s v y yv)
Disp.mixMulti forall (f :: * -> *) (t :: * -> *) a b.
(Applicative f, Traversable t) =>
f (t a -> b) -> t (f a) -> f b
$::
       [forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fatSaw ( a
1    forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq),
        forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fatSaw ((a
5forall a. C a => a -> a -> a
/a
4) forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq),
        forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fatSaw ((a
3forall a. C a => a -> a -> a
/a
2) forall u a. (C u, C a) => a -> T u a -> T u a
*& T Frequency a
freq)])

{-# INLINE filterDown #-}
filterDown :: (RealField.C a, Trans.C a) =>
   Proc.T s Dim.Time a (SigA.R s Dim.Frequency a a)
filterDown :: forall a s. (C a, C a) => T s Time a (R s Frequency a a)
filterDown =
   forall a. a -> Frequency a
DN.frequency a
4000 forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time (a
1forall a. C a => a -> a -> a
/a
3))

{-# INLINE simpleSaw #-}
simpleSaw :: (Ring.C a, Dim.C u, RealField.C v) =>
   DN.T (Dim.Recip u) v ->
   Proc.T s u v (SigA.R s Dim.Voltage a v)
simpleSaw :: forall a u v s.
(C a, C u, C v) =>
T (Recip u) v -> T s u v (R s Voltage a v)
simpleSaw T (Recip u) v
freq =
   forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall a. a -> Voltage a
DN.voltage a
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero T (Recip u) v
freq


{-| accumulate multiple similar saw sounds and observe the increase of volume
    The oscillator @osc@ must accept relative frequencies. -}
{-# INLINE modulatedWave #-}
modulatedWave :: (Trans.C a, RealField.C a, Dim.C u) =>
   Proc.T s u a (SigA.R s (Dim.Recip u) a a -> SigA.R s Dim.Voltage a a) ->
   DN.T (Dim.Recip u) a ->
   a -> Phase.T a ->
   DN.T (Dim.Recip u) a ->
   Proc.T s u a (SigA.R s Dim.Voltage a a)
modulatedWave :: forall a u s.
(C a, C a, C u) =>
T s u a (R s (Recip u) a a -> R s Voltage a a)
-> T (Recip u) a
-> a
-> T a
-> T (Recip u) a
-> T s u a (R s Voltage a a)
modulatedWave T s u a (R s (Recip u) a a -> R s Voltage a a)
osc T (Recip u) a
freq a
depth T a
phase T (Recip u) a
speed =
   T s u a (R s (Recip u) a a -> R s Voltage a a)
osc forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapLinear a
depth T (Recip u) a
freq forall a. C a => T a a
Wave.sine) T a
phase T (Recip u) a
speed


{-# INLINE accumulationParameters #-}
accumulationParameters :: (Random a, Trans.C a, RealField.C a, Module.C a a) =>
   [(Phase.T a, a, Phase.T a, DN.T Dim.Frequency a)]
accumulationParameters :: forall a.
(Random a, C a, C a, C a a) =>
[(T a, a, T a, T Frequency a)]
accumulationParameters =
   let starts :: [T a]
starts = forall a g. (Random a, RandomGen g) => g -> [a]
randoms           (Int -> StdGen
mkStdGen Int
48251)
       depths :: [a]
depths = forall a g. (Random a, RandomGen g) => (a, a) -> g -> [a]
randomRs (a
0,a
0.02) (Int -> StdGen
mkStdGen Int
12354)
       phases :: [T a]
phases = forall a g. (Random a, RandomGen g) => g -> [a]
randoms           (Int -> StdGen
mkStdGen Int
74389)
       speeds :: [Frequency a]
speeds = forall a g. (Random a, RandomGen g) => (a, a) -> g -> [a]
randomRs (forall a. a -> Frequency a
DN.frequency a
0.1, forall a. a -> Frequency a
DN.frequency a
0.3)
                                  (Int -> StdGen
mkStdGen Int
03445)
   in  forall a b c d. [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
zip4 [T a]
starts [a]
depths [T a]
phases [Frequency a]
speeds

{-# INLINE accumulatedSaws #-}
{-# INLINE choir #-}
accumulatedSaws, choir ::
   (Random a, Trans.C a, RealField.C a, Module.C a a) =>
   DN.T Dim.Frequency a ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
accumulatedSaws :: forall a s.
(Random a, C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
accumulatedSaws T Frequency a
freq =
    forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t ([R s v y yv] -> R s v y yv)
Disp.mixMulti forall (f :: * -> *) (t :: * -> *) a b.
(Applicative f, Traversable t) =>
f (t a -> b) -> t (f a) -> f b
$::
       (forall a b. (a -> b) -> [a] -> [b]
map
          (\(T a
start, a
depth, T a
phase, T Frequency a
speed) ->
               forall a u s.
(C a, C a, C u) =>
T s u a (R s (Recip u) a a -> R s Voltage a a)
-> T (Recip u) a
-> a
-> T a
-> T (Recip u) a
-> T s u a (R s Voltage a a)
modulatedWave
                  (forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod (forall a. a -> Voltage a
DN.voltage a
1 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) T a
start)
                  T Frequency a
freq a
depth T a
phase T Frequency a
speed)
          forall a.
(Random a, C a, C a, C a a) =>
[(T a, a, T a, T Frequency a)]
accumulationParameters)

choir :: forall a s.
(Random a, C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
choir T Frequency a
freq =
   forall y u v s t yv.
(C y, C u, C v) =>
y -> T s u t (R s v y yv -> R s v y yv)
FiltA.amplify a
0.2 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t ([R s v y yv] -> R s v y yv)
Disp.mixMulti forall (f :: * -> *) (t :: * -> *) a b.
(Applicative f, Traversable t) =>
f (t a -> b) -> t (f a) -> f b
$::
      forall a. Int -> [a] -> [a]
take Int
10
         (forall a b. (a -> b) -> [a] -> [b]
map
            (\(T a
start, a
depth, T a
phase, T Frequency a
speed) ->
                forall a u s.
(C a, C a, C u) =>
T s u a (R s (Recip u) a a -> R s Voltage a a)
-> T (Recip u) a
-> a
-> T a
-> T (Recip u) a
-> T s u a (R s Voltage a a)
modulatedWave
                  (forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod
                      (forall t y amp. C t => T t y -> amp -> [y] -> T t (Numeric amp y)
sampledWave forall t y. T t y
Interpolation.constant (forall a. a -> Voltage a
DN.voltage a
1) forall a. C a => [a]
choirWave) T a
start)
                  T Frequency a
freq a
depth T a
phase T Frequency a
speed)
            forall a.
(Random a, C a, C a, C a a) =>
[(T a, a, T a, T Frequency a)]
accumulationParameters))


fatSaw :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
fatSaw T Frequency a
freq =
    {- a simplified version of modulatedWave -}
    let partial :: a -> a -> T Frequency a -> T s Time a (R s Voltage a a)
partial a
depth a
modPhase T Frequency a
modFreq =
           forall a u s.
(C a, C a a, C u) =>
T s u a (R s (Recip u) a a -> R s Voltage a a)
osciDoubleSaw forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
              forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapLinear a
depth T Frequency a
freq forall a. C a => T a a
Wave.sine)
                 (forall a. C a => a -> T a
Phase.fromRepresentative a
modPhase) T Frequency a
modFreq
    in  forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t ([R s v y yv] -> R s v y yv)
Disp.mixMulti forall (f :: * -> *) (t :: * -> *) a b.
(Applicative f, Traversable t) =>
f (t a -> b) -> t (f a) -> f b
$::
            [forall {s}. a -> a -> T Frequency a -> T s Time a (R s Voltage a a)
partial a
0.00311 a
0.0 (forall a. a -> Frequency a
DN.frequency a
20),
             forall {s}. a -> a -> T Frequency a -> T s Time a (R s Voltage a a)
partial a
0.00532 a
0.3 (forall a. a -> Frequency a
DN.frequency a
17),
             forall {s}. a -> a -> T Frequency a -> T s Time a (R s Voltage a a)
partial a
0.00981 a
0.9 (forall a. a -> Frequency a
DN.frequency  a
6)]


{-# INLINE wasp #-}
{- |
A good choice is @freq = DN.frequency 110@
-}
wasp ::
   (RealField.C q, Trans.C q, Module.C q q, Random q, Dim.C u) =>
   DN.T (Dim.Recip u) q ->
   Proc.T s u q (SigA.R s Dim.Voltage q q)
wasp :: forall q u s.
(C q, C q, C q q, Random q, C u) =>
T (Recip u) q -> T s u q (R s Voltage q q)
wasp T (Recip u) q
freq =
   forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapLinear q
1 (forall a. a -> Scalar a
DN.scalar q
0.5) forall a. C a => T a a
Wave.saw)
           forall a. C a => a
zero (forall a. C a => a -> a
recip q
2.01 forall u a. (C u, C a) => a -> T u a -> T u a
*& T (Recip u) q
freq)
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall a. a -> Voltage a
DN.voltage q
0.7 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.saw) forall a. C a => a
zero T (Recip u) q
freq


{-# INLINE osciDoubleSaw #-}
osciDoubleSaw ::
   (RealField.C a, Module.C a a, Dim.C u) =>
   Proc.T s u a (
      SigA.R s (Dim.Recip u) a a ->
      SigA.R s Dim.Voltage a a)
osciDoubleSaw :: forall a u s.
(C a, C a a, C u) =>
T s u a (R s (Recip u) a a -> R s Voltage a a)
osciDoubleSaw =
   forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod
      (forall t y amp. C t => T t y -> amp -> [y] -> T t (Numeric amp y)
sampledWave forall t y. C t y => T t y
Interpolation.linear (forall a. a -> Voltage a
DN.voltage a
1)
          [-a
1, -a
0.2, a
0.5, -a
0.5, a
0.2, a
1.0]) forall a. C a => a
zero

{-
sampledWave :: (RealField.C t, Storable y) =>
   Interpolation.T t y -> amp -> [y] ->
   WaveD.T t (Sample.Numeric amp y)
sampledWave ip amp =
   WaveD.amplified amp . WaveG.sample ip .
   SigSt.fromList SigSt.defaultChunkSize
-}

sampledWave :: (RealField.C t) =>
   Interpolation.T t y -> amp -> [y] ->
   WaveD.T t (Sample.Numeric amp y)
sampledWave :: forall t y amp. C t => T t y -> amp -> [y] -> T t (Numeric amp y)
sampledWave T t y
ip amp
amp =
   forall amp t y. amp -> T t y -> T t (Numeric amp y)
WaveD.amplified amp
amp forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a (sig :: * -> *) v.
(C a, Transform sig v) =>
T a v -> sig v -> T a v
WaveG.sample T t y
ip

{-|
A tone with a waveform with roughly the dependency @x -> x^?p@,
where the waveform is normalized to constant quadratic norm
-}
{-# INLINE osciSharp #-}
osciSharp :: (RealField.C a, Trans.C a) =>
   DN.T Dim.Frequency a ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
osciSharp :: forall a s.
(C a, C a) =>
T Frequency a -> T s Time a (R s Voltage a a)
osciSharp T Frequency a
freq =
   forall t u cAmp c amp y s.
(C t, C u) =>
T (T cAmp c) t (T amp y)
-> T t
-> T (Recip u) t
-> T s u t (Signal s cAmp c -> Signal s amp y)
Osci.shapeMod (forall a. a -> Voltage a
DN.voltage a
1 forall y u cAmp c t.
(C y, C u, Primitive cAmp) =>
T u y -> (c -> T t y) -> T (T cAmp c) t (Dimensional u y y)
`WaveCtrl.amplified` forall a. (C a, C a) => a -> T a a
Wave.powerNormed2) forall a. C a => a
zero T Frequency a
freq forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
   (forall y flat (sig :: * -> *) rate.
(C y flat, Transform sig y) =>
T rate flat (sig y) -> T rate (Flat y) (sig y)
Flat.canonicalize forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
$^
    forall a. a -> Scalar a
DN.fromNumber a
10 forall y flat (sig :: * -> *) amp s u t rate.
(C y flat, Transform sig y) =>
amp
-> T s u t (T rate flat (sig y))
-> T s u t (T rate (Numeric amp) (sig y))
&*^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.01))

{-|
Build a saw sound from its harmonics and modulate it.
Different to normal modulation
I modulate each harmonic with the same depth rather than a proportional one.
-}
{-# INLINE osciAbsModSaw #-}
osciAbsModSaw :: (RealField.C a, Trans.C a, Module.C a a) =>
   DN.T Dim.Frequency a ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
osciAbsModSaw :: forall a s.
(C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
osciAbsModSaw T Frequency a
freq =
   let harmonic :: Integer -> T s Time a (Signal s (Numeric (Voltage a)) a)
harmonic Integer
n =
          forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod (forall a. a -> Voltage a
DN.voltage (a
0.25 forall a. C a => a -> a -> a
/ forall a. C a => Integer -> a
fromInteger Integer
n) forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.sine) forall a. C a => a
zero
             forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall y u t.
(C y, C u) =>
y -> T u y -> T t y -> T t (Dimensional u y y)
WaveD.mapLinear a
0.03 T Frequency a
freq forall a. C a => T a a
Wave.sine) forall a. C a => a
zero (forall a. a -> Frequency a
DN.frequency a
1)
   in  forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t ([R s v y yv] -> R s v y yv)
Disp.mixMulti forall (f :: * -> *) (t :: * -> *) a b.
(Applicative f, Traversable t) =>
f (t a -> b) -> t (f a) -> f b
$:: forall a b. (a -> b) -> [a] -> [b]
map forall {a} {s}.
C a =>
Integer -> T s Time a (Signal s (Numeric (Voltage a)) a)
harmonic [Integer
1..Integer
20]

{-|
Short pulsed Noise.white,
i.e. Noise.white amplified with pulses of varying H\/L ratio.
-}
{-# INLINE pulsedNoise #-}
pulsedNoise :: (Random a, RealField.C a, Trans.C a, Module.C a a) =>
   DN.T Dim.Frequency a   {-^ frequency of the pulses, interesting ones are around 100 Hz and below -} ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
pulsedNoise :: forall a s.
(Random a, C a, C a, C a a) =>
T Frequency a -> T s Time a (R s Voltage a a)
pulsedNoise T Frequency a
freq =
   let raisedSine :: Trans.C a => a -> WaveD.T a (Sample.Dimensional Dim.Voltage a a)
       raisedSine :: forall a. C a => a -> T a (Dimensional Voltage a a)
raisedSine a
v = forall a. a -> Voltage a
DN.voltage a
v forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall y t. C y => y -> T t y -> T t y
Wave.raise forall a. C a => a
one forall a. C a => T a a
Wave.sine
       c :: T s Time a (T (Phantom s) Abstract (T Bool))
c = forall a s u t. a -> T s u t a
Proc.pure forall y u yv s.
(Ord y, C y, C u, C y yv, Ord yv) =>
R s u y yv -> R s u y yv -> T (Phantom s) Abstract (T Bool)
Ana.lessOrEqual
              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall a. C a => a -> T a (Dimensional Voltage a a)
raisedSine a
1.0) forall a. C a => a
zero T Frequency a
freq
              forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall t u amp y s.
(C t, C u) =>
T t (T amp y) -> T t -> T (Recip u) t -> T s u t (Signal s amp y)
Osci.static (forall a. C a => a -> T a (Dimensional Voltage a a)
raisedSine a
0.2) forall a. C a => a
zero (forall a. a -> Frequency a
DN.frequency a
0.1)
   in  forall a s u t. a -> T s u t a
Proc.pure forall y u yv (sig :: * -> *) s.
(Ord y, C y, C u, C y yv, Read sig yv, Transform sig Bool,
 Transform sig yv) =>
Signal s u y sig yv
-> Signal s u y sig yv
-> T (Phantom s) Abstract (sig Bool)
-> Signal s u y sig yv
CutA.selectBool
          forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- forall a. a -> Voltage a
DN.voltage a
0
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall yv q u v s.
(C yv, Random yv, C q, C u, C v) =>
T (Recip u) q -> T v q -> T s u q (R s v q yv)
Noise.white (forall a. a -> Frequency a
DN.frequency a
20000) (forall a. a -> Voltage a
DN.voltage a
1.0)
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall {s}. T s Time a (T (Phantom s) Abstract (T Bool))
c


{-# INLINE noisePerc #-}
noisePerc :: (Random a, RealField.C a, Trans.C a) =>
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
noisePerc :: forall a s. (Random a, C a, C a) => T s Time a (R s Voltage a a)
noisePerc =
   forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.1)
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall yv q u v s.
(C yv, Random yv, C q, C u, C v) =>
T (Recip u) q -> T v q -> T s u q (R s v q yv)
Noise.white (forall a. a -> Frequency a
DN.frequency a
20000) (forall a. a -> Voltage a
DN.voltage a
1.0)

{-# INLINE noiseBass #-}
noiseBass :: (Random a, RealField.C a, Trans.C a, Module.C a a, Storable a) =>
   DN.T Dim.Frequency a ->
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
noiseBass :: forall a s.
(Random a, C a, C a, C a a, Storable a) =>
T Frequency a -> T s Time a (R s Voltage a a)
noiseBass T Frequency a
freq =
   forall t y yv u v s.
(C t, C y, C y, C y yv, C u, C v, Storable yv) =>
T u t
-> T s u t (R s v y yv -> R s v y yv)
-> T s u t (R s v y yv -> R s v y yv)
FiltA.combProc (forall u a. (C u, C a) => T (Recip u) a -> T u a
DN.unrecip T Frequency a
freq)
      (forall q yv u s amp.
(C q, C q yv, C u) =>
T s u q (R s (Recip u) q q -> Signal s amp yv -> Signal s amp yv)
Filt.firstOrderLowpass forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- forall a. a -> Frequency a
DN.frequency a
2000)
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a s. (Random a, C a, C a) => T s Time a (R s Voltage a a)
noisePerc

{-|
Drum sound using the Karplus-Strong-Algorithm
This is a Noise.white enveloped by an exponential2
which is piped through the Karplus-Strong machine
for generating some frequency.
The whole thing is then frequency modulated
to give a falling frequency.
-}
{-# INLINE electroTom #-}
electroTom ::
   (Random a, RealField.C a, Trans.C a, Module.C a a, Storable a) =>
   Proc.T s Dim.Time a (SigA.R s Dim.Voltage a a)
electroTom :: forall a s.
(Random a, C a, C a, C a a, Storable a) =>
T s Time a (R s Voltage a a)
electroTom =
   let ks :: T s Time a (R s Voltage a a)
ks =
         forall t y yv u v s.
(C t, C y, C y, C y yv, C u, C v, Storable yv) =>
T u t
-> T s u t (R s v y yv -> R s v y yv)
-> T s u t (R s v y yv -> R s v y yv)
FiltA.combProc (forall a. a -> Time a
DN.time (a
1forall a. C a => a -> a -> a
/a
30))
            (forall q yv u s amp.
(C q, C q yv, C u) =>
T s u q (R s (Recip u) q q -> Signal s amp yv -> Signal s amp yv)
Filt.firstOrderLowpass forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- (forall a. a -> Frequency a
DN.frequency a
1000))
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall a s. (Random a, C a, C a) => T s Time a (R s Voltage a a)
noisePerc
   in  forall t flat yv u s amp.
(C t flat, C yv, C t, C u) =>
T t yv
-> T s u t (Signal s flat t -> Signal s amp yv -> Signal s amp yv)
Filt.frequencyModulation forall t y. C t y => T t y
Interpolation.linear
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time a
0.3)
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: forall {s}. T s Time a (R s Voltage a a)
ks

{-# INLINE bassDrum #-}
bassDrum ::
   (RealField.C q, Trans.C q, Module.C q q, Random q) =>
   Proc.T s Dim.Time q (SigA.R s Dim.Voltage q q)
bassDrum :: forall q s.
(C q, C q, C q q, Random q) =>
T s Time q (R s Voltage q q)
bassDrum =
   forall t u v s y yv.
(C t, C u, C v) =>
T u t -> T s u t (R s v y yv -> R s v y yv)
Cut.take (forall a. a -> Time a
DN.time q
0.15) forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$:
   (forall y yv v s u t.
(C y, C y, C y yv, C v) =>
T s u t (R s v y yv -> R s v y yv -> R s v y yv)
Disp.mix
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall q yv u s amp.
(C q, C q yv, C u) =>
T s u q (R s (Recip u) q q -> Signal s amp yv -> Signal s amp yv)
Filt.firstOrderLowpass
          forall y u v s t a.
(C y, C y, C u, C v) =>
T s u t (R s v y y -> a) -> T v y -> T s u t a
$- (forall a. a -> Frequency a
DN.frequency q
5000)
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall amp y0 y1 rate.
Primitive amp =>
(y0 -> y1) -> T rate amp (T y0) -> T rate amp (T y1)
DispA.map (q
0.03forall a. C a => a -> a -> a
+) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
$^ forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time q
0.002))
                forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall yv q u v s.
(C yv, Random yv, C q, C u, C v) =>
T (Recip u) q -> T v q -> T s u q (R s v q yv)
Noise.white (forall a. a -> Frequency a
DN.frequency q
20000) (forall a. a -> Voltage a
DN.voltage q
1))))
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall y0 flat u s t amp.
(C y0 flat, C y0, C u) =>
T s u t (Signal s flat y0 -> Signal s amp y0 -> Signal s amp y0)
Filt.envelope
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall q u s. (C q, C u) => T u q -> T s u q (Signal s q)
CtrlR.exponential2 (forall a. a -> Time a
DN.time q
0.05))
          forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall t u amp y s.
(C t, C u) =>
T t (T amp y)
-> T t -> T s u t (R s (Recip u) t t -> Signal s amp y)
Osci.freqMod (forall a. a -> Voltage a
DN.voltage q
0.5 forall amp t y. amp -> T t y -> T t (Numeric amp y)
&*~ forall a. C a => T a a
Wave.sine) forall a. C a => a
zero
                 forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
$: (forall q u v s.
(C q, C q, C u, C v) =>
T u q -> T v q -> T s u q (R s v q q)
Ctrl.exponential2
                       (forall a. a -> Time a
DN.time q
0.15) (forall a. a -> Frequency a
DN.frequency q
100)))))