Struct inc_stats::Mode

pub struct Mode { /* private fields */ }

Mode computation struct

This struct stores data to allow efficient computation of the mode. This struct takes linear space. It implements FromIterator to allow collection.

Examples

let nums = [2.0, 4.0, 8.0];
let mut mode = inc_stats::Mode::new();
for num in nums.iter() {
    mode.add(num.clone());
}
assert_eq!(3, mode.count());

let nums = [2.0, 4.0, 8.0];
let mode: inc_stats::Mode = nums.iter().cloned().collect();
assert_eq!(3, mode.count());

Implementations

impl Mode

pub fn new() -> Self

Create a new Mode object with no data

pub fn add(&mut self, val: f64)

Add a data point

pub fn count(&self) -> i64

Get the number of data points

pub fn modes(&self) -> Cloned<Iter<'_, f64>>

Return an iterator of all of the modes

This iterator has read only reference to the mode data structure that must be dropped to continue modifying the mode. Constant time.

Examples

let mut mode = inc_stats::Mode::new();
{
    let mut it = mode.modes();
    assert!(it.next().is_none());
}

mode.add(5.0);
{
    let mut it = mode.modes();
    assert_eq!(Some(5.0), it.next());
    assert!(it.next().is_none());
}

mode.add(3.0);
{
    let mut it = mode.modes();
    assert_eq!(Some(5.0), it.next());
    assert_eq!(Some(3.0), it.next());
    assert!(it.next().is_none());
}

mode.add(3.0);
{
    let mut it = mode.modes();
    assert_eq!(Some(3.0), it.next());
    assert!(it.next().is_none());
}

pub fn mode(&self) -> Option<f64>

Return the current mode

If multiple modes exist, this returns the first element that reached the largest count. NaNs are ignored when computing the mode. Constant time.

Examples

let nums = [2.0, 4.0, std::f64::NAN, 4.0];
let mode: inc_stats::Mode = nums.iter().cloned().collect();
assert!((4.0 - mode.mode().unwrap()).abs() < 1.0e-6);

let mode = inc_stats::Mode::new();
assert!(mode.mode().is_none());

pub fn mode_count(&self) -> i64

Return the number of times the mode occurred

Constant time.

Examples

let nums = [2.0, 4.0, std::f64::NAN, 4.0];
let mode: inc_stats::Mode = nums.iter().cloned().collect();
assert_eq!(2, mode.mode_count());

Trait Implementations

impl Debug for Mode

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

Formats the value using the given formatter.

impl FromIterator<f64> for Mode

fn from_iter<I>(iter: I) -> Selfwhere
    I: IntoIterator<Item = f64>,

Creates a value from an iterator.