Synthesizer.Plain.Analysis

Documentation

volumeMaximum :: C y => T y -> y

Volume based on Manhattan norm.

volumeEuclidean :: C y => T y -> y

Volume based on Energy norm.

volumeEuclideanSqr :: C y => T y -> y

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

Volume based on Sum norm.

volumeVectorMaximum :: (C y yv, Ord y) => T yv -> y

Volume based on Manhattan norm.

volumeVectorEuclidean :: (C y, C y yv) => T yv -> y

Volume based on Energy norm.

volumeVectorEuclideanSqr :: (C y, Sqr y yv) => T yv -> y

volumeVectorSum :: (C y yv, C y) => T yv -> y

Volume based on Sum norm.

bounds :: Ord y => T T y -> (y, y)

Compute minimum and maximum value of the stream the efficient way. Input list must be non-empty and finite.

histogramDiscreteArray :: T T Int -> (Int, T Int)

Input list must be finite. List is scanned twice, but counting may be faster.

histogramLinearArray :: C y => T T y -> (Int, T y)

Input list must be finite. If the input signal is empty, the offset is undefined. List is scanned twice, but counting may be faster. The sum of all histogram values is one less than the length of the signal.

histogramDiscreteIntMap :: T T Int -> (Int, T Int)

Input list must be finite. If the input signal is empty, the offset is undefined. List is scanned once, counting may be slower.

histogramLinearIntMap :: C y => T T y -> (Int, T y)

histogramIntMap :: C y => y -> T T y -> (Int, T Int)

directCurrentOffset :: C y => T y -> y

Requires finite length. This is identical to the arithmetic mean.

scalarProduct :: C y => T y -> T y -> y

centroid :: C y => T y -> y

directCurrentOffset must be non-zero.

centroidAlt :: C y => T y -> y

firstMoment :: C y => T y -> y

average :: C y => T y -> y

rectify :: C y => T y -> T y

zeros :: (Ord y, C y) => T y -> T Bool

Detects zeros (sign changes) in a signal. This can be used as a simple measure of the portion of high frequencies or noise in the signal. It ca be used as voiced/unvoiced detector in a vocoder.

zeros x !! n is True if and only if (x !! n >= 0) /= (x !! (n+1) >= 0). The result will be one value shorter than the input.

data BinaryLevel

Constructors

Low

High

Instances

Enum BinaryLevel

Defined in Synthesizer.Plain.Analysis

Methods

succ :: BinaryLevel -> BinaryLevel

pred :: BinaryLevel -> BinaryLevel

toEnum :: Int -> BinaryLevel

fromEnum :: BinaryLevel -> Int

enumFrom :: BinaryLevel -> [BinaryLevel]

enumFromThen :: BinaryLevel -> BinaryLevel -> [BinaryLevel]

enumFromTo :: BinaryLevel -> BinaryLevel -> [BinaryLevel]

enumFromThenTo :: BinaryLevel -> BinaryLevel -> BinaryLevel -> [BinaryLevel]

Eq BinaryLevel

Defined in Synthesizer.Plain.Analysis

Methods

(==) :: BinaryLevel -> BinaryLevel -> Bool

(/=) :: BinaryLevel -> BinaryLevel -> Bool

Show BinaryLevel

Defined in Synthesizer.Plain.Analysis

Methods

showsPrec :: Int -> BinaryLevel -> ShowS

show :: BinaryLevel -> String

showList :: [BinaryLevel] -> ShowS

binaryLevelFromBool :: Bool -> BinaryLevel

binaryLevelToNumber :: C a => BinaryLevel -> a

flipFlopHysteresis :: Ord y => (y, y) -> BinaryLevel -> T y -> T BinaryLevel

Detect thresholds with a hysteresis.

flipFlopHysteresisStep :: Ord a => (a, a) -> BinaryLevel -> a -> BinaryLevel

chirpTransform :: C y => y -> T y -> T y

Almost naive implementation of the chirp transform, a generalization of the Fourier transform.

More sophisticated algorithms like Rader, Cooley-Tukey, Winograd, Prime-Factor may follow.

binarySign :: (Ord y, C y) => T y -> T BinaryLevel

deltaSigmaModulation :: C y => T y -> T BinaryLevel

A kind of discretization for signals with sample values between -1 and 1. If you smooth the resulting signal (after you transformed with 'map binaryLevelToNumber'), you should obtain an approximation to the input signal.

deltaSigmaModulationPositive :: C y => y -> T y -> T y

A kind of discretization for signals with sample values between 0 and a threshold. We accumulate input values and emit a threshold value whenever the accumulator exceeds the threshold. This is intended for generating clicks from input noise.

See also deltaSigmaModulation.

spread :: C y => (y, y) -> [(Int, y)]