if (xSumOfSquaresOfDeltas > 0.0) { if (yStats.sumOfSquaresOfDeltas() > 0.0) { return LinearTransformation.mapping(xStats.mean(), yStats.mean()) .withSlope(sumOfProductsOfDeltas / xSumOfSquaresOfDeltas); } else { return LinearTransformation.horizontal(yStats.mean()); return LinearTransformation.vertical(xStats.mean());
public void testEquivalentStreams() { // 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) { double[] array = values.asArray(); Stats stats = Stats.of(array); // instance methods on Stats vs on instance methods on DoubleStream assertThat(stats.count()).isEqualTo(stream(array).count()); assertEquivalent(stats.mean(), stream(array).average().getAsDouble()); assertEquivalent(stats.sum(), stream(array).sum()); assertEquivalent(stats.max(), stream(array).max().getAsDouble()); assertEquivalent(stats.min(), stream(array).min().getAsDouble()); // static method on Stats vs on instance method on DoubleStream assertEquivalent(Stats.meanOf(array), stream(array).average().getAsDouble()); // instance methods on Stats vs instance methods on DoubleSummaryStatistics DoubleSummaryStatistics streamStats = stream(array).summaryStatistics(); assertThat(stats.count()).isEqualTo(streamStats.getCount()); assertEquivalent(stats.mean(), streamStats.getAverage()); assertEquivalent(stats.sum(), streamStats.getSum()); assertEquivalent(stats.max(), streamStats.getMax()); assertEquivalent(stats.min(), streamStats.getMin()); } }
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(Stats values) { if (values.count() == 0) { return; } if (count == 0) { count = values.count(); mean = values.mean(); sumOfSquaresOfDeltas = values.sumOfSquaresOfDeltas(); min = values.min(); max = values.max(); } else { count += values.count(); if (isFinite(mean) && isFinite(values.mean())) { // This is a generalized version of the calculation in add(double) above. double delta = values.mean() - mean; mean += delta * values.count() / count; sumOfSquaresOfDeltas += values.sumOfSquaresOfDeltas() + delta * (values.mean() - mean) * values.count(); } else { mean = calculateNewMeanNonFinite(mean, values.mean()); sumOfSquaresOfDeltas = NaN; } min = Math.min(min, values.min()); max = Math.max(max, values.max()); } }
public void testEquivalentStreams() { // 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) { double[] array = values.asArray(); Stats stats = Stats.of(array); // instance methods on Stats vs on instance methods on DoubleStream assertThat(stats.count()).isEqualTo(stream(array).count()); assertEquivalent(stats.mean(), stream(array).average().getAsDouble()); assertEquivalent(stats.sum(), stream(array).sum()); assertEquivalent(stats.max(), stream(array).max().getAsDouble()); assertEquivalent(stats.min(), stream(array).min().getAsDouble()); // static method on Stats vs on instance method on DoubleStream assertEquivalent(Stats.meanOf(array), stream(array).average().getAsDouble()); // instance methods on Stats vs instance methods on DoubleSummaryStatistics DoubleSummaryStatistics streamStats = stream(array).summaryStatistics(); assertThat(stats.count()).isEqualTo(streamStats.getCount()); assertEquivalent(stats.mean(), streamStats.getAverage()); assertEquivalent(stats.sum(), streamStats.getSum()); assertEquivalent(stats.max(), streamStats.getMax()); assertEquivalent(stats.min(), streamStats.getMin()); } }
if (xSumOfSquaresOfDeltas > 0.0) { if (yStats.sumOfSquaresOfDeltas() > 0.0) { return LinearTransformation.mapping(xStats.mean(), yStats.mean()) .withSlope(sumOfProductsOfDeltas / xSumOfSquaresOfDeltas); } else { return LinearTransformation.horizontal(yStats.mean()); return LinearTransformation.vertical(xStats.mean());
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(Stats values) { if (values.count() == 0) { return; } if (count == 0) { count = values.count(); mean = values.mean(); sumOfSquaresOfDeltas = values.sumOfSquaresOfDeltas(); min = values.min(); max = values.max(); } else { count += values.count(); if (isFinite(mean) && isFinite(values.mean())) { // This is a generalized version of the calculation in add(double) above. double delta = values.mean() - mean; mean += delta * values.count() / count; sumOfSquaresOfDeltas += values.sumOfSquaresOfDeltas() + delta * (values.mean() - mean) * values.count(); } else { mean = calculateNewMeanNonFinite(mean, values.mean()); sumOfSquaresOfDeltas = NaN; } min = Math.min(min, values.min()); max = Math.max(max, values.max()); } }
if (xSumOfSquaresOfDeltas > 0.0) { if (yStats.sumOfSquaresOfDeltas() > 0.0) { return LinearTransformation.mapping(xStats.mean(), yStats.mean()) .withSlope(sumOfProductsOfDeltas / xSumOfSquaresOfDeltas); } else { return LinearTransformation.horizontal(yStats.mean()); return LinearTransformation.vertical(xStats.mean());
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(Stats values) { if (values.count() == 0) { return; } if (count == 0) { count = values.count(); mean = values.mean(); sumOfSquaresOfDeltas = values.sumOfSquaresOfDeltas(); min = values.min(); max = values.max(); } else { count += values.count(); if (isFinite(mean) && isFinite(values.mean())) { // This is a generalized version of the calculation in add(double) above. double delta = values.mean() - mean; mean += delta * values.count() / count; sumOfSquaresOfDeltas += values.sumOfSquaresOfDeltas() + delta * (values.mean() - mean) * values.count(); } else { mean = calculateNewMeanNonFinite(mean, values.mean()); sumOfSquaresOfDeltas = NaN; } min = Math.min(min, values.min()); max = Math.max(max, values.max()); } }
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(PairedStats values) { if (values.count() == 0) { return; } xStats.addAll(values.xStats()); if (yStats.count() == 0) { sumOfProductsOfDeltas = values.sumOfProductsOfDeltas(); } else { // This is a generalized version of the calculation in add(double, double) above. Note that // non-finite inputs will have sumOfProductsOfDeltas = NaN, so non-finite values will result // in NaN naturally. sumOfProductsOfDeltas += values.sumOfProductsOfDeltas() + (values.xStats().mean() - xStats.mean()) * (values.yStats().mean() - yStats.mean()) * values.count(); } yStats.addAll(values.yStats()); }
public void testMean() { try { EMPTY_STATS_VARARGS.mean(); fail("Expected IllegalStateException"); } catch (IllegalStateException expected) { EMPTY_STATS_ITERABLE.mean(); fail("Expected IllegalStateException"); } catch (IllegalStateException expected) { assertThat(ONE_VALUE_STATS.mean()).isWithin(ALLOWED_ERROR).of(ONE_VALUE); assertThat(Stats.of(POSITIVE_INFINITY).mean()).isPositiveInfinity(); assertThat(Stats.of(NEGATIVE_INFINITY).mean()).isNegativeInfinity(); assertThat(Stats.of(NaN).mean()).isNaN(); assertThat(TWO_VALUES_STATS.mean()).isWithin(ALLOWED_ERROR).of(TWO_VALUES_MEAN); double mean = Stats.of(values.asArray()).mean(); if (values.hasAnyNaN()) { assertThat(mean).named("mean of " + values).isNaN(); assertThat(MANY_VALUES_STATS_ITERABLE.mean()).isWithin(ALLOWED_ERROR).of(MANY_VALUES_MEAN); assertThat(MANY_VALUES_STATS_ITERATOR.mean()).isWithin(ALLOWED_ERROR).of(MANY_VALUES_MEAN); assertThat(MANY_VALUES_STATS_SNAPSHOT.mean()).isWithin(ALLOWED_ERROR).of(MANY_VALUES_MEAN); assertThat(LARGE_VALUES_STATS.mean()) .isWithin(ALLOWED_ERROR * Double.MAX_VALUE) .of(LARGE_VALUES_MEAN); assertThat(INTEGER_MANY_VALUES_STATS_VARARGS.mean()) .isWithin(ALLOWED_ERROR) .of(INTEGER_MANY_VALUES_MEAN); assertThat(INTEGER_MANY_VALUES_STATS_ITERABLE.mean())
public void testToString() { assertThat(EMPTY_STATS_VARARGS.toString()).isEqualTo("Stats{count=0}"); assertThat(MANY_VALUES_STATS_ITERABLE.toString()) .isEqualTo( "Stats{count=" + MANY_VALUES_STATS_ITERABLE.count() + ", mean=" + MANY_VALUES_STATS_ITERABLE.mean() + ", populationStandardDeviation=" + MANY_VALUES_STATS_ITERABLE.populationStandardDeviation() + ", min=" + MANY_VALUES_STATS_ITERABLE.min() + ", max=" + MANY_VALUES_STATS_ITERABLE.max() + "}"); }
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(PairedStats values) { if (values.count() == 0) { return; } xStats.addAll(values.xStats()); if (yStats.count() == 0) { sumOfProductsOfDeltas = values.sumOfProductsOfDeltas(); } else { // This is a generalized version of the calculation in add(double, double) above. Note that // non-finite inputs will have sumOfProductsOfDeltas = NaN, so non-finite values will result // in NaN naturally. sumOfProductsOfDeltas += values.sumOfProductsOfDeltas() + (values.xStats().mean() - xStats.mean()) * (values.yStats().mean() - yStats.mean()) * values.count(); } yStats.addAll(values.yStats()); }
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(PairedStats values) { if (values.count() == 0) { return; } xStats.addAll(values.xStats()); if (yStats.count() == 0) { sumOfProductsOfDeltas = values.sumOfProductsOfDeltas(); } else { // This is a generalized version of the calculation in add(double, double) above. Note that // non-finite inputs will have sumOfProductsOfDeltas = NaN, so non-finite values will result // in NaN naturally. sumOfProductsOfDeltas += values.sumOfProductsOfDeltas() + (values.xStats().mean() - xStats.mean()) * (values.yStats().mean() - yStats.mean()) * values.count(); } yStats.addAll(values.yStats()); }
if (expectedStats.count() == 0) { try { actualStats.mean(); fail("Expected IllegalStateException"); } catch (IllegalStateException expected) { assertThat(actualStats.mean()).isWithin(ALLOWED_ERROR).of(expectedStats.mean()); assertThat(actualStats.populationVariance()).isWithin(0.0).of(0.0); assertThat(actualStats.min()).isWithin(ALLOWED_ERROR).of(expectedStats.min()); assertThat(actualStats.max()).isWithin(ALLOWED_ERROR).of(expectedStats.max()); } else { assertThat(actualStats.mean()).isWithin(ALLOWED_ERROR).of(expectedStats.mean()); assertThat(actualStats.populationVariance()) .isWithin(ALLOWED_ERROR)
twoValuesAccumulator.xStats().mean(), twoValuesAccumulator.yStats().mean(), twoValuesAccumulator.xStats().populationVariance(), twoValuesAccumulator.populationCovariance()); assertDiagonalLinearTransformation( twoValuesAccumulatorByAddAllPartitionedPairedStats.leastSquaresFit(), twoValuesAccumulatorByAddAllPartitionedPairedStats.xStats().mean(), twoValuesAccumulatorByAddAllPartitionedPairedStats.yStats().mean(), twoValuesAccumulatorByAddAllPartitionedPairedStats.xStats().populationVariance(), twoValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance()); assertDiagonalLinearTransformation( manyValuesAccumulator.leastSquaresFit(), manyValuesAccumulator.xStats().mean(), manyValuesAccumulator.yStats().mean(), manyValuesAccumulator.xStats().populationVariance(), manyValuesAccumulator.populationCovariance()); assertDiagonalLinearTransformation( manyValuesAccumulatorByAddAllPartitionedPairedStats.leastSquaresFit(), manyValuesAccumulatorByAddAllPartitionedPairedStats.xStats().mean(), manyValuesAccumulatorByAddAllPartitionedPairedStats.yStats().mean(), manyValuesAccumulatorByAddAllPartitionedPairedStats.xStats().populationVariance(), manyValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance()); assertDiagonalLinearTransformation( fit, accumulator.xStats().mean(), accumulator.yStats().mean(), accumulator.xStats().populationVariance(), accumulator.populationCovariance());
TWO_VALUES_PAIRED_STATS.xStats().mean(), TWO_VALUES_PAIRED_STATS.yStats().mean(), TWO_VALUES_PAIRED_STATS.xStats().populationVariance(), TWO_VALUES_PAIRED_STATS.populationCovariance()); assertDiagonalLinearTransformation( fit, stats.xStats().mean(), stats.yStats().mean(), stats.xStats().populationVariance(), stats.populationCovariance()); HORIZONTAL_VALUES_PAIRED_STATS.yStats().mean()); assertVerticalLinearTransformation( VERTICAL_VALUES_PAIRED_STATS.leastSquaresFit(), VERTICAL_VALUES_PAIRED_STATS.xStats().mean()); try { CONSTANT_VALUES_PAIRED_STATS.leastSquaresFit();
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(Stats values) { if (values.count() == 0) { return; } if (count == 0) { count = values.count(); mean = values.mean(); sumOfSquaresOfDeltas = values.sumOfSquaresOfDeltas(); min = values.min(); max = values.max(); } else { count += values.count(); if (isFinite(mean) && isFinite(values.mean())) { // This is a generalized version of the calculation in add(double) above. double delta = values.mean() - mean; mean += delta * values.count() / count; sumOfSquaresOfDeltas += values.sumOfSquaresOfDeltas() + delta * (values.mean() - mean) * values.count(); } else { mean = calculateNewMeanNonFinite(mean, values.mean()); sumOfSquaresOfDeltas = NaN; } min = Math.min(min, values.min()); max = Math.max(max, values.max()); } }
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(PairedStats values) { if (values.count() == 0) { return; } xStats.addAll(values.xStats()); if (yStats.count() == 0) { sumOfProductsOfDeltas = values.sumOfProductsOfDeltas(); } else { // This is a generalized version of the calculation in add(double, double) above. Note that // non-finite inputs will have sumOfProductsOfDeltas = NaN, so non-finite values will result // in NaN naturally. sumOfProductsOfDeltas += values.sumOfProductsOfDeltas() + (values.xStats().mean() - xStats.mean()) * (values.yStats().mean() - yStats.mean()) * values.count(); } yStats.addAll(values.yStats()); }
/** * Adds the given statistics to the dataset, as if the individual values used to compute the * statistics had been added directly. */ public void addAll(PairedStats values) { if (values.count() == 0) { return; } xStats.addAll(values.xStats()); if (yStats.count() == 0) { sumOfProductsOfDeltas = values.sumOfProductsOfDeltas(); } else { // This is a generalized version of the calculation in add(double, double) above. Note that // non-finite inputs will have sumOfProductsOfDeltas = NaN, so non-finite values will result // in NaN naturally. sumOfProductsOfDeltas += values.sumOfProductsOfDeltas() + (values.xStats().mean() - xStats.mean()) * (values.yStats().mean() - yStats.mean()) * values.count(); } yStats.addAll(values.yStats()); }
public void testToString() { assertThat(EMPTY_STATS_VARARGS.toString()).isEqualTo("Stats{count=0}"); assertThat(MANY_VALUES_STATS_ITERABLE.toString()) .isEqualTo( "Stats{count=" + MANY_VALUES_STATS_ITERABLE.count() + ", mean=" + MANY_VALUES_STATS_ITERABLE.mean() + ", populationStandardDeviation=" + MANY_VALUES_STATS_ITERABLE.populationStandardDeviation() + ", min=" + MANY_VALUES_STATS_ITERABLE.min() + ", max=" + MANY_VALUES_STATS_ITERABLE.max() + "}"); }