Struct NaiveSum 

pub struct NaiveSum<T>(/* private fields */);

Naive (plain +=) accumulator.

This strategy keeps a single running sum and updates it with standard floating-point addition. It has minimal overhead and is usually the fastest option, but it may lose small addends when values have very different magnitudes.

In norm routines this is used by the default APIs such as crate::algorithms::vector_norms::vector_norm_l1, crate::algorithms::vector_norms::vector_norm_l2, and crate::algorithms::vector_norms::vector_norm_l2_sq.

Example

use num_valid::algorithms::accumulators::*;

let mut naive = NaiveSum::<f64>::new();
naive.push(1.0);
naive.push(2.0);
naive.push(3.0);
assert_eq!(naive.result(), 6.0);

Trait Implementations

impl<T: FpScalar> Accumulator for NaiveSum<T>

type Input = T

The type of values pushed into the accumulator.

type Output = T

The type of the final result produced by result.

fn new() -> Self

Creates a new, empty accumulator (the identity for combine).

fn push(&mut self, r: T)

Adds a single value to the accumulator.

fn result(self) -> T

Consumes the accumulator and returns the final result.

fn combine(&mut self, other: Self)

Merges other into self.

fn new_sequential<I>(values: I) -> Self

where I: IntoIterator<Item = Self::Input>,

Creates a new accumulator by sequentially adding all values from values.

fn new_parallel<I>(values: I) -> Self

where Self: Send, I: IntoParallelIterator<Item = Self::Input>,

Builds an accumulator by processing a parallel iterator.

impl<T: FpScalar> SumAccumulator for NaiveSum<T>

fn rescale_by(&mut self, r: &T)

Multiply the entire accumulated sum by r.