Synthesizer.Dimensional.Causal.Filter

Non-recursive

Amplification

amplify :: C y amp => y -> T s u t (Single s (Numeric amp) (Numeric amp) yv yv)

The amplification factor must be positive.

amplifyDimension :: (C y, C u, C v0, C v1) => T v0 y -> T s u t (Single s (Dimensional v1 y) (Dimensional (Mul v0 v1) y) yv yv)

amplifyScalarDimension :: (C y, C u, C v) => T v y -> T s u t (Single s (Dimensional Scalar y) (Dimensional v y) yv yv)

negate :: C (Displacement sample) => T s u t (T s sample sample)

envelope :: C y => T s u t (T s (Flat y, Numeric amp y) (Numeric amp y))

envelopeScalarDimension :: (C y, C u, C v) => T s u t (T s (Dimensional Scalar y y, Dimensional v y y) (Dimensional v y y))

envelopeVector :: C y (Displacement sample) => T s u t (T s (Flat y, sample) sample)

envelopeVectorDimension :: (C y0 yv, C y, C u, C v0, C v1) => T s u t (T s (Dimensional v0 y y0, Dimensional v1 y yv) (Dimensional (Mul v0 v1) y yv))

Filter operators from calculus

differentiate :: (C yv, C q, C u, C v) => T s u q (Single s (Dimensional v q) (Dimensional (DimensionGradient u v) q) yv yv)

Recursive

type ResonantFilter s u q ic amp yv0 yv1 = T s u q (T (Converter s (Dimensional Scalar q q, Dimensional (Recip u) q q) ic) (T s (T amp yv0, SampleRateDep s ic) (T amp yv1)))

type FrequencyFilter s u q ic amp yv0 yv1 = T s u q (T (Converter s (Dimensional (Recip u) q q) ic) (T s (T amp yv0, SampleRateDep s ic) (T amp yv1)))

Without resonance

firstOrderLowpass :: (C q, C q yv, C u) => FrequencyFilter s u q (Parameter q) amp yv yv

firstOrderHighpass :: (C q, C q yv, C u) => FrequencyFilter s u q (Parameter q) amp yv yv

butterworthLowpass

Arguments

:: (C a, C a yv, Storable a, Storable yv, C u)

=> Int

Order of the filter, must be even, the higher the order, the sharper is the separation of frequencies.

-> ResonantFilter s u a (Parameter a) amp yv yv

butterworthHighpass

Arguments

:: (C a, C a yv, Storable a, Storable yv, C u)

=> Int

Order of the filter, must be even, the higher the order, the sharper is the separation of frequencies.

-> ResonantFilter s u a (Parameter a) amp yv yv

chebyshevALowpass :: (C a, C a yv, Storable a, Storable yv, C u) => Int -> ResonantFilter s u a (ParameterA a) amp yv yv

chebyshevAHighpass :: (C a, C a yv, Storable a, Storable yv, C u) => Int -> ResonantFilter s u a (ParameterA a) amp yv yv

chebyshevBLowpass :: (C a, C a yv, Storable a, Storable yv, C u) => Int -> ResonantFilter s u a (ParameterB a) amp yv yv

chebyshevBHighpass :: (C a, C a yv, Storable a, Storable yv, C u) => Int -> ResonantFilter s u a (ParameterB a) amp yv yv

butterworthLowpassPole

Arguments

:: (C q, C q yv, C u)

=> Int

Order of the filter, must be even, the higher the order, the sharper is the separation of frequencies.

-> ResonantFilter s u q (Pole q) amp yv yv

butterworthHighpassPole

Arguments

:: (C q, C q yv, C u)

=> Int

Order of the filter, must be even, the higher the order, the sharper is the separation of frequencies.

-> ResonantFilter s u q (Pole q) amp yv yv

chebyshevALowpassPole

Arguments

:: (C q, C q yv, C u)

=> Int

Order of the filter, must be even, the higher the order, the sharper is the separation of frequencies.

-> ResonantFilter s u q (Pole q) amp yv yv

chebyshevAHighpassPole

Arguments

:: (C q, C q yv, C u)

=> Int

Order of the filter, must be even, the higher the order, the sharper is the separation of frequencies.

-> ResonantFilter s u q (Pole q) amp yv yv

chebyshevBLowpassPole

Arguments

:: (C q, C q yv, C u)

=> Int

Order of the filter, must be even, the higher the order, the sharper is the separation of frequencies.

-> ResonantFilter s u q (Pole q) amp yv yv

chebyshevBHighpassPole

Arguments

:: (C q, C q yv, C u)

=> Int

Order of the filter, must be even, the higher the order, the sharper is the separation of frequencies.

-> ResonantFilter s u q (Pole q) amp yv yv

With resonance

universal :: (C q, C q yv, C u) => ResonantFilter s u q (Parameter q) amp yv (Result yv)

highpassFromUniversal :: Single s amp amp (Result yv) yv

bandpassFromUniversal :: Single s amp amp (Result yv) yv

lowpassFromUniversal :: Single s amp amp (Result yv) yv

bandlimitFromUniversal :: Single s amp amp (Result yv) yv

moogLowpass :: (C q, C q yv, C u) => Int -> ResonantFilter s u q (Parameter q) amp yv yv

Allpass

allpassCascade

Arguments

:: (C q, C q yv, C u)

=> Int

order, number of filters in the cascade

-> q

the phase shift to be achieved for the given frequency

-> FrequencyFilter s u q (Parameter q) amp yv yv

the lowest comb frequency is used as the filter frequency

allpassPhaser

Arguments

:: (C q, C q yv, C u)

=> Int

order, number of filters in the cascade

-> ResonantFilter s u q (q, Parameter q) amp yv yv

We use the mixing ratio as resonance parameter. Mixing ratio r means: Amplify input by r and delayed signal by 1-r. Maximum effect is achieved for r=0.5.

allpassFlangerPhase :: C a => a

Filter operators from calculus

integrate :: (C yv, C q, C u, C v) => T s u q (T s (Dimensional v q yv) (Dimensional (Mul u v) q yv))