Portability | requires multi-parameter type classes |
---|---|

Stability | provisional |

Maintainer | synthesizer@henning-thielemann.de |

Safe Haskell | None |

- amplify :: C a => a -> T a -> T a
- amplifyVector :: C a v => a -> T v -> T v
- envelope :: C a => T a -> T a -> T a
- envelopeVector :: C a v => T a -> T v -> T v
- fadeInOut :: C a => Int -> Int -> Int -> T a -> T a
- fadeInOutAlt :: C a => Int -> Int -> Int -> T a -> T a
- delay :: C y => Int -> T y -> T y
- delayPad :: y -> Int -> T y -> T y
- generic :: C a v => T a -> T v -> T v
- genericAlt :: C a v => T a -> T v -> T v
- 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
- binomial :: (C a, C a, C a v) => a -> a -> T v -> T v
- ratioFreqToVariance :: C a => a -> a -> a
- binomial1 :: C v => T v -> T v
- sums :: C v => Int -> T v -> T v
- sumsDownsample2 :: C v => T v -> T v
- downsample2 :: T a -> T a
- sumsUpsampleOdd :: C v => Int -> T v -> T v -> T v
- 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
- 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
- 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
- movingAverageModulatedPyramid :: (C a, C a v) => a -> Int -> Int -> T Int -> T v -> T v
- differentiate :: C v => T v -> T v
- differentiateCenter :: C v => T v -> T v
- differentiate2 :: C v => T v -> T v

# Envelope application

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

# Shift

# Smoothing

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

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

It is elegant but leaks memory.

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

`eps`

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

,
then the function truncated.

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

Compute the variance of the Gaussian
such that its Fourier transform has value `ratio`

at frequency `freq`

.

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

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 vSource

downsample2 :: T a -> T aSource

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

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, ...]

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

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.

unitSizesFromPyramid :: [signal] -> [Int]Source

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

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.

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

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

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 vSource

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 vSource

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 vSource

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 vSource

Second derivative.
It is `differentiate2 == differentiate . differentiate`

but `differentiate2`

should be faster.