Java example source code file (LinearTransformationTest.java)

This example Java source code file (LinearTransformationTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

allowed_error, expected, illegalargumentexception, lineartransformation, lineartransformationtest, nan, testcase

The LinearTransformationTest.java Java example source code

/*
 * 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);
  }
}