synthesizer-0.2.0.1: Audio signal processing coded in HaskellSource codeContentsIndex
Synthesizer.Dimensional.Causal.Process
Contents
map functions
Synopsis
newtype T s amp0 amp1 yv0 yv1 = Cons (amp0 -> (amp1, T yv0 yv1))
apply :: (C amp0 T signal0, C amp1 T signal1) => T s amp0 amp1 yv0 yv1 -> T s signal0 yv0 -> T s signal1 yv1
applyGeneric :: (C amp0 storage signal0, C amp1 storage signal1, Transform storage yv0 yv1) => T s amp0 amp1 yv0 yv1 -> T s signal0 yv0 -> T s signal1 yv1
applyConst :: (C v0, C v1, C y0) => T s (T v0 y0) (T v1 y1) y0 yv1 -> T v0 y0 -> R s v1 y1 yv1
($/:) :: (C v0, C v1, Applicative f) => f (T s (T v0 y0) (T v1 y1) yv0 yv1) -> f (R s v0 y0 yv0) -> f (R s v1 y1 yv1)
($/-) :: (C v0, C v1, Applicative f, C y0) => f (T s (T v0 y0) (T v1 y1) y0 yv1) -> T v0 y0 -> f (R s v1 y1 yv1)
applyFst' :: C v => T s (T v y, restAmpIn) restAmpOut (yv, restSampIn) restSampOut -> R s v y yv -> T s restAmpIn restAmpOut restSampIn restSampOut
applyFst :: C v => T s (T v y, restAmpIn) restAmpOut (yv, restSampIn) restSampOut -> R s v y yv -> T s restAmpIn restAmpOut restSampIn restSampOut
feedFst :: C v => R s v y yv -> T s restAmp (T v y, restAmp) restSamp (yv, restSamp)
applyFlat :: (C v1, C sig yv0) => T s Flat (T v1 y1) yv0 yv1 -> T s sig yv0 -> R s v1 y1 yv1
applyFlatFst' :: C sig yv => T s (Flat, restAmpIn) restAmpOut (yv, restSampIn) restSampOut -> T s sig yv -> T s restAmpIn restAmpOut restSampIn restSampOut
applyFlatFst :: C sig yv => T s (Flat, restAmpIn) restAmpOut (yv, restSampIn) restSampOut -> T s sig yv -> T s restAmpIn restAmpOut restSampIn restSampOut
feedFlatFst :: C sig yv => T s sig yv -> T s restAmp (Flat, restAmp) restSamp (yv, restSamp)
map :: T amp0 amp1 yv0 yv1 -> T s amp0 amp1 yv0 yv1
mapAmplitude :: (C amp0, C amp1) => (amp0 -> amp1) -> T s amp0 amp1 yv yv
mapAmplitudeSameType :: (amp -> amp) -> T s amp amp yv yv
homogeneous :: T yv0 yv1 -> T s amp amp yv0 yv1
(>>>) :: T s amp0 amp1 yv0 yv1 -> T s amp1 amp2 yv1 yv2 -> T s amp0 amp2 yv0 yv2
compose :: T s amp0 amp1 yv0 yv1 -> T s amp1 amp2 yv1 yv2 -> T s amp0 amp2 yv0 yv2
(<<<) :: T s amp1 amp2 yv1 yv2 -> T s amp0 amp1 yv0 yv1 -> T s amp0 amp2 yv0 yv2
first :: T s amp0 amp1 yv0 yv1 -> T s (amp0, amp) (amp1, amp) (yv0, yv) (yv1, yv)
second :: T s amp0 amp1 yv0 yv1 -> T s (amp, amp0) (amp, amp1) (yv, yv0) (yv, yv1)
(***) :: T s amp0 amp1 yv0 yv1 -> T s amp2 amp3 yv2 yv3 -> T s (amp0, amp2) (amp1, amp3) (yv0, yv2) (yv1, yv3)
split :: T s amp0 amp1 yv0 yv1 -> T s amp2 amp3 yv2 yv3 -> T s (amp0, amp2) (amp1, amp3) (yv0, yv2) (yv1, yv3)
(&&&) :: T s amp amp0 yv yv0 -> T s amp amp1 yv yv1 -> T s amp (amp0, amp1) yv (yv0, yv1)
fanout :: T s amp amp0 yv yv0 -> T s amp amp1 yv yv1 -> T s amp (amp0, amp1) yv (yv0, yv1)
(^>>) :: T amp0 amp1 yv0 yv1 -> T s amp1 amp2 yv1 yv2 -> T s amp0 amp2 yv0 yv2
(>>^) :: T s amp0 amp1 yv0 yv1 -> T amp1 amp2 yv1 yv2 -> T s amp0 amp2 yv0 yv2
(<<^) :: T s amp1 amp2 yv1 yv2 -> T amp0 amp1 yv0 yv1 -> T s amp0 amp2 yv0 yv2
(^<<) :: T amp1 amp2 yv1 yv2 -> T s amp0 amp1 yv0 yv1 -> T s amp0 amp2 yv0 yv2
loop :: (C y, C y yv, C v) => T v y -> T s (restAmpIn, T v y) (restAmpOut, T v y) (restSampIn, yv) (restSampOut, yv) -> T s restAmpIn restAmpOut restSampIn restSampOut
loop2' :: (C y0, C y0 yv0, C v0, C y1, C y1 yv1, C v1) => (T v0 y0, T v1 y1) -> T s (restAmpIn, (T v0 y0, T v1 y1)) (restAmpOut, (T v0 y0, T v1 y1)) (restSampIn, (yv0, yv1)) (restSampOut, (yv0, yv1)) -> T s restAmpIn restAmpOut restSampIn restSampOut
loop2 :: (C y0, C y0 yv0, C v0, C y1, C y1 yv1, C v1) => (T v0 y0, T v1 y1) -> T s (restAmpIn, (T v0 y0, T v1 y1)) (restAmpOut, (T v0 y0, T v1 y1)) (restSampIn, (yv0, yv1)) (restSampOut, (yv0, yv1)) -> T s restAmpIn restAmpOut restSampIn restSampOut
id :: T s amp amp yv yv
data Flat = Flat
Documentation
newtype T s amp0 amp1 yv0 yv1 Source
Constructors
Cons (amp0 -> (amp1, T yv0 yv1))
show/hide Instances
C (T s)
apply :: (C amp0 T signal0, C amp1 T signal1) => T s amp0 amp1 yv0 yv1 -> T s signal0 yv0 -> T s signal1 yv1Source
applyGeneric :: (C amp0 storage signal0, C amp1 storage signal1, Transform storage yv0 yv1) => T s amp0 amp1 yv0 yv1 -> T s signal0 yv0 -> T s signal1 yv1Source
applyConst :: (C v0, C v1, C y0) => T s (T v0 y0) (T v1 y1) y0 yv1 -> T v0 y0 -> R s v1 y1 yv1Source
($/:) :: (C v0, C v1, Applicative f) => f (T s (T v0 y0) (T v1 y1) yv0 yv1) -> f (R s v0 y0 yv0) -> f (R s v1 y1 yv1)Source
($/-) :: (C v0, C v1, Applicative f, C y0) => f (T s (T v0 y0) (T v1 y1) y0 yv1) -> T v0 y0 -> f (R s v1 y1 yv1)Source
applyFst' :: C v => T s (T v y, restAmpIn) restAmpOut (yv, restSampIn) restSampOut -> R s v y yv -> T s restAmpIn restAmpOut restSampIn restSampOutSource
applyFst :: C v => T s (T v y, restAmpIn) restAmpOut (yv, restSampIn) restSampOut -> R s v y yv -> T s restAmpIn restAmpOut restSampIn restSampOutSource
feedFst :: C v => R s v y yv -> T s restAmp (T v y, restAmp) restSamp (yv, restSamp)Source
applyFlat :: (C v1, C sig yv0) => T s Flat (T v1 y1) yv0 yv1 -> T s sig yv0 -> R s v1 y1 yv1Source
applyFlatFst' :: C sig yv => T s (Flat, restAmpIn) restAmpOut (yv, restSampIn) restSampOut -> T s sig yv -> T s restAmpIn restAmpOut restSampIn restSampOutSource
applyFlatFst :: C sig yv => T s (Flat, restAmpIn) restAmpOut (yv, restSampIn) restSampOut -> T s sig yv -> T s restAmpIn restAmpOut restSampIn restSampOutSource
feedFlatFst :: C sig yv => T s sig yv -> T s restAmp (Flat, restAmp) restSamp (yv, restSamp)Source
map :: T amp0 amp1 yv0 yv1 -> T s amp0 amp1 yv0 yv1Source
mapAmplitude :: (C amp0, C amp1) => (amp0 -> amp1) -> T s amp0 amp1 yv yvSource
We restrict the amplitude types to those of class Amplitude. Otherwise mapAmplitude could be abused for bringing amplitudes and respective sample values out of sync. For mapping amplitudes that are nested in some pairs, use it in combination with first and second.
mapAmplitudeSameType :: (amp -> amp) -> T s amp amp yv yvSource
homogeneous :: T yv0 yv1 -> T s amp amp yv0 yv1Source

Lift a low-level homogeneous process to a dimensional one.

Note that the amp type variable is unrestricted. This way we show, that the amplitude is not touched, which also means that the underlying low-level process must be homogeneous.

(>>>) :: T s amp0 amp1 yv0 yv1 -> T s amp1 amp2 yv1 yv2 -> T s amp0 amp2 yv0 yv2Source
compose :: T s amp0 amp1 yv0 yv1 -> T s amp1 amp2 yv1 yv2 -> T s amp0 amp2 yv0 yv2Source
(<<<) :: T s amp1 amp2 yv1 yv2 -> T s amp0 amp1 yv0 yv1 -> T s amp0 amp2 yv0 yv2Source
first :: T s amp0 amp1 yv0 yv1 -> T s (amp0, amp) (amp1, amp) (yv0, yv) (yv1, yv)Source
second :: T s amp0 amp1 yv0 yv1 -> T s (amp, amp0) (amp, amp1) (yv, yv0) (yv, yv1)Source
(***) :: T s amp0 amp1 yv0 yv1 -> T s amp2 amp3 yv2 yv3 -> T s (amp0, amp2) (amp1, amp3) (yv0, yv2) (yv1, yv3)Source
split :: T s amp0 amp1 yv0 yv1 -> T s amp2 amp3 yv2 yv3 -> T s (amp0, amp2) (amp1, amp3) (yv0, yv2) (yv1, yv3)Source
(&&&) :: T s amp amp0 yv yv0 -> T s amp amp1 yv yv1 -> T s amp (amp0, amp1) yv (yv0, yv1)Source
fanout :: T s amp amp0 yv yv0 -> T s amp amp1 yv yv1 -> T s amp (amp0, amp1) yv (yv0, yv1)Source
map functions
(^>>) :: T amp0 amp1 yv0 yv1 -> T s amp1 amp2 yv1 yv2 -> T s amp0 amp2 yv0 yv2Source
Precomposition with a pure function.
(>>^) :: T s amp0 amp1 yv0 yv1 -> T amp1 amp2 yv1 yv2 -> T s amp0 amp2 yv0 yv2Source
Postcomposition with a pure function.
(<<^) :: T s amp1 amp2 yv1 yv2 -> T amp0 amp1 yv0 yv1 -> T s amp0 amp2 yv0 yv2Source
Precomposition with a pure function (right-to-left variant).
(^<<) :: T amp1 amp2 yv1 yv2 -> T s amp0 amp1 yv0 yv1 -> T s amp0 amp2 yv0 yv2Source
Postcomposition with a pure function (right-to-left variant).
loop :: (C y, C y yv, C v) => T v y -> T s (restAmpIn, T v y) (restAmpOut, T v y) (restSampIn, yv) (restSampOut, yv) -> T s restAmpIn restAmpOut restSampIn restSampOutSource
loop2' :: (C y0, C y0 yv0, C v0, C y1, C y1 yv1, C v1) => (T v0 y0, T v1 y1) -> T s (restAmpIn, (T v0 y0, T v1 y1)) (restAmpOut, (T v0 y0, T v1 y1)) (restSampIn, (yv0, yv1)) (restSampOut, (yv0, yv1)) -> T s restAmpIn restAmpOut restSampIn restSampOutSource
loop2 :: (C y0, C y0 yv0, C v0, C y1, C y1 yv1, C v1) => (T v0 y0, T v1 y1) -> T s (restAmpIn, (T v0 y0, T v1 y1)) (restAmpOut, (T v0 y0, T v1 y1)) (restSampIn, (yv0, yv1)) (restSampOut, (yv0, yv1)) -> T s restAmpIn restAmpOut restSampIn restSampOutSource
id :: T s amp amp yv yvSource
data Flat Source
Can be used as amplitude value in Synthesizer.Dimensional.Causal.Process.T or in Synthesizer.Dimensional.Abstraction.HomogeneousGen, whenever the signal has no amplitude. It would be a bad idea to omit the Flat parameter in Synthesizer.Dimensional.Causal.Process.applyFlat routine, since Synthesizer.Dimensional.Causal.Process.apply can still be used but the correspondence between amplitude type and sample type is lost.
Constructors
Flat
show/hide Instances
C Flat
C y => Amplitude y Flat
C Flat T T
C Flat T T
C Flat sig (T sig)
Smooth Flat t (T t) (T T)
Simple Flat t (T t) (T T)
C Flat (T t) (T t)
C Flat (T t) (T t)
Produced by Haddock version 2.4.2