synthesizer-core-0.8.2: Audio signal processing coded in Haskell: Low level part

Synthesizer.Plain.Control

Synopsis

# Documentation

constant :: y -> T y Source #

Arguments

 :: C y => y steepness -> y initial value -> T y linear progression

linearMultiscale :: C y => y -> y -> T y Source #

Minimize rounding errors by reducing number of operations per element to a logarithmuc number.

linearMultiscaleNeutral :: C y => y -> T y Source #

Linear curve starting at zero.

linearStable :: C y => y -> y -> T y Source #

As stable as the addition of time values.

linearMean :: C y => y -> y -> T y Source #

It computes the same like linear but in a numerically more stable manner, namely using a subdivision scheme. The division needed is a division by two.

0       4       8
0   2   4   6   8
0 1 2 3 4 5 6 7 8

Arguments

 :: C y => Int length -> (y, y) initial and final value -> T y linear progression

Linear curve of a fixed length. The final value is not actually reached, instead we stop one step before. This way we can concatenate several lines without duplicate adjacent values.

Arguments

 :: C y => y time where the function reaches 1/e of the initial value -> y initial value -> T y exponential decay

Arguments

 :: C y => y time where the function reaches 1/e of the initial value -> y initial value -> T y exponential decay

Arguments

 :: C y => y time where the function reaches 1/e of the initial value -> y initial value -> T y exponential decay

Arguments

 :: C y => y time where the function reaches 1/e of the initial value -> T y exponential decay

Arguments

 :: C y => y half life -> y initial value -> T y exponential decay

Arguments

 :: C y => y half life -> y initial value -> T y exponential decay

Arguments

 :: C y => y half life -> y initial value -> T y exponential decay

Arguments

 :: C y => y half life -> T y exponential decay

Arguments

 :: C y => y time where the function reaches 1/e of the initial value -> y initial value -> y value after given time -> T y exponential decay

Arguments

 :: C y => y time where the function reaches 1/e of the initial value -> y initial value -> y value after given time -> T y exponential decay

Arguments

 :: (C y, C y v) => y time where the function reaches 1/e of the initial value -> v initial value -> T v exponential decay

This is an extension of exponential to vectors which is straight-forward but requires more explicit signatures. But since it is needed rarely I setup a separate function.

Arguments

 :: (C y, C y v) => y half life -> v initial value -> T v exponential decay

Arguments

 :: C y => y time t0 where 1 is approached -> y time t1 where -1 is approached -> T y a cosine wave where one half wave is between t0 and t1

Arguments

 :: C y => y time t0 where 1 is approached -> y time t1 where -1 is approached -> T y a cosine wave where one half wave is between t0 and t1

Arguments

 :: C y => y time t0 where 1 is approached -> y time t1 where -1 is approached -> T y a cosine wave where one half wave is between t0 and t1

Arguments

 :: C y => y time t0 where 1 is approached -> y time t1 where -1 is approached -> T y a cosine wave where one half wave is between t0 and t1

cubicHermite :: C y => (y, (y, y)) -> (y, (y, y)) -> T y Source #

cubicHermiteStable :: C y => (y, (y, y)) -> (y, (y, y)) -> T y Source #

curveMultiscale :: (y -> y -> y) -> y -> y -> T y Source #

curveMultiscaleNeutral :: (y -> y -> y) -> y -> y -> T y Source #

cubicFunc :: C y => (y, (y, y)) -> (y, (y, y)) -> y -> y Source #

0                                     16
0               8                     16
0       4       8         12          16
0   2   4   6   8   10    12    14    16
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

cosineWithSlope :: C y => (y -> y -> signal) -> y -> y -> signal Source #