You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ce...@apache.org on 2012/02/11 18:38:30 UTC
svn commit: r1243110 - in /commons/proper/math/trunk/src:
main/java/org/apache/commons/math/transform/
test/java/org/apache/commons/math/transform/
Author: celestin
Date: Sat Feb 11 17:38:30 2012
New Revision: 1243110
URL: http://svn.apache.org/viewvc?rev=1243110&view=rev
Log:
In package o.a.c.m.transform
- replaced RealTransformer.transform(double[]) and RealTransformer.inverseTransform(double[]) with RealTransformer.transform(double[], TransformType)
- replaced RealTransformer.transform(UnivariateFunction, double, double, int) and RealTransformer.inverseTransform(UnivariateFunction, double, double, int) with RealTransformer.transform(UnivariateFunction, double, double, int, TransformType).
See MATH-743
Modified:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastCosineTransformer.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastHadamardTransformer.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastSineTransformer.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/RealTransformer.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastCosineTransformerTest.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastFourierTransformerTest.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastHadamardTransformerTest.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/RealTransformerAbstractTest.java
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastCosineTransformer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastCosineTransformer.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastCosineTransformer.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastCosineTransformer.java Sat Feb 11 17:38:30 2012
@@ -22,8 +22,6 @@ import org.apache.commons.math.analysis.
import org.apache.commons.math.analysis.UnivariateFunction;
import org.apache.commons.math.complex.Complex;
import org.apache.commons.math.exception.MathIllegalArgumentException;
-import org.apache.commons.math.exception.NonMonotonicSequenceException;
-import org.apache.commons.math.exception.NotStrictlyPositiveException;
import org.apache.commons.math.exception.util.LocalizedFormats;
import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
@@ -115,7 +113,7 @@ import org.apache.commons.math.util.Fast
public class FastCosineTransformer implements RealTransformer, Serializable {
/** Serializable version identifier. */
- static final long serialVersionUID = 20120501L;
+ static final long serialVersionUID = 20120211L;
/**
* {@code true} if the orthogonal version of the DCT should be used.
@@ -169,44 +167,14 @@ public class FastCosineTransformer imple
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two plus one
*/
- public double[] transform(double[] f) throws MathIllegalArgumentException {
-
- if (orthogonal) {
- final double s = FastMath.sqrt(2.0 / (f.length - 1));
- return TransformUtils.scaleArray(fct(f), s);
+ public double[] transform(final double[] f, final TransformType type) {
+ if (type == TransformType.FORWARD) {
+ if (orthogonal) {
+ final double s = FastMath.sqrt(2.0 / (f.length - 1));
+ return TransformUtils.scaleArray(fct(f), s);
+ }
+ return fct(f);
}
- return fct(f);
- }
-
- /**
- * {@inheritDoc}
- *
- * @throws NonMonotonicSequenceException if the lower bound is greater
- * than, or equal to the upper bound
- * @throws NotStrictlyPositiveException if the number of sample points is
- * negative
- * @throws MathIllegalArgumentException if the number of sample points is
- * not a power of two plus one
- */
- public double[] transform(UnivariateFunction f,
- double min, double max, int n) throws
- NonMonotonicSequenceException,
- NotStrictlyPositiveException,
- MathIllegalArgumentException {
-
- final double[] data = FunctionUtils.sample(f, min, max, n);
- return transform(data);
- }
-
- /**
- * {@inheritDoc}
- *
- * @throws MathIllegalArgumentException if the length of the data array is
- * not a power of two plus one
- */
- public double[] inverseTransform(double[] f) throws
- MathIllegalArgumentException {
-
final double s2 = 2.0 / (f.length - 1);
final double s1 = orthogonal ? FastMath.sqrt(s2) : s2;
return TransformUtils.scaleArray(fct(f), s1);
@@ -215,21 +183,19 @@ public class FastCosineTransformer imple
/**
* {@inheritDoc}
*
- * @throws NonMonotonicSequenceException if the lower bound is greater
- * than, or equal to the upper bound
- * @throws NotStrictlyPositiveException if the number of sample points is
- * negative
+ * @throws org.apache.commons.math.exception.NonMonotonicSequenceException
+ * if the lower bound is greater than, or equal to the upper bound
+ * @throws org.apache.commons.math.exception.NotStrictlyPositiveException
+ * if the number of sample points is negative
* @throws MathIllegalArgumentException if the number of sample points is
* not a power of two plus one
*/
- public double[] inverseTransform(UnivariateFunction f,
- double min, double max, int n) throws
- NonMonotonicSequenceException,
- NotStrictlyPositiveException,
- MathIllegalArgumentException {
+ public double[] transform(final UnivariateFunction f,
+ final double min, final double max, final int n,
+ final TransformType type) {
final double[] data = FunctionUtils.sample(f, min, max, n);
- return inverseTransform(data);
+ return transform(data, type);
}
/**
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastHadamardTransformer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastHadamardTransformer.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastHadamardTransformer.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastHadamardTransformer.java Sat Feb 11 17:38:30 2012
@@ -21,8 +21,6 @@ import java.io.Serializable;
import org.apache.commons.math.analysis.FunctionUtils;
import org.apache.commons.math.analysis.UnivariateFunction;
import org.apache.commons.math.exception.MathIllegalArgumentException;
-import org.apache.commons.math.exception.NonMonotonicSequenceException;
-import org.apache.commons.math.exception.NotStrictlyPositiveException;
import org.apache.commons.math.exception.util.LocalizedFormats;
import org.apache.commons.math.util.ArithmeticUtils;
@@ -40,7 +38,7 @@ import org.apache.commons.math.util.Arit
public class FastHadamardTransformer implements RealTransformer, Serializable {
/** Serializable version identifier. */
- static final long serialVersionUID = 20120501L;
+ static final long serialVersionUID = 20120211L;
/**
* {@inheritDoc}
@@ -48,60 +46,28 @@ public class FastHadamardTransformer imp
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two
*/
- public double[] transform(double[] f) throws MathIllegalArgumentException {
- return fht(f);
+ public double[] transform(final double[] f, final TransformType type) {
+ if (type == TransformType.FORWARD) {
+ return fht(f);
+ }
+ return TransformUtils.scaleArray(fht(f), 1.0 / f.length);
}
/**
* {@inheritDoc}
*
- * @throws NonMonotonicSequenceException if the lower bound is greater
- * than, or equal to the upper bound
- * @throws NotStrictlyPositiveException if the number of sample points is
- * negative
+ * @throws org.apache.commons.math.exception.NonMonotonicSequenceException
+ * if the lower bound is greater than, or equal to the upper bound
+ * @throws org.apache.commons.math.exception.NotStrictlyPositiveException
+ * if the number of sample points is negative
* @throws MathIllegalArgumentException if the number of sample points is
* not a power of two
*/
- public double[] transform(UnivariateFunction f,
- double min, double max, int n) throws
- NonMonotonicSequenceException,
- NotStrictlyPositiveException,
- MathIllegalArgumentException {
-
- return fht(FunctionUtils.sample(f, min, max, n));
- }
-
- /**
- * {@inheritDoc}
- *
- * @throws MathIllegalArgumentException if the length of the data array is
- * not a power of two
- */
- public double[] inverseTransform(double[] f)
- throws IllegalArgumentException {
+ public double[] transform(final UnivariateFunction f,
+ final double min, final double max, final int n,
+ final TransformType type) {
- return TransformUtils.scaleArray(fht(f), 1.0 / f.length);
- }
-
- /**
- * {@inheritDoc}
- *
- * @throws NonMonotonicSequenceException if the lower bound is greater
- * than, or equal to the upper bound
- * @throws NotStrictlyPositiveException if the number of sample points is
- * negative
- * @throws MathIllegalArgumentException if the number of sample points is
- * not a power of two
- */
- public double[] inverseTransform(UnivariateFunction f,
- double min, double max, int n) throws
- NonMonotonicSequenceException,
- NotStrictlyPositiveException,
- MathIllegalArgumentException {
-
- final double[] unscaled =
- fht(FunctionUtils.sample(f, min, max, n));
- return TransformUtils.scaleArray(unscaled, 1.0 / n);
+ return transform(FunctionUtils.sample(f, min, max, n), type);
}
/**
@@ -114,7 +80,7 @@ public class FastHadamardTransformer imp
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two
*/
- public int[] transform(int[] f) throws MathIllegalArgumentException {
+ public int[] transform(final int[] f) {
return fht(f);
}
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastSineTransformer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastSineTransformer.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastSineTransformer.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastSineTransformer.java Sat Feb 11 17:38:30 2012
@@ -22,8 +22,6 @@ import org.apache.commons.math.analysis.
import org.apache.commons.math.analysis.UnivariateFunction;
import org.apache.commons.math.complex.Complex;
import org.apache.commons.math.exception.MathIllegalArgumentException;
-import org.apache.commons.math.exception.NonMonotonicSequenceException;
-import org.apache.commons.math.exception.NotStrictlyPositiveException;
import org.apache.commons.math.exception.util.LocalizedFormats;
import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
@@ -105,9 +103,6 @@ import org.apache.commons.math.util.Fast
* {@link #inverseTransform(UnivariateFunction, double, double, int)}, after
* sampling.
* </p>
- * <p>
- * As of version 2.0 this no longer implements Serializable.
- * </p>
*
* @version $Id: FastSineTransformer.java 1213157 2011-12-12 07:19:23Z celestin$
* @since 1.2
@@ -115,7 +110,7 @@ import org.apache.commons.math.util.Fast
public class FastSineTransformer implements RealTransformer, Serializable {
/** Serializable version identifier. */
- static final long serialVersionUID = 20120501L;
+ static final long serialVersionUID = 20120211L;
/**
* {@code true} if the orthogonal version of the DCT should be used.
@@ -171,54 +166,13 @@ public class FastSineTransformer impleme
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two, or the first element of the data array is not zero
*/
- public double[] transform(double[] f) throws MathIllegalArgumentException {
+ public double[] transform(final double[] f, final TransformType type) {
if (orthogonal) {
final double s = FastMath.sqrt(2.0 / f.length);
return TransformUtils.scaleArray(fst(f), s);
}
- return fst(f);
- }
-
- /**
- * {@inheritDoc}
- *
- * This implementation enforces {@code f(x) = 0.0} at {@code x = 0.0}.
- *
- * @throws NonMonotonicSequenceException if the lower bound is greater
- * than, or equal to the upper bound
- * @throws NotStrictlyPositiveException if the number of sample points is
- * negative
- * @throws MathIllegalArgumentException if the number of sample points is
- * not a power of two
- */
- public double[] transform(UnivariateFunction f,
- double min, double max, int n) throws
- NonMonotonicSequenceException,
- NotStrictlyPositiveException,
- MathIllegalArgumentException {
-
- final double[] data = FunctionUtils.sample(f, min, max, n);
- data[0] = 0.0;
- if (orthogonal) {
- final double s = FastMath.sqrt(2.0 / n);
- return TransformUtils.scaleArray(fst(data), s);
- }
- return fst(data);
- }
-
- /**
- * {@inheritDoc}
- *
- * The first element of the specified data set is required to be {@code 0}.
- *
- * @throws MathIllegalArgumentException if the length of the data array is
- * not a power of two, or the first element of the data array is not zero
- */
- public double[] inverseTransform(double[] f)
- throws IllegalArgumentException {
-
- if (orthogonal) {
- return transform(f);
+ if (type == TransformType.FORWARD) {
+ return fst(f);
}
final double s = 2.0 / f.length;
return TransformUtils.scaleArray(fst(f), s);
@@ -229,28 +183,20 @@ public class FastSineTransformer impleme
*
* This implementation enforces {@code f(x) = 0.0} at {@code x = 0.0}.
*
- * @throws NonMonotonicSequenceException if the lower bound is greater
- * than, or equal to the upper bound
- * @throws NotStrictlyPositiveException if the number of sample points is
- * negative
+ * @throws org.apache.commons.math.exception.NonMonotonicSequenceException
+ * if the lower bound is greater than, or equal to the upper bound
+ * @throws org.apache.commons.math.exception.NotStrictlyPositiveException
+ * if the number of sample points is negative
* @throws MathIllegalArgumentException if the number of sample points is
* not a power of two
*/
- public double[] inverseTransform(UnivariateFunction f,
- double min, double max, int n) throws
- NonMonotonicSequenceException,
- NotStrictlyPositiveException,
- MathIllegalArgumentException {
-
- if (orthogonal) {
- return transform(f, min, max, n);
- }
+ public double[] transform(final UnivariateFunction f,
+ final double min, final double max, final int n,
+ final TransformType type) {
final double[] data = FunctionUtils.sample(f, min, max, n);
data[0] = 0.0;
- final double s = 2.0 / n;
-
- return TransformUtils.scaleArray(fst(data), s);
+ return transform(data, type);
}
/**
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/RealTransformer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/RealTransformer.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/RealTransformer.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/RealTransformer.java Sat Feb 11 17:38:30 2012
@@ -34,42 +34,30 @@ import org.apache.commons.math.analysis.
public interface RealTransformer {
/**
- * Returns the forward transform of the specified real data set.
+ * Returns the (forward, inverse) transform of the specified real data set.
*
* @param f the real data array to be transformed (signal)
+ * @param type the type of transform (forward, inverse) to be performed
* @return the real transformed array (spectrum)
*/
- double[] transform(double[] f);
+ double[] transform(double[] f, TransformType type);
/**
- * Returns the forward transform of the specified real function, sampled on
- * the specified interval.
+ * Returns the (forward, inverse) transform of the specified real function,
+ * sampled on the specified interval.
*
* @param f the function to be sampled and transformed
* @param min the (inclusive) lower bound for the interval
* @param max the (exclusive) upper bound for the interval
* @param n the number of sample points
+ * @param type the type of transform (forward, inverse) to be performed
* @return the real transformed array
+ * @throws org.apache.commons.math.exception.NonMonotonicSequenceException
+ * if the lower bound is greater than, or equal to the upper bound
+ * @throws org.apache.commons.math.exception.NotStrictlyPositiveException
+ * if the number of sample points is negative
*/
- double[] transform(UnivariateFunction f, double min, double max, int n);
-
- /**
- * Returns the inverse transform of the specified real data set.
- *
- * @param f the real data array to be inversely transformed
- * @return the real inversely transformed array
- */
- double[] inverseTransform(double[] f);
-
- /**
- * Returns the inverse transform of the specified real function, sampled
- * on the given interval.
- *
- * @param f the function to be sampled and inversely transformed
- * @param min the (inclusive) lower bound for the interval
- * @param max the (exclusive) upper bound for the interval
- * @param n the number of sample points
- * @return the real inversely transformed array
- */
- double[] inverseTransform(UnivariateFunction f, double min, double max, int n);
+ double[] transform(UnivariateFunction f,
+ double min, double max, int n,
+ TransformType type);
}
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastCosineTransformerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastCosineTransformerTest.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastCosineTransformerTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastCosineTransformerTest.java Sat Feb 11 17:38:30 2012
@@ -22,6 +22,7 @@ import java.util.Collection;
import org.apache.commons.math.analysis.SinFunction;
import org.apache.commons.math.analysis.UnivariateFunction;
import org.apache.commons.math.analysis.function.Sinc;
+import org.apache.commons.math.exception.MathIllegalStateException;
import org.apache.commons.math.util.FastMath;
import org.junit.Assert;
import org.junit.Test;
@@ -130,7 +131,7 @@ public final class FastCosineTransformer
}
@Override
- double[] transform(final double[] x, final boolean forward) {
+ double[] transform(final double[] x, final TransformType type) {
final int n = x.length;
final double[] y = new double[n];
final double[] cos = new double[2 * (n - 1)];
@@ -147,10 +148,16 @@ public final class FastCosineTransformer
sgn *= -1;
}
final double s;
- if (forward) {
+ if (type == TransformType.FORWARD) {
s = standard ? 1.0 : FastMath.sqrt(2.0 / (n - 1.0));
- } else {
+ } else if (type == TransformType.INVERSE) {
s = standard ? 2.0 / (n - 1.0) : FastMath.sqrt(2.0 / (n - 1.0));
+ } 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;
@@ -176,12 +183,12 @@ public final class FastCosineTransformer
4.0
};
- result = transformer.transform(x);
+ result = transformer.transform(x, TransformType.FORWARD);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(y[i], result[i], tolerance);
}
- result = transformer.inverseTransform(y);
+ result = transformer.transform(y, TransformType.INVERSE);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(x[i], result[i], tolerance);
}
@@ -189,12 +196,12 @@ public final class FastCosineTransformer
TransformUtils.scaleArray(x, FastMath.sqrt(0.5 * (x.length - 1)));
transformer = FastCosineTransformer.createOrthogonal();
- result = transformer.transform(y);
+ result = transformer.transform(y, TransformType.FORWARD);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(x[i], result[i], tolerance);
}
- result = transformer.inverseTransform(x);
+ result = transformer.transform(x, TransformType.INVERSE);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(y[i], result[i], tolerance);
}
@@ -209,14 +216,14 @@ public final class FastCosineTransformer
try {
// bad interval
- transformer.transform(f, 1, -1, 65);
+ transformer.transform(f, 1, -1, 65, TransformType.FORWARD);
Assert.fail("Expecting IllegalArgumentException - bad interval");
} catch (IllegalArgumentException ex) {
// expected
}
try {
// bad samples number
- transformer.transform(f, -1, 1, 1);
+ transformer.transform(f, -1, 1, 1, TransformType.FORWARD);
Assert
.fail("Expecting IllegalArgumentException - bad samples number");
} catch (IllegalArgumentException ex) {
@@ -224,7 +231,7 @@ public final class FastCosineTransformer
}
try {
// bad samples number
- transformer.transform(f, -1, 1, 64);
+ transformer.transform(f, -1, 1, 64, TransformType.FORWARD);
Assert
.fail("Expecting IllegalArgumentException - bad samples number");
} catch (IllegalArgumentException ex) {
@@ -247,14 +254,14 @@ public final class FastCosineTransformer
};
min = 0.0;
max = 2.0 * FastMath.PI * N / (N - 1);
- result = transformer.transform(f, min, max, N);
+ result = transformer.transform(f, min, max, N, TransformType.FORWARD);
for (int i = 0; i < N; i++) {
Assert.assertEquals(expected[i], result[i], tolerance);
}
min = -FastMath.PI;
max = FastMath.PI * (N + 1) / (N - 1);
- result = transformer.transform(f, min, max, N);
+ result = transformer.transform(f, min, max, N, TransformType.FORWARD);
for (int i = 0; i < N; i++) {
Assert.assertEquals(-expected[i], result[i], tolerance);
}
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastFourierTransformerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastFourierTransformerTest.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastFourierTransformerTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastFourierTransformerTest.java Sat Feb 11 17:38:30 2012
@@ -517,8 +517,6 @@ public final class FastFourierTransforme
for (int i = 0; i < input.length; i++) {
for (int j = 0; j < input[0].length; j++) {
- System.out.println(i + ", " + j + ", " + input[i][j] + ", " +
- goodOutput[i][j] + ", " + output[i][j] + ", ");
Assert.assertEquals(input[i][j].getImaginary(), output2[i][j].getImaginary(),
tolerance);
Assert.assertEquals(input[i][j].getReal(), output2[i][j].getReal(), tolerance);
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastHadamardTransformerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastHadamardTransformerTest.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastHadamardTransformerTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastHadamardTransformerTest.java Sat Feb 11 17:38:30 2012
@@ -51,7 +51,7 @@ public final class FastHadamardTransform
@Test
public void testNoIntInverse() {
FastHadamardTransformer transformer = new FastHadamardTransformer();
- double[] x = transformer.inverseTransform(new double[] { 0, 1, 0, 1});
+ double[] x = transformer.transform(new double[] { 0, 1, 0, 1}, TransformType.INVERSE);
Assert.assertEquals( 0.5, x[0], 0);
Assert.assertEquals(-0.5, x[1], 0);
Assert.assertEquals( 0.0, x[2], 0);
@@ -64,7 +64,7 @@ public final class FastHadamardTransform
@Test
public void test3Points() {
try {
- new FastHadamardTransformer().transform(new double[3]);
+ new FastHadamardTransformer().transform(new double[3], TransformType.FORWARD);
Assert.fail("an exception should have been thrown");
} catch (IllegalArgumentException iae) {
// expected
@@ -86,7 +86,7 @@ public final class FastHadamardTransform
for (int i = 0; i < dX.length; ++i) {
dX[i] = x[i];
}
- double dResult[] = transformer.transform(dX);
+ double dResult[] = transformer.transform(dX, TransformType.FORWARD);
for (int i = 0; i < dResult.length; i++) {
// compare computed results to precomputed results
Assert.assertTrue(Precision.equals(y[i], dResult[i], 1));
@@ -115,7 +115,7 @@ public final class FastHadamardTransform
for (int i = 0; i < dY.length; ++i) {
dY[i] = y[i];
}
- double dResult[] = transformer.inverseTransform(dY);
+ double dResult[] = transformer.transform(dY, TransformType.INVERSE);
for (int i = 0; i < dResult.length; i++) {
// compare computed results to precomputed results
Assert.assertTrue(Precision.equals(x[i], dResult[i], 1));
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java Sat Feb 11 17:38:30 2012
@@ -23,6 +23,7 @@ import org.apache.commons.math.analysis.
import org.apache.commons.math.analysis.UnivariateFunction;
import org.apache.commons.math.analysis.function.Sinc;
import org.apache.commons.math.exception.MathIllegalArgumentException;
+import org.apache.commons.math.exception.MathIllegalStateException;
import org.apache.commons.math.util.FastMath;
import org.junit.Assert;
import org.junit.Test;
@@ -143,7 +144,7 @@ public final class FastSineTransformerTe
}
@Override
- double[] transform(final double[] x, final boolean forward) {
+ 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];
@@ -158,10 +159,16 @@ public final class FastSineTransformerTe
y[j] = yj;
}
final double s;
- if (forward) {
+ if (type == TransformType.FORWARD) {
s = standard ? 1.0 : FastMath.sqrt(2.0 / (double) n);
- } else {
+ } else if (type == TransformType.INVERSE){
s = standard ? 2.0 / n : FastMath.sqrt(2.0 / (double) n);
+ } 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;
@@ -170,22 +177,21 @@ public final class FastSineTransformerTe
/*
* Additional tests.
*/
- @Test(expected = MathIllegalArgumentException.class)
+ @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();
- transformer.transform(data);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testInverseTransformRealFirstElementNotZero() {
- final double[] data = new double[] {
- 1.0, 1.0, 1.0, 1.0
- };
- final RealTransformer transformer = createRealTransformer();
- transformer.inverseTransform(data);
+ 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
+ }
+ }
}
/*
@@ -205,12 +211,12 @@ public final class FastSineTransformerTe
5.98642305066196, -4.0, 2.67271455167720,
-1.65685424949238, 0.795649469518633 };
- result = transformer.transform(x);
+ result = transformer.transform(x, TransformType.FORWARD);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(y[i], result[i], tolerance);
}
- result = transformer.inverseTransform(y);
+ result = transformer.transform(y, TransformType.INVERSE);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(x[i], result[i], tolerance);
}
@@ -218,12 +224,12 @@ public final class FastSineTransformerTe
TransformUtils.scaleArray(x, FastMath.sqrt(x.length / 2.0));
transformer = FastSineTransformer.createOrthogonal();
- result = transformer.transform(y);
+ result = transformer.transform(y, TransformType.FORWARD);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(x[i], result[i], tolerance);
}
- result = transformer.inverseTransform(x);
+ result = transformer.transform(x, TransformType.INVERSE);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(y[i], result[i], tolerance);
}
@@ -239,14 +245,14 @@ public final class FastSineTransformerTe
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);
+ 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);
+ 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);
@@ -263,21 +269,21 @@ public final class FastSineTransformerTe
try {
// bad interval
- transformer.transform(f, 1, -1, 64);
+ 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);
+ 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);
+ transformer.transform(f, -1, 1, 100, TransformType.FORWARD);
Assert.fail("Expecting IllegalArgumentException - bad samples number");
} catch (IllegalArgumentException ex) {
// expected
Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/RealTransformerAbstractTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/RealTransformerAbstractTest.java?rev=1243110&r1=1243109&r2=1243110&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/RealTransformerAbstractTest.java (original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/RealTransformerAbstractTest.java Sat Feb 11 17:38:30 2012
@@ -137,181 +137,107 @@ public abstract class RealTransformerAbs
* Returns the expected transform of the specified real data array.
*
* @param x the real data array to be transformed
- * @param forward {@code true} (resp. {@code false}) if the forward (resp.
- * inverse) transform is to be performed
+ * @param type the type of transform (forward, inverse) to be performed
* @return the expected transform
*/
- abstract double[] transform(double[] x, boolean forward);
+ abstract double[] transform(double[] x, TransformType type);
/*
* Check of preconditions.
*/
/**
- * {@link RealTransformer#transform(double[])} should throw a
+ * {@link RealTransformer#transform(double[], TransformType))} should throw a
* {@link MathIllegalArgumentException} if data size is invalid.
*/
@Test
public void testTransformRealInvalidDataSize() {
+ final TransformType[] type = TransformType.values();
final RealTransformer transformer = createRealTransformer();
for (int i = 0; i < getNumberOfInvalidDataSizes(); i++) {
final int n = getInvalidDataSize(i);
- try {
- transformer.transform(createRealData(n));
- Assert.fail(Integer.toString(n));
- } catch (MathIllegalArgumentException e) {
- // Expected: do nothing
+ for (int j = 0; j < type.length; j++) {
+ try {
+ transformer.transform(createRealData(n), type[j]);
+ Assert.fail(type[j] + ", " + n);
+ } catch (MathIllegalArgumentException e) {
+ // Expected: do nothing
+ }
}
}
}
/**
- * {@link RealTransformer#transform(UnivariateFunction, double, double, int)}
+ * {@link RealTransformer#transform(UnivariateFunction, double, double, int, TransformType)}
* should throw a {@link MathIllegalArgumentException} if number of samples
* is invalid.
*/
@Test
public void testTransformFunctionInvalidDataSize() {
+ final TransformType[] type = TransformType.values();
final RealTransformer transformer = createRealTransformer();
final UnivariateFunction f = getValidFunction();
final double a = getValidLowerBound();
final double b = getValidUpperBound();
for (int i = 0; i < getNumberOfInvalidDataSizes(); i++) {
final int n = getInvalidDataSize(i);
- try {
- transformer.transform(f, a, b, n);
- Assert.fail(Integer.toString(n));
- } catch (MathIllegalArgumentException e) {
- // Expected: do nothing
+ for (int j = 0; j < type.length; j++) {
+ try {
+ transformer.transform(f, a, b, n, type[j]);
+ Assert.fail(type[j] + ", " + n);
+ } catch (MathIllegalArgumentException e) {
+ // Expected: do nothing
+ }
}
}
}
/**
- * {@link RealTransformer#transform(UnivariateFunction, double, double, int)}
+ * {@link RealTransformer#transform(UnivariateFunction, double, double, int, TransformType)}
* should throw a {@link NotStrictlyPositiveException} if number of samples
* is not strictly positive.
*/
@Test
public void testTransformFunctionNotStrictlyPositiveNumberOfSamples() {
+ final TransformType[] type = TransformType.values();
final RealTransformer transformer = createRealTransformer();
final UnivariateFunction f = getValidFunction();
final double a = getValidLowerBound();
final double b = getValidUpperBound();
for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
final int n = getValidDataSize(i);
- try {
- transformer.transform(f, a, b, -n);
- Assert.fail(Integer.toString(-n));
- } catch (NotStrictlyPositiveException e) {
- // Expected: do nothing
+ for (int j = 0; j < type.length; j++) {
+ try {
+ transformer.transform(f, a, b, -n, type[j]);
+ Assert.fail(type[j] + ", " + (-n));
+ } catch (NotStrictlyPositiveException e) {
+ // Expected: do nothing
+ }
}
}
}
/**
- * {@link RealTransformer#transform(UnivariateFunction, double, double, int)}
+ * {@link RealTransformer#transform(UnivariateFunction, double, double, int, TransformType)}
* should throw a {@link NumberIsTooLargeException} if sampling bounds are
* not correctly ordered.
*/
@Test
public void testTransformFunctionInvalidBounds() {
+ final TransformType[] type = TransformType.values();
final RealTransformer transformer = createRealTransformer();
final UnivariateFunction f = getValidFunction();
final double a = getValidLowerBound();
final double b = getValidUpperBound();
for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
final int n = getValidDataSize(i);
- try {
- transformer.transform(f, b, a, n);
- Assert.fail(Double.toString(b) + ", " + Double.toString(a));
- } catch (NumberIsTooLargeException e) {
- // Expected: do nothing
- }
- }
- }
-
- /**
- * {@link RealTransformer#inverseTransform(double[])} should throw a
- * {@link MathIllegalArgumentException} if data size is invalid.
- */
- @Test
- public void testInverseTransformRealInvalidDataSize() {
- final RealTransformer transformer = createRealTransformer();
- for (int i = 0; i < getNumberOfInvalidDataSizes(); i++) {
- final int n = getInvalidDataSize(i);
- try {
- transformer.inverseTransform(createRealData(n));
- Assert.fail(Integer.toString(n));
- } catch (MathIllegalArgumentException e) {
- // Expected: do nothing
- }
- }
- }
-
- /**
- * {@link RealTransformer#inverseTransform(UnivariateFunction, double, double, int)}
- * should throw a {@link MathIllegalArgumentException} if number of samples
- * is invalid.
- */
- @Test
- public void testInverseTransformFunctionInvalidDataSize() {
- final RealTransformer transformer = createRealTransformer();
- final UnivariateFunction f = getValidFunction();
- final double a = getValidLowerBound();
- final double b = getValidUpperBound();
- for (int i = 0; i < getNumberOfInvalidDataSizes(); i++) {
- final int n = getInvalidDataSize(i);
- try {
- transformer.inverseTransform(f, a, b, n);
- Assert.fail(Integer.toString(n));
- } catch (MathIllegalArgumentException e) {
- // Expected: do nothing
- }
- }
- }
-
- /**
- * {@link RealTransformer#inverseTransform(UnivariateFunction, double, double, int)}
- * should throw a {@link NotStrictlyPositiveException} if number of samples
- * is not strictly positive.
- */
- @Test
- public void
- testInverseTransformFunctionNotStrictlyPositiveNumberOfSamples() {
- final RealTransformer transformer = createRealTransformer();
- final UnivariateFunction f = getValidFunction();
- final double a = getValidLowerBound();
- final double b = getValidUpperBound();
- for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
- final int n = getValidDataSize(i);
- try {
- transformer.inverseTransform(f, a, b, -n);
- Assert.fail(Integer.toString(-n));
- } catch (NotStrictlyPositiveException e) {
- // Expected: do nothing
- }
- }
- }
-
- /**
- * {@link RealTransformer#inverseTransform(UnivariateFunction, double, double, int)}
- * should throw a {@link NumberIsTooLargeException} if sampling bounds are
- * not correctly ordered.
- */
- @Test
- public void testInverseTransformFunctionInvalidBounds() {
- final RealTransformer transformer = createRealTransformer();
- final UnivariateFunction f = getValidFunction();
- final double a = getValidLowerBound();
- final double b = getValidUpperBound();
- for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
- final int n = getValidDataSize(i);
- try {
- transformer.inverseTransform(f, b, a, n);
- Assert.fail(Double.toString(b) + ", " + Double.toString(a));
- } catch (NumberIsTooLargeException e) {
- // Expected: do nothing
+ for (int j = 0; j < type.length; j++) {
+ try {
+ transformer.transform(f, b, a, n, type[j]);
+ Assert.fail(type[j] + ", " + b + ", " + a);
+ } catch (NumberIsTooLargeException e) {
+ // Expected: do nothing
+ }
}
}
}
@@ -333,10 +259,13 @@ public abstract class RealTransformerAbs
*/
@Test
public void testTransformReal() {
+ final TransformType[] type = TransformType.values();
for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
final int n = getValidDataSize(i);
final double tol = getRelativeTolerance(i);
- doTestTransformReal(n, tol, true);
+ for (int j = 0; j < type.length; j++) {
+ doTestTransformReal(n, tol, type[j]);
+ }
}
}
@@ -353,50 +282,13 @@ public abstract class RealTransformerAbs
*/
@Test
public void testTransformFunction() {
+ final TransformType[] type = TransformType.values();
for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
final int n = getValidDataSize(i);
final double tol = getRelativeTolerance(i);
- doTestTransformFunction(n, tol, true);
- }
- }
-
- /**
- * Accuracy check of {@link RealTransformer#inverseTransform(double[])}. For
- * each valid data size returned by
- * {@link #getValidDataSize(int) getValidDataSize(i)},
- * a random data array is generated with
- * {@link RealTransformerAbstractTest#createRealData(int)}. 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 testInverseTransformReal() {
- for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
- final int n = getValidDataSize(i);
- final double tol = getRelativeTolerance(i);
- doTestTransformReal(n, tol, false);
- }
- }
-
- /**
- * Accuracy check of
- * {@link RealTransformer#inverseTransform(UnivariateFunction, double, double, int)}.
- * For each valid data size returned by
- * {@link #getValidDataSize(int) getValidDataSize(i)},
- * the {@link 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 testInverseTransformFunction() {
- for (int i = 0; i < getNumberOfValidDataSizes(); i++) {
- final int n = getValidDataSize(i);
- final double tol = getRelativeTolerance(i);
- doTestTransformFunction(n, tol, false);
+ for (int j = 0; j < type.length; j++) {
+ doTestTransformFunction(n, tol, type[j]);
+ }
}
}
@@ -425,16 +317,11 @@ public abstract class RealTransformerAbs
*/
private void doTestTransformReal(final int n, final double tol,
- final boolean forward) {
+ final TransformType type) {
final RealTransformer transformer = createRealTransformer();
final double[] x = createRealData(n);
- final double[] expected = transform(x, forward);
- final double[] actual;
- if (forward) {
- actual = transformer.transform(x);
- } else {
- actual = transformer.inverseTransform(x);
- }
+ final double[] expected = transform(x, type);
+ final double[] actual = transformer.transform(x, type);
for (int i = 0; i < n; i++) {
final String msg = String.format("%d, %d", n, i);
final double delta = tol * FastMath.abs(expected[i]);
@@ -443,7 +330,7 @@ public abstract class RealTransformerAbs
}
private void doTestTransformFunction(final int n, final double tol,
- final boolean forward) {
+ final TransformType type) {
final RealTransformer transformer = createRealTransformer();
final UnivariateFunction f = getValidFunction();
final double a = getValidLowerBound();
@@ -453,13 +340,8 @@ public abstract class RealTransformerAbs
final double t = a + i * (b - a) / n;
x[i] = f.value(t);
}
- final double[] expected = transform(x, forward);
- final double[] actual;
- if (forward) {
- actual = transformer.transform(f, a, b, n);
- } else {
- actual = transformer.inverseTransform(f, a, b, n);
- }
+ final double[] expected = transform(x, type);
+ final double[] actual = transformer.transform(f, a, b, n, type);
for (int i = 0; i < n; i++) {
final String msg = String.format("%d, %d", n, i);
final double delta = tol * FastMath.abs(expected[i]);