| /* |
| * 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.EMPTY_STATS_ITERABLE; |
| 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_STATS_ITERABLE; |
| import static com.google.common.math.StatsTesting.MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS; |
| import static com.google.common.math.StatsTesting.ONE_VALUE; |
| import static com.google.common.math.StatsTesting.ONE_VALUE_STATS; |
| import static com.google.common.math.StatsTesting.OTHER_MANY_VALUES; |
| import static com.google.common.math.StatsTesting.OTHER_MANY_VALUES_COUNT; |
| import static com.google.common.math.StatsTesting.OTHER_MANY_VALUES_STATS; |
| import static com.google.common.math.StatsTesting.OTHER_ONE_VALUE; |
| import static com.google.common.math.StatsTesting.OTHER_ONE_VALUE_STATS; |
| import static com.google.common.math.StatsTesting.OTHER_TWO_VALUES; |
| import static com.google.common.math.StatsTesting.OTHER_TWO_VALUES_STATS; |
| import static com.google.common.math.StatsTesting.TWO_VALUES; |
| import static com.google.common.math.StatsTesting.TWO_VALUES_STATS; |
| import static com.google.common.math.StatsTesting.TWO_VALUES_SUM_OF_PRODUCTS_OF_DELTAS; |
| import static com.google.common.math.StatsTesting.assertDiagonalLinearTransformation; |
| import static com.google.common.math.StatsTesting.assertHorizontalLinearTransformation; |
| import static com.google.common.math.StatsTesting.assertLinearTransformationNaN; |
| import static com.google.common.math.StatsTesting.assertStatsApproxEqual; |
| import static com.google.common.math.StatsTesting.assertVerticalLinearTransformation; |
| import static com.google.common.math.StatsTesting.createFilledPairedStatsAccumulator; |
| import static com.google.common.math.StatsTesting.createPartitionedFilledPairedStatsAccumulator; |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import com.google.common.math.StatsTesting.ManyValues; |
| import java.util.Collections; |
| import junit.framework.TestCase; |
| |
| /** |
| * Tests for {@link PairedStatsAccumulator}. This tests the stats methods for instances built with |
| * {@link PairedStatsAccumulator#add}, and various error cases of that method. For tests of the |
| * {@link PairedStatsAccumulator#snapshot} method which returns {@link PairedStats} instances, see |
| * {@link PairedStatsTest}. |
| * |
| * @author Pete Gillin |
| */ |
| public class PairedStatsAccumulatorTest extends TestCase { |
| |
| private PairedStatsAccumulator emptyAccumulator; |
| private PairedStatsAccumulator emptyAccumulatorByAddAllEmptyPairedStats; |
| private PairedStatsAccumulator oneValueAccumulator; |
| private PairedStatsAccumulator oneValueAccumulatorByAddAllEmptyPairedStats; |
| private PairedStatsAccumulator twoValuesAccumulator; |
| private PairedStatsAccumulator twoValuesAccumulatorByAddAllPartitionedPairedStats; |
| private PairedStatsAccumulator manyValuesAccumulator; |
| private PairedStatsAccumulator manyValuesAccumulatorByAddAllPartitionedPairedStats; |
| private PairedStatsAccumulator horizontalValuesAccumulator; |
| private PairedStatsAccumulator horizontalValuesAccumulatorByAddAllPartitionedPairedStats; |
| private PairedStatsAccumulator verticalValuesAccumulator; |
| private PairedStatsAccumulator verticalValuesAccumulatorByAddAllPartitionedPairedStats; |
| private PairedStatsAccumulator constantValuesAccumulator; |
| private PairedStatsAccumulator constantValuesAccumulatorByAddAllPartitionedPairedStats; |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| |
| emptyAccumulator = new PairedStatsAccumulator(); |
| |
| emptyAccumulatorByAddAllEmptyPairedStats = new PairedStatsAccumulator(); |
| emptyAccumulatorByAddAllEmptyPairedStats.addAll(emptyAccumulator.snapshot()); |
| |
| oneValueAccumulator = new PairedStatsAccumulator(); |
| oneValueAccumulator.add(ONE_VALUE, OTHER_ONE_VALUE); |
| |
| oneValueAccumulatorByAddAllEmptyPairedStats = new PairedStatsAccumulator(); |
| oneValueAccumulatorByAddAllEmptyPairedStats.add(ONE_VALUE, OTHER_ONE_VALUE); |
| oneValueAccumulatorByAddAllEmptyPairedStats.addAll(emptyAccumulator.snapshot()); |
| |
| twoValuesAccumulator = createFilledPairedStatsAccumulator(TWO_VALUES, OTHER_TWO_VALUES); |
| twoValuesAccumulatorByAddAllPartitionedPairedStats = |
| createPartitionedFilledPairedStatsAccumulator(TWO_VALUES, OTHER_TWO_VALUES, 1); |
| |
| manyValuesAccumulator = createFilledPairedStatsAccumulator(MANY_VALUES, OTHER_MANY_VALUES); |
| manyValuesAccumulatorByAddAllPartitionedPairedStats = |
| createPartitionedFilledPairedStatsAccumulator(MANY_VALUES, OTHER_MANY_VALUES, 2); |
| |
| horizontalValuesAccumulator = |
| createFilledPairedStatsAccumulator( |
| MANY_VALUES, Collections.nCopies(MANY_VALUES_COUNT, OTHER_ONE_VALUE)); |
| horizontalValuesAccumulatorByAddAllPartitionedPairedStats = |
| createPartitionedFilledPairedStatsAccumulator( |
| MANY_VALUES, Collections.nCopies(MANY_VALUES_COUNT, OTHER_ONE_VALUE), 2); |
| |
| verticalValuesAccumulator = |
| createFilledPairedStatsAccumulator( |
| Collections.nCopies(OTHER_MANY_VALUES_COUNT, ONE_VALUE), OTHER_MANY_VALUES); |
| verticalValuesAccumulatorByAddAllPartitionedPairedStats = |
| createPartitionedFilledPairedStatsAccumulator( |
| Collections.nCopies(OTHER_MANY_VALUES_COUNT, ONE_VALUE), OTHER_MANY_VALUES, 2); |
| |
| constantValuesAccumulator = |
| createFilledPairedStatsAccumulator( |
| Collections.nCopies(MANY_VALUES_COUNT, ONE_VALUE), |
| Collections.nCopies(MANY_VALUES_COUNT, OTHER_ONE_VALUE)); |
| constantValuesAccumulatorByAddAllPartitionedPairedStats = |
| createPartitionedFilledPairedStatsAccumulator( |
| Collections.nCopies(MANY_VALUES_COUNT, ONE_VALUE), |
| Collections.nCopies(MANY_VALUES_COUNT, OTHER_ONE_VALUE), |
| 2); |
| } |
| |
| public void testCount() { |
| assertThat(emptyAccumulator.count()).isEqualTo(0); |
| assertThat(emptyAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(0); |
| assertThat(oneValueAccumulator.count()).isEqualTo(1); |
| assertThat(oneValueAccumulatorByAddAllEmptyPairedStats.count()).isEqualTo(1); |
| assertThat(twoValuesAccumulator.count()).isEqualTo(2); |
| assertThat(twoValuesAccumulatorByAddAllPartitionedPairedStats.count()).isEqualTo(2); |
| assertThat(manyValuesAccumulator.count()).isEqualTo(MANY_VALUES_COUNT); |
| assertThat(manyValuesAccumulatorByAddAllPartitionedPairedStats.count()) |
| .isEqualTo(MANY_VALUES_COUNT); |
| } |
| |
| public void testCountOverflow_doesNotThrow() { |
| PairedStatsAccumulator accumulator = new PairedStatsAccumulator(); |
| accumulator.add(ONE_VALUE, OTHER_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 testXStats() { |
| assertStatsApproxEqual(EMPTY_STATS_ITERABLE, emptyAccumulator.xStats()); |
| assertStatsApproxEqual(EMPTY_STATS_ITERABLE, emptyAccumulatorByAddAllEmptyPairedStats.xStats()); |
| assertStatsApproxEqual(ONE_VALUE_STATS, oneValueAccumulator.xStats()); |
| assertStatsApproxEqual(ONE_VALUE_STATS, oneValueAccumulatorByAddAllEmptyPairedStats.xStats()); |
| assertStatsApproxEqual(TWO_VALUES_STATS, twoValuesAccumulator.xStats()); |
| assertStatsApproxEqual( |
| TWO_VALUES_STATS, twoValuesAccumulatorByAddAllPartitionedPairedStats.xStats()); |
| assertStatsApproxEqual(MANY_VALUES_STATS_ITERABLE, manyValuesAccumulator.xStats()); |
| assertStatsApproxEqual( |
| MANY_VALUES_STATS_ITERABLE, manyValuesAccumulatorByAddAllPartitionedPairedStats.xStats()); |
| } |
| |
| public void testYStats() { |
| assertStatsApproxEqual(EMPTY_STATS_ITERABLE, emptyAccumulator.yStats()); |
| assertStatsApproxEqual(EMPTY_STATS_ITERABLE, emptyAccumulatorByAddAllEmptyPairedStats.yStats()); |
| assertStatsApproxEqual(OTHER_ONE_VALUE_STATS, oneValueAccumulator.yStats()); |
| assertStatsApproxEqual( |
| OTHER_ONE_VALUE_STATS, oneValueAccumulatorByAddAllEmptyPairedStats.yStats()); |
| assertStatsApproxEqual(OTHER_TWO_VALUES_STATS, twoValuesAccumulator.yStats()); |
| assertStatsApproxEqual( |
| OTHER_TWO_VALUES_STATS, twoValuesAccumulatorByAddAllPartitionedPairedStats.yStats()); |
| assertStatsApproxEqual(OTHER_MANY_VALUES_STATS, manyValuesAccumulator.yStats()); |
| assertStatsApproxEqual( |
| OTHER_MANY_VALUES_STATS, manyValuesAccumulatorByAddAllPartitionedPairedStats.yStats()); |
| } |
| |
| public void testPopulationCovariance() { |
| try { |
| emptyAccumulator.populationCovariance(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| emptyAccumulatorByAddAllEmptyPairedStats.populationCovariance(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| assertThat(oneValueAccumulator.populationCovariance()).isWithin(0.0).of(0.0); |
| assertThat(oneValueAccumulatorByAddAllEmptyPairedStats.populationCovariance()) |
| .isWithin(0.0) |
| .of(0.0); |
| assertThat(twoValuesAccumulator.populationCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(TWO_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / 2); |
| assertThat(twoValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(TWO_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / 2); |
| assertThat(manyValuesAccumulator.populationCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / MANY_VALUES_COUNT); |
| assertThat(manyValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / MANY_VALUES_COUNT); |
| // For datasets of many double values, we test many combinations of finite and non-finite |
| // x-values: |
| for (ManyValues values : ALL_MANY_VALUES) { |
| PairedStatsAccumulator accumulator = |
| createFilledPairedStatsAccumulator(values.asIterable(), OTHER_MANY_VALUES); |
| PairedStatsAccumulator accumulatorByAddAllPartitionedPairedStats = |
| createPartitionedFilledPairedStatsAccumulator(values.asIterable(), OTHER_MANY_VALUES, 2); |
| double populationCovariance = accumulator.populationCovariance(); |
| double populationCovarianceByAddAllPartitionedPairedStats = |
| accumulatorByAddAllPartitionedPairedStats.populationCovariance(); |
| if (values.hasAnyNonFinite()) { |
| assertThat(populationCovariance).named("population covariance of " + values).isNaN(); |
| assertThat(populationCovarianceByAddAllPartitionedPairedStats) |
| .named("population covariance by addAll(PairedStats) of " + values) |
| .isNaN(); |
| } else { |
| assertThat(populationCovariance) |
| .named("population covariance of " + values) |
| .isWithin(ALLOWED_ERROR) |
| .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / MANY_VALUES_COUNT); |
| assertThat(populationCovarianceByAddAllPartitionedPairedStats) |
| .named("population covariance by addAll(PairedStats) of " + values) |
| .isWithin(ALLOWED_ERROR) |
| .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / MANY_VALUES_COUNT); |
| } |
| } |
| assertThat(horizontalValuesAccumulator.populationCovariance()).isWithin(ALLOWED_ERROR).of(0.0); |
| assertThat(horizontalValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(0.0); |
| assertThat(verticalValuesAccumulator.populationCovariance()).isWithin(ALLOWED_ERROR).of(0.0); |
| assertThat(verticalValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(0.0); |
| assertThat(constantValuesAccumulator.populationCovariance()).isWithin(ALLOWED_ERROR).of(0.0); |
| assertThat(constantValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(0.0); |
| } |
| |
| public void testSampleCovariance() { |
| try { |
| emptyAccumulator.sampleCovariance(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| emptyAccumulatorByAddAllEmptyPairedStats.sampleCovariance(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| oneValueAccumulator.sampleCovariance(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| oneValueAccumulatorByAddAllEmptyPairedStats.sampleCovariance(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| assertThat(twoValuesAccumulator.sampleCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(TWO_VALUES_SUM_OF_PRODUCTS_OF_DELTAS); |
| assertThat(twoValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(TWO_VALUES_SUM_OF_PRODUCTS_OF_DELTAS); |
| assertThat(manyValuesAccumulator.sampleCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / (MANY_VALUES_COUNT - 1)); |
| assertThat(manyValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS / (MANY_VALUES_COUNT - 1)); |
| assertThat(horizontalValuesAccumulator.sampleCovariance()).isWithin(ALLOWED_ERROR).of(0.0); |
| assertThat(horizontalValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(0.0); |
| assertThat(verticalValuesAccumulator.sampleCovariance()).isWithin(ALLOWED_ERROR).of(0.0); |
| assertThat(verticalValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(0.0); |
| assertThat(constantValuesAccumulator.sampleCovariance()).isWithin(ALLOWED_ERROR).of(0.0); |
| assertThat(constantValuesAccumulatorByAddAllPartitionedPairedStats.sampleCovariance()) |
| .isWithin(ALLOWED_ERROR) |
| .of(0.0); |
| } |
| |
| public void testPearsonsCorrelationCoefficient() { |
| try { |
| emptyAccumulator.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| emptyAccumulatorByAddAllEmptyPairedStats.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| oneValueAccumulator.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| oneValueAccumulatorByAddAllEmptyPairedStats.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| assertThat(twoValuesAccumulator.pearsonsCorrelationCoefficient()) |
| .isWithin(ALLOWED_ERROR) |
| .of( |
| twoValuesAccumulator.populationCovariance() |
| / (twoValuesAccumulator.xStats().populationStandardDeviation() |
| * twoValuesAccumulator.yStats().populationStandardDeviation())); |
| assertThat(manyValuesAccumulator.pearsonsCorrelationCoefficient()) |
| .isWithin(ALLOWED_ERROR) |
| .of( |
| manyValuesAccumulator.populationCovariance() |
| / (manyValuesAccumulator.xStats().populationStandardDeviation() |
| * manyValuesAccumulator.yStats().populationStandardDeviation())); |
| assertThat(manyValuesAccumulatorByAddAllPartitionedPairedStats.pearsonsCorrelationCoefficient()) |
| .isWithin(ALLOWED_ERROR) |
| .of( |
| manyValuesAccumulatorByAddAllPartitionedPairedStats.populationCovariance() |
| / (manyValuesAccumulatorByAddAllPartitionedPairedStats |
| .xStats() |
| .populationStandardDeviation() |
| * manyValuesAccumulatorByAddAllPartitionedPairedStats |
| .yStats() |
| .populationStandardDeviation())); |
| // For datasets of many double values, we test many combinations of finite and non-finite |
| // y-values: |
| for (ManyValues values : ALL_MANY_VALUES) { |
| PairedStatsAccumulator accumulator = |
| createFilledPairedStatsAccumulator(MANY_VALUES, values.asIterable()); |
| PairedStatsAccumulator accumulatorByAddAllPartitionedPairedStats = |
| createPartitionedFilledPairedStatsAccumulator(MANY_VALUES, values.asIterable(), 2); |
| double pearsonsCorrelationCoefficient = accumulator.pearsonsCorrelationCoefficient(); |
| double pearsonsCorrelationCoefficientByAddAllPartitionedPairedStats = |
| accumulatorByAddAllPartitionedPairedStats.pearsonsCorrelationCoefficient(); |
| if (values.hasAnyNonFinite()) { |
| assertThat(pearsonsCorrelationCoefficient) |
| .named("Pearson's correlation coefficient of " + values) |
| .isNaN(); |
| assertThat(pearsonsCorrelationCoefficient) |
| .named("Pearson's correlation coefficient by addAll(PairedStats) of " + values) |
| .isNaN(); |
| } else { |
| assertThat(pearsonsCorrelationCoefficient) |
| .named("Pearson's correlation coefficient of " + values) |
| .isWithin(ALLOWED_ERROR) |
| .of( |
| accumulator.populationCovariance() |
| / (accumulator.xStats().populationStandardDeviation() |
| * accumulator.yStats().populationStandardDeviation())); |
| assertThat(pearsonsCorrelationCoefficientByAddAllPartitionedPairedStats) |
| .named("Pearson's correlation coefficient by addAll(PairedStats) of " + values) |
| .isWithin(ALLOWED_ERROR) |
| .of( |
| accumulatorByAddAllPartitionedPairedStats.populationCovariance() |
| / (accumulatorByAddAllPartitionedPairedStats |
| .xStats() |
| .populationStandardDeviation() |
| * accumulatorByAddAllPartitionedPairedStats |
| .yStats() |
| .populationStandardDeviation())); |
| } |
| } |
| try { |
| horizontalValuesAccumulator.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| horizontalValuesAccumulatorByAddAllPartitionedPairedStats.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| verticalValuesAccumulator.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| verticalValuesAccumulatorByAddAllPartitionedPairedStats.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| constantValuesAccumulator.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| constantValuesAccumulatorByAddAllPartitionedPairedStats.pearsonsCorrelationCoefficient(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| } |
| |
| public void testLeastSquaresFit() { |
| try { |
| emptyAccumulator.leastSquaresFit(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| emptyAccumulatorByAddAllEmptyPairedStats.leastSquaresFit(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| oneValueAccumulator.leastSquaresFit(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| oneValueAccumulatorByAddAllEmptyPairedStats.leastSquaresFit(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| assertDiagonalLinearTransformation( |
| twoValuesAccumulator.leastSquaresFit(), |
| 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()); |
| // For datasets of many double values, we test many combinations of finite and non-finite |
| // x-values: |
| for (ManyValues values : ALL_MANY_VALUES) { |
| PairedStatsAccumulator accumulator = |
| createFilledPairedStatsAccumulator(values.asIterable(), OTHER_MANY_VALUES); |
| PairedStatsAccumulator accumulatorByAddAllPartitionedPairedStats = |
| createPartitionedFilledPairedStatsAccumulator(values.asIterable(), OTHER_MANY_VALUES, 2); |
| LinearTransformation fit = accumulator.leastSquaresFit(); |
| LinearTransformation fitByAddAllPartitionedPairedStats = |
| accumulatorByAddAllPartitionedPairedStats.leastSquaresFit(); |
| if (values.hasAnyNonFinite()) { |
| assertLinearTransformationNaN(fit); |
| assertLinearTransformationNaN(fitByAddAllPartitionedPairedStats); |
| } else { |
| assertDiagonalLinearTransformation( |
| fit, |
| accumulator.xStats().mean(), |
| accumulator.yStats().mean(), |
| accumulator.xStats().populationVariance(), |
| accumulator.populationCovariance()); |
| assertDiagonalLinearTransformation( |
| fitByAddAllPartitionedPairedStats, |
| accumulatorByAddAllPartitionedPairedStats.xStats().mean(), |
| accumulatorByAddAllPartitionedPairedStats.yStats().mean(), |
| accumulatorByAddAllPartitionedPairedStats.xStats().populationVariance(), |
| accumulatorByAddAllPartitionedPairedStats.populationCovariance()); |
| } |
| } |
| assertHorizontalLinearTransformation( |
| horizontalValuesAccumulator.leastSquaresFit(), horizontalValuesAccumulator.yStats().mean()); |
| assertHorizontalLinearTransformation( |
| horizontalValuesAccumulatorByAddAllPartitionedPairedStats.leastSquaresFit(), |
| horizontalValuesAccumulatorByAddAllPartitionedPairedStats.yStats().mean()); |
| assertVerticalLinearTransformation( |
| verticalValuesAccumulator.leastSquaresFit(), verticalValuesAccumulator.xStats().mean()); |
| assertVerticalLinearTransformation( |
| verticalValuesAccumulatorByAddAllPartitionedPairedStats.leastSquaresFit(), |
| verticalValuesAccumulatorByAddAllPartitionedPairedStats.xStats().mean()); |
| try { |
| constantValuesAccumulator.leastSquaresFit(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| constantValuesAccumulatorByAddAllPartitionedPairedStats.leastSquaresFit(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| } |
| } |
