Synthesizer.Plain.Signal

Documentation

type T = []

Generic routines that are useful for filters

type Modifier s ctrl a b = Simple s ctrl a b

modifyStatic :: Modifier s ctrl a b -> ctrl -> T a -> T b

modif is a process controlled by values of type c with an internal state of type s, it converts an input value of type a into an output value of type b while turning into a new state

ToDo: Shall finite signals be padded with zeros?

modifyModulated :: Modifier s ctrl a b -> T ctrl -> T a -> T b

Here the control may vary over the time.

type ModifierInit s init ctrl a b = Initialized s init ctrl a b

modifierInitialize :: ModifierInit s init ctrl a b -> init -> Modifier s ctrl a b

modifyStaticInit :: ModifierInit s init ctrl a b -> init -> ctrl -> T a -> T b

modifyModulatedInit :: ModifierInit s init ctrl a b -> init -> T ctrl -> T a -> T b

Here the control may vary over the time.

unfoldR :: (acc -> Maybe (y, acc)) -> acc -> (acc, T y)

reduceL :: (x -> acc -> Maybe acc) -> acc -> T x -> acc

mapAccumL :: (x -> acc -> Maybe (y, acc)) -> acc -> T x -> (acc, T y)

crochetL :: (x -> acc -> Maybe (y, acc)) -> acc -> T x -> T y

fix1 :: y -> (T y -> T y) -> T y

Feed back signal into signal processor, and apply a delay by one value. fix1 is a kind of generate.

dropMarginRem :: Int -> Int -> T a -> (Int, T a)

dropMarginRem n m xs drops at most the first m elements of xs and ensures that xs still contains n elements. Additionally returns the number of elements that could not be dropped due to the margin constraint. That is dropMarginRem n m xs == (k,ys) implies length xs - m == length ys - k. Requires length xs >= n.

dropMargin :: Int -> Int -> T a -> T a

lengthAtLeast :: Int -> T a -> Bool

Test whether a list has at least n elements.

zipWithTails :: (y0 -> T y1 -> y2) -> T y0 -> T y1 -> T y2

Can be implemented more efficiently than just by zipWith and tails for other data structures.

zipWithRest :: (y0 -> y0 -> y1) -> T y0 -> T y0 -> (T y1, (Bool, T y0))

zipWithRestRec :: (y0 -> y0 -> y1) -> T y0 -> T y0 -> (T y1, (Bool, T y0))

zipWithAppend :: (y -> y -> y) -> T y -> T y -> T y