sum Vs simpleSum vs sumCompensation in DoubleSummaryStatistics? What is significant having them?

Question

How is use of having these three things.

public class DoubleSummaryStatistics
      implements DoubleConsumer
    {
      private long count;
      private double sum;
      private double sumCompensation;
      private double simpleSum;
      private double min = Double.POSITIVE_INFINITY;
      private double max = Double.NEGATIVE_INFINITY;
    }

Answer 1

sum and sumCompensation are used to reduce the error of regular floating point summation.

simpleSum contains the simple sum (obtained by applying simpleSum += value; on each added value), and is used for non-finite sums.

The implementation details explain that:

private double sum;
private double sumCompensation; // Low order bits of sum
private double simpleSum; // Used to compute right sum for non-finite inputs

This is how sum and sumCompensation are computed:

/**
 * Incorporate a new double value using Kahan summation /
 * compensated summation.
 */
private void sumWithCompensation(double value) {
    double tmp = value - sumCompensation;
    double velvel = sum + tmp; // Little wolf of rounding error
    sumCompensation = (velvel - sum) - tmp;
    sum = velvel;
}

You can see how they are used in getSum():

public final double getSum() {
    // Better error bounds to add both terms as the final sum
    double tmp =  sum + sumCompensation;
    if (Double.isNaN(tmp) && Double.isInfinite(simpleSum))
        // If the compensated sum is spuriously NaN from
        // accumulating one or more same-signed infinite values,
        // return the correctly-signed infinity stored in
        // simpleSum.
        return simpleSum;
    else
        return tmp;
}

The Javadoc of getSum() doesn't require any specific implementation, but allows for implementations that reduce the error bound:

The value of a floating-point sum is a function both of the input values as well as the order of addition operations. The order of addition operations of this method is intentionally not defined to allow for implementation flexibility to improve the speed and accuracy of the computed result. In particular, this method may be implemented using compensated summation or other technique to reduce the error bound in the numerical sum compared to a simple summation of double values.