Struct Spectrum 

pub struct Spectrum<T: Float> {
    pub num_frames: usize,
    pub freq_bins: usize,
    pub data: Vec<T>,
}

Fields

num_frames: usize

freq_bins: usize

data: Vec<T>

Implementations

impl<T: Float> Spectrum<T>

pub fn new(num_frames: usize, freq_bins: usize) -> Self

pub fn real(&self, frame: usize, bin: usize) -> T

pub fn imag(&self, frame: usize, bin: usize) -> T

pub fn get_complex(&self, frame: usize, bin: usize) -> Complex<T>

pub fn frames(&self) -> impl Iterator<Item = SpectrumFrame<T>> + '_

pub fn set_real(&mut self, frame: usize, bin: usize, value: T)

Set the real part of a bin

pub fn set_imag(&mut self, frame: usize, bin: usize, value: T)

Set the imaginary part of a bin

pub fn set_complex(&mut self, frame: usize, bin: usize, value: Complex<T>)

Set a bin from a complex value

pub fn magnitude(&self, frame: usize, bin: usize) -> T

Get the magnitude of a frequency bin

pub fn phase(&self, frame: usize, bin: usize) -> T

Get the phase of a frequency bin in radians

pub fn set_magnitude_phase( &mut self, frame: usize, bin: usize, magnitude: T, phase: T, )

Set a frequency bin from magnitude and phase

pub fn frame_magnitudes(&self, frame: usize) -> Vec<T>

Get all magnitudes for a frame

pub fn frame_phases(&self, frame: usize) -> Vec<T>

Get all phases for a frame

pub fn apply<F>(&mut self, f: F)

where F: FnMut(usize, usize, Complex<T>) -> Complex<T>,

Apply a function to all bins

pub fn apply_gain(&mut self, bin_range: Range<usize>, gain: T)

Apply a gain to a range of bins across all frames

pub fn zero_bins(&mut self, bin_range: Range<usize>)

Zero out a range of bins across all frames

Trait Implementations

impl<T: Clone + Float> Clone for Spectrum<T>

fn clone(&self) -> Spectrum<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + Float> Debug for Spectrum<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: PartialEq + Float> PartialEq for Spectrum<T>

fn eq(&self, other: &Spectrum<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Float> StructuralPartialEq for Spectrum<T>