Struct Unsorted 

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

A commutative data structure for lazily sorted sequences of data.

The sort does not occur until statistics need to be computed.

Note that this works on types that do not define a total ordering like f32 and f64. When an ordering is not defined, an arbitrary order is returned.

Implementations

impl<T: PartialOrd> Unsorted<T>

pub fn new() -> Unsorted<T>

Create initial empty state.

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

Add a new element to the set.

pub const fn len(&self) -> usize

Return the number of data points.

pub const fn is_empty(&self) -> bool

pub fn add_bulk(&mut self, values: Vec<T>)

Add multiple elements efficiently

pub fn shrink_to_fit(&mut self)

Shrink capacity to fit current data

pub fn with_capacity(capacity: usize) -> Self

Create with specific capacity

pub fn push_ascending(&mut self, value: T)

Add a value assuming it’s greater than all existing values

impl<T: PartialOrd + PartialEq + Clone> Unsorted<T>

pub fn cardinality(&mut self, sorted: bool, parallel_threshold: usize) -> u64

Returns the cardinality of the data. Set sorted to true if the data is already sorted. Set parallel_threshold to 0 to force sequential processing. Set parallel_threshold to 1 to use the default parallel threshold (10_000). Set parallel_threshold to 2 to force parallel processing. Set parallel_threshold to any other value to use a custom parallel threshold greater than the default threshold of 10_000.

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

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

Returns the mode of the data.

pub fn modes_antimodes( &mut self, ) -> ((Vec<T>, usize, u32), (Vec<T>, usize, u32))

Returns the modes and antimodes of the data. antimodes_result only returns the first 10 antimodes

impl<T: PartialOrd + ToPrimitive> Unsorted<T>

pub fn median(&mut self) -> Option<f64>

Returns the median of the data.

impl<T: PartialOrd + ToPrimitive> Unsorted<T>

pub fn mad(&mut self, existing_median: Option<f64>) -> Option<f64>

Returns the Median Absolute Deviation (MAD) of the data.

impl<T: PartialOrd + ToPrimitive> Unsorted<T>

pub fn quartiles(&mut self) -> Option<(f64, f64, f64)>

Returns the quartiles of the data using the traditional sorting approach.

This method sorts the data first and then computes quartiles. Time complexity: O(n log n)

impl<T: PartialOrd + ToPrimitive + Sync> Unsorted<T>

pub fn gini(&mut self) -> Option<f64>

Returns the Gini Coefficient of the data.

The Gini Coefficient measures inequality in a distribution, ranging from 0 (perfect equality) to 1 (perfect inequality). This method sorts the data first and then computes the Gini coefficient. Time complexity: O(n log n)

pub fn kurtosis(&mut self) -> Option<f64>

Returns the kurtosis (excess kurtosis) of the data.

Kurtosis measures the “tailedness” of a distribution. Excess kurtosis is kurtosis - 3, where 0 indicates a normal distribution, positive values indicate heavy tails, and negative values indicate light tails. This method sorts the data first and then computes kurtosis. Time complexity: O(n log n)

pub fn percentile_rank<V>(&mut self, value: V) -> Option<f64>

where V: PartialOrd + ToPrimitive,

Returns the percentile rank of a value in the data.

Returns the percentile rank (0-100) of the given value. If the value is less than all values, returns 0.0. If greater than all, returns 100.0. This method sorts the data first and then computes the percentile rank. Time complexity: O(n log n)

pub fn atkinson(&mut self, epsilon: f64) -> Option<f64>

Returns the Atkinson Index of the data.

The Atkinson Index measures inequality with an inequality aversion parameter ε. It ranges from 0 (perfect equality) to 1 (perfect inequality). Higher ε values give more weight to inequality at the lower end of the distribution. This method sorts the data first and then computes the Atkinson index. Time complexity: O(n log n)

Arguments

• epsilon - Inequality aversion parameter (must be >= 0). Common values:
  • 0.0: No inequality aversion (returns 0)
  • 0.5: Moderate aversion
  • 1.0: Uses geometric mean (special case)
  • 2.0: High aversion

impl<T: PartialOrd + ToPrimitive + Clone> Unsorted<T>

pub fn quartiles_with_selection(&mut self) -> Option<(f64, f64, f64)>

Returns the quartiles of the data using selection algorithm.

This implementation uses a selection algorithm (quickselect) to find quartiles in O(n) average time complexity instead of O(n log n) sorting. Requires T to implement Clone to create a working copy of the data.

Performance Note: While theoretically O(n) vs O(n log n), this implementation is often slower than the sorting-based approach for small to medium datasets due to:

• Need to find multiple order statistics (3 separate quickselect calls)
• Overhead of copying data to avoid mutation
• Rayon’s highly optimized parallel sorting

impl<T: PartialOrd + ToPrimitive> Unsorted<T>

pub fn quartiles_zero_copy(&self) -> Option<(f64, f64, f64)>

Returns the quartiles using zero-copy selection algorithm.

This implementation avoids copying data by working with indices instead, providing better performance than the clone-based selection approach. The algorithm is O(n) average time and only allocates a vector of indices (usize).

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

pub fn custom_percentiles(&mut self, percentiles: &[u8]) -> Option<Vec<T>>

Returns the requested percentiles of the data.

Uses the nearest-rank method to compute percentiles. Each returned value is an actual value from the dataset.

Arguments

• percentiles - A slice of u8 values representing percentiles to compute (0-100)

Returns

• None if the data is empty or if any percentile is > 100
• Some(Vec<T>) containing percentile values in the same order as requested

Example

use stats::Unsorted;
let mut data = Unsorted::new();
data.extend(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
let percentiles = vec![25, 50, 75];
let results = data.custom_percentiles(&percentiles).unwrap();
assert_eq!(results, vec![3, 5, 8]);

Trait Implementations

impl<T: Clone> Clone for Unsorted<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: PartialOrd> Commute for Unsorted<T>

fn merge(&mut self, v: Unsorted<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: PartialOrd> Default for Unsorted<T>

fn default() -> Unsorted<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Unsorted<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> Extend<T> for Unsorted<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> FromIterator<T> for Unsorted<T>

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

Creates a value from an iterator.

impl<T: PartialEq> PartialEq for Unsorted<T>

fn eq(&self, other: &Unsorted<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 Unsorted<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: Eq> Eq for Unsorted<T>

impl<T> StructuralPartialEq for Unsorted<T>