Struct sample::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.

Methods

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.

extern crate sample;

use sample::ring_buffer;
use sample::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.

extern crate sample;

use sample::ring_buffer;
use sample::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.

extern crate sample;

use sample::ring_buffer;
use sample::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.

extern crate sample;

use sample::ring_buffer;
use sample::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.

extern crate sample;

use sample::ring_buffer;
use sample::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, S> Detect<F> for Rms<F, S> where     F: Frame,     S: Slice<Element = F::Float> + SliceMut,

type Output = F::Float

The result of detection.

fn detect(&mut self, frame: F) -> Self::Output

Given some frame, return the detected envelope over each channel.

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.