Numeric.Signal

Signal processing functions

Documentation

class Convolvable a where

Minimal complete definition

convolve

Methods

convolve :: a -> a -> a

convolve two containers, output is the size of the second argument, no zero padding

Instances

Convolvable (Vector Double)

Methods

convolve :: Vector Double -> Vector Double -> Vector Double

Convolvable (Vector Float)

Methods

convolve :: Vector Float -> Vector Float -> Vector Float

Convolvable (Vector (Complex Double))

Methods

convolve :: Vector (Complex Double) -> Vector (Complex Double) -> Vector (Complex Double)

Convolvable (Vector (Complex Float))

Methods

convolve :: Vector (Complex Float) -> Vector (Complex Float) -> Vector (Complex Float)

class (Storable a, Container Vector a, Num (Vector a), Convert a, Floating (Vector a), RealElement a, Num a) => Filterable a

Minimal complete definition

fromDouble, filter_, hamming_, complex_power_, downsample_, deriv_, unwrap_, polyEval_, cross_covariance_, cumulative_sum_

Instances

Filterable Double

Methods

fromDouble :: Vector Double -> Vector Double

filter_ :: Vector Double -> Vector Double -> Vector Double -> Vector Double

hamming_ :: Int -> Vector Double

complex_power_ :: Vector (Complex Double) -> Vector Double

downsample_ :: Int -> Vector Double -> Vector Double

deriv_ :: Vector Double -> Vector Double

unwrap_ :: Vector Double -> Vector Double

polyEval_ :: Vector Double -> Vector (Complex Double) -> Vector (Complex Double)

cross_covariance_ :: Int -> Vector Double -> Vector Double -> (Double, Double, Vector Double)

cumulative_sum_ :: Vector Double -> Vector Double

Filterable Float

Methods

fromDouble :: Vector Double -> Vector Float

filter_ :: Vector Float -> Vector Float -> Vector Float -> Vector Float

hamming_ :: Int -> Vector Float

complex_power_ :: Vector (Complex Double) -> Vector Float

downsample_ :: Int -> Vector Float -> Vector Float

deriv_ :: Vector Float -> Vector Float

unwrap_ :: Vector Float -> Vector Float

polyEval_ :: Vector Float -> Vector (Complex Double) -> Vector (Complex Double)

cross_covariance_ :: Int -> Vector Float -> Vector Float -> (Float, Float, Vector Float)

cumulative_sum_ :: Vector Float -> Vector Float

Filtering

hamming

Arguments

:: Filterable a

=> Int

length

-> Vector a

the Hamming coeffficents

coefficients of a Hamming window

pwelch

Arguments

:: Int

sampling rate

-> Int

window size

-> Vector Double

input signal

-> (Vector Double, Vector Double)

(frequency index,power density)

Welch (1967) power spectrum density using periodogram/FFT method

fir

Arguments

:: (Filterable a, Convert (Complex a), Double ~ DoubleOf a)

=> Int

order (one less than the length of the filter)

-> [(a, a)]

band edge frequency, nondecreasing, [0, f1, ..., f(n-1), 1] ^ band edge magnitude

-> Int

grid spacing

-> Int

transition width

-> Vector a

smoothing window (size is order + 1)

-> Vector a

the filter coefficients

produce an FIR filter

standard_fir :: (Filterable a, Double ~ DoubleOf a, Convert (Complex a)) => Int -> [(a, a)] -> Vector a

standard FIR filter | FIR filter with grid a power of 2 greater than the order, ramp = grid/16, hamming window

broadband_fir

Arguments

:: (Filterable a, Double ~ DoubleOf a, Convert (Complex a))

=> Int

sampling rate

-> (Int, Int)

(lower,upper) frequency cutoff

-> Vector a

filter coefficients

a broadband FIR

freqzF

Arguments

:: (Filterable a, Double ~ DoubleOf a, Filterable (DoubleOf a))

=> Vector a

zero coefficients

-> Vector a

pole coefficients

-> Int

sampling rate

-> Vector a

frequencies

-> Vector a

frequency response

determine the frequency response of a filter, given a vector of frequencies

freqzN

Arguments

:: (Filterable a, Double ~ DoubleOf a)

=> Vector a

zero coefficients

-> Vector a

pole coefficients

-> Int

sampling rate

-> Int

number of points

-> (Vector a, Vector a)

(frequencies,response)

determine the frequency response of a filter, given a number of points and sampling rate

filter

Arguments

:: Filterable a

=> Vector a

zero coefficients

-> Vector a

pole coefficients

-> Int

sampling rate

-> Vector a

input signal

-> Vector a

output signal

filters the signal

broadband_filter

Arguments

:: (Filterable a, Double ~ DoubleOf a)

=> Int

sampling rate

-> (Int, Int)

(lower,upper) frequency cutoff

-> Vector a

input signal

-> Vector a

output signal

a broadband filter

Analytic Signal

analytic_signal :: Vector Double -> Vector (Complex Double)

an analytic signal is the original signal with Hilbert-transformed signal as imaginary component

analytic_power :: Filterable a => Vector (Complex Double) -> Vector a

the power (amplitude^2 = v * (conj c)) of an analytic signal

analytic_phase :: Filterable a => Vector (Complex a) -> Vector a

the phase of an analytic signal

unwrap :: Filterable a => Vector a -> Vector a

unwrap the phase of signal (input expected to be within (-pi,pi))

Statistics

cross_covariance

Arguments

:: Filterable a

=> Int

maximum delay

-> Vector a

time series

-> Vector a

time series

-> (a, a, Vector a)

(sd_x,sd_y,cov_xy)

cross covariance of two signals the cross correlation is computed by dividing the result by the product of the two standard deviations

cross_correlation

Arguments

:: Filterable a

=> Int

maximum delay

-> Vector a

time series

-> Vector a

time series

-> Vector a

result

cross correlation of two signals

cross_spectrum

Arguments

:: (Filterable a, Double ~ DoubleOf a)

=> Int

maximum delay

-> Vector a

time series

-> Vector a

time series

-> Vector (Complex Double)

result

compute the cross spectrum

auto_covariance

Arguments

:: Filterable a

=> Int

maximum delay

-> Vector a

time series

-> (a, Vector a)

(var,cov_xx)

auto covariance of two signals the auto correlation is computed by dividing the result by the variance

auto_correlation

Arguments

:: Filterable a

=> Int

maximum delay

-> Vector a

time series

-> Vector a

result

auto correlation of two signals

Preprocessing

detrend

Arguments

:: Int

window size

-> Vector Double

data to be detrended

-> Vector Double

detrended data

remove a linear trend from data

resize :: Filterable a => Int -> Vector a -> Vector a

resize the vector to length n by resampling

downsample :: Filterable a => Int -> Vector a -> Vector a

resample, take one sample every n samples in the original

deriv :: Filterable a => Vector a -> Vector a

the difference between consecutive elements of a vector

cumulative_sum :: Filterable a => Vector a -> Vector a

cumulative sum of a series