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

Synthesizer.Generic.Signal

Description

Type classes that give a uniform interface to storable signals, stateful signals, lists, fusable lists. Some of the signal types require constraints on the element type. Storable signals require Storable elements. Thus we need multiparameter type classes. In this module we collect functions where the element type is not altered by the function.

Synopsis

Documentation

class Read (sig y) => Read sig y whereSource

Methods

toList :: sig y -> [y]Source

toState :: sig y -> T ySource

foldL :: (s -> y -> s) -> s -> sig y -> sSource

foldR :: (y -> s -> s) -> s -> sig y -> sSource

index :: sig y -> Int -> ySource

Instances

Read [] y 
Storable y => Read Vector y 
Read T y 
(C time, Integral time) => Read (T time) y 

class (Read sig y, Transform (sig y)) => Transform sig y whereSource

Methods

cons :: y -> sig y -> sig ySource

takeWhile :: (y -> Bool) -> sig y -> sig ySource

dropWhile :: (y -> Bool) -> sig y -> sig ySource

span :: (y -> Bool) -> sig y -> (sig y, sig y)Source

viewL :: sig y -> Maybe (y, sig y)Source

When using viewL for traversing a signal, it is certainly better to convert to State signal first, since this might involve optimized traversing like in case of Storable signals.

viewR :: sig y -> Maybe (sig y, y)Source

map :: (y -> y) -> sig y -> sig ySource

scanL :: (y -> y -> y) -> y -> sig y -> sig ySource

crochetL :: (y -> s -> Maybe (y, s)) -> s -> sig y -> sig ySource

zipWithAppend :: (y -> y -> y) -> sig y -> sig y -> sig ySource

Instances

Transform [] y 
Storable y => Transform Vector y 
Transform T y 
(C time, Integral time) => Transform (T time) y 

newtype LazySize Source

This type is used for specification of the maximum size of strict packets. Packets can be smaller, can have different sizes in one signal. In some kinds of streams, like lists and stateful generators, the packet size is always 1. The packet size is not just a burden caused by efficiency, but we need control over packet size in applications with feedback.

Constructors

LazySize Int 

defaultLazySize :: LazySizeSource

This can be used for internal signals that have no observable effect on laziness. E.g. when you construct a list by repeat defaultLazySize zero we assume that zero is defined for all Additive types.

class Transform sig y => Write sig y whereSource

We could provide the LazySize by a Reader monad, but we don't do that because we expect that the choice of the lazy size is more local than say the choice of the sample rate. E.g. there is no need to have the same laziness coarseness for multiple signal processors.

Methods

fromList :: LazySize -> [y] -> sig ySource

repeat :: LazySize -> y -> sig ySource

replicate :: LazySize -> Int -> y -> sig ySource

iterate :: LazySize -> (y -> y) -> y -> sig ySource

iterateAssociative :: LazySize -> (y -> y -> y) -> y -> sig ySource

unfoldR :: LazySize -> (s -> Maybe (y, s)) -> s -> sig ySource

Instances

Write [] y 
Storable y => Write Vector y 
Write T y 
(C time, Integral time) => Write (T time) y 

switchL :: Transform sig y => a -> (y -> sig y -> a) -> sig y -> aSource

switchR :: Transform sig y => a -> (sig y -> y -> a) -> sig y -> aSource

runViewL :: Read sig y => sig y -> (forall s. (s -> Maybe (y, s)) -> s -> x) -> xSource

runSwitchL :: Read sig y => sig y -> (forall s. (forall z. z -> (y -> s -> z) -> s -> z) -> s -> x) -> xSource

mix :: (C y, Transform sig y) => sig y -> sig y -> sig ySource

zipWith :: (Read sig a, Transform sig b) => (a -> b -> b) -> sig a -> sig b -> sig bSource

zipWithState :: Transform sig b => (a -> b -> b) -> T a -> sig b -> sig bSource

zipWithState3 :: Transform sig c => (a -> b -> c -> c) -> T a -> T b -> sig c -> sig cSource

delay :: Write sig y => LazySize -> y -> Int -> sig y -> sig ySource

delayLoopSource

Arguments

:: Transform sig y 
=> (sig y -> sig y)

processor that shall be run in a feedback loop

-> sig y

prefix of the output, its length determines the delay

-> sig y 

delayLoopOverlapSource

Arguments

:: (C y, Write sig y) 
=> Int 
-> (sig y -> sig y)

Processor that shall be run in a feedback loop. It's absolutely necessary that this function preserves the chunk structure and that it does not look a chunk ahead. That's guaranteed for processes that do not look ahead at all, like map, crochetL and all of type Causal.Process.

-> sig y

input

-> sig y

output has the same length as the input

sum :: (C a, Read sig a) => sig a -> aSource

monoidConcatMap :: (Read sig a, Monoid m) => (a -> m) -> sig a -> mSource

tails :: Transform sig y => sig y -> T (sig y)Source

laxTail :: Transform sig y => sig y -> sig ySource

Like tail, but for an empty signal it simply returns an empty signal.

mapAdjacent :: (Read sig a, Transform sig a) => (a -> a -> a) -> sig a -> sig aSource

modifyStatic :: Transform sig a => Simple s ctrl a a -> ctrl -> sig a -> sig aSource

modifyModulated :: (Transform sig a, Read sig ctrl) => Simple s ctrl a a -> sig ctrl -> sig a -> sig aSource

Here the control may vary over the time.

linearComb :: (C t y, Read sig t, Read sig y) => sig t -> sig y -> ySource

fromState :: Write sig y => LazySize -> T y -> sig ySource

extendConstant :: Write sig y => LazySize -> sig y -> sig ySource

mapTails :: Transform sig a => (sig a -> a) -> sig a -> sig aSource

mapTailsAlt :: (Transform sig a, Write sig b) => LazySize -> (sig a -> b) -> sig a -> sig bSource

zipWithTails :: (Transform sig b, Transform sig a) => (a -> sig b -> a) -> sig a -> sig b -> sig aSource

Only non-empty suffixes are processed. More oftenly we might need

 zipWithTails :: (Read sig b, Transform2 sig a) =>
    (b -> sig a -> a) -> sig b -> sig a -> sig a

this would preserve the chunk structure of sig a, but it is a bit more hassle to implement that.

indexByDrop :: Transform sig a => sig a -> Int -> aSource

null :: Read sig => sig -> BoolSource

length :: Read sig => sig -> IntSource

empty :: Monoid sig => sigSource

cycle :: Monoid sig => sig -> sigSource

append :: Monoid sig => sig -> sig -> sigSource

concat :: Monoid sig => [sig] -> sigSource

take :: Transform sig => Int -> sig -> sigSource

drop :: Transform sig => Int -> sig -> sigSource

dropMarginRem :: Transform sig => Int -> Int -> sig -> (Int, sig)Source

splitAt :: Transform sig => Int -> sig -> (sig, sig)Source

reverse :: Transform sig => sig -> sigSource

lengthAtLeast :: Transform sig => Int -> sig -> BoolSource

Like lengthAtLeast n xs = length xs >= n, but is more efficient, because it is more lazy.

lengthAtMost :: Transform sig => Int -> sig -> BoolSource

sliceVertical :: Transform sig => Int -> sig -> T sigSource