Struct NeumaierSum 

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

Neumaier compensated sum of an iterable object of floating-point (real or scalar) numbers.

When summing floating-point values in a vector, the standard method of adding values sequentially can lead to precision loss, especially when there are a large number of elements or a mix of very large and very small values. This happens because floating-point arithmetic is not associative due to rounding errors. The most accurate algorithm to sum floating-point numbers typically avoids these precision problems.

Kahan summation is a popular algorithm that reduces numerical errors when adding a sequence of floating-point numbers. It keeps track of a running compensation for lost low-order bits during summation.

Neumaier summation is a slight modification of Kahan summation that can handle larger errors better. It uses an extra step to correct for the compensation term if the summation results in a larger round-off error than Kahan’s method can correct.

Example

use num_valid::neumaier_compensated_sum::NeumaierSum;

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

let sum = neumaier.sum();
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.

impl<ScalarType> NeumaierSum<ScalarType>

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

pub fn new(value: ScalarType) -> Self

Creates a new instance of the Neumaier compensated sum, initializing the sum with the provided value.

pub fn zero() -> Self

Creates a new instance of the Neumaier compensated sum, initialized to zero.

pub fn sum(&self) -> ScalarType

Computes and returns the compensated sum.

pub fn reset(&mut self)

Resets the sum to zero.

pub fn add(&mut self, value: ScalarType)

Adds a value to the sum. This method should be called for each value to be summed.

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

where I: IntoIterator<Item = ScalarType>,

Creates a new instance of the NeumaierSum object summing the values in the iterable object values (sequential_version).

Example

use num_valid::neumaier_compensated_sum::NeumaierSum;

let values = vec![1.0, 1.0e100, 1.0, -1.0e100];

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

Trait Implementations

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.