com.google.gwt.emul.java.util.DoubleSummaryStatistics Maven / Gradle / Ivy
/*
* Copyright 2015 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
package java.util;
import java.util.function.DoubleConsumer;
/**
* See the
* official Java API doc for details.
*/
public class DoubleSummaryStatistics implements DoubleConsumer {
private long count;
private double min = Double.POSITIVE_INFINITY;
private double max = Double.NEGATIVE_INFINITY;
private double sum;
private double sumError;
// Because of Kahan summation compensation a naive summation is required
// to keep track of infinity values correctly.
private double naiveSum;
@Override
public void accept(double value) {
count++;
min = Math.min(min, value);
max = Math.max(max, value);
naiveSum += value;
sum(value);
}
public void combine(DoubleSummaryStatistics other) {
count += other.count;
min = Math.min(min, other.min);
max = Math.max(max, other.max);
naiveSum += other.naiveSum;
sum(other.sum);
sum(other.sumError);
}
public double getAverage() {
return count > 0 ? getSum() / count : 0d;
}
public long getCount() {
return count;
}
public double getMin() {
return min;
}
public double getMax() {
return max;
}
public double getSum() {
// Adding sum and sumError here to get a better result
// because Kahan summation always applies error compensation
// on the next summation.
double compensatedSum = sum + sumError;
// sumError can be NaN if infinity values had been accepted.
if (Double.isNaN(compensatedSum) && Double.isInfinite(naiveSum)) {
return naiveSum;
}
return compensatedSum;
}
@Override
public String toString() {
return "DoubleSummaryStatistics[" +
"count = " + count +
", avg = " + getAverage() +
", min = " + min +
", max = " + max +
", sum = " + getSum() +
"]";
}
/**
* Adds a new value to the current sum using Kahan summation
* algorithm for improved summation precision.
*
* https://en.wikipedia.org/wiki/Kahan_summation_algorithm
*
* @param value the value being added to the sum
*/
private void sum(double value) {
double compensatedValue = value - sumError;
double newSum = sum + compensatedValue;
// Logically 'summationError' always evaluates to 0
// but in reality it contains a small summation error
// that can occur because of rounding in floating point arithmetic.
// For example 1.0 + EPSILON with EPSILON being half machine precision
// (basically Math.ulp(1.0)/2) will result in 1.0.
// Tests should verify that GWT compiler / Closure compiler do not
// remove this line during optimizations.
// NOTE: sumError can become NaN for infinity values.
sumError = (newSum - sum) - compensatedValue;
sum = newSum;
}
}