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

Safe HaskellNone
LanguageHaskell2010

Synthesizer.Plain.Control

Synopsis

Documentation

constant :: y -> T y Source #

linear 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

line Source #

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.

exponential Source #

Arguments

:: C y 
=> y

time where the function reaches 1/e of the initial value

-> y

initial value

-> T y

exponential decay

exponentialMultiscale Source #

Arguments

:: C y 
=> y

time where the function reaches 1/e of the initial value

-> y

initial value

-> T y

exponential decay

exponentialStable Source #

Arguments

:: C y 
=> y

time where the function reaches 1/e of the initial value

-> y

initial value

-> T y

exponential decay

exponentialMultiscaleNeutral Source #

Arguments

:: C y 
=> y

time where the function reaches 1/e of the initial value

-> T y

exponential decay

exponential2 Source #

Arguments

:: C y 
=> y

half life

-> y

initial value

-> T y

exponential decay

exponential2Multiscale Source #

Arguments

:: C y 
=> y

half life

-> y

initial value

-> T y

exponential decay

exponential2Stable Source #

Arguments

:: C y 
=> y

half life

-> y

initial value

-> T y

exponential decay

exponential2MultiscaleNeutral Source #

Arguments

:: C y 
=> y

half life

-> T y

exponential decay

exponentialFromTo Source #

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

exponentialFromToMultiscale Source #

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

vectorExponential Source #

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.

vectorExponential2 Source #

Arguments

:: (C y, C y v) 
=> y

half life

-> v

initial value

-> T v

exponential decay

cosine Source #

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

cosineMultiscale Source #

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

cosineSubdiv Source #

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

cosineStable Source #

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 #