Struct inc_stats::Mode

pub struct Mode<T: Float + ToBytes> { /* fields omitted */ }

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 mut mode = inc_stats::Mode::new();
for &num in &[2.0, 4.0, 8.0] {
    mode.add(num);
}
assert_eq!(3, mode.count());

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

Implementations

impl<T: Float + ToBytes> Mode<T>

pub fn new() -> Self

Create a new Mode object with no data

pub fn add(&mut self, rval: impl DerefCopy<Output = T>)

Add a data point

pub fn count(&self) -> usize

Get the number of data points

Examples

let num: inc_stats::Mode<_> = [1.0, 2.0, std::f64::NAN].iter().collect();
assert_eq!(3, num.count());

pub fn count_distinct(&self) -> usize

Count the number of distinct values

Distinctness for floating points is very finicy. Values that may print the same may not be same underlying value. Computations that yield the same value in “real” math may not yield the same value in floating point math.

This ignores nans

Examples

let num: inc_stats::Mode<_> = [1.0, 2.0, 2.0, std::f64::NAN].iter().collect();
assert_eq!(2, num.count_distinct());

pub fn count_distinct_nan(&self) -> usize

Count the number of distinct values

This treats all NaNs as different

Examples

let num: inc_stats::Mode<_> = [1.0, std::f64::NAN, std::f64::NAN].iter().collect();
assert_eq!(3, num.count_distinct_nan());

Treat all nans the same

let num: inc_stats::Mode<_> = [1.0, std::f64::NAN, std::f64::NAN].iter().collect();
assert_eq!(2, std::cmp::min(num.count_distinct() + 1, num.count_distinct_nan()));

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

Return an iterator of all of the modes

Multiple modes are retruned in the order they became a mode. NaNs are ignored.

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 modes_nan(&self) -> impl Iterator<Item = T> + '_

Return an iterator of all of the modes

This iterator will include NaN if present as a mode. NaN will always be returned last

Constant time.

Examples

let mode: inc_stats::Mode<_> = [std::f64::NAN, 5.0].iter().collect();
let mut it = mode.modes_nan();
assert_eq!(Some(5.0), it.next());
assert!(it.next().unwrap().is_nan());
assert!(it.next().is_none());

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

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 mode: inc_stats::Mode<_> = [2.0, 4.0, std::f64::NAN, 4.0].iter().collect();
assert_eq!(4.0, mode.mode().unwrap());

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

pub fn mode_nan(&self) -> Option<T>

Return the current mode

If multiple modes exist, this returns the first element that reached the largest count that wasn’t NaN. NaN will be returned only if it is the unique mode.

Constant time.

Examples

let mode: inc_stats::Mode<_> = [2.0, 4.0, std::f64::NAN, std::f64::NAN].iter().collect();
assert!(mode.mode_nan().unwrap().is_nan());

pub fn mode_count(&self) -> usize

Return the number of times the mode occurred

Constant time.

Examples

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

pub fn mode_count_nan(&self) -> usize

Return the number of times the mode occurred

Counts NaNs as a possible mode.

Constant time.

Examples

let mode: inc_stats::Mode<_> = [2.0, 4.0, std::f64::NAN, std::f64::NAN].iter().collect();
assert_eq!(2, mode.mode_count_nan());

Trait Implementations

impl<T: Debug + Float + ToBytes> Debug for Mode<T>

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

Formats the value using the given formatter.

impl<T: Float + ToBytes, V: DerefCopy<Output = T>> FromIterator<V> for Mode<T>

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = V>, 

Creates a value from an iterator.