Struct NeumaierSumReal 

pub struct NeumaierSumReal<T: NumKernel> { /* private fields */ }

Neumaier compensated sum of an iterable object of floating-point 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 ftl_numkernel::{
    Native64,
    neumaier_compensated_sum::{NeumaierSum,NeumaierSumReal}
};

let mut neumaier = NeumaierSumReal::<Native64>::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

Trait Implementations

impl<T: Clone + NumKernel> Clone for NeumaierSumReal<T>

where T::RealType: Clone,

fn clone(&self) -> NeumaierSumReal<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + NumKernel> Debug for NeumaierSumReal<T>

where T::RealType: Debug,

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

Formats the value using the given formatter.

impl<T: NumKernel> NeumaierSum<T> for NeumaierSumReal<T>

fn new(value: T::RealType) -> Self

Creates a new instance of the Neumaier compensated sum with user provided initial value. This is the default constructor.

fn add(&mut self, value: T::RealType)

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

fn sum(&self) -> T::RealType

Computes and returns the compensated sum.

fn reset(&mut self)

Resets the sum to zero.

type ScalarType = <T as NumKernel>::RealType

fn zero() -> Self

Creates a new instance of the Neumaier compensated sum with user initial value set to zero. This is the default constructor.

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

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

Creates a new instance of the NeumaierSumReal object summing the values in the iterable object values (sequential_version). /// # Example