/*
* Copyright (C) 2012 The Guava Authors
*
* 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 com.google.common.math;
import static com.google.common.math.StatsTesting.ALLOWED_ERROR;
import static com.google.common.math.StatsTesting.ALL_MANY_VALUES;
import static com.google.common.math.StatsTesting.INTEGER_MANY_VALUES;
import static com.google.common.math.StatsTesting.INTEGER_MANY_VALUES_COUNT;
import static com.google.common.math.StatsTesting.INTEGER_MANY_VALUES_MAX;
import static com.google.common.math.StatsTesting.INTEGER_MANY_VALUES_MEAN;
import static com.google.common.math.StatsTesting.INTEGER_MANY_VALUES_MIN;
import static com.google.common.math.StatsTesting.INTEGER_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS;
import static com.google.common.math.StatsTesting.LONG_MANY_VALUES;
import static com.google.common.math.StatsTesting.LONG_MANY_VALUES_COUNT;
import static com.google.common.math.StatsTesting.LONG_MANY_VALUES_MAX;
import static com.google.common.math.StatsTesting.LONG_MANY_VALUES_MEAN;
import static com.google.common.math.StatsTesting.LONG_MANY_VALUES_MIN;
import static com.google.common.math.StatsTesting.LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS;
import static com.google.common.math.StatsTesting.MANY_VALUES;
import static com.google.common.math.StatsTesting.MANY_VALUES_COUNT;
import static com.google.common.math.StatsTesting.MANY_VALUES_MAX;
import static com.google.common.math.StatsTesting.MANY_VALUES_MEAN;
import static com.google.common.math.StatsTesting.MANY_VALUES_MIN;
import static com.google.common.math.StatsTesting.MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS;
import static com.google.common.math.StatsTesting.ONE_VALUE;
import static com.google.common.math.StatsTesting.OTHER_ONE_VALUE;
import static com.google.common.math.StatsTesting.TWO_VALUES;
import static com.google.common.math.StatsTesting.TWO_VALUES_MAX;
import static com.google.common.math.StatsTesting.TWO_VALUES_MEAN;
import static com.google.common.math.StatsTesting.TWO_VALUES_MIN;
import static com.google.common.math.StatsTesting.TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS;
import static com.google.common.truth.Truth.assertThat;
import static java.lang.Math.sqrt;
import com.google.common.collect.ImmutableList;
import com.google.common.math.StatsTesting.ManyValues;
import com.google.common.primitives.Doubles;
import com.google.common.primitives.Longs;
import junit.framework.TestCase;
/**
* Tests for {@link StatsAccumulator}. This tests the stats methods for instances built with
* {@link StatsAccumulator#add} and {@link StatsAccumulator#addAll}, and various error cases of the
* {@link StatsAccumulator#add} and {@link StatsAccumulator#addAll} methods. For tests of the
* {@link StatsAccumulator#snapshot} method which returns {@link Stats} instances, see
* {@link StatsTest}.
*
* @author Pete Gillin
*/
public class StatsAccumulatorTest extends TestCase {
private StatsAccumulator emptyAccumulator;
private StatsAccumulator emptyAccumulatorByAddAllEmptyIterable;
private StatsAccumulator emptyAccumulatorByAddAllEmptyStats;
private StatsAccumulator oneValueAccumulator;
private StatsAccumulator oneValueAccumulatorByAddAllEmptyStats;
private StatsAccumulator twoValuesAccumulator;
private StatsAccumulator twoValuesAccumulatorByAddAllStats;
private StatsAccumulator manyValuesAccumulatorByAddAllIterable;
private StatsAccumulator manyValuesAccumulatorByAddAllIterator;
private StatsAccumulator manyValuesAccumulatorByAddAllVarargs;
private StatsAccumulator manyValuesAccumulatorByRepeatedAdd;
private StatsAccumulator manyValuesAccumulatorByAddAndAddAll;
private StatsAccumulator manyValuesAccumulatorByAddAllStats;
private StatsAccumulator integerManyValuesAccumulatorByAddAllIterable;
private StatsAccumulator longManyValuesAccumulatorByAddAllIterator;
private StatsAccumulator longManyValuesAccumulatorByAddAllVarargs;
@Override
protected void setUp() throws Exception {
super.setUp();
emptyAccumulator = new StatsAccumulator();
emptyAccumulatorByAddAllEmptyIterable = new StatsAccumulator();
emptyAccumulatorByAddAllEmptyIterable.addAll(ImmutableList.<Double>of());
emptyAccumulatorByAddAllEmptyStats = new StatsAccumulator();
emptyAccumulatorByAddAllEmptyStats.addAll(Stats.of());
oneValueAccumulator = new StatsAccumulator();
oneValueAccumulator.add(ONE_VALUE);
oneValueAccumulatorByAddAllEmptyStats = new StatsAccumulator();
oneValueAccumulatorByAddAllEmptyStats.add(ONE_VALUE);
oneValueAccumulatorByAddAllEmptyStats.addAll(Stats.of());
twoValuesAccumulator = new StatsAccumulator();
twoValuesAccumulator.addAll(TWO_VALUES);
twoValuesAccumulatorByAddAllStats = new StatsAccumulator();
twoValuesAccumulatorByAddAllStats.addAll(Stats.of(ONE_VALUE));
twoValuesAccumulatorByAddAllStats.addAll(Stats.of(OTHER_ONE_VALUE));
manyValuesAccumulatorByAddAllIterable = new StatsAccumulator();
manyValuesAccumulatorByAddAllIterable.addAll(MANY_VALUES);
manyValuesAccumulatorByAddAllIterator = new StatsAccumulator();
manyValuesAccumulatorByAddAllIterator.addAll(MANY_VALUES.iterator());
manyValuesAccumulatorByAddAllVarargs = new StatsAccumulator();
manyValuesAccumulatorByAddAllVarargs.addAll(Doubles.toArray(MANY_VALUES));
manyValuesAccumulatorByRepeatedAdd = new StatsAccumulator();
for (double value : MANY_VALUES) {
manyValuesAccumulatorByRepeatedAdd.add(value);
}
manyValuesAccumulatorByAddAndAddAll = new StatsAccumulator();
manyValuesAccumulatorByAddAndAddAll.add(MANY_VALUES.get(0));
manyValuesAccumulatorByAddAndAddAll.addAll(MANY_VALUES.subList(1, MANY_VALUES.size()));
manyValuesAccumulatorByAddAllStats = new StatsAccumulator();
manyValuesAccumulatorByAddAllStats.addAll(
Stats.of(MANY_VALUES.subList(0, MANY_VALUES.size() / 2)));
manyValuesAccumulatorByAddAllStats.addAll(
Stats.of(MANY_VALUES.subList(MANY_VALUES.size() / 2, MANY_VALUES.size())));
integerManyValuesAccumulatorByAddAllIterable = new StatsAccumulator();
integerManyValuesAccumulatorByAddAllIterable.addAll(INTEGER_MANY_VALUES);
longManyValuesAccumulatorByAddAllIterator = new StatsAccumulator();
longManyValuesAccumulatorByAddAllIterator.addAll(LONG_MANY_VALUES.iterator());
longManyValuesAccumulatorByAddAllVarargs = new StatsAccumulator();
longManyValuesAccumulatorByAddAllVarargs.addAll(Longs.toArray(LONG_MANY_VALUES));
}
public void testCount() {
assertThat(emptyAccumulator.count()).isEqualTo(0);
assertThat(emptyAccumulatorByAddAllEmptyIterable.count()).isEqualTo(0);
assertThat(emptyAccumulatorByAddAllEmptyStats.count()).isEqualTo(0);
assertThat(oneValueAccumulator.count()).isEqualTo(1);
assertThat(oneValueAccumulatorByAddAllEmptyStats.count()).isEqualTo(1);
assertThat(twoValuesAccumulator.count()).isEqualTo(2);
assertThat(twoValuesAccumulatorByAddAllStats.count()).isEqualTo(2);
assertThat(manyValuesAccumulatorByAddAllIterable.count()).isEqualTo(MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllIterator.count()).isEqualTo(MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllVarargs.count()).isEqualTo(MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByRepeatedAdd.count()).isEqualTo(MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAndAddAll.count()).isEqualTo(MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllStats.count()).isEqualTo(MANY_VALUES_COUNT);
assertThat(integerManyValuesAccumulatorByAddAllIterable.count())
.isEqualTo(StatsTesting.INTEGER_MANY_VALUES_COUNT);
assertThat(longManyValuesAccumulatorByAddAllIterator.count())
.isEqualTo(StatsTesting.LONG_MANY_VALUES_COUNT);
assertThat(longManyValuesAccumulatorByAddAllVarargs.count())
.isEqualTo(StatsTesting.LONG_MANY_VALUES_COUNT);
}
public void testCountOverflow_doesNotThrow() {
StatsAccumulator accumulator = new StatsAccumulator();
accumulator.add(ONE_VALUE);
for (int power = 1; power < Long.SIZE - 1; power++) {
accumulator.addAll(accumulator.snapshot());
}
// Should overflow without throwing.
accumulator.addAll(accumulator.snapshot());
assertThat(accumulator.count()).isLessThan(0L);
}
public void testMean() {
try {
emptyAccumulator.mean();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyIterable.mean();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyStats.mean();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
assertThat(oneValueAccumulator.mean()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
assertThat(oneValueAccumulatorByAddAllEmptyStats.mean()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
assertThat(twoValuesAccumulator.mean()).isWithin(ALLOWED_ERROR).of(TWO_VALUES_MEAN);
assertThat(twoValuesAccumulatorByAddAllStats.mean())
.isWithin(ALLOWED_ERROR)
.of(TWO_VALUES_MEAN);
assertThat(manyValuesAccumulatorByAddAllIterable.mean())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN);
assertThat(manyValuesAccumulatorByAddAllIterator.mean())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN);
assertThat(manyValuesAccumulatorByAddAllVarargs.mean())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN);
assertThat(manyValuesAccumulatorByRepeatedAdd.mean())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN);
assertThat(manyValuesAccumulatorByAddAndAddAll.mean())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN);
assertThat(manyValuesAccumulatorByAddAllStats.mean())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN);
// For datasets of many double values created from an iterable, we test many combinations of
// finite and non-finite values:
for (ManyValues values : ALL_MANY_VALUES) {
StatsAccumulator accumulator = new StatsAccumulator();
StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
accumulator.addAll(values.asIterable());
for (double value : values.asIterable()) {
accumulatorByAddAllStats.addAll(Stats.of(value));
}
double mean = accumulator.mean();
double meanByAddAllStats = accumulatorByAddAllStats.mean();
if (values.hasAnyNaN()) {
assertThat(mean).named("mean of " + values).isNaN();
assertThat(meanByAddAllStats).named("mean by addAll(Stats) of " + values).isNaN();
} else if (values.hasAnyPositiveInfinity() && values.hasAnyNegativeInfinity()) {
assertThat(mean).named("mean of " + values).isNaN();
assertThat(meanByAddAllStats).named("mean by addAll(Stats) of " + values).isNaN();
} else if (values.hasAnyPositiveInfinity()) {
assertThat(mean).named("mean of " + values).isPositiveInfinity();
assertThat(meanByAddAllStats)
.named("mean by addAll(Stats) of " + values)
.isPositiveInfinity();
} else if (values.hasAnyNegativeInfinity()) {
assertThat(mean).named("mean of " + values).isNegativeInfinity();
assertThat(meanByAddAllStats)
.named("mean by addAll(Stats) of " + values)
.isNegativeInfinity();
} else {
assertThat(mean).named("mean of " + values).isWithin(ALLOWED_ERROR).of(MANY_VALUES_MEAN);
assertThat(meanByAddAllStats)
.named("mean by addAll(Stats) of " + values)
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN);
}
}
assertThat(integerManyValuesAccumulatorByAddAllIterable.mean())
.isWithin(ALLOWED_ERROR)
.of(INTEGER_MANY_VALUES_MEAN);
assertThat(longManyValuesAccumulatorByAddAllIterator.mean())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_MEAN);
assertThat(longManyValuesAccumulatorByAddAllVarargs.mean())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_MEAN);
}
public void testSum() {
assertThat(emptyAccumulator.sum()).isWithin(0.0).of(0.0);
assertThat(emptyAccumulatorByAddAllEmptyIterable.sum()).isWithin(0.0).of(0.0);
assertThat(emptyAccumulatorByAddAllEmptyStats.sum()).isWithin(0.0).of(0.0);
assertThat(oneValueAccumulator.sum()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
assertThat(oneValueAccumulatorByAddAllEmptyStats.sum()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
assertThat(twoValuesAccumulator.sum()).isWithin(ALLOWED_ERROR).of(TWO_VALUES_MEAN * 2);
assertThat(twoValuesAccumulatorByAddAllStats.sum())
.isWithin(ALLOWED_ERROR)
.of(TWO_VALUES_MEAN * 2);
assertThat(manyValuesAccumulatorByAddAllIterable.sum())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN * MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllIterator.sum())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN * MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllVarargs.sum())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN * MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByRepeatedAdd.sum())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN * MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAndAddAll.sum())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN * MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllStats.sum())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MEAN * MANY_VALUES_COUNT);
assertThat(integerManyValuesAccumulatorByAddAllIterable.sum())
.isWithin(ALLOWED_ERROR)
.of(INTEGER_MANY_VALUES_MEAN * INTEGER_MANY_VALUES_COUNT);
assertThat(longManyValuesAccumulatorByAddAllIterator.sum())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_MEAN * LONG_MANY_VALUES_COUNT);
assertThat(longManyValuesAccumulatorByAddAllVarargs.sum())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_MEAN * LONG_MANY_VALUES_COUNT);
}
public void testPopulationVariance() {
try {
emptyAccumulator.populationVariance();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyIterable.populationVariance();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyStats.populationVariance();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
assertThat(oneValueAccumulator.populationVariance()).isWithin(0.0).of(0.0);
assertThat(oneValueAccumulatorByAddAllEmptyStats.populationVariance()).isWithin(0.0).of(0.0);
assertThat(twoValuesAccumulator.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS / 2);
assertThat(twoValuesAccumulatorByAddAllStats.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS / 2);
assertThat(manyValuesAccumulatorByAddAllIterable.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllIterator.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllVarargs.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByRepeatedAdd.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAndAddAll.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT);
assertThat(manyValuesAccumulatorByAddAllStats.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT);
// For datasets of many double values created from an iterator, we test many combinations of
// finite and non-finite values:
for (ManyValues values : ALL_MANY_VALUES) {
StatsAccumulator accumulator = new StatsAccumulator();
StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
accumulator.addAll(values.asIterable().iterator());
for (double value : values.asIterable()) {
accumulatorByAddAllStats.addAll(Stats.of(value));
}
double populationVariance = accumulator.populationVariance();
double populationVarianceByAddAllStats = accumulatorByAddAllStats.populationVariance();
if (values.hasAnyNonFinite()) {
assertThat(populationVariance).named("population variance of " + values).isNaN();
assertThat(populationVarianceByAddAllStats)
.named("population variance by addAll(Stats) of " + values)
.isNaN();
} else {
assertThat(populationVariance)
.named("population variance of " + values)
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT);
assertThat(populationVarianceByAddAllStats)
.named("population variance by addAll(Stats) of " + values)
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT);
}
}
assertThat(integerManyValuesAccumulatorByAddAllIterable.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(INTEGER_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / INTEGER_MANY_VALUES_COUNT);
assertThat(longManyValuesAccumulatorByAddAllIterator.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / LONG_MANY_VALUES_COUNT);
assertThat(longManyValuesAccumulatorByAddAllVarargs.populationVariance())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / LONG_MANY_VALUES_COUNT);
}
public void testPopulationStandardDeviation() {
try {
emptyAccumulator.populationStandardDeviation();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyIterable.populationStandardDeviation();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyStats.populationStandardDeviation();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
assertThat(oneValueAccumulator.populationStandardDeviation()).isWithin(0.0).of(0.0);
assertThat(oneValueAccumulatorByAddAllEmptyStats.populationStandardDeviation())
.isWithin(0.0)
.of(0.0);
assertThat(twoValuesAccumulator.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS / 2));
assertThat(twoValuesAccumulatorByAddAllStats.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS / 2));
assertThat(manyValuesAccumulatorByAddAllIterable.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT));
assertThat(manyValuesAccumulatorByAddAllIterator.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT));
assertThat(manyValuesAccumulatorByAddAllVarargs.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT));
assertThat(manyValuesAccumulatorByRepeatedAdd.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT));
assertThat(manyValuesAccumulatorByAddAndAddAll.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT));
assertThat(manyValuesAccumulatorByAddAllStats.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / MANY_VALUES_COUNT));
assertThat(integerManyValuesAccumulatorByAddAllIterable.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(INTEGER_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / INTEGER_MANY_VALUES_COUNT));
assertThat(longManyValuesAccumulatorByAddAllIterator.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / LONG_MANY_VALUES_COUNT));
assertThat(longManyValuesAccumulatorByAddAllVarargs.populationStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / LONG_MANY_VALUES_COUNT));
}
public void testSampleVariance() {
try {
emptyAccumulator.sampleVariance();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyIterable.sampleVariance();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyStats.sampleVariance();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
oneValueAccumulator.sampleVariance();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
oneValueAccumulatorByAddAllEmptyStats.sampleVariance();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
assertThat(twoValuesAccumulator.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS);
assertThat(twoValuesAccumulatorByAddAllStats.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS);
assertThat(manyValuesAccumulatorByAddAllIterable.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1));
assertThat(manyValuesAccumulatorByAddAllIterator.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1));
assertThat(manyValuesAccumulatorByAddAllVarargs.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1));
assertThat(manyValuesAccumulatorByRepeatedAdd.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1));
assertThat(manyValuesAccumulatorByAddAndAddAll.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1));
assertThat(manyValuesAccumulatorByAddAllStats.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1));
assertThat(integerManyValuesAccumulatorByAddAllIterable.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(INTEGER_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (INTEGER_MANY_VALUES_COUNT - 1));
assertThat(longManyValuesAccumulatorByAddAllIterator.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (LONG_MANY_VALUES_COUNT - 1));
assertThat(longManyValuesAccumulatorByAddAllVarargs.sampleVariance())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (LONG_MANY_VALUES_COUNT - 1));
}
public void testSampleStandardDeviation() {
try {
emptyAccumulator.sampleStandardDeviation();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyIterable.sampleStandardDeviation();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyStats.sampleStandardDeviation();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
oneValueAccumulator.sampleStandardDeviation();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
oneValueAccumulatorByAddAllEmptyStats.sampleStandardDeviation();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
assertThat(twoValuesAccumulator.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS));
assertThat(twoValuesAccumulatorByAddAllStats.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS));
assertThat(manyValuesAccumulatorByAddAllIterable.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1)));
assertThat(manyValuesAccumulatorByAddAllIterator.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1)));
assertThat(manyValuesAccumulatorByAddAllVarargs.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1)));
assertThat(manyValuesAccumulatorByRepeatedAdd.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1)));
assertThat(manyValuesAccumulatorByAddAndAddAll.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1)));
assertThat(manyValuesAccumulatorByAddAllStats.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (MANY_VALUES_COUNT - 1)));
assertThat(integerManyValuesAccumulatorByAddAllIterable.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(INTEGER_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (INTEGER_MANY_VALUES_COUNT - 1)));
assertThat(longManyValuesAccumulatorByAddAllIterator.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (LONG_MANY_VALUES_COUNT - 1)));
assertThat(longManyValuesAccumulatorByAddAllVarargs.sampleStandardDeviation())
.isWithin(ALLOWED_ERROR)
.of(sqrt(LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS / (LONG_MANY_VALUES_COUNT - 1)));
}
public void testMax() {
try {
emptyAccumulator.max();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyIterable.max();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyStats.max();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
assertThat(oneValueAccumulator.max()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
assertThat(oneValueAccumulatorByAddAllEmptyStats.max()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
assertThat(twoValuesAccumulator.max()).isWithin(ALLOWED_ERROR).of(TWO_VALUES_MAX);
assertThat(twoValuesAccumulatorByAddAllStats.max()).isWithin(ALLOWED_ERROR).of(TWO_VALUES_MAX);
assertThat(manyValuesAccumulatorByAddAllIterable.max())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MAX);
assertThat(manyValuesAccumulatorByAddAllIterator.max())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MAX);
assertThat(manyValuesAccumulatorByAddAllVarargs.max())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MAX);
assertThat(manyValuesAccumulatorByRepeatedAdd.max())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MAX);
assertThat(manyValuesAccumulatorByAddAndAddAll.max())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MAX);
assertThat(manyValuesAccumulatorByAddAllStats.max())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MAX);
// For datasets of many double values created from an array, we test many combinations of
// finite and non-finite values:
for (ManyValues values : ALL_MANY_VALUES) {
StatsAccumulator accumulator = new StatsAccumulator();
StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
accumulator.addAll(values.asArray());
for (double value : values.asIterable()) {
accumulatorByAddAllStats.addAll(Stats.of(value));
}
double max = accumulator.max();
double maxByAddAllStats = accumulatorByAddAllStats.max();
if (values.hasAnyNaN()) {
assertThat(max).named("max of " + values).isNaN();
assertThat(maxByAddAllStats).named("max by addAll(Stats) of " + values).isNaN();
} else if (values.hasAnyPositiveInfinity()) {
assertThat(max).named("max of " + values).isPositiveInfinity();
assertThat(maxByAddAllStats)
.named("max by addAll(Stats) of " + values)
.isPositiveInfinity();
} else {
assertThat(max).named("max of " + values).isWithin(ALLOWED_ERROR).of(MANY_VALUES_MAX);
assertThat(maxByAddAllStats)
.named("max by addAll(Stats) of " + values)
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MAX);
}
}
assertThat(integerManyValuesAccumulatorByAddAllIterable.max())
.isWithin(ALLOWED_ERROR)
.of(INTEGER_MANY_VALUES_MAX);
assertThat(longManyValuesAccumulatorByAddAllIterator.max())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_MAX);
assertThat(longManyValuesAccumulatorByAddAllVarargs.max())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_MAX);
}
public void testMin() {
try {
emptyAccumulator.min();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyIterable.min();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
try {
emptyAccumulatorByAddAllEmptyStats.min();
fail("Expected IllegalStateException");
} catch (IllegalStateException expected) {
}
assertThat(oneValueAccumulator.min()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
assertThat(oneValueAccumulatorByAddAllEmptyStats.min()).isWithin(ALLOWED_ERROR).of(ONE_VALUE);
assertThat(twoValuesAccumulator.min()).isWithin(ALLOWED_ERROR).of(TWO_VALUES_MIN);
assertThat(twoValuesAccumulatorByAddAllStats.min()).isWithin(ALLOWED_ERROR).of(TWO_VALUES_MIN);
assertThat(manyValuesAccumulatorByAddAllIterable.min())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MIN);
assertThat(manyValuesAccumulatorByAddAllIterator.min())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MIN);
assertThat(manyValuesAccumulatorByAddAllVarargs.min())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MIN);
assertThat(manyValuesAccumulatorByRepeatedAdd.min())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MIN);
assertThat(manyValuesAccumulatorByAddAndAddAll.min())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MIN);
assertThat(manyValuesAccumulatorByAddAllStats.min())
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MIN);
// For datasets of many double values created by adding elements individually, we test many
// combinations of finite and non-finite values:
for (ManyValues values : ALL_MANY_VALUES) {
StatsAccumulator accumulator = new StatsAccumulator();
StatsAccumulator accumulatorByAddAllStats = new StatsAccumulator();
for (double value : values.asIterable()) {
accumulator.add(value);
accumulatorByAddAllStats.addAll(Stats.of(value));
}
double min = accumulator.min();
double minByAddAllStats = accumulatorByAddAllStats.min();
if (values.hasAnyNaN()) {
assertThat(min).named("min of " + values).isNaN();
assertThat(minByAddAllStats).named("min by addAll(Stats) of " + values).isNaN();
} else if (values.hasAnyNegativeInfinity()) {
assertThat(min).named("min of " + values).isNegativeInfinity();
assertThat(minByAddAllStats)
.named("min by addAll(Stats) of " + values)
.isNegativeInfinity();
} else {
assertThat(min).named("min of " + values).isWithin(ALLOWED_ERROR).of(MANY_VALUES_MIN);
assertThat(minByAddAllStats)
.named("min by addAll(Stats) of " + values)
.isWithin(ALLOWED_ERROR)
.of(MANY_VALUES_MIN);
}
}
assertThat(integerManyValuesAccumulatorByAddAllIterable.min())
.isWithin(ALLOWED_ERROR)
.of(INTEGER_MANY_VALUES_MIN);
assertThat(longManyValuesAccumulatorByAddAllIterator.min())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_MIN);
assertThat(longManyValuesAccumulatorByAddAllVarargs.min())
.isWithin(ALLOWED_ERROR)
.of(LONG_MANY_VALUES_MIN);
}
}