Safe Haskell	None
Language	Haskell2010

Synthesizer.Plain.Control

Synopsis

constant :: y -> T y
linear :: C y => y -> y -> T y
linearMultiscale :: C y => y -> y -> T y
linearMultiscaleNeutral :: C y => y -> T y
linearStable :: C y => y -> y -> T y
linearMean :: C y => y -> y -> T y
line :: C y => Int -> (y, y) -> T y
exponential :: C y => y -> y -> T y
exponentialMultiscale :: C y => y -> y -> T y
exponentialStable :: C y => y -> y -> T y
exponentialMultiscaleNeutral :: C y => y -> T y
exponential2 :: C y => y -> y -> T y
exponential2Multiscale :: C y => y -> y -> T y
exponential2Stable :: C y => y -> y -> T y
exponential2MultiscaleNeutral :: C y => y -> T y
exponentialFromTo :: C y => y -> y -> y -> T y
exponentialFromToMultiscale :: C y => y -> y -> y -> T y
vectorExponential :: (C y, C y v) => y -> v -> T v
vectorExponential2 :: (C y, C y v) => y -> v -> T v
cosine :: C y => y -> y -> T y
cosineMultiscale :: C y => y -> y -> T y
cosineSubdiv :: C y => y -> y -> T y
cosineStable :: C y => y -> y -> T y
cubicHermite :: C y => (y, (y, y)) -> (y, (y, y)) -> T y
cubicHermiteStable :: C y => (y, (y, y)) -> (y, (y, y)) -> T y
curveMultiscale :: (y -> y -> y) -> y -> y -> T y
curveMultiscaleNeutral :: (y -> y -> y) -> y -> y -> T y
cubicFunc :: C y => (y, (y, y)) -> (y, (y, y)) -> y -> y
cosineWithSlope :: C y => (y -> y -> signal) -> y -> y -> signal

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 #