Struct dasp_rms::Rms

pub struct Rms<F, S> where
    F: Frame,
    S: Slice<Element = F::Float>,  { /* fields omitted */ }

Iteratively extracts the RMS (root mean square) envelope from a window over a signal of sample Frames.

Implementations

impl<F, S> Rms<F, S> where
    F: Frame,
    S: Slice<Element = F::Float>, 

pub fn new(ring_buffer: Fixed<S>) -> Self

Construct a new Rms that uses the given ring buffer as its window.

The window size of the Rms is equal to the length of the given ring buffer.

use dasp_ring_buffer as ring_buffer;
use dasp_rms::Rms;

fn main() {
    let window = ring_buffer::Fixed::from([[0.0]; 4]);
    let mut rms = Rms::new(window);
    rms.next([0.5]);
}

pub fn reset(&mut self) where
    S: SliceMut, 

Zeroes the square_sum and the buffer of the window.

use dasp_ring_buffer as ring_buffer;
use dasp_rms::Rms;

fn main() {
    let window = ring_buffer::Fixed::from([[0.0]; 4]);
    let mut rms = Rms::new(window);
    rms.next([0.6]);
    rms.next([0.9]);
    rms.reset();
    assert_eq!(rms.current(), [0.0]);
}

pub fn window_frames(&self) -> usize

The length of the window as a number of frames.

use dasp_ring_buffer as ring_buffer;
use dasp_rms::Rms;

fn main() {
    let window = ring_buffer::Fixed::from([[0.0]; 4]);
    let mut rms = Rms::new(window);
    assert_eq!(rms.window_frames(), 4);
    rms.next([0.5]);
    assert_eq!(rms.window_frames(), 4);
}

pub fn next(&mut self, new_frame: F) -> F::Float where
    S: SliceMut, 

The next RMS given the new frame in the sequence.

The Rms pops its front frame and adds the new frame to the back.

The yielded RMS is the RMS of all frame squares in the window after the new frame is added.

This method uses Rms::next_squared internally and then calculates the square root.

use dasp_ring_buffer as ring_buffer;
use dasp_rms::Rms;

fn main() {
    let window = ring_buffer::Fixed::from([[0.0]; 4]);
    let mut rms = Rms::new(window);
    assert_eq!(rms.next([1.0]), [0.5]);
    assert_eq!(rms.next([-1.0]), [0.7071067811865476]);
    assert_eq!(rms.next([1.0]), [0.8660254037844386]);
    assert_eq!(rms.next([-1.0]), [1.0]);
}

pub fn next_squared(&mut self, new_frame: F) -> F::Float where
    S: SliceMut, 

The same as Rms::next, but does not calculate the final square root required to determine the RMS.

pub fn into_parts(self) -> (Fixed<S>, S::Element)

Consumes the Rms and returns its inner ring buffer of squared frames along with a frame representing the sum of all frame squares contained within the ring buffer.

pub fn current(&self) -> F::Float

Calculates the RMS of all frames currently stored within the inner window.

use dasp_ring_buffer as ring_buffer;
use dasp_rms::Rms;

fn main() {
    let window = ring_buffer::Fixed::from([[0.0]; 4]);
    let mut rms = Rms::new(window);
    assert_eq!(rms.current(), [0.0]);
    rms.next([1.0]);
    rms.next([1.0]);
    rms.next([1.0]);
    rms.next([1.0]);
    assert_eq!(rms.current(), [1.0]);
}

Trait Implementations

impl<F: Clone, S: Clone> Clone for Rms<F, S> where
    F: Frame,
    S: Slice<Element = F::Float>,
    F::Float: Clone, 

fn clone(&self) -> Rms<F, S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, S> Debug for Rms<F, S> where
    F: Frame,
    F::Float: Debug,
    S: Debug + Slice<Element = F::Float>, 

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

Formats the value using the given formatter.