basic_dsp

Trait FrequencyToTimeDomainOperations

Source 
pub trait FrequencyToTimeDomainOperations<S, T>: ToTimeResult
where
    S: ToSliceMut<T>,
    T: RealNumber,
{
    // Required methods
    fn plain_ifft<B>(self, buffer: &mut B) -> Self::TimeResult
       where B: for<'a> Buffer<'a, S, T>;
    fn ifft<B>(self, buffer: &mut B) -> Self::TimeResult
       where B: for<'a> Buffer<'a, S, T>;
    fn windowed_ifft<B>(
        self,
        buffer: &mut B,
        window: &dyn WindowFunction<T>,
    ) -> Self::TimeResult
       where B: for<'a> Buffer<'a, S, T>;
}
Expand description

Defines all operations which are valid on DataVecs containing frequency domain data.

§Failures

All operations in this trait set self.len() to 0 if the vector isn’t in frequency domain and complex number space.

Required Methods§

Source

fn plain_ifft<B>(self, buffer: &mut B) -> Self::TimeResult
where B: for<'a> Buffer<'a, S, T>,

Performs an Inverse Fast Fourier Transformation transforming a frequency domain vector into a time domain vector.

This version of the IFFT neither applies a window nor does it scale the vector.

§Example
use std::f32;
use basic_dsp_vector::*;
let vector = vec!(Complex::new(0.0, 0.0), Complex::new(1.0, 0.0), Complex::new(0.0, 0.0)).to_complex_freq_vec();
let mut buffer = SingleBuffer::new();
let result = vector.plain_ifft(&mut buffer);
let actual = &result[..];
let expected = &[Complex::new(1.0, 0.0), Complex::new(-0.5, 0.8660254), Complex::new(-0.5, -0.8660254)];
assert_eq!(actual.len(), expected.len());
for i in 0..actual.len() {
       assert!((actual[i] - expected[i]).norm() < 1e-4);
}
Source

fn ifft<B>(self, buffer: &mut B) -> Self::TimeResult
where B: for<'a> Buffer<'a, S, T>,

Performs an Inverse Fast Fourier Transformation transforming a frequency domain vector into a time domain vector.

§Example
use std::f32;
use basic_dsp_vector::*;
let vector = vec!(Complex::new(0.0, 0.0), Complex::new(0.0, 0.0), Complex::new(3.0, 0.0)).to_complex_freq_vec();
let mut buffer = SingleBuffer::new();
let result = vector.ifft(&mut buffer);
let actual = &result[..];
let expected = &[Complex::new(1.0, 0.0), Complex::new(-0.5, 0.8660254), Complex::new(-0.5, -0.8660254)];
assert_eq!(actual.len(), expected.len());
for i in 0..actual.len() {
       assert!((actual[i] - expected[i]).norm() < 1e-4);
}
Source

fn windowed_ifft<B>( self, buffer: &mut B, window: &dyn WindowFunction<T>, ) -> Self::TimeResult
where B: for<'a> Buffer<'a, S, T>,

Performs an Inverse Fast Fourier Transformation transforming a frequency domain vector into a time domain vector and removes the FFT window.

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§