synthesizer-0.0.3: Audio signal processing coded in Haskell Source code Contents Index

Synthesizer.Inference.Func.Signal Portability requires multi-parameter type classes Stability provisional Maintainer synthesizer@henning-thielemann.de

Contents Is this one correct? Has the usage of infered a cycle?

Description

Synopsis

newtype T t t' y y' yv = Cons { eval :: (t', y') -> Evaluated t t' y y' yv } type Evaluated t t' y y' yv = T t (Parameter t') y (Parameter y') yv newtype Parameter a = Parameter { parameterDesc :: [Maybe a] } liftParam2 :: ([Maybe a] -> [Maybe b] -> [Maybe c]) -> Parameter a -> Parameter b -> Parameter c cons :: ((t', y') -> T t (Parameter t') y (Parameter y') yv) -> T t t' y y' yv contextFixAmplitude :: y' -> Evaluated t t' y y' yv -> T y y' yv fromContextFreeAmplitude :: Parameter t' -> T y y' yv -> Evaluated t t' y y' yv fromContextCheckAmplitude :: Eq y' => Parameter t' -> y' -> T y y' yv -> Evaluated t t' y y' yv anyParameter :: Parameter q justParameter :: q -> Parameter q inSampleRate :: (t', y') -> t' inAmplitude :: (t', y') -> y' equalParameter :: Eq q => String -> Maybe q -> Maybe q -> Maybe q equalSampleRate :: Eq t' => Maybe t' -> Maybe t' -> Maybe t' zipJut :: (a -> a -> a) -> [a] -> [a] -> [a] mergeParameter :: Parameter q -> Parameter q -> Parameter q mergeSampleRate :: Evaluated t t' y0 y0' yv0 -> Evaluated t t' y1 y1' yv1 -> Parameter t' mergeParameterEq :: Eq q => String -> Parameter q -> Parameter q -> Parameter q mergeSampleRateEq :: Eq t' => Parameter t' -> Parameter t' -> Parameter t' merge :: [a] -> [a] -> [a] propMerge :: Eq a => [a] -> [a] -> Bool mergeParameter' :: Parameter t' -> Parameter t' -> Parameter t' checkParameter :: Eq q => String -> q -> Maybe q -> q checkSampleRate :: Eq t' => t' -> Maybe t' -> t' checkAmplitude :: Eq y' => y' -> Maybe y' -> y' mergeParameters :: [Parameter q] -> Parameter q mergeSampleRates :: [Evaluated t t' y y' yv] -> Parameter t' mergeParametersEq :: Eq q => String -> [Parameter q] -> Parameter q mergeSampleRatesEq :: Eq t' => [Parameter t'] -> Parameter t' mergeParameters' :: [Parameter q] -> Parameter q guessParameter :: String -> Parameter q -> q guessSampleRate :: Evaluated t t' y y' yv -> t' guessAmplitude :: Evaluated t t' y y' yv -> y' fixSampleRate :: Eq t' => t' -> T t t' y y' yv -> T t t' y y' yv loop :: Eq t' => (T t t' y y' yv -> T t t' y y' yv) -> T t t' y y' yv

Documentation

newtype T t t' y y' yv Source

Each process must work the following way: If the signal processor has a fixed sample rate or amplitude either implied by its parameters or its inputs then this parameter should be set as Just in the corresponding fields of SigP.T. These fields must be computed independently from the function argument of type (t',y'). This function argument is the pair of eventually used signal parameters sample rate and amplitude. If you set signal parameters to Just with a value, then you can expect that the corresponding pair member has the same value. Constructors Cons eval :: (t', y') -> Evaluated t t' y y' yv

type Evaluated t t' y y' yv = T t (Parameter t') y (Parameter y') yv Source

newtype Parameter a Source

Since all Just values must contain the same value, we could also use the data structure '(Peano, a)' just like in the unique-logic package. Constructors Parameter parameterDesc :: [Maybe a]

liftParam2 :: ([Maybe a] -> [Maybe b] -> [Maybe c]) -> Parameter a -> Parameter b -> Parameter c Source

cons :: ((t', y') -> T t (Parameter t') y (Parameter y') yv) -> T t t' y y' yv Source

contextFixAmplitude :: y' -> Evaluated t t' y y' yv -> T y y' yv Source

fromContextFreeAmplitude :: Parameter t' -> T y y' yv -> Evaluated t t' y y' yv Source

fromContextCheckAmplitude :: Eq y' => Parameter t' -> y' -> T y y' yv -> Evaluated t t' y y' yv Source

anyParameter :: Parameter q Source

justParameter :: q -> Parameter q Source

inSampleRate :: (t', y') -> t' Source

inAmplitude :: (t', y') -> y' Source

equalParameter :: Eq q => String -> Maybe q -> Maybe q -> Maybe q Source

equalSampleRate :: Eq t' => Maybe t' -> Maybe t' -> Maybe t' Source

zipJut :: (a -> a -> a) -> [a] -> [a] -> [a] Source

mergeParameter :: Parameter q -> Parameter q -> Parameter q Source

Merge the Justs of two lists. It does not check for validity of the data.

mergeSampleRate :: Evaluated t t' y0 y0' yv0 -> Evaluated t t' y1 y1' yv1 -> Parameter t' Source

mergeParameterEq :: Eq q => String -> Parameter q -> Parameter q -> Parameter q Source

mergeSampleRateEq :: Eq t' => Parameter t' -> Parameter t' -> Parameter t' Source

merge :: [a] -> [a] -> [a] Source

propMerge :: Eq a => [a] -> [a] -> Bool Source

mergeParameter' :: Parameter t' -> Parameter t' -> Parameter t' Source

checkParameter :: Eq q => String -> q -> Maybe q -> q Source

checkSampleRate :: Eq t' => t' -> Maybe t' -> t' Source

checkAmplitude :: Eq y' => y' -> Maybe y' -> y' Source

mergeParameters :: [Parameter q] -> Parameter q Source

This routine is prepared for infinite lists. In order to handle them we employ a Cantor diagonalization scheme. It does not check for validity of the data (i.e. equal Just values) but it does only keep some Justs, and thus allows for a quick search of a guess of a parameter value.

mergeSampleRates :: [Evaluated t t' y y' yv] -> Parameter t' Source

mergeParametersEq :: Eq q => String -> [Parameter q] -> Parameter q Source

mergeSampleRatesEq :: Eq t' => [Parameter t'] -> Parameter t' Source

mergeParameters' :: [Parameter q] -> Parameter q Source

This is a simple working version of mergeParameters, which does not need Eq constraint. However, flattening a three-dimensional list does handle different dimensions differently, that is slower than the others.

guessParameter :: String -> Parameter q -> q Source

guessSampleRate :: Evaluated t t' y y' yv -> t' Source

guessAmplitude :: Evaluated t t' y y' yv -> y' Source

fixSampleRate Source

:: Eq t' => t' sample rate -> T t t' y y' yv passed through signal -> T t t' y y' yv A complex signal graph can be built without ever mentioning a sampling rate. However when it comes to playing or writing a file, we must determine the sampling rate eventually. This function simply passes a signal through while forcing it to the given sampling rate.

Is this one correct? Has the usage of infered a cycle?

loop Source

:: Eq t' => T t t' y y' yv -> T t t' y y' yv process chain that shall be looped -> T t t' y y' yv Create a loop (feedback) from one node to another one. That is, compute the fix point of a process iteration.

Produced by Haddock version 2.3.0