android/guava-tests/test/com/google/common/math/LinearTransformationTest.java

/*
 * 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.assertDiagonalLinearTransformation;
import static com.google.common.math.StatsTesting.assertHorizontalLinearTransformation;
import static com.google.common.math.StatsTesting.assertLinearTransformationNaN;
import static com.google.common.math.StatsTesting.assertVerticalLinearTransformation;
import static com.google.common.truth.Truth.assertThat;

import junit.framework.TestCase;

/**
 * Tests for {@link LinearTransformation}.
 *
 * @author Pete Gillin
 */
public class LinearTransformationTest extends TestCase {

  private static final double ALLOWED_ERROR = 1e-10;

  public void testMappingAnd_regular() {
    double x1 = 1.2;
    double y1 = 3.4;
    double xDelta = 5.6;
    double yDelta = 7.8;
    LinearTransformation transformation =
        LinearTransformation.mapping(x1, y1).and(x1 + xDelta, y1 + yDelta);
    assertDiagonalLinearTransformation(transformation, x1, y1, xDelta, yDelta);
  }

  public void testMappingAnd_horizontal() {
    double x1 = 1.2;
    double xDelta = 3.4;
    double y = 5.6;
    LinearTransformation transformation = LinearTransformation.mapping(x1, y).and(x1 + xDelta, y);
    assertHorizontalLinearTransformation(transformation, y);
  }

  public void testMappingAnd_vertical() {
    double x = 1.2;
    double y1 = 3.4;
    double yDelta = 5.6;
    LinearTransformation transformation = LinearTransformation.mapping(x, y1).and(x, y1 + yDelta);
    assertVerticalLinearTransformation(transformation, x);
  }

  public void testMapping_infiniteX1() {
    try {
      LinearTransformation.mapping(Double.POSITIVE_INFINITY, 3.4);
      fail("Expected IllegalArgumentException from mapping(x, y) with infinite x");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMapping_infiniteY1() {
    try {
      LinearTransformation.mapping(1.2, Double.NEGATIVE_INFINITY);
      fail("Expected IllegalArgumentException from mapping(x, y) with infinite y");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMappingAnd_infiniteX2() {
    try {
      LinearTransformation.mapping(1.2, 3.4).and(Double.NEGATIVE_INFINITY, 7.8);
      fail("Expected IllegalArgumentException from and(x, y) with infinite x");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMappingAnd_infiniteY2() {
    try {
      LinearTransformation.mapping(1.2, 3.4).and(5.6, Double.POSITIVE_INFINITY);
      fail("Expected IllegalArgumentException from and(x, y) with infinite y");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMapping_nanX1() {
    try {
      LinearTransformation.mapping(Double.NaN, 3.4);
      fail("Expected IllegalArgumentException from mapping(x, y) with NaN x");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMapping_nanY1() {
    try {
      LinearTransformation.mapping(1.2, Double.NaN);
      fail("Expected IllegalArgumentException from mapping(x, y) with NaN y");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMappingAnd_nanX2() {
    try {
      LinearTransformation.mapping(1.2, 3.4).and(Double.NaN, 7.8);
      fail("Expected IllegalArgumentException from and(x, y) with NaN x");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMappingAnd_nanY2() {
    try {
      LinearTransformation.mapping(1.2, 3.4).and(5.6, Double.NaN);
      fail("Expected IllegalArgumentException from and(x, y) with NaN y");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMappingAnd_samePointTwice() {
    try {
      double x = 1.2;
      double y = 3.4;
      LinearTransformation.mapping(x, y).and(x, y);
      fail(
          "Expected IllegalArgumentException from mapping(x1, y1).and(x2, y2) with"
              + " (x1 == x2) && (y1 == y2)");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testMappingWithSlope_regular() {
    double x1 = 1.2;
    double y1 = 3.4;
    double xDelta = -5.6;
    double slope = -7.8;
    LinearTransformation transformation = LinearTransformation.mapping(x1, y1).withSlope(slope);
    assertDiagonalLinearTransformation(transformation, x1, y1, xDelta, xDelta * slope);
  }

  public void testMappingWithSlope_horizontal() {
    double x1 = 1.2;
    double y = 5.6;
    LinearTransformation transformation = LinearTransformation.mapping(x1, y).withSlope(0.0);
    assertHorizontalLinearTransformation(transformation, y);
  }

  public void testMappingWithSlope_vertical() {
    double x = 1.2;
    double y1 = 3.4;
    LinearTransformation transformation =
        LinearTransformation.mapping(x, y1).withSlope(Double.POSITIVE_INFINITY);
    assertVerticalLinearTransformation(transformation, x);
  }

  public void testMappingWithSlope_minimalSlope() {
    double x1 = 1.2;
    double y1 = 3.4;
    double slope = Double.MIN_VALUE;
    LinearTransformation transformation = LinearTransformation.mapping(x1, y1).withSlope(slope);
    assertThat(transformation.isVertical()).isFalse();
    assertThat(transformation.isHorizontal()).isFalse();
    assertThat(transformation.slope()).isWithin(ALLOWED_ERROR).of(slope);
    // Note that we cannot test the actual mapping of points, as the results will be unreliable due
    // to loss of precision with this value of the slope.
  }

  public void testMappingWithSlope_maximalSlope() {
    double x1 = 1.2;
    double y1 = 3.4;
    double slope = Double.MAX_VALUE;
    LinearTransformation transformation = LinearTransformation.mapping(x1, y1).withSlope(slope);
    assertThat(transformation.isVertical()).isFalse();
    assertThat(transformation.isHorizontal()).isFalse();
    assertThat(transformation.slope()).isWithin(ALLOWED_ERROR).of(slope);
    // Note that we cannot test the actual mapping of points, as the results will be unreliable due
    // to loss of precision with this value of the slope.
  }

  public void testMappingWithSlope_nanSlope() {
    try {
      LinearTransformation.mapping(1.2, 3.4).withSlope(Double.NaN);
      fail("Expected IllegalArgumentException from withSlope(slope) with NaN slope");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testVertical_regular() {
    double x = 1.2;
    LinearTransformation transformation = LinearTransformation.vertical(x);
    assertVerticalLinearTransformation(transformation, x);
  }

  public void testVertical_infiniteX() {
    try {
      LinearTransformation.vertical(Double.NEGATIVE_INFINITY);
      fail("Expected IllegalArgumentException from vertical(x) with infinite x");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testVertical_nanX() {
    try {
      LinearTransformation.vertical(Double.NaN);
      fail("Expected IllegalArgumentException from vertical(x) with NaN x");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testHorizontal_regular() {
    double y = 1.2;
    LinearTransformation transformation = LinearTransformation.horizontal(y);
    assertHorizontalLinearTransformation(transformation, y);
  }

  public void testHorizontal_infiniteY() {
    try {
      LinearTransformation.horizontal(Double.POSITIVE_INFINITY);
      fail("Expected IllegalArgumentException from horizontal(y) with infinite y");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testHorizontal_nanY() {
    try {
      LinearTransformation.horizontal(Double.NaN);
      fail("Expected IllegalArgumentException from horizontal(y) with NaN y");
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testForNaN() {
    LinearTransformation transformation = LinearTransformation.forNaN();
    assertLinearTransformationNaN(transformation);
  }
}