Enum Reduce 

pub enum Reduce {
    Sum,
    Product,
    Max,
    Min,
    And,
    Or,
    Xor,
    Xnor,
}

A reduction by name: the tag by which a function object’s row names the reduction it folds by (facts::Facts::fold, facts::Facts::truth), and by which a frontend’s block stages and compiled code fold. with_reduce! gives its type.

Variants

Sum

Product

Max

Min

And

Or

Xor

Xnor

Implementations

impl Reduce

pub fn stage(self, item: DType, exact: bool) -> bool

Whether a block stage folds items of item by this reduction a block at a time: floats by a sum, a product, a maximum or a minimum; integers by a maximum or a minimum, and by a sum where its sums are exact (exact), as a sum whose range lies within the items’ type is; Booleans by a sum (a count), a minimum, a maximum, an exclusive or or its negation.

pub fn seeds(self, items: DType, seed: DType, result: DType) -> bool

Whether a stage’s fold by this reduction of items of items takes a seed of type seed into a result of type result, merging the seed into each total at the end: floats with a float seed, where the result keeps the items’ width; integers with an integer or Boolean seed by a maximum or a minimum, or by a sum into a result of the items’ type; and a count of Booleans with an integer or Boolean seed. A sum of integers into a wider integer folds after the stage, because compiled code sums integers at the items’ width.

pub fn compiles(self) -> bool

Whether compiled code folds by this reduction: a sum, a product, a maximum or a minimum.

impl Reduce

pub fn total_dtype(self, variant: Variant) -> Option<DType>

pub fn run_pieces( self, variant: Variant, dims: [usize; 3], seed: Seed<'_>, pieces: &Pieces<'_>, output: &mut Buffer, ) -> Result<(), Error>

pub fn run_read( self, variant: Variant, shape: &[usize], axis: Option<usize>, seed: Seed<'_>, input: Read<'_>, output: &mut Buffer, ) -> Result<Option<Vec<Steps>>, Error>

pub fn run_sliding_2d( self, variant: Variant, dims: [usize; 5], widths: [usize; 2], every: [usize; 2], input: View<'_>, output: &mut Buffer, ) -> Result<(), Error>

The folds by this reduction of each window along axes 1 and 3 of input, an array of shape dims, as sliding_2d folds them, with each axis’s window width and the positions between windows’ starts. A domain error for windows wider than sliding_2d folds directly.

pub fn run_groups( self, variant: Variant, groups: &impl Grouping, input: View<'_>, output: &mut Buffer, ) -> Result<(), Error>

The fold by this reduction of each group of input that groups gives, in group order (Grouping::fold).

pub fn inverse_pieces( self, variant: Variant, dims: [usize; 3], pieces: &Pieces<'_>, ) -> Result<Option<Buffer>, Error>

pub fn inverse_read( self, variant: Variant, shape: &[usize], axis: usize, input: Read<'_>, ) -> Result<Option<Buffer>, Error>

impl Reduce

pub fn run_scan( self, variant: Variant, dims: [usize; 3], seed: Seed<'_>, direction: Direction, input: Read<'_>, output: &mut Buffer, ) -> Result<(), Error>

Trait Implementations

impl Clone for Reduce

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Reduce

impl Debug for Reduce

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

Formats the value using the given formatter.

impl Eq for Reduce

impl Hash for Reduce

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Reduce

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for Reduce