| /* |
| * Copyright (C) 2013 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.base.Preconditions.checkArgument; |
| import static com.google.common.truth.Truth.assertThat; |
| import static java.lang.Double.NEGATIVE_INFINITY; |
| import static java.lang.Double.NaN; |
| import static java.lang.Double.POSITIVE_INFINITY; |
| import static org.junit.Assert.fail; |
| |
| import com.google.common.base.Predicates; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Lists; |
| import com.google.common.primitives.Doubles; |
| import com.google.common.primitives.Ints; |
| import java.math.BigInteger; |
| import java.util.List; |
| |
| /** |
| * Inputs, expected outputs, and helper methods for tests of {@link StatsAccumulator}, {@link |
| * Stats}, {@link PairedStatsAccumulator}, and {@link PairedStats}. |
| * |
| * @author Pete Gillin |
| */ |
| class StatsTesting { |
| |
| static final double ALLOWED_ERROR = 1e-10; |
| |
| // Inputs and their statistics: |
| |
| static final double ONE_VALUE = 12.34; |
| |
| static final double OTHER_ONE_VALUE = -56.78; |
| |
| static final ImmutableList<Double> TWO_VALUES = ImmutableList.of(12.34, -56.78); |
| static final double TWO_VALUES_MEAN = (12.34 - 56.78) / 2; |
| static final double TWO_VALUES_SUM_OF_SQUARES_OF_DELTAS = |
| (12.34 - TWO_VALUES_MEAN) * (12.34 - TWO_VALUES_MEAN) |
| + (-56.78 - TWO_VALUES_MEAN) * (-56.78 - TWO_VALUES_MEAN); |
| static final double TWO_VALUES_MAX = 12.34; |
| static final double TWO_VALUES_MIN = -56.78; |
| |
| static final ImmutableList<Double> OTHER_TWO_VALUES = ImmutableList.of(123.456, -789.012); |
| static final double OTHER_TWO_VALUES_MEAN = (123.456 - 789.012) / 2; |
| static final double TWO_VALUES_SUM_OF_PRODUCTS_OF_DELTAS = |
| (12.34 - TWO_VALUES_MEAN) * (123.456 - OTHER_TWO_VALUES_MEAN) |
| + (-56.78 - TWO_VALUES_MEAN) * (-789.012 - OTHER_TWO_VALUES_MEAN); |
| |
| /** |
| * Helper class for testing with non-finite values. {@link #ALL_MANY_VALUES} gives a number |
| * instances with many combinations of finite and non-finite values. All have {@link |
| * #MANY_VALUES_COUNT} values. If all the values are finite then the mean is {@link |
| * #MANY_VALUES_MEAN} and the sum-of-squares-of-deltas is {@link |
| * #MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS}. The smallest and largest finite values are always |
| * {@link #MANY_VALUES_MIN} and {@link #MANY_VALUES_MAX}, although setting non-finite values will |
| * change the true min and max. |
| */ |
| static class ManyValues { |
| |
| private final ImmutableList<Double> values; |
| |
| ManyValues(double[] values) { |
| this.values = ImmutableList.copyOf(Doubles.asList(values)); |
| } |
| |
| ImmutableList<Double> asIterable() { |
| return values; |
| } |
| |
| double[] asArray() { |
| return Doubles.toArray(values); |
| } |
| |
| boolean hasAnyPositiveInfinity() { |
| return Iterables.any(values, Predicates.equalTo(POSITIVE_INFINITY)); |
| } |
| |
| boolean hasAnyNegativeInfinity() { |
| return Iterables.any(values, Predicates.equalTo(NEGATIVE_INFINITY)); |
| } |
| |
| boolean hasAnyNaN() { |
| return Iterables.any(values, Predicates.equalTo(NaN)); |
| } |
| |
| boolean hasAnyNonFinite() { |
| return hasAnyPositiveInfinity() || hasAnyNegativeInfinity() || hasAnyNaN(); |
| } |
| |
| @Override |
| public String toString() { |
| return values.toString(); |
| } |
| |
| private static ImmutableList<ManyValues> createAll() { |
| ImmutableList.Builder<ManyValues> builder = ImmutableList.builder(); |
| double[] values = new double[5]; |
| for (double first : ImmutableList.of(1.1, POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN)) { |
| values[0] = first; |
| values[1] = -44.44; |
| for (double third : ImmutableList.of(33.33, POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN)) { |
| values[2] = third; |
| values[3] = 555.555; |
| for (double fifth : ImmutableList.of(-2.2, POSITIVE_INFINITY, NEGATIVE_INFINITY, NaN)) { |
| values[4] = fifth; |
| builder.add(new ManyValues(values)); |
| } |
| } |
| } |
| return builder.build(); |
| } |
| } |
| |
| static final ImmutableList<ManyValues> ALL_MANY_VALUES = ManyValues.createAll(); |
| |
| static final ImmutableList<Double> MANY_VALUES = |
| ImmutableList.of(1.1, -44.44, 33.33, 555.555, -2.2); |
| static final int MANY_VALUES_COUNT = 5; |
| static final double MANY_VALUES_MEAN = (1.1 - 44.44 + 33.33 + 555.555 - 2.2) / 5; |
| static final double MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS = |
| (1.1 - MANY_VALUES_MEAN) * (1.1 - MANY_VALUES_MEAN) |
| + (-44.44 - MANY_VALUES_MEAN) * (-44.44 - MANY_VALUES_MEAN) |
| + (33.33 - MANY_VALUES_MEAN) * (33.33 - MANY_VALUES_MEAN) |
| + (555.555 - MANY_VALUES_MEAN) * (555.555 - MANY_VALUES_MEAN) |
| + (-2.2 - MANY_VALUES_MEAN) * (-2.2 - MANY_VALUES_MEAN); |
| static final double MANY_VALUES_MAX = 555.555; |
| static final double MANY_VALUES_MIN = -44.44; |
| |
| // Doubles which will overflow if summed: |
| static final double[] LARGE_VALUES = {Double.MAX_VALUE, Double.MAX_VALUE / 2.0}; |
| static final double LARGE_VALUES_MEAN = 0.75 * Double.MAX_VALUE; |
| |
| static final ImmutableList<Double> OTHER_MANY_VALUES = |
| ImmutableList.of(1.11, -2.22, 33.3333, -44.4444, 555.555555); |
| static final int OTHER_MANY_VALUES_COUNT = 5; |
| static final double OTHER_MANY_VALUES_MEAN = (1.11 - 2.22 + 33.3333 - 44.4444 + 555.555555) / 5; |
| |
| static final double MANY_VALUES_SUM_OF_PRODUCTS_OF_DELTAS = |
| (1.1 - MANY_VALUES_MEAN) * (1.11 - OTHER_MANY_VALUES_MEAN) |
| + (-44.44 - MANY_VALUES_MEAN) * (-2.22 - OTHER_MANY_VALUES_MEAN) |
| + (33.33 - MANY_VALUES_MEAN) * (33.3333 - OTHER_MANY_VALUES_MEAN) |
| + (555.555 - MANY_VALUES_MEAN) * (-44.4444 - OTHER_MANY_VALUES_MEAN) |
| + (-2.2 - MANY_VALUES_MEAN) * (555.555555 - OTHER_MANY_VALUES_MEAN); |
| |
| static final ImmutableList<Integer> INTEGER_MANY_VALUES = |
| ImmutableList.of(11, -22, 3333, -4444, 555555); |
| static final int INTEGER_MANY_VALUES_COUNT = 5; |
| static final double INTEGER_MANY_VALUES_MEAN = (11.0 - 22.0 + 3333.0 - 4444.0 + 555555.0) / 5; |
| static final double INTEGER_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS = |
| (11.0 - INTEGER_MANY_VALUES_MEAN) * (11.0 - INTEGER_MANY_VALUES_MEAN) |
| + (-22.0 - INTEGER_MANY_VALUES_MEAN) * (-22.0 - INTEGER_MANY_VALUES_MEAN) |
| + (3333.0 - INTEGER_MANY_VALUES_MEAN) * (3333.0 - INTEGER_MANY_VALUES_MEAN) |
| + (-4444.0 - INTEGER_MANY_VALUES_MEAN) * (-4444.0 - INTEGER_MANY_VALUES_MEAN) |
| + (555555.0 - INTEGER_MANY_VALUES_MEAN) * (555555.0 - INTEGER_MANY_VALUES_MEAN); |
| static final double INTEGER_MANY_VALUES_MAX = 555555.0; |
| static final double INTEGER_MANY_VALUES_MIN = -4444.0; |
| |
| // Integers which will overflow if summed (using integer arithmetic): |
| static final int[] LARGE_INTEGER_VALUES = {Integer.MAX_VALUE, Integer.MAX_VALUE / 2}; |
| static final double LARGE_INTEGER_VALUES_MEAN = |
| BigInteger.valueOf(Integer.MAX_VALUE) |
| .multiply(BigInteger.valueOf(3L)) |
| .divide(BigInteger.valueOf(4L)) |
| .doubleValue(); |
| static final double LARGE_INTEGER_VALUES_POPULATION_VARIANCE = |
| BigInteger.valueOf(Integer.MAX_VALUE) |
| .multiply(BigInteger.valueOf(Integer.MAX_VALUE)) |
| .divide(BigInteger.valueOf(16L)) |
| .doubleValue(); |
| |
| static final ImmutableList<Long> LONG_MANY_VALUES = |
| ImmutableList.of(1111L, -2222L, 33333333L, -44444444L, 5555555555L); |
| static final int LONG_MANY_VALUES_COUNT = 5; |
| static final double LONG_MANY_VALUES_MEAN = |
| (1111.0 - 2222.0 + 33333333.0 - 44444444.0 + 5555555555.0) / 5; |
| static final double LONG_MANY_VALUES_SUM_OF_SQUARES_OF_DELTAS = |
| (1111.0 - LONG_MANY_VALUES_MEAN) * (1111.0 - LONG_MANY_VALUES_MEAN) |
| + (-2222.0 - LONG_MANY_VALUES_MEAN) * (-2222.0 - LONG_MANY_VALUES_MEAN) |
| + (33333333.0 - LONG_MANY_VALUES_MEAN) * (33333333.0 - LONG_MANY_VALUES_MEAN) |
| + (-44444444.0 - LONG_MANY_VALUES_MEAN) * (-44444444.0 - LONG_MANY_VALUES_MEAN) |
| + (5555555555.0 - LONG_MANY_VALUES_MEAN) * (5555555555.0 - LONG_MANY_VALUES_MEAN); |
| static final double LONG_MANY_VALUES_MAX = 5555555555.0; |
| static final double LONG_MANY_VALUES_MIN = -44444444.0; |
| |
| // Longs which will overflow if summed (using long arithmetic): |
| static final long[] LARGE_LONG_VALUES = {Long.MAX_VALUE, Long.MAX_VALUE / 2}; |
| static final double LARGE_LONG_VALUES_MEAN = |
| BigInteger.valueOf(Long.MAX_VALUE) |
| .multiply(BigInteger.valueOf(3L)) |
| .divide(BigInteger.valueOf(4L)) |
| .doubleValue(); |
| static final double LARGE_LONG_VALUES_POPULATION_VARIANCE = |
| BigInteger.valueOf(Long.MAX_VALUE) |
| .multiply(BigInteger.valueOf(Long.MAX_VALUE)) |
| .divide(BigInteger.valueOf(16L)) |
| .doubleValue(); |
| |
| // Stats instances: |
| |
| static final Stats EMPTY_STATS_VARARGS = Stats.of(); |
| static final Stats EMPTY_STATS_ITERABLE = Stats.of(ImmutableList.<Double>of()); |
| static final Stats ONE_VALUE_STATS = Stats.of(ONE_VALUE); |
| static final Stats OTHER_ONE_VALUE_STATS = Stats.of(OTHER_ONE_VALUE); |
| static final Stats TWO_VALUES_STATS = Stats.of(TWO_VALUES); |
| static final Stats OTHER_TWO_VALUES_STATS = Stats.of(OTHER_TWO_VALUES); |
| static final Stats MANY_VALUES_STATS_VARARGS = Stats.of(1.1, -44.44, 33.33, 555.555, -2.2); |
| static final Stats MANY_VALUES_STATS_ITERABLE = Stats.of(MANY_VALUES); |
| static final Stats MANY_VALUES_STATS_ITERATOR = Stats.of(MANY_VALUES.iterator()); |
| static final Stats MANY_VALUES_STATS_SNAPSHOT = buildManyValuesStatsSnapshot(); |
| static final Stats LARGE_VALUES_STATS = Stats.of(LARGE_VALUES); |
| static final Stats OTHER_MANY_VALUES_STATS = Stats.of(OTHER_MANY_VALUES); |
| static final Stats INTEGER_MANY_VALUES_STATS_VARARGS = |
| Stats.of(Ints.toArray(INTEGER_MANY_VALUES)); |
| static final Stats INTEGER_MANY_VALUES_STATS_ITERABLE = Stats.of(INTEGER_MANY_VALUES); |
| static final Stats LARGE_INTEGER_VALUES_STATS = Stats.of(LARGE_INTEGER_VALUES); |
| static final Stats LONG_MANY_VALUES_STATS_ITERATOR = Stats.of(LONG_MANY_VALUES.iterator()); |
| static final Stats LONG_MANY_VALUES_STATS_SNAPSHOT = buildLongManyValuesStatsSnapshot(); |
| static final Stats LARGE_LONG_VALUES_STATS = Stats.of(LARGE_LONG_VALUES); |
| |
| private static Stats buildManyValuesStatsSnapshot() { |
| StatsAccumulator accumulator = new StatsAccumulator(); |
| accumulator.addAll(MANY_VALUES); |
| Stats stats = accumulator.snapshot(); |
| accumulator.add(999.999); // should do nothing to the snapshot |
| return stats; |
| } |
| |
| private static Stats buildLongManyValuesStatsSnapshot() { |
| StatsAccumulator accumulator = new StatsAccumulator(); |
| accumulator.addAll(LONG_MANY_VALUES); |
| return accumulator.snapshot(); |
| } |
| |
| static final ImmutableList<Stats> ALL_STATS = |
| ImmutableList.of( |
| EMPTY_STATS_VARARGS, |
| EMPTY_STATS_ITERABLE, |
| ONE_VALUE_STATS, |
| OTHER_ONE_VALUE_STATS, |
| TWO_VALUES_STATS, |
| OTHER_TWO_VALUES_STATS, |
| MANY_VALUES_STATS_VARARGS, |
| MANY_VALUES_STATS_ITERABLE, |
| MANY_VALUES_STATS_ITERATOR, |
| MANY_VALUES_STATS_SNAPSHOT, |
| LARGE_VALUES_STATS, |
| OTHER_MANY_VALUES_STATS, |
| INTEGER_MANY_VALUES_STATS_VARARGS, |
| INTEGER_MANY_VALUES_STATS_ITERABLE, |
| LARGE_INTEGER_VALUES_STATS, |
| LONG_MANY_VALUES_STATS_ITERATOR, |
| LONG_MANY_VALUES_STATS_SNAPSHOT, |
| LARGE_LONG_VALUES_STATS); |
| |
| // PairedStats instances: |
| |
| static final PairedStats EMPTY_PAIRED_STATS = |
| createPairedStatsOf(ImmutableList.<Double>of(), ImmutableList.<Double>of()); |
| static final PairedStats ONE_VALUE_PAIRED_STATS = |
| createPairedStatsOf(ImmutableList.of(ONE_VALUE), ImmutableList.of(OTHER_ONE_VALUE)); |
| static final PairedStats TWO_VALUES_PAIRED_STATS = |
| createPairedStatsOf(TWO_VALUES, OTHER_TWO_VALUES); |
| static final PairedStats MANY_VALUES_PAIRED_STATS = buildManyValuesPairedStats(); |
| static final PairedStats DUPLICATE_MANY_VALUES_PAIRED_STATS = |
| createPairedStatsOf(MANY_VALUES, OTHER_MANY_VALUES); |
| static final PairedStats HORIZONTAL_VALUES_PAIRED_STATS = buildHorizontalValuesPairedStats(); |
| static final PairedStats VERTICAL_VALUES_PAIRED_STATS = buildVerticalValuesPairedStats(); |
| static final PairedStats CONSTANT_VALUES_PAIRED_STATS = buildConstantValuesPairedStats(); |
| |
| private static PairedStats buildManyValuesPairedStats() { |
| PairedStatsAccumulator accumulator = |
| createFilledPairedStatsAccumulator(MANY_VALUES, OTHER_MANY_VALUES); |
| PairedStats stats = accumulator.snapshot(); |
| accumulator.add(99.99, 9999.9999); // should do nothing to the snapshot |
| return stats; |
| } |
| |
| private static PairedStats buildHorizontalValuesPairedStats() { |
| PairedStatsAccumulator accumulator = new PairedStatsAccumulator(); |
| for (double x : MANY_VALUES) { |
| accumulator.add(x, OTHER_ONE_VALUE); |
| } |
| return accumulator.snapshot(); |
| } |
| |
| private static PairedStats buildVerticalValuesPairedStats() { |
| PairedStatsAccumulator accumulator = new PairedStatsAccumulator(); |
| for (double y : OTHER_MANY_VALUES) { |
| accumulator.add(ONE_VALUE, y); |
| } |
| return accumulator.snapshot(); |
| } |
| |
| private static PairedStats buildConstantValuesPairedStats() { |
| PairedStatsAccumulator accumulator = new PairedStatsAccumulator(); |
| for (int i = 0; i < MANY_VALUES_COUNT; ++i) { |
| accumulator.add(ONE_VALUE, OTHER_ONE_VALUE); |
| } |
| return accumulator.snapshot(); |
| } |
| |
| static final ImmutableList<PairedStats> ALL_PAIRED_STATS = |
| ImmutableList.of( |
| EMPTY_PAIRED_STATS, |
| ONE_VALUE_PAIRED_STATS, |
| TWO_VALUES_PAIRED_STATS, |
| MANY_VALUES_PAIRED_STATS, |
| DUPLICATE_MANY_VALUES_PAIRED_STATS, |
| HORIZONTAL_VALUES_PAIRED_STATS, |
| VERTICAL_VALUES_PAIRED_STATS, |
| CONSTANT_VALUES_PAIRED_STATS); |
| |
| // Helper methods: |
| |
| static void assertStatsApproxEqual(Stats expectedStats, Stats actualStats) { |
| assertThat(actualStats.count()).isEqualTo(expectedStats.count()); |
| if (expectedStats.count() == 0) { |
| try { |
| actualStats.mean(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| actualStats.populationVariance(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| actualStats.min(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| try { |
| actualStats.max(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| } else if (expectedStats.count() == 1) { |
| 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) |
| .of(expectedStats.populationVariance()); |
| assertThat(actualStats.min()).isWithin(ALLOWED_ERROR).of(expectedStats.min()); |
| assertThat(actualStats.max()).isWithin(ALLOWED_ERROR).of(expectedStats.max()); |
| } |
| } |
| |
| /** |
| * Asserts that {@code transformation} is diagonal (i.e. neither horizontal or vertical) and |
| * passes through both {@code (x1, y1)} and {@code (x1 + xDelta, y1 + yDelta)}. Includes |
| * assertions about all the public instance methods of {@link LinearTransformation} (on both |
| * {@code transformation} and its inverse). Since the transformation is expected to be diagonal, |
| * neither {@code xDelta} nor {@code yDelta} may be zero. |
| */ |
| static void assertDiagonalLinearTransformation( |
| LinearTransformation transformation, double x1, double y1, double xDelta, double yDelta) { |
| checkArgument(xDelta != 0.0); |
| checkArgument(yDelta != 0.0); |
| assertThat(transformation.isHorizontal()).isFalse(); |
| assertThat(transformation.isVertical()).isFalse(); |
| assertThat(transformation.inverse().isHorizontal()).isFalse(); |
| assertThat(transformation.inverse().isVertical()).isFalse(); |
| assertThat(transformation.transform(x1)).isWithin(ALLOWED_ERROR).of(y1); |
| assertThat(transformation.transform(x1 + xDelta)).isWithin(ALLOWED_ERROR).of(y1 + yDelta); |
| assertThat(transformation.inverse().transform(y1)).isWithin(ALLOWED_ERROR).of(x1); |
| assertThat(transformation.inverse().transform(y1 + yDelta)) |
| .isWithin(ALLOWED_ERROR) |
| .of(x1 + xDelta); |
| assertThat(transformation.slope()).isWithin(ALLOWED_ERROR).of(yDelta / xDelta); |
| assertThat(transformation.inverse().slope()).isWithin(ALLOWED_ERROR).of(xDelta / yDelta); |
| assertThat(transformation.inverse()).isSameInstanceAs(transformation.inverse()); |
| assertThat(transformation.inverse().inverse()).isSameInstanceAs(transformation); |
| } |
| |
| /** |
| * Asserts that {@code transformation} is horizontal with the given value of {@code y}. Includes |
| * assertions about all the public instance methods of {@link LinearTransformation}, including an |
| * assertion that {@link LinearTransformation#transform} and {@link LinearTransformation#slope} on |
| * its inverse throws as expected. |
| */ |
| static void assertHorizontalLinearTransformation(LinearTransformation transformation, double y) { |
| assertThat(transformation.isHorizontal()).isTrue(); |
| assertThat(transformation.isVertical()).isFalse(); |
| assertThat(transformation.inverse().isHorizontal()).isFalse(); |
| assertThat(transformation.inverse().isVertical()).isTrue(); |
| assertThat(transformation.transform(-1.0)).isWithin(ALLOWED_ERROR).of(y); |
| assertThat(transformation.transform(1.0)).isWithin(ALLOWED_ERROR).of(y); |
| try { |
| transformation.inverse().transform(0.0); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| assertThat(transformation.slope()).isWithin(ALLOWED_ERROR).of(0.0); |
| try { |
| transformation.inverse().slope(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| assertThat(transformation.inverse()).isSameInstanceAs(transformation.inverse()); |
| assertThat(transformation.inverse().inverse()).isSameInstanceAs(transformation); |
| } |
| |
| /** |
| * Asserts that {@code transformation} is vertical with the given value of {@code x}. Includes |
| * assertions about all the public instance methods of {@link LinearTransformation}, including |
| * assertions that {@link LinearTransformation#slope} and {@link LinearTransformation#transform} |
| * throw as expected. |
| */ |
| static void assertVerticalLinearTransformation(LinearTransformation transformation, double x) { |
| assertThat(transformation.isHorizontal()).isFalse(); |
| assertThat(transformation.isVertical()).isTrue(); |
| assertThat(transformation.inverse().isHorizontal()).isTrue(); |
| assertThat(transformation.inverse().isVertical()).isFalse(); |
| try { |
| transformation.transform(0.0); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| assertThat(transformation.inverse().transform(-1.0)).isWithin(ALLOWED_ERROR).of(x); |
| assertThat(transformation.inverse().transform(1.0)).isWithin(ALLOWED_ERROR).of(x); |
| try { |
| transformation.slope(); |
| fail("Expected IllegalStateException"); |
| } catch (IllegalStateException expected) { |
| } |
| assertThat(transformation.inverse().slope()).isWithin(ALLOWED_ERROR).of(0.0); |
| assertThat(transformation.inverse()).isSameInstanceAs(transformation.inverse()); |
| assertThat(transformation.inverse().inverse()).isSameInstanceAs(transformation); |
| } |
| |
| /** |
| * Asserts that {@code transformation} behaves as expected for {@link |
| * LinearTransformation#forNaN}. |
| */ |
| static void assertLinearTransformationNaN(LinearTransformation transformation) { |
| assertThat(transformation.isHorizontal()).isFalse(); |
| assertThat(transformation.isVertical()).isFalse(); |
| assertThat(transformation.slope()).isNaN(); |
| assertThat(transformation.transform(0.0)).isNaN(); |
| assertThat(transformation.inverse()).isSameInstanceAs(transformation); |
| } |
| |
| /** |
| * Creates a {@link PairedStats} from with the given lists of {@code x} and {@code y} values, |
| * which must be of the same size. |
| */ |
| static PairedStats createPairedStatsOf(List<Double> xValues, List<Double> yValues) { |
| return createFilledPairedStatsAccumulator(xValues, yValues).snapshot(); |
| } |
| |
| /** |
| * Creates a {@link PairedStatsAccumulator} filled with the given lists of {@code x} and {@code y} |
| * values, which must be of the same size. |
| */ |
| static PairedStatsAccumulator createFilledPairedStatsAccumulator( |
| List<Double> xValues, List<Double> yValues) { |
| checkArgument(xValues.size() == yValues.size()); |
| PairedStatsAccumulator accumulator = new PairedStatsAccumulator(); |
| for (int index = 0; index < xValues.size(); index++) { |
| accumulator.add(xValues.get(index), yValues.get(index)); |
| } |
| return accumulator; |
| } |
| |
| /** |
| * Creates a {@link PairedStatsAccumulator} filled with the given lists of {@code x} and {@code y} |
| * values, which must be of the same size, added in groups of {@code partitionSize} using {@link |
| * PairedStatsAccumulator#addAll(PairedStats)}. |
| */ |
| static PairedStatsAccumulator createPartitionedFilledPairedStatsAccumulator( |
| List<Double> xValues, List<Double> yValues, int partitionSize) { |
| checkArgument(xValues.size() == yValues.size()); |
| checkArgument(partitionSize > 0); |
| PairedStatsAccumulator accumulator = new PairedStatsAccumulator(); |
| List<List<Double>> xPartitions = Lists.partition(xValues, partitionSize); |
| List<List<Double>> yPartitions = Lists.partition(yValues, partitionSize); |
| for (int index = 0; index < xPartitions.size(); index++) { |
| accumulator.addAll(createPairedStatsOf(xPartitions.get(index), yPartitions.get(index))); |
| } |
| return accumulator; |
| } |
| |
| private StatsTesting() {} |
| } |
