commons-math-transform/src/test/java/org/apache/commons/math4/transform/RealTransformerAbstractTest.java - commons-math - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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 org.apache.commons.math4.transform;

 import org.junit.Assert;
 import org.junit.Test;

 import java.util.function.DoubleUnaryOperator;
 import org.apache.commons.rng.UniformRandomProvider;
 import org.apache.commons.rng.simple.RandomSource;

 /**
  * Abstract test for classes implementing the {@link RealTransform} interface.
  * This abstract test handles the automatic generation of random data of various
  * sizes. For each generated data array, actual values (returned by the
  * transformer to be tested) are compared to expected values, returned by the
  * {@link #transform(double[], boolean)} (to be implemented by the user: a naive method may
  * be used). Methods are also provided to test that invalid parameters throw the
  * expected exceptions.
  *
  * @since 3.0
  */
 public abstract class RealTransformerAbstractTest {
     /** RNG. */
     private static final UniformRandomProvider RNG = RandomSource.MWC_256.create();

     /**
      * Returns a new instance of the {@link RealTransform} to be tested.
      *
      * @param inverse Whether to apply the inverse transform.
      * @return a the transformer to be tested
      */
     abstract RealTransform createRealTransformer(boolean inverse);

     /**
      * Returns an invalid data size. Transforms with this data size should
      * trigger a {@link IllegalArgumentException}.
      *
      * @param i the index of the invalid data size ({@code 0 <= i <}
      * {@link #getNumberOfInvalidDataSizes()}
      * @return an invalid data size
      */
     abstract int getInvalidDataSize(int i);

     /**
      * Returns the total number of invalid data sizes to be tested. If data
      * array of any
      * size can be handled by the {@link RealTransform} to be tested, this
      * method should return {@code 0}.
      *
      * @return the total number of invalid data sizes
      */
     abstract int getNumberOfInvalidDataSizes();

     /**
      * Returns the total number of valid data sizes to be tested.
      *
      * @return the total number of valid data sizes
      */
     abstract int getNumberOfValidDataSizes();

     /**
      * Returns the expected relative accuracy for data arrays of size
      * {@code getValidDataSize(i)}.
      *
      * @param i the index of the valid data size
      * @return the expected relative accuracy
      */
     abstract double getRelativeTolerance(int i);

     /**
      * Returns a valid data size. This method allows for data arrays of various
      * sizes to be automatically tested (by allowing multiple values of the
      * specified index).
      *
      * @param i the index of the valid data size ({@code 0 <= i <}
      * {@link #getNumberOfValidDataSizes()}
      * @return a valid data size
      */
     abstract int getValidDataSize(int i);

     /**
      * Returns a function for the accuracy check of
      * {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}.
      * This function should be valid. In other words, none of the above methods
      * should throw an exception when passed this function.
      *
      * @return a valid function
      */
     abstract DoubleUnaryOperator getValidFunction();

     /**
      * Returns a sampling lower bound for the accuracy check of
      * {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}.
      * This lower bound should be valid. In other words, none of the above
      * methods should throw an exception when passed this bound.
      *
      * @return a valid lower bound
      */
     abstract double getValidLowerBound();

     /**
      * Returns a sampling upper bound for the accuracy check of
      * {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}.
      * This upper bound should be valid. In other words, none of the above
      * methods should throw an exception when passed this bound.
      *
      * @return a valid bound
      */
     abstract double getValidUpperBound();

     /**
      * Returns the expected transform of the specified real data array.
      *
      * @param x Data to be transformed.
      * @param type Whether to perform the inverse) transform.
      * @return the expected transform.
      */
     abstract double[] transform(double[] x, boolean type);

     // Check of preconditions.

     /**
      * {@link RealTransform#apply(double[])} should throw a
      * {@link IllegalArgumentException} if data size is invalid.
      */
     @Test
     public void testTransformRealInvalidDataSize() {
         for (int i = 0; i < getNumberOfInvalidDataSizes(); i++) {
             final int n = getInvalidDataSize(i);
             for (boolean type : new boolean[] {true, false}) {
                 try {
                     final RealTransform transformer = createRealTransformer(type);
                     transformer.apply(createRealData(n));
                     Assert.fail(type + ", " + n);
                 } catch (IllegalArgumentException e) {
                     // Expected: do nothing
                 }
             }
         }
     }

     /**
      * {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}
      * should throw {@link IllegalArgumentException} if number of samples is
      * invalid.
      */
     @Test
     public void testTransformFunctionInvalidDataSize() {
         final DoubleUnaryOperator f = getValidFunction();
         final double a = getValidLowerBound();
         final double b = getValidUpperBound();
         for (int i = 0; i < getNumberOfInvalidDataSizes(); i++) {
             final int n = getInvalidDataSize(i);
             for (boolean type : new boolean[] {true, false}) {
                 try {
                     final RealTransform transformer = createRealTransformer(type);
                     transformer.apply(f, a, b, n);
                     Assert.fail(type + ", " + n);
                 } catch (IllegalArgumentException e) {
                     // Expected: do nothing
                 }
             }
         }
     }

     /**
      * {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}
      * should throw {@link IllegalArgumentException} if number of samples
      * is not strictly positive.
      */
     @Test
     public void testTransformFunctionNotStrictlyPositiveNumberOfSamples() {
         final DoubleUnaryOperator f = getValidFunction();
         final double a = getValidLowerBound();
         final double b = getValidUpperBound();
         for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
             final int n = getValidDataSize(i);
             for (boolean type : new boolean[] {true, false}) {
                 try {
                     final RealTransform transformer = createRealTransformer(type);
                     transformer.apply(f, a, b, -n);
                     Assert.fail(type + ", " + (-n));
                 } catch (IllegalArgumentException e) {
                     // Expected: do nothing
                 }
             }
         }
     }

     /**
      * {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}
      * should throw {@link IllegalArgumentException} if sampling bounds are
      * not correctly ordered.
      */
     @Test
     public void testTransformFunctionInvalidBounds() {
         final DoubleUnaryOperator f = getValidFunction();
         final double a = getValidLowerBound();
         final double b = getValidUpperBound();
         for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
             final int n = getValidDataSize(i);
             for (boolean type : new boolean[] {true, false}) {
                 try {
                     final RealTransform transformer = createRealTransformer(type);
                     transformer.apply(f, b, a, n);
                     Assert.fail(type + ", " + b + ", " + a);
                 } catch (IllegalArgumentException e) {
                     // Expected: do nothing
                 }
             }
         }
     }

     // Accuracy tests of transform of valid data.

     /**
      * Accuracy check of {@link RealTransform#apply(double[])}.
      * For each valid data size returned by
      * {@link #getValidDataSize(int) getValidDataSize(i)},
      * a random data array is generated with
      * {@link #createRealData(int) createRealData(i)}. The actual
      * transform is computed and compared to the expected transform, return by
      * {@link #transform(double[], boolean)}. Actual and expected values
      * should be equal to within the relative error returned by
      * {@link #getRelativeTolerance(int) getRelativeTolerance(i)}.
      */
     @Test
     public void testTransformReal() {
         for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
             final int n = getValidDataSize(i);
             final double tol = getRelativeTolerance(i);
             for (boolean type : new boolean[] {true, false}) {
                 doTestTransformReal(n, tol, type);
             }
         }
     }

     /**
      * Accuracy check of
      * {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}.
      * For each valid data size returned by
      * {@link #getValidDataSize(int) getValidDataSize(i)},
      * the {@link org.apache.commons.math3.analysis.UnivariateFunction UnivariateFunction}
      * returned by {@link #getValidFunction()} is
      * sampled. The actual transform is computed and compared to the expected
      * transform, return by {@link #transform(double[], boolean)}. Actual
      * and expected values should be equal to within the relative error returned
      * by {@link #getRelativeTolerance(int) getRelativeTolerance(i)}.
      */
     @Test
     public void testTransformFunction() {
         for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
             final int n = getValidDataSize(i);
             final double tol = getRelativeTolerance(i);
             for (boolean type : new boolean[] {true, false}) {
                 doTestTransformFunction(n, tol, type);
             }
         }
     }

     // Utility methods.

     /**
      * Returns a random array of doubles.
      *
      * @param n the size of the array to be returned
      * @return a random array of specified size
      */
     double[] createRealData(final int n) {
         final double[] data = new double[n];
         for (int i = 0; i < n; i++) {
             data[i] = 2 * RNG.nextDouble() - 1;
         }
         return data;
     }

     // Actual tests.

     private void doTestTransformReal(final int n,
                                      final double tol,
                                      final boolean type) {
         final RealTransform transformer = createRealTransformer(type);
         final double[] x = createRealData(n);
         final double[] expected = transform(x, type);
         final double[] actual = transformer.apply(x);
         for (int i = 0; i < n; i++) {
             final String msg = String.format("%d, %d", n, i);
             final double delta = tol * Math.abs(expected[i]);
             Assert.assertEquals(msg, expected[i], actual[i], delta);
         }
     }

     private void doTestTransformFunction(final int n,
                                          final double tol,
                                          final boolean type) {
         final RealTransform transformer = createRealTransformer(type);
         final DoubleUnaryOperator f = getValidFunction();
         final double a = getValidLowerBound();
         final double b = getValidUpperBound();
         final double[] x = createRealData(n);
         for (int i = 0; i < n; i++) {
             final double t = a + i * (b - a) / n;
             x[i] = f.applyAsDouble(t);
         }
         final double[] expected = transform(x, type);
         final double[] actual = transformer.apply(f, a, b, n);
         for (int i = 0; i < n; i++) {
             final String msg = String.format("%d, %d", n, i);
             final double delta = tol * Math.abs(expected[i]);
             Assert.assertEquals(msg, expected[i], actual[i], delta);
         }
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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 org.apache.commons.math4.transform;

	import org.junit.Assert;
	import org.junit.Test;

	import java.util.function.DoubleUnaryOperator;
	import org.apache.commons.rng.UniformRandomProvider;
	import org.apache.commons.rng.simple.RandomSource;

	/**
	* Abstract test for classes implementing the {@link RealTransform} interface.
	* This abstract test handles the automatic generation of random data of various
	* sizes. For each generated data array, actual values (returned by the
	* transformer to be tested) are compared to expected values, returned by the
	* {@link #transform(double[], boolean)} (to be implemented by the user: a naive method may
	* be used). Methods are also provided to test that invalid parameters throw the
	* expected exceptions.
	*
	* @since 3.0
	*/
	public abstract class RealTransformerAbstractTest {
	/** RNG. */
	private static final UniformRandomProvider RNG = RandomSource.MWC_256.create();

	/**
	* Returns a new instance of the {@link RealTransform} to be tested.
	*
	* @param inverse Whether to apply the inverse transform.
	* @return a the transformer to be tested
	*/
	abstract RealTransform createRealTransformer(boolean inverse);

	/**
	* Returns an invalid data size. Transforms with this data size should
	* trigger a {@link IllegalArgumentException}.
	*
	* @param i the index of the invalid data size ({@code 0 <= i <}
	* {@link #getNumberOfInvalidDataSizes()}
	* @return an invalid data size
	*/
	abstract int getInvalidDataSize(int i);

	/**
	* Returns the total number of invalid data sizes to be tested. If data
	* array of any
	* size can be handled by the {@link RealTransform} to be tested, this
	* method should return {@code 0}.
	*
	* @return the total number of invalid data sizes
	*/
	abstract int getNumberOfInvalidDataSizes();

	/**
	* Returns the total number of valid data sizes to be tested.
	*
	* @return the total number of valid data sizes
	*/
	abstract int getNumberOfValidDataSizes();

	/**
	* Returns the expected relative accuracy for data arrays of size
	* {@code getValidDataSize(i)}.
	*
	* @param i the index of the valid data size
	* @return the expected relative accuracy
	*/
	abstract double getRelativeTolerance(int i);

	/**
	* Returns a valid data size. This method allows for data arrays of various
	* sizes to be automatically tested (by allowing multiple values of the
	* specified index).
	*
	* @param i the index of the valid data size ({@code 0 <= i <}
	* {@link #getNumberOfValidDataSizes()}
	* @return a valid data size
	*/
	abstract int getValidDataSize(int i);

	/**
	* Returns a function for the accuracy check of
	* {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}.
	* This function should be valid. In other words, none of the above methods
	* should throw an exception when passed this function.
	*
	* @return a valid function
	*/
	abstract DoubleUnaryOperator getValidFunction();

	/**
	* Returns a sampling lower bound for the accuracy check of
	* {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}.
	* This lower bound should be valid. In other words, none of the above
	* methods should throw an exception when passed this bound.
	*
	* @return a valid lower bound
	*/
	abstract double getValidLowerBound();

	/**
	* Returns a sampling upper bound for the accuracy check of
	* {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}.
	* This upper bound should be valid. In other words, none of the above
	* methods should throw an exception when passed this bound.
	*
	* @return a valid bound
	*/
	abstract double getValidUpperBound();

	/**
	* Returns the expected transform of the specified real data array.
	*
	* @param x Data to be transformed.
	* @param type Whether to perform the inverse) transform.
	* @return the expected transform.
	*/
	abstract double[] transform(double[] x, boolean type);

	// Check of preconditions.

	/**
	* {@link RealTransform#apply(double[])} should throw a
	* {@link IllegalArgumentException} if data size is invalid.
	*/
	@Test
	public void testTransformRealInvalidDataSize() {
	for (int i = 0; i < getNumberOfInvalidDataSizes(); i++) {
	final int n = getInvalidDataSize(i);
	for (boolean type : new boolean[] {true, false}) {
	try {
	final RealTransform transformer = createRealTransformer(type);
	transformer.apply(createRealData(n));
	Assert.fail(type + ", " + n);
	} catch (IllegalArgumentException e) {
	// Expected: do nothing
	}
	}
	}
	}

	/**
	* {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}
	* should throw {@link IllegalArgumentException} if number of samples is
	* invalid.
	*/
	@Test
	public void testTransformFunctionInvalidDataSize() {
	final DoubleUnaryOperator f = getValidFunction();
	final double a = getValidLowerBound();
	final double b = getValidUpperBound();
	for (int i = 0; i < getNumberOfInvalidDataSizes(); i++) {
	final int n = getInvalidDataSize(i);
	for (boolean type : new boolean[] {true, false}) {
	try {
	final RealTransform transformer = createRealTransformer(type);
	transformer.apply(f, a, b, n);
	Assert.fail(type + ", " + n);
	} catch (IllegalArgumentException e) {
	// Expected: do nothing
	}
	}
	}
	}

	/**
	* {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}
	* should throw {@link IllegalArgumentException} if number of samples
	* is not strictly positive.
	*/
	@Test
	public void testTransformFunctionNotStrictlyPositiveNumberOfSamples() {
	final DoubleUnaryOperator f = getValidFunction();
	final double a = getValidLowerBound();
	final double b = getValidUpperBound();
	for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
	final int n = getValidDataSize(i);
	for (boolean type : new boolean[] {true, false}) {
	try {
	final RealTransform transformer = createRealTransformer(type);
	transformer.apply(f, a, b, -n);
	Assert.fail(type + ", " + (-n));
	} catch (IllegalArgumentException e) {
	// Expected: do nothing
	}
	}
	}
	}

	/**
	* {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}
	* should throw {@link IllegalArgumentException} if sampling bounds are
	* not correctly ordered.
	*/
	@Test
	public void testTransformFunctionInvalidBounds() {
	final DoubleUnaryOperator f = getValidFunction();
	final double a = getValidLowerBound();
	final double b = getValidUpperBound();
	for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
	final int n = getValidDataSize(i);
	for (boolean type : new boolean[] {true, false}) {
	try {
	final RealTransform transformer = createRealTransformer(type);
	transformer.apply(f, b, a, n);
	Assert.fail(type + ", " + b + ", " + a);
	} catch (IllegalArgumentException e) {
	// Expected: do nothing
	}
	}
	}
	}

	// Accuracy tests of transform of valid data.

	/**
	* Accuracy check of {@link RealTransform#apply(double[])}.
	* For each valid data size returned by
	* {@link #getValidDataSize(int) getValidDataSize(i)},
	* a random data array is generated with
	* {@link #createRealData(int) createRealData(i)}. The actual
	* transform is computed and compared to the expected transform, return by
	* {@link #transform(double[], boolean)}. Actual and expected values
	* should be equal to within the relative error returned by
	* {@link #getRelativeTolerance(int) getRelativeTolerance(i)}.
	*/
	@Test
	public void testTransformReal() {
	for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
	final int n = getValidDataSize(i);
	final double tol = getRelativeTolerance(i);
	for (boolean type : new boolean[] {true, false}) {
	doTestTransformReal(n, tol, type);
	}
	}
	}

	/**
	* Accuracy check of
	* {@link RealTransform#apply(DoubleUnaryOperator, double, double, int)}.
	* For each valid data size returned by
	* {@link #getValidDataSize(int) getValidDataSize(i)},
	* the {@link org.apache.commons.math3.analysis.UnivariateFunction UnivariateFunction}
	* returned by {@link #getValidFunction()} is
	* sampled. The actual transform is computed and compared to the expected
	* transform, return by {@link #transform(double[], boolean)}. Actual
	* and expected values should be equal to within the relative error returned
	* by {@link #getRelativeTolerance(int) getRelativeTolerance(i)}.
	*/
	@Test
	public void testTransformFunction() {
	for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
	final int n = getValidDataSize(i);
	final double tol = getRelativeTolerance(i);
	for (boolean type : new boolean[] {true, false}) {
	doTestTransformFunction(n, tol, type);
	}
	}
	}

	// Utility methods.

	/**
	* Returns a random array of doubles.
	*
	* @param n the size of the array to be returned
	* @return a random array of specified size
	*/
	double[] createRealData(final int n) {
	final double[] data = new double[n];
	for (int i = 0; i < n; i++) {
	data[i] = 2 * RNG.nextDouble() - 1;
	}
	return data;
	}

	// Actual tests.

	private void doTestTransformReal(final int n,
	final double tol,
	final boolean type) {
	final RealTransform transformer = createRealTransformer(type);
	final double[] x = createRealData(n);
	final double[] expected = transform(x, type);
	final double[] actual = transformer.apply(x);
	for (int i = 0; i < n; i++) {
	final String msg = String.format("%d, %d", n, i);
	final double delta = tol * Math.abs(expected[i]);
	Assert.assertEquals(msg, expected[i], actual[i], delta);
	}
	}

	private void doTestTransformFunction(final int n,
	final double tol,
	final boolean type) {
	final RealTransform transformer = createRealTransformer(type);
	final DoubleUnaryOperator f = getValidFunction();
	final double a = getValidLowerBound();
	final double b = getValidUpperBound();
	final double[] x = createRealData(n);
	for (int i = 0; i < n; i++) {
	final double t = a + i * (b - a) / n;
	x[i] = f.applyAsDouble(t);
	}
	final double[] expected = transform(x, type);
	final double[] actual = transformer.apply(f, a, b, n);
	for (int i = 0; i < n; i++) {
	final String msg = String.format("%d, %d", n, i);
	final double delta = tol * Math.abs(expected[i]);
	Assert.assertEquals(msg, expected[i], actual[i], delta);
	}
	}
	}