src/test/java/org/apache/commons/math3/transform/FastSineTransformerTest.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.math3.transform;

 import java.util.Arrays;
 import java.util.Collection;

 import org.apache.commons.math3.analysis.UnivariateFunction;
 import org.apache.commons.math3.analysis.function.Sin;
 import org.apache.commons.math3.analysis.function.Sinc;
 import org.apache.commons.math3.exception.MathIllegalArgumentException;
 import org.apache.commons.math3.exception.MathIllegalStateException;
 import org.apache.commons.math3.util.FastMath;
 import org.junit.Assert;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;

 /**
  * Test case for fast sine transformer.
  * <p>
  * FST algorithm is exact, the small tolerance number is used only
  * to account for round-off errors.
  *
  */
 @RunWith(value = Parameterized.class)
 public final class FastSineTransformerTest extends RealTransformerAbstractTest {

     private final DstNormalization normalization;

     private final int[] invalidDataSize;

     private final double[] relativeTolerance;

     private final int[] validDataSize;

     public FastSineTransformerTest(final DstNormalization normalization) {
         this.normalization = normalization;
         this.validDataSize = new int[] {
             1, 2, 4, 8, 16, 32, 64, 128
         };
         this.invalidDataSize = new int[] {
             129
         };
         this.relativeTolerance = new double[] {
             1E-15, 1E-15, 1E-14, 1E-14, 1E-13, 1E-12, 1E-11, 1E-11
         };
     }

     /**
      * Returns an array containing {@code true, false} in order to check both
      * standard and orthogonal DSTs.
      *
      * @return an array of parameters for this parameterized test
      */
     @Parameters
     public static Collection<Object[]> data() {
         final DstNormalization[] normalization = DstNormalization.values();
         final Object[][] data = new DstNormalization[normalization.length][1];
         for (int i = 0; i < normalization.length; i++) {
             data[i][0] = normalization[i];
         }
         return Arrays.asList(data);
     }

     /**
      * {@inheritDoc}
      *
      * Overriding the default implementation allows to ensure that the first
      * element of the data set is zero.
      */
     @Override
     double[] createRealData(final int n) {
         final double[] data = super.createRealData(n);
         data[0] = 0.0;
         return data;
     }

     @Override
     RealTransformer createRealTransformer() {
         return new FastSineTransformer(normalization);
     }

     @Override
     int getInvalidDataSize(final int i) {
         return invalidDataSize[i];
     }

     @Override
     int getNumberOfInvalidDataSizes() {
         return invalidDataSize.length;
     }

     @Override
     int getNumberOfValidDataSizes() {
         return validDataSize.length;
     }

     @Override
     double getRelativeTolerance(final int i) {
         return relativeTolerance[i];
     }

     @Override
     int getValidDataSize(final int i) {
         return validDataSize[i];
     }

     @Override
     UnivariateFunction getValidFunction() {
         return new Sinc();
     }

     @Override
     double getValidLowerBound() {
         return 0.0;
     }

     @Override
     double getValidUpperBound() {
         return FastMath.PI;
     }

     @Override
     double[] transform(final double[] x, final TransformType type) {
         final int n = x.length;
         final double[] y = new double[n];
         final double[] sin = new double[2 * n];
         for (int i = 0; i < sin.length; i++) {
             sin[i] = FastMath.sin(FastMath.PI * i / n);
         }
         for (int j = 0; j < n; j++) {
             double yj = 0.0;
             for (int i = 0; i < n; i++) {
                 yj += x[i] * sin[(i * j) % sin.length];
             }
             y[j] = yj;
         }
         final double s;
         if (type == TransformType.FORWARD) {
             if (normalization == DstNormalization.STANDARD_DST_I) {
                 s = 1.0;
             } else if (normalization == DstNormalization.ORTHOGONAL_DST_I) {
                 s = FastMath.sqrt(2.0 / n);
             } else {
                 throw new MathIllegalStateException();
             }
         } else if (type == TransformType.INVERSE) {
             if (normalization == DstNormalization.STANDARD_DST_I) {
                 s = 2.0 / n;
             } else if (normalization == DstNormalization.ORTHOGONAL_DST_I) {
                 s = FastMath.sqrt(2.0 / n);
             } else {
                 throw new MathIllegalStateException();
             }
         } else {
             /*
              * Should never occur. This clause is a safeguard in case other
              * types are used to TransformType (which should not be done).
              */
             throw new MathIllegalStateException();
         }
         TransformUtils.scaleArray(y, s);
         return y;
     }

     /*
      * Additional tests.
      */
     @Test
     public void testTransformRealFirstElementNotZero() {
         final TransformType[] type = TransformType.values();
         final double[] data = new double[] {
             1.0, 1.0, 1.0, 1.0
         };
         final RealTransformer transformer = createRealTransformer();
         for (int j = 0; j < type.length; j++) {
             try {
                 transformer.transform(data, type[j]);
                 Assert.fail(type[j].toString());
             } catch (MathIllegalArgumentException e) {
                 // Expected: do nothing
             }
         }
     }

     /*
      * Additional (legacy) tests.
      */

     /**
      * Test of transformer for the ad hoc data.
      */
     @Test
     public void testAdHocData() {
         FastSineTransformer transformer;
         transformer = new FastSineTransformer(DstNormalization.STANDARD_DST_I);
         double result[], tolerance = 1E-12;

         double x[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 };
         double y[] = { 0.0, 20.1093579685034, -9.65685424949238,
                        5.98642305066196, -4.0, 2.67271455167720,
                       -1.65685424949238, 0.795649469518633 };

         result = transformer.transform(x, TransformType.FORWARD);
         for (int i = 0; i < result.length; i++) {
             Assert.assertEquals(y[i], result[i], tolerance);
         }

         result = transformer.transform(y, TransformType.INVERSE);
         for (int i = 0; i < result.length; i++) {
             Assert.assertEquals(x[i], result[i], tolerance);
         }

         TransformUtils.scaleArray(x, FastMath.sqrt(x.length / 2.0));
         transformer = new FastSineTransformer(DstNormalization.ORTHOGONAL_DST_I);

         result = transformer.transform(y, TransformType.FORWARD);
         for (int i = 0; i < result.length; i++) {
             Assert.assertEquals(x[i], result[i], tolerance);
         }

         result = transformer.transform(x, TransformType.INVERSE);
         for (int i = 0; i < result.length; i++) {
             Assert.assertEquals(y[i], result[i], tolerance);
         }
     }

     /**
      * Test of transformer for the sine function.
      */
     @Test
     public void testSinFunction() {
         UnivariateFunction f = new Sin();
         FastSineTransformer transformer;
         transformer = new FastSineTransformer(DstNormalization.STANDARD_DST_I);
         double min, max, result[], tolerance = 1E-12; int N = 1 << 8;

         min = 0.0; max = 2.0 * FastMath.PI;
         result = transformer.transform(f, min, max, N, TransformType.FORWARD);
         Assert.assertEquals(N >> 1, result[2], tolerance);
         for (int i = 0; i < N; i += (i == 1 ? 2 : 1)) {
             Assert.assertEquals(0.0, result[i], tolerance);
         }

         min = -FastMath.PI; max = FastMath.PI;
         result = transformer.transform(f, min, max, N, TransformType.FORWARD);
         Assert.assertEquals(-(N >> 1), result[2], tolerance);
         for (int i = 0; i < N; i += (i == 1 ? 2 : 1)) {
             Assert.assertEquals(0.0, result[i], tolerance);
         }
     }

     /**
      * Test of parameters for the transformer.
      */
     @Test
     public void testParameters() throws Exception {
         UnivariateFunction f = new Sin();
         FastSineTransformer transformer;
         transformer = new FastSineTransformer(DstNormalization.STANDARD_DST_I);

         try {
             // bad interval
             transformer.transform(f, 1, -1, 64, TransformType.FORWARD);
             Assert.fail("Expecting IllegalArgumentException - bad interval");
         } catch (IllegalArgumentException ex) {
             // expected
         }
         try {
             // bad samples number
             transformer.transform(f, -1, 1, 0, TransformType.FORWARD);
             Assert.fail("Expecting IllegalArgumentException - bad samples number");
         } catch (IllegalArgumentException ex) {
             // expected
         }
         try {
             // bad samples number
             transformer.transform(f, -1, 1, 100, TransformType.FORWARD);
             Assert.fail("Expecting IllegalArgumentException - bad samples number");
         } catch (IllegalArgumentException ex) {
             // expected
         }
     }
 }
	/*
	* 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.math3.transform;

	import java.util.Arrays;
	import java.util.Collection;

	import org.apache.commons.math3.analysis.UnivariateFunction;
	import org.apache.commons.math3.analysis.function.Sin;
	import org.apache.commons.math3.analysis.function.Sinc;
	import org.apache.commons.math3.exception.MathIllegalArgumentException;
	import org.apache.commons.math3.exception.MathIllegalStateException;
	import org.apache.commons.math3.util.FastMath;
	import org.junit.Assert;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.Parameterized;
	import org.junit.runners.Parameterized.Parameters;

	/**
	* Test case for fast sine transformer.
	* <p>
	* FST algorithm is exact, the small tolerance number is used only
	* to account for round-off errors.
	*
	*/
	@RunWith(value = Parameterized.class)
	public final class FastSineTransformerTest extends RealTransformerAbstractTest {

	private final DstNormalization normalization;

	private final int[] invalidDataSize;

	private final double[] relativeTolerance;

	private final int[] validDataSize;

	public FastSineTransformerTest(final DstNormalization normalization) {
	this.normalization = normalization;
	this.validDataSize = new int[] {
	1, 2, 4, 8, 16, 32, 64, 128
	};
	this.invalidDataSize = new int[] {
	129
	};
	this.relativeTolerance = new double[] {
	1E-15, 1E-15, 1E-14, 1E-14, 1E-13, 1E-12, 1E-11, 1E-11
	};
	}

	/**
	* Returns an array containing {@code true, false} in order to check both
	* standard and orthogonal DSTs.
	*
	* @return an array of parameters for this parameterized test
	*/
	@Parameters
	public static Collection<Object[]> data() {
	final DstNormalization[] normalization = DstNormalization.values();
	final Object[][] data = new DstNormalization[normalization.length][1];
	for (int i = 0; i < normalization.length; i++) {
	data[i][0] = normalization[i];
	}
	return Arrays.asList(data);
	}

	/**
	* {@inheritDoc}
	*
	* Overriding the default implementation allows to ensure that the first
	* element of the data set is zero.
	*/
	@Override
	double[] createRealData(final int n) {
	final double[] data = super.createRealData(n);
	data[0] = 0.0;
	return data;
	}

	@Override
	RealTransformer createRealTransformer() {
	return new FastSineTransformer(normalization);
	}

	@Override
	int getInvalidDataSize(final int i) {
	return invalidDataSize[i];
	}

	@Override
	int getNumberOfInvalidDataSizes() {
	return invalidDataSize.length;
	}

	@Override
	int getNumberOfValidDataSizes() {
	return validDataSize.length;
	}

	@Override
	double getRelativeTolerance(final int i) {
	return relativeTolerance[i];
	}

	@Override
	int getValidDataSize(final int i) {
	return validDataSize[i];
	}

	@Override
	UnivariateFunction getValidFunction() {
	return new Sinc();
	}

	@Override
	double getValidLowerBound() {
	return 0.0;
	}

	@Override
	double getValidUpperBound() {
	return FastMath.PI;
	}

	@Override
	double[] transform(final double[] x, final TransformType type) {
	final int n = x.length;
	final double[] y = new double[n];
	final double[] sin = new double[2 * n];
	for (int i = 0; i < sin.length; i++) {
	sin[i] = FastMath.sin(FastMath.PI * i / n);
	}
	for (int j = 0; j < n; j++) {
	double yj = 0.0;
	for (int i = 0; i < n; i++) {
	yj += x[i] * sin[(i * j) % sin.length];
	}
	y[j] = yj;
	}
	final double s;
	if (type == TransformType.FORWARD) {
	if (normalization == DstNormalization.STANDARD_DST_I) {
	s = 1.0;
	} else if (normalization == DstNormalization.ORTHOGONAL_DST_I) {
	s = FastMath.sqrt(2.0 / n);
	} else {
	throw new MathIllegalStateException();
	}
	} else if (type == TransformType.INVERSE) {
	if (normalization == DstNormalization.STANDARD_DST_I) {
	s = 2.0 / n;
	} else if (normalization == DstNormalization.ORTHOGONAL_DST_I) {
	s = FastMath.sqrt(2.0 / n);
	} else {
	throw new MathIllegalStateException();
	}
	} else {
	/*
	* Should never occur. This clause is a safeguard in case other
	* types are used to TransformType (which should not be done).
	*/
	throw new MathIllegalStateException();
	}
	TransformUtils.scaleArray(y, s);
	return y;
	}

	/*
	* Additional tests.
	*/
	@Test
	public void testTransformRealFirstElementNotZero() {
	final TransformType[] type = TransformType.values();
	final double[] data = new double[] {
	1.0, 1.0, 1.0, 1.0
	};
	final RealTransformer transformer = createRealTransformer();
	for (int j = 0; j < type.length; j++) {
	try {
	transformer.transform(data, type[j]);
	Assert.fail(type[j].toString());
	} catch (MathIllegalArgumentException e) {
	// Expected: do nothing
	}
	}
	}

	/*
	* Additional (legacy) tests.
	*/

	/**
	* Test of transformer for the ad hoc data.
	*/
	@Test
	public void testAdHocData() {
	FastSineTransformer transformer;
	transformer = new FastSineTransformer(DstNormalization.STANDARD_DST_I);
	double result[], tolerance = 1E-12;

	double x[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 };
	double y[] = { 0.0, 20.1093579685034, -9.65685424949238,
	5.98642305066196, -4.0, 2.67271455167720,
	-1.65685424949238, 0.795649469518633 };

	result = transformer.transform(x, TransformType.FORWARD);
	for (int i = 0; i < result.length; i++) {
	Assert.assertEquals(y[i], result[i], tolerance);
	}

	result = transformer.transform(y, TransformType.INVERSE);
	for (int i = 0; i < result.length; i++) {
	Assert.assertEquals(x[i], result[i], tolerance);
	}

	TransformUtils.scaleArray(x, FastMath.sqrt(x.length / 2.0));
	transformer = new FastSineTransformer(DstNormalization.ORTHOGONAL_DST_I);

	result = transformer.transform(y, TransformType.FORWARD);
	for (int i = 0; i < result.length; i++) {
	Assert.assertEquals(x[i], result[i], tolerance);
	}

	result = transformer.transform(x, TransformType.INVERSE);
	for (int i = 0; i < result.length; i++) {
	Assert.assertEquals(y[i], result[i], tolerance);
	}
	}

	/**
	* Test of transformer for the sine function.
	*/
	@Test
	public void testSinFunction() {
	UnivariateFunction f = new Sin();
	FastSineTransformer transformer;
	transformer = new FastSineTransformer(DstNormalization.STANDARD_DST_I);
	double min, max, result[], tolerance = 1E-12; int N = 1 << 8;

	min = 0.0; max = 2.0 * FastMath.PI;
	result = transformer.transform(f, min, max, N, TransformType.FORWARD);
	Assert.assertEquals(N >> 1, result[2], tolerance);
	for (int i = 0; i < N; i += (i == 1 ? 2 : 1)) {
	Assert.assertEquals(0.0, result[i], tolerance);
	}

	min = -FastMath.PI; max = FastMath.PI;
	result = transformer.transform(f, min, max, N, TransformType.FORWARD);
	Assert.assertEquals(-(N >> 1), result[2], tolerance);
	for (int i = 0; i < N; i += (i == 1 ? 2 : 1)) {
	Assert.assertEquals(0.0, result[i], tolerance);
	}
	}

	/**
	* Test of parameters for the transformer.
	*/
	@Test
	public void testParameters() throws Exception {
	UnivariateFunction f = new Sin();
	FastSineTransformer transformer;
	transformer = new FastSineTransformer(DstNormalization.STANDARD_DST_I);

	try {
	// bad interval
	transformer.transform(f, 1, -1, 64, TransformType.FORWARD);
	Assert.fail("Expecting IllegalArgumentException - bad interval");
	} catch (IllegalArgumentException ex) {
	// expected
	}
	try {
	// bad samples number
	transformer.transform(f, -1, 1, 0, TransformType.FORWARD);
	Assert.fail("Expecting IllegalArgumentException - bad samples number");
	} catch (IllegalArgumentException ex) {
	// expected
	}
	try {
	// bad samples number
	transformer.transform(f, -1, 1, 100, TransformType.FORWARD);
	Assert.fail("Expecting IllegalArgumentException - bad samples number");
	} catch (IllegalArgumentException ex) {
	// expected
	}
	}
	}