Synthesizer.Plain.Filter.NonRecursive

Envelope application

amplify :: C a => a -> T a -> T a

amplifyVector :: C a v => a -> T v -> T v

envelope

Arguments

:: C a

=> T a

the envelope

-> T a

the signal to be enveloped

-> T a

envelopeVector

Arguments

:: C a v

=> T a

the envelope

-> T v

the signal to be enveloped

-> T v

fadeInOut :: C a => Int -> Int -> Int -> T a -> T a

fadeInOutAlt :: C a => Int -> Int -> Int -> T a -> T a

Shift

delay :: C y => Int -> T y -> T y

delayPad :: y -> Int -> T y -> T y

Smoothing

generic :: C a v => T a -> T v -> T v

Unmodulated non-recursive filter

genericAlt :: C a v => T a -> T v -> T v

Unmodulated non-recursive filter Output has same length as the input.

It is elegant but leaks memory.

propGeneric :: (C a v, Eq v) => T a -> T v -> Bool

gaussian :: (C a, C a, C a v) => a -> a -> a -> T v -> T v

eps is the threshold relatively to the maximum. That is, if the gaussian falls below eps * gaussian 0, then the function truncated.

binomial :: (C a, C a, C a v) => a -> a -> T v -> T v

ratioFreqToVariance :: C a => a -> a -> a

Compute the variance of the Gaussian such that its Fourier transform has value ratio at frequency freq.

binomial1 :: C v => T v -> T v

sums :: C v => Int -> T v -> T v

Moving (uniformly weighted) average in the most trivial form. This is very slow and needs about n * length x operations.

sumsDownsample2 :: C v => T v -> T v

downsample2 :: T a -> T a

sumsUpsampleOdd :: C v => Int -> T v -> T v -> T v

Given a list of numbers and a list of sums of (2*k) of successive summands, compute a list of the sums of (2*k+1) or (2*k+2) summands.

Example for 2*k+1

 [0+1+2+3, 2+3+4+5, 4+5+6+7, ...] ->
    [0+1+2+3+4, 1+2+3+4+5, 2+3+4+5+6, 3+4+5+6+7, 4+5+6+7+8, ...]

Example for 2*k+2

 [0+1+2+3, 2+3+4+5, 4+5+6+7, ...] ->
    [0+1+2+3+4+5, 1+2+3+4+5+6, 2+3+4+5+6+7, 3+4+5+6+7+8, 4+5+6+7+8+9, ...]

sumsUpsampleEven :: C v => Int -> T v -> T v -> T v

sumsPyramid :: C v => Int -> T v -> T v

sumRange :: C v => T v -> (Int, Int) -> v

Compute the sum of the values from index l to (r-1). (I.e. somehow a right open interval.) This can be used for implementation of a moving average filter. However, its counterpart sumRangeFromPyramid is much faster for large windows.

pyramid :: C v => T v -> [T v]

unitSizesFromPyramid :: [signal] -> [Int]

sumRangePrepare :: C v => ((Int, Int) -> source -> v) -> source -> (Int, Int) -> v

sumRangeFromPyramid :: C v => [T v] -> (Int, Int) -> v

This function should be much faster than sumRange but slower than the recursively implemented movingAverage. However in contrast to movingAverage it should not suffer from cancelation.

symmetricRangePrepare :: ((Int, Int) -> source -> v) -> source -> (Int, Int) -> v

minRange :: Ord v => T v -> (Int, Int) -> v

getRangeFromPyramid :: [T v] -> (Int, Int) -> [v]

sumRangeFromPyramidRec :: C v => [T v] -> (Int, Int) -> v

sumRangeFromPyramidFoldr :: C v => [T v] -> (Int, Int) -> v

sumsPosModulated :: C v => T (Int, Int) -> T v -> T v

sumsPosModulatedPyramid :: C v => Int -> T (Int, Int) -> T v -> T v

Moving average, where window bounds must be always non-negative.

The laziness granularity is 2^height.

movingAverageModulatedPyramid :: (C a, C a v) => a -> Int -> Int -> T Int -> T v -> T v

The first argument is the amplification. The main reason to introduce it, was to have only a Module constraint instead of Field. This way we can also filter stereo signals.

A control value n corresponds to filter window size 2*n+1.

Filter operators from calculus

differentiate :: C v => T v -> T v

Forward difference quotient. Shortens the signal by one. Inverts run in the sense that differentiate (zero : integrate x) == x. The signal is shifted by a half time unit.

differentiateCenter :: C v => T v -> T v

Central difference quotient. Shortens the signal by two elements, and shifts the signal by one element. (Which can be fixed by prepending an appropriate value.) For linear functions this will yield essentially the same result as differentiate. You obtain the result of differentiateCenter if you smooth the one of differentiate by averaging pairs of adjacent values.

ToDo: Vector variant

differentiate2 :: C v => T v -> T v

Second derivative. It is differentiate2 == differentiate . differentiate but differentiate2 should be faster.