pub trait Reduction<T> {
type Total: Copy + Send + Sync;
const COMMUTATIVE: bool = false;
const SPLIT: usize = 8;
// Required methods
fn unit() -> Self::Total;
fn step(acc: Self::Total, x: T) -> Self::Total;
fn merge(a: Self::Total, b: Self::Total) -> (Self::Total, bool);
// Provided methods
fn identity() -> Self::Total { ... }
fn checked(acc: Self::Total, x: T) -> (Self::Total, bool) { ... }
fn one(x: T) -> (Self::Total, bool) { ... }
fn chain(a: Self::Total, b: Self::Total) -> (Self::Total, bool) { ... }
fn slice(x: &[T]) -> (Self::Total, bool)
where Self: Sized,
T: Copy { ... }
fn scan(
x: &[T],
start: Option<Self::Total>,
out: &mut Vec<Self::Total>,
) -> bool
where Self: Sized,
T: Copy { ... }
fn rows(data: &[T], columns: usize, out: &mut [Self::Total]) -> bool
where Self: Sized,
T: Copy { ... }
fn short_lanes(
_data: &[T],
_len: usize,
_start: Option<Self::Total>,
_out: &mut Vec<Self::Total>,
) -> Option<bool>
where Self: Sized { ... }
}Expand description
A reduction by Sum, Product, ScaledProduct, Max, Min, And, Or, Xor, Xnor, SumAs, Squares or Alternated, implemented inside rustymath once for each item type it takes. slice folds a whole slice of consecutive items, in any order, merge combines the folds of two neighbouring runs, and scan gives the running folds. along, fold_into and scan_along fold along an axis whose items aren’t consecutive. Sum and Product take floats, integers and complex numbers. Max and Min take floats, integers and Booleans, And, Or and Xor take integers and Booleans, Xnor takes signed integers, bytes and Booleans, SumAs takes Booleans and integers, Squares takes floats and complex numbers, ScaledProduct takes floats, Alternated<Sum> takes floats, integers and complex numbers, Alternated<ScaledProduct> takes floats, and Alternated<Product> takes complex numbers. An f16 reduction computes in f32. A sum or product of f16s gives an f32 total, for its caller to round once. A total that doesn’t fit its type fails, with its value wrapped to that type.
Provided Associated Constants§
Sourceconst COMMUTATIVE: bool = false
const COMMUTATIVE: bool = false
Whether disjoint subsequences may be merged in any order.
Sourceconst SPLIT: usize = 8
const SPLIT: usize = 8
The most classes for which crate::search::ClassNumbers folds each class into four totals by position. Each step of a class’s total waits on the last through memory, so a reduction whose step takes longer gains from the split over more classes.
Required Associated Types§
Sourcetype Total: Copy + Send + Sync
type Total: Copy + Send + Sync
The type of a fold: the item type, i64 for a sum or product of integers narrower than 64 bits, f32 for a sum or product of f16s, i16 for an XNOR of bytes, the C of SumAs, f64 for Squares, a Scaled product for ScaledProduct, or a total with the parity of its count for Alternated.
Required Methods§
Provided Methods§
Sourcefn identity() -> Self::Total
fn identity() -> Self::Total
The exact identity of step, which leaves every total unchanged. For float sums it’s -0.0, because adding unit(), 0.0, turns a total of -0.0 into 0.0. For every other reduction it’s unit().
Sourcefn checked(acc: Self::Total, x: T) -> (Self::Total, bool)
fn checked(acc: Self::Total, x: T) -> (Self::Total, bool)
step, and whether its result fits. An integer sum or product wraps where it doesn’t.
Sourcefn one(x: T) -> (Self::Total, bool)
fn one(x: T) -> (Self::Total, bool)
The fold of the one item x, checked(identity(), x), and whether it fits.
Sourcefn chain(a: Self::Total, b: Self::Total) -> (Self::Total, bool)
fn chain(a: Self::Total, b: Self::Total) -> (Self::Total, bool)
merge, for a chain of folds whose every step waits for the one before, as van Herk-Gil-Werman’s suffixes and prefixes do. As in merge, a folds the earlier items. Float maximums and minimums override it with Folds::step_max and step_min, which use AArch64’s one-instruction fmaxnm and fminnm. LLVM can’t vectorize those, so they stay out of merge.
Sourcefn slice(x: &[T]) -> (Self::Total, bool)
fn slice(x: &[T]) -> (Self::Total, bool)
The fold of x, which is unit() where x is empty, and whether it fits. The default takes each item in turn by checked.
Sourcefn scan(x: &[T], start: Option<Self::Total>, out: &mut Vec<Self::Total>) -> bool
fn scan(x: &[T], start: Option<Self::Total>, out: &mut Vec<Self::Total>) -> bool
Appends the running folds of x to out, the first combining start where it is given, and gives whether every one fits. The default takes each item in turn by checked (checked_steps).
Sourcefn rows(data: &[T], columns: usize, out: &mut [Self::Total]) -> bool
fn rows(data: &[T], columns: usize, out: &mut [Self::Total]) -> bool
Folds each row of data, a matrix with columns items in each row, into the matching item of out, and gives whether every fold fits. The default is fold_rows, which folds each row of 16 items or more by slice. Float sums and products, integer maximums and minimums, and bitwise folds fold rows of 16 to 63 items by checked instead, eight rows side by side (rows_side_by_side). Each of their steps is one instruction, so keeping several rows’ steps in flight costs less than a call of slice for each row. Other reductions keep fold_rows, where slice vectorizes within the row: an integer sum’s step checks for overflow, and a float maximum’s or minimum’s slice runs Folds’ vector kernels. Nobody has timed float maximums side by side since their step became one select on x86.
Sourcefn short_lanes(
_data: &[T],
_len: usize,
_start: Option<Self::Total>,
_out: &mut Vec<Self::Total>,
) -> Option<bool>where
Self: Sized,
fn short_lanes(
_data: &[T],
_len: usize,
_start: Option<Self::Total>,
_out: &mut Vec<Self::Total>,
) -> Option<bool>where
Self: Sized,
Appends the running folds of data’s lanes of len consecutive items to out, each lane from start, through a route that runs many short lanes at once, and gives whether every fold fits. A reduction without such a route gives None and appends nothing, as the default does. scan_along then runs the lanes itself. The Boolean reductions run lanes of 1 to 64 items through Logical, 64 items to a word.
Dyn Compatibility§
This trait is not dyn compatible.
In older versions of Rust, dyn compatibility was called "object safety".
Implementors§
Source§impl Reduction<u8> for Xnor
Xnor of bytes, totalled at i16. Each total lies between -256 and 255, and the XNOR of two bytes is negative.
impl Reduction<u8> for Xnor
Xnor of bytes, totalled at i16. Each total lies between -256 and 255, and the XNOR of two bytes is negative.
Source§impl<F> Reduction<Complex<F>> for Productwhere
F: Native,
Complex products regroup multiplication through the same running totals as real products.
impl<F> Reduction<Complex<F>> for Productwhere
F: Native,
Complex products regroup multiplication through the same running totals as real products.
Source§impl<F> Reduction<Complex<F>> for Sumwhere
F: Native,
Each sum of complex numbers adds their real parts and their imaginary parts, in any order.
impl<F> Reduction<Complex<F>> for Sumwhere
F: Native,
Each sum of complex numbers adds their real parts and their imaginary parts, in any order.