Struct ClassNumbers 

pub struct ClassNumbers<'a, N> {
    pub count: usize,
    pub numbers: &'a [N],
}

Each item’s class number below count, at any integer width: classes that a fold totals, or a scan runs, each on its own (Grouping).

Fields

count: usize

The number of classes.

numbers: &'a [N]

Each item’s class number.

Implementations

impl<N> ClassNumbers<'_, N>

where N: Key,

pub fn counts(self) -> Vec<usize>

The number of items in each class.

Trait Implementations

impl<'a, N> Clone for ClassNumbers<'a, N>

where N: Clone,

fn clone(&self) -> ClassNumbers<'a, N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, N> Copy for ClassNumbers<'a, N>

where N: Copy,

impl<'a, N> Debug for ClassNumbers<'a, N>

where N: Debug,

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

Formats the value using the given formatter.

impl<N> Grouping for ClassNumbers<'_, N>

where N: Key,

fn fold<T, R>(&self, data: &[T]) -> (Vec<<R as Reduction<T>>::Total>, bool)

where T: Copy, R: Reduction<T>,

Each class’s fold from R’s exact identity. With few classes, a class’s items lie close together, and each step of its total waits on the last through memory. So with at most R::SPLIT classes, each class folds into four totals, one for each position modulo 4, which the end merges in turn. A float sum then adds its items in another order.

fn len(&self) -> usize

The number of groups.

fn scan<T, R>(&self, data: &[T]) -> (Vec<<R as Reduction<T>>::Total>, bool)

where T: Copy, R: Reduction<T>,

Scans each group of data by R: every item’s running total within its group, the groups one after another in group order, each in its items’ order, and whether every total fits.