Struct MinMax 

pub struct MinMax<T> { /* private fields */ }

A commutative data structure for tracking minimum and maximum values and detecting sort order in a stream of data.

Implementations

impl<T: PartialOrd + Clone> MinMax<T>

pub fn new() -> MinMax<T>

Create an empty state where min and max values do not exist.

pub fn add(&mut self, sample: T)

Add a sample to the data and track min/max, the sort order & “sortiness”.

pub fn add_ref(&mut self, sample: &T)

Add a sample by reference, only cloning when necessary to update min, max, first_value, or last_value.

This is more efficient than add() when the caller has a reference and most samples don’t update min/max, because it avoids the upfront allocation that add() requires from the caller.

For last_value, the existing allocation is reused when possible by clearing and cloning into it rather than replacing.

pub const fn min(&self) -> Option<&T>

Returns the minimum of the data set.

None is returned if and only if the number of samples is 0.

pub const fn max(&self) -> Option<&T>

Returns the maximum of the data set.

None is returned if and only if the number of samples is 0.

pub const fn len(&self) -> usize

Returns the number of data points.

pub const fn is_empty(&self) -> bool

Returns true if there are no data points.

pub fn sort_order(&self) -> SortOrder

Returns the current sort order of the data.

pub fn sortiness(&self) -> f64

Calculates a “sortiness” score for the data, indicating how close it is to being sorted.

Returns a value between -1.0 and 1.0:

• 1.0 indicates perfectly ascending order
• -1.0 indicates perfectly descending order
• Values in between indicate the general tendency towards ascending or descending order
• 0.0 indicates either no clear ordering or empty/single-element collections

Examples

use stats::MinMax;

let mut asc: MinMax<i32> = vec![1, 2, 3, 4, 5].into_iter().collect();
assert_eq!(asc.sortiness(), 1.0);

let mut desc: MinMax<i32> = vec![5, 4, 3, 2, 1].into_iter().collect();
assert_eq!(desc.sortiness(), -1.0);

let mut mostly_asc: MinMax<i32> = vec![1, 2, 4, 3, 5].into_iter().collect();
assert!(mostly_asc.sortiness() > 0.0); // Positive but less than 1.0

impl MinMax<Vec<u8>>

pub fn add_bytes(&mut self, sample: &[u8])

Add a byte slice sample, avoiding heap allocation when the value doesn’t update min, max, or first_value. Only last_value is always updated (reusing its existing allocation via clone_from).

This is significantly more efficient than add(sample.to_vec()) for large datasets where most values don’t update min/max — avoiding ~99% of allocations in the common case.

Trait Implementations

impl<T: Clone> Clone for MinMax<T>

fn clone(&self) -> MinMax<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: PartialOrd + Clone> Commute for MinMax<T>

fn merge(&mut self, v: MinMax<T>)

Merges the value other into self.

fn consume<I: Iterator<Item = Self>>(&mut self, other: I)

Merges the values in the iterator into self.

impl<T: Debug> Debug for MinMax<T>

Available on debug-assertions enabled only.

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

Formats the value using the given formatter.

impl<T: PartialOrd> Default for MinMax<T>

fn default() -> MinMax<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for MinMax<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: PartialOrd + Clone> Extend<T> for MinMax<T>

fn extend<I: IntoIterator<Item = T>>(&mut self, it: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<T: PartialOrd + Clone> FromIterator<T> for MinMax<T>

fn from_iter<I: IntoIterator<Item = T>>(it: I) -> MinMax<T>

Creates a value from an iterator.

impl<T: PartialEq> PartialEq for MinMax<T>

fn eq(&self, other: &MinMax<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for MinMax<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Copy> Copy for MinMax<T>

impl<T: Eq> Eq for MinMax<T>

impl<T> StructuralPartialEq for MinMax<T>