Struct inc_stats::Mode [−][src]
pub struct Mode<T: Float + ToBytes> { /* fields omitted */ }
Expand description
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
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());
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());
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()));
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());
}
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());
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());
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());
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());
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
Creates a value from an iterator. Read more