Crate apodize

very simple rust iterators that yield generalized cosine, hanning, hamming, blackman, nuttall and triangular windows

useful for smoothing the sharp discontinuities at the beginning and end of a slice of samples when doing a short time fourier transform. windowing also improves temporal resolution by making the signal near the time being analyzed have higher weight than the signal further away from the time being analyzed.

all iterators yield f64s. previously they were generic over the floating type used. this was removed because it introduced complexity. if you need f32s just .map(|x| x as f32) over the iterator.

example

you will most likely want to collect the yielded values in a vector and then multiply that window vector repeatedly with some data vectors to apodize them.

here is an example of that for a hanning window (hamming, blackman and nuttall are analogous).

#[macro_use]
extern crate approx;

fn main() {
    // create a hanning window iterator of size 7
    // and collect the values it yields in a Vec
    let window = apodize::hanning_iter(7).collect::<Vec<f64>>();

    let expected = vec![
        0.0,
        0.24999999999999994,
        0.7499999999999999,
        1.0,
        0.7500000000000002,
        0.25,
        0.0
    ];
    assert_ulps_eq!(window.as_slice(), expected.as_slice(), max_ulps = 10);

    // some data we want to apodize (multiply with the window)
    let data: Vec<f64> = vec![1., 2., 3., 4., 5., 6., 7.];

    // buffer that will hold data * window
    let mut windowed_data = vec![0.; data.len()];

    for (windowed, (window, data)) in windowed_data.iter_mut().zip(window.iter().zip(data.iter())) {
        *windowed = *window * *data;
    }

    let expected = vec![
        0.0,
        0.4999999999999999,
        2.2499999999999996,
        4.0,
        3.750000000000001,
        1.5,
        0.0
    ];
    assert_ulps_eq!(windowed_data.as_slice(), expected.as_slice(), max_ulps = 10);
}

Structs

CosineWindowIter

holds the window coefficients and iteration state of an iterator for a cosine window

TriangularWindowIter

holds the iteration state of an iterator for a triangular window

Functions

blackman_iter

returns an iterator that yields the values for a blackman window of size

cosine_at

returns the value of the cosine window of size with the coefficients a, b, c and d at index

cosine_iter

returns an iterator that yields the values for a cosine window of size with the coefficients a, b, c and d

hamming_iter

returns an iterator that yields the values for a hamming window of size

hanning_iter

returns an iterator that yields the values for a hanning window of size

nuttall_iter

returns an iterator that yields the values for a nuttall window of size

triangular_at

returns the value of the [triangular window] (https://en.wikipedia.org/wiki/Window_function#Triangular_window) of size at index

triangular_iter

returns an iterator that yields the values for a triangular window if l = size - 1 then the outermost values of the window are 0. if l = size then the outermost values of the window are higher. if l = size + 1 then the outermost values of the window are even higher.