Synthesizer.Plain.Control

Control curve generation

constant :: y -> T y

linear

Arguments

:: C y

=> y

steepness

-> y

initial value

-> T y

linear progression

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

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

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

Linear curve starting at zero.

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

As stable as the addition of time values.

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

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

linearSubdivision :: C y => T y -> T y

Intersperse linearly interpolated values.

line

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

Arguments

:: C y

=> y

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

-> y

initial value

-> T y

exponential decay

exponentialStable

Arguments

:: C y

=> y

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

-> y

initial value

-> T y

exponential decay

exponentialMultiscale

Arguments

:: C y

=> y

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

-> y

initial value

-> T y

exponential decay

exponentialMultiscaleNeutral

Arguments

:: C y

=> y

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

-> T y

exponential decay

exponential2

Arguments

:: C y

=> y

half life

-> y

initial value

-> T y

exponential decay

exponential2Stable

Arguments

:: C y

=> y

half life

-> y

initial value

-> T y

exponential decay

exponential2Multiscale

Arguments

:: C y

=> y

half life

-> y

initial value

-> T y

exponential decay

exponential2MultiscaleNeutral

Arguments

:: C y

=> y

half life

-> T y

exponential decay

exponentialFromTo

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

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

exponentialStableGen :: (C y, C t) => (t -> y) -> t -> y -> T y

vectorExponential

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

Arguments

:: (C y, C y v)

=> y

half life

-> v

initial value

-> T v

exponential decay

cosine

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

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

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

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

cosineSubdivision :: C y => y -> T y -> T y

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

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

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

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

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

cubicSubdivision :: C y => T y -> T y

data Control y

Deprecated: use Synthesizer.State.Piece instead

The curve type of a piece of a piecewise defined control curve.

Constructors

CtrlStep

CtrlLin

CtrlExp

Fields

ctrlExpSaturation :: y

CtrlCos

CtrlCubic

Fields

ctrlCubicGradient0 :: y

ctrlCubicGradient1 :: y

Instances

Eq y => Eq (Control y)

Show y => Show (Control y)

data ControlPiece y

The full description of a control curve piece.

Constructors

ControlPiece

Fields

pieceType :: Control y

pieceY0 :: y

pieceY1 :: y

pieceDur :: y

Instances

Eq y => Eq (ControlPiece y)

Show y => Show (ControlPiece y)

newtype PieceRightSingle y

Constructors

PRS y

newtype PieceRightDouble y

Constructors

PRD y

type ControlDist y = (y, Control y, y)

(#|-) :: (y, Control y) -> (PieceRightSingle y, [ControlPiece y]) -> (ControlDist y, [ControlPiece y]) infixr 5

The 6 operators simplify constructing a list of ControlPiece a. The description consists of nodes (namely the curve values at nodes) and the connecting curve types. The naming scheme is as follows: In the middle there is a bar |. With respect to the bar, the pad symbol # is at the side of the curve type, at the other side there is nothing, a minus sign -, or an equality sign =.

1. Nothing means that here is the start or the end node of a curve.
2. Minus means that here is a node where left and right curve meet at the same value. The node description is thus one value.
3. Equality sign means that here is a split node, where left and right curve might have different ending and beginning values, respectively. The node description consists of a pair of values.

(-|#) :: y -> (ControlDist y, [ControlPiece y]) -> (PieceRightSingle y, [ControlPiece y]) infixr 5

(#|=) :: (y, Control y) -> (PieceRightDouble y, [ControlPiece y]) -> (ControlDist y, [ControlPiece y]) infixr 5

(=|#) :: (y, y) -> (ControlDist y, [ControlPiece y]) -> (PieceRightDouble y, [ControlPiece y]) infixr 5

(#|) :: (y, Control y) -> y -> (ControlDist y, [ControlPiece y]) infixr 5

(|#) :: y -> (ControlDist y, [ControlPiece y]) -> [ControlPiece y] infixr 5

piecewise :: (C y, C y) => [ControlPiece y] -> T y

piecewisePart :: C y => y -> y -> y -> y -> Int -> Control y -> T y

Auxiliary functions

curveStable :: C t => (t -> y) -> (y -> y -> y) -> t -> y -> T y

unreachable :: a

double :: C t => t -> t

concatMapPair :: (a -> (b, b)) -> T a -> T b

flattenPairs :: T (a, a) -> T a

subdivide :: (y -> y -> y) -> T y -> T y

concatMapPair' :: (a -> (b, b)) -> T a -> T b

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

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