Struct FrequencyDistribution

pub struct FrequencyDistribution<K, S = RandomState> { /* private fields */ }

Implementations

impl<K, H, S> FrequencyDistribution<K, S>

where K: Eq + Hash, H: Hasher, S: BuildHasher<Hasher = H>,

pub fn with_capacity_and_hasher( size: usize, state: S, ) -> FrequencyDistribution<K, S>

Creates a new FrequencyDistrbution with a hasher and size, where the size is known or can be estimated.

pub fn with_hasher(state: S) -> FrequencyDistribution<K, S>

Creates a new FrequencyDistribution with a hasher and default size.

pub fn keys(&self) -> Keys<'_, K, usize>

Iterator over the keys.

pub fn iter(&self) -> Iter<'_, K, usize>

Iterator over the key, frequency pairs.

pub fn iter_non_zero(&self) -> NonZeroKeysIter<'_, K>

Iterator over the non-zero frequency keys.

Example

let existing = vec![
  ("shoes", 1),
  ("scarf", 0),
  ("shirt", 13),
  ("pants", 4)
];

let fdist: FrequencyDistribution<&str> =
  FromIterator::from_iter(existing.into_iter());
let mut iter = fdist.iter_non_zero();

assert!(iter.next().is_some());
assert!(iter.next().is_some());
assert!(iter.next().is_some());
assert!(iter.next().is_none());

pub fn sum_counts(&self) -> usize

Sum of the total number of items counted thus far.

pub fn len(&self) -> usize

Returns the number of entries in the distribution

pub fn get<Q>(&self, k: &Q) -> usize

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Gets the frequency in which the key occurs.

pub fn clear(&mut self)

Clears the counts of all keys and clears all keys from the distribution.

pub fn insert(&mut self, k: K)

Updates the frequency of the value found with the key if it already exists. Otherwise, inserts the key sizeo the hashmap, and sets its frequency to 1.

pub fn remove<Q>(&mut self, k: &Q)

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

Removes an item and its associated counts.

impl<K, H, S> FrequencyDistribution<K, S>

where K: Eq + Hash, H: Hasher + Default, S: BuildHasher<Hasher = H> + Default,

pub fn new() -> FrequencyDistribution<K, S>

Creates a new FrequencyDistribution where the size of the HashMap is unknown.

pub fn with_capacity(size: usize) -> FrequencyDistribution<K, S>

Creates a new FrequencyDistribution where the size of the HashMap is known, or a estimate can be made.

Trait Implementations

impl<K, H, S> Default for FrequencyDistribution<K, S>

where K: Eq + Hash, H: Hasher + Default, S: BuildHasher<Hasher = H> + Default,

fn default() -> FrequencyDistribution<K, S>

Creates a default FrequencyDistribution.

impl<K, H, S> Extend<(K, usize)> for FrequencyDistribution<K, S>

where K: Eq + Hash, H: Hasher, S: BuildHasher<Hasher = H>,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = (K, usize)>,

Extends the hashmap by adding the keys or updating the frequencies of the keys.

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<K, H, S> FromIterator<(K, usize)> for FrequencyDistribution<K, S>

where K: Eq + Hash, H: Hasher, S: BuildHasher<Hasher = H> + Default,

fn from_iter<T>(iter: T) -> FrequencyDistribution<K, S>

where T: IntoIterator<Item = (K, usize)>,

Iterates through an iterator, and creates a new FrequencyDistribution from it. The iterator should be an iterator over keys and frequencies. If a upper bounded size_hsize is available, then it is used, otherwise the lower bounded size_hsize is used.

Example

let existing = vec![
  ("apples", 3),
  ("oranges", 4),
  ("bannana", 7)
];

let fdist: FrequencyDistribution<&str> =
  FromIterator::from_iter(existing.into_iter());

assert_eq!(fdist.get(&"apples"), 3);
assert_eq!(fdist.get(&"oranges"), 4);
assert_eq!(fdist.get(&"bannana"), 7);

impl<'a, K, H, S, Q> Index<&'a Q> for FrequencyDistribution<K, S>

where K: Eq + Hash + Borrow<Q>, H: Hasher, S: BuildHasher<Hasher = H>, Q: Eq + Hash + ?Sized,

type Output = usize

The returned type after indexing.

fn index<'b>(&'b self, index: &Q) -> &'b usize

Performs the indexing (container[index]) operation.

impl<K, H, S> IntoIterator for FrequencyDistribution<K, S>

where K: Eq + Hash, H: Hasher, S: BuildHasher<Hasher = H>,

fn into_iter(self) -> IntoIter<K, usize>

Consumes the distribution, and creates an iterator over the (Key, Quantity: usize) pairs.

type Item = (K, usize)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, usize>

Which kind of iterator are we turning this into?