Struct Frequencies 

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

A commutative data structure for exact frequency counts.

Implementations

impl<T: Eq + Hash> Frequencies<T>

pub fn new() -> Frequencies<T>

Create a new frequency table with no samples.

pub fn with_capacity(capacity: usize) -> Self

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

Add a value to the frequency table.

pub fn count(&self, v: &T) -> u64

Return the number of occurrences of v in the data.

pub fn cardinality(&self) -> u64

Return the cardinality (number of unique elements) in the data.

pub fn most_frequent(&self) -> (Vec<(&T, u64)>, u64)

Return a Vec of elements, their corresponding counts in descending order, and the total count.

pub fn least_frequent(&self) -> (Vec<(&T, u64)>, u64)

Return a Vec of elements, their corresponding counts in ascending order, and the total count.

pub fn par_frequent(&self, least: bool) -> (Vec<(&T, u64)>, u64)

where for<'a> (&'a T, u64): Send, T: Ord,

Return a Vec of elements, their corresponding counts in order based on the least parameter, and the total count. Uses parallel sort.

pub fn len(&self) -> usize

Returns the cardinality of the data.

pub fn is_empty(&self) -> bool

Returns true if there is no frequency/cardinality data.

pub fn unique_values(&self) -> UniqueValues<'_, T>

Return an iterator over the unique values of the data.

pub fn top_n(&self, n: usize) -> Vec<(&T, u64)>

where T: Ord,

Get the top N most frequent items without sorting the entire vector This is much faster than most_frequent() when you only need a few items

pub fn bottom_n(&self, n: usize) -> Vec<(&T, u64)>

where T: Ord,

Similar to top_n but for least frequent items

pub fn items_with_count(&self, n: u64) -> Vec<&T>

Get items with exactly n occurrences

pub fn total_count(&self) -> u64

Get the sum of all counts

pub fn has_count(&self, n: u64) -> bool

Check if any item occurs exactly n times

pub fn increment_by(&mut self, v: T, count: u64)

Add specialized method for single increment

impl<T: Eq + Hash + Ord + Clone + Send + Sync> Frequencies<T>

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

Returns the modes and antimodes of the data.

Produces results identical to crate::Unsorted::modes_antimodes for the same multiset of samples with per-value counts <= u32::MAX (verified by the modes_antimodes_matches_unsorted property test and the equivalence assertion in benches/modesfreq.rs). Above that the two diverge: selection here is exact via full u64 counts, while Unsorted tracks u32 run counts (and cannot practically hold that many samples anyway).

Rather than sorting all unique values, this only sorts what the output actually contains: one O(c) pass over the counts finds the highest/lowest occurrence counts, a second pass collects only the matching keys, then the (typically tiny) mode set is sorted and the 10 smallest antimodes are picked via select_nth_unstable - O(c) average instead of O(c log c), where c is the cardinality. Uniform-count data (highest == lowest: every value is both a mode and an antimode) falls back to a single full key sort, which beats collecting the keys twice.

Counts are compared as u64, so mode/antimode selection is exact even when occurrence counts exceed u32::MAX; only the returned occurrence counts saturate at u32::MAX.

Returns ((modes, modes_count, mode_occurrences), (antimodes, antimodes_count, antimode_occurrences)). Only the first 10 antimodes are returned.

impl Frequencies<Vec<u8>>

pub fn add_borrowed(&mut self, v: &[u8])

Increment count for a byte slice key, avoiding allocation when key exists. Uses hashbrown’s entry_ref(&[u8]), which probes once with the borrowed key and only allocates ([u8]::to_owned() -> Vec<u8>) on the vacant branch. For low-cardinality columns (the common case), this eliminates ~99% of allocations; for new keys it is a single hash+probe (std’s HashMap has no stable raw-entry API, so the old path hashed twice).

pub fn increment_by_borrowed(&mut self, v: &[u8], count: u64)

Increment by a count for a byte slice key, avoiding allocation when key exists.

pub fn add_borrowed_capped(&mut self, v: &[u8], cap: u64) -> bool

Increment the count for v, enforcing a cardinality cap.

Existing keys always increment (the map doesn’t grow). A NEW key that would grow the map past cap unique entries is rejected: the map is left unchanged and false is returned, so the caller can drop the tracker. cap == 0 means unbounded.

Like Self::add_borrowed, this single-probes via entry_ref and only allocates an owned key on the (admitted) vacant branch.

Trait Implementations

impl<T: Clone> Clone for Frequencies<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Eq + Hash> Commute for Frequencies<T>

fn merge(&mut self, v: Frequencies<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 + Eq + Hash> Debug for Frequencies<T>

Available on debug-assertions enabled only.

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

Formats the value using the given formatter.

impl<T: Eq + Hash> Default for Frequencies<T>

fn default() -> Frequencies<T>

Returns the “default value” for a type.

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

where T: Deserialize<'de> + Eq + Hash,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Eq + Hash> Extend<T> for Frequencies<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: Eq + Hash> FromIterator<T> for Frequencies<T>

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

Creates a value from an iterator.

impl<T: Eq + Hash> PartialEq for Frequencies<T>

fn eq(&self, other: &Self) -> 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 Frequencies<T>

where T: Serialize + Eq + Hash,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.