Struct NeumaierSum 

pub struct NeumaierSum<ScalarType> { /* private fields */ }

Neumaier compensated accumulator for sums of floating-point (real or complex) numbers.

Standard sequential summation loses precision when values of very different magnitudes are added: a small addend can be completely swallowed by a much larger running total. NeumaierSum corrects for this by maintaining a compensation term that captures the low-order bits discarded at each step, then folds them back into the result at the end.

NeumaierSum<T> implements SumAccumulator, so it can be used directly as the accumulation strategy in the norms vector-norm functions (e.g., vector_norm_l2_neumaier, vector_norm_l1_neumaier).

Example

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

let mut neumaier = NeumaierSum::<f64>::new();
neumaier.push(1.0);
neumaier.push(1e100);
neumaier.push(1.0);
neumaier.push(-1e100);

let sum = neumaier.result();
println!("Sum: {}", sum);
assert_eq!(sum, 2.0);

References

• Neumaier Summation

Implementations

impl<ScalarType> NeumaierSum<ScalarType>

pub fn sum_before_compensation(&self) -> &ScalarType

The sum before the compensation term is added.

pub fn compensation(&self) -> &ScalarType

The compensation term. This is the correction term that is added to the sum_before_compensation to correct for the loss of precision.

Trait Implementations

impl<ScalarType> Accumulator for NeumaierSum<ScalarType>

where ScalarType: Clone + Zero + for<'a> Add<&'a ScalarType, Output = ScalarType> + for<'a> AddAssign<&'a ScalarType> + for<'a> Mul<&'a ScalarType, Output = ScalarType> + for<'a> MulAssign<&'a ScalarType> + NeumaierAddable,

type Input = ScalarType

The type of values pushed into the accumulator.

type Output = ScalarType

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, value: Self::Input)

Adds a single value to the accumulator.

fn result(self) -> Self::Input

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<ScalarType: Clone> Clone for NeumaierSum<ScalarType>

fn clone(&self) -> NeumaierSum<ScalarType>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<ScalarType: Debug> Debug for NeumaierSum<ScalarType>

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

Formats the value using the given formatter.

impl<ScalarType> SumAccumulator for NeumaierSum<ScalarType>

where ScalarType: Clone + Zero + for<'a> Add<&'a ScalarType, Output = ScalarType> + for<'a> AddAssign<&'a ScalarType> + for<'a> Mul<&'a ScalarType, Output = ScalarType> + for<'a> MulAssign<&'a ScalarType> + NeumaierAddable,

fn rescale_by(&mut self, r: &Self::Input)

Multiply the entire accumulated sum by r.