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/10 09:46:41 UTC
svn commit: r1242703 - in /commons/proper/math/trunk/src:
main/java/org/apache/commons/math/transform/
test/java/org/apache/commons/math/transform/
Author: celestin
Date: Fri Feb 10 08:46:40 2012
New Revision: 1242703
URL: http://svn.apache.org/viewvc?rev=1242703&view=rev
Log:
In o.a.c.m.transform, introduced an enumeration for the type (forward, inverse) of transform asked by the user (MATH-743).
Added:
commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/TransformType.java (with props)
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/FastFourierTransformer.java
commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastSineTransformer.java
commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastFourierTransformerTest.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=1242703&r1=1242702&r2=1242703&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 Fri Feb 10 08:46:40 2012
@@ -25,7 +25,7 @@ import org.apache.commons.math.exception
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.transform.FastFourierTransformer.Normalization;
+import org.apache.commons.math.transform.FastFourierTransformer.DftNormalization;
import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
@@ -273,8 +273,8 @@ public class FastCosineTransformer imple
t1 += c;
}
FastFourierTransformer transformer;
- transformer = new FastFourierTransformer(Normalization.STANDARD);
- Complex[] y = transformer.transform(x);
+ transformer = new FastFourierTransformer(DftNormalization.STANDARD);
+ Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FCT result for the original array
transformed[0] = y[0].getReal();
Modified: commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastFourierTransformer.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastFourierTransformer.java?rev=1242703&r1=1242702&r2=1242703&view=diff
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastFourierTransformer.java (original)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/FastFourierTransformer.java Fri Feb 10 08:46:40 2012
@@ -85,17 +85,22 @@ import org.apache.commons.math.util.Math
*/
public class FastFourierTransformer implements Serializable {
- /** The various types of normalizations that can be applied. */
- public static enum Normalization {
- /** Standard DFT. */
+ /**
+ * The various types of normalizations that can be applied to discrete
+ * Fourier transforms.
+ *
+ * @see FastFourierTransformer
+ */
+ public static enum DftNormalization {
+ /** The normalization to be specified for standard DFT. */
STANDARD,
- /** Unitary DFT. */
+ /** The normalization to be specified for unitary DFT. */
UNITARY;
}
/** Serializable version identifier. */
- static final long serialVersionUID = 20120902L;
+ static final long serialVersionUID = 20120210L;
/**
* {@code W_SUB_N_R[i]} is the real part of
@@ -143,19 +148,18 @@ public class FastFourierTransformer impl
, -0x1.921fb54442d18p-54, -0x1.921fb54442d18p-55, -0x1.921fb54442d18p-56, -0x1.921fb54442d18p-57
, -0x1.921fb54442d18p-58, -0x1.921fb54442d18p-59, -0x1.921fb54442d18p-60 };
- /**
- * The type of DFT to be performed.
- */
- private final Normalization type;
+ /** The type of DFT to be performed. */
+ private final DftNormalization normalization;
/**
* Creates a new instance of this class, with various normalization
* conventions.
*
- * @param type the type of transform to be computed
+ * @param normalization the type of normalization to be applied to the
+ * transformed data
*/
- public FastFourierTransformer(final Normalization type) {
- this.type = type;
+ public FastFourierTransformer(final DftNormalization normalization) {
+ this.normalization = normalization;
}
/**
@@ -199,21 +203,21 @@ public class FastFourierTransformer impl
* Applies the proper normalization to the specified transformed data.
*
* @param dataRI the unscaled transformed data
- * @param type the type of transform
- * @param inverse {@code true} if normalization should be performed for the
- * inverse transform
+ * @param normalization the normalization to be applied
+ * @param type the type of transform (forward, inverse) which resulted in the
+ * specified data
*/
private static void normalizeTransformedData(final double[][] dataRI,
- final Normalization type, final boolean inverse) {
+ final DftNormalization normalization, final TransformType type) {
final double[] dataR = dataRI[0];
final double[] dataI = dataRI[1];
final int n = dataR.length;
assert dataI.length == n;
- switch (type) {
+ switch (normalization) {
case STANDARD:
- if (inverse) {
+ if (type == TransformType.INVERSE) {
final double scaleFactor = 1.0 / ((double) n);
for (int i = 0; i < n; i++) {
dataR[i] *= scaleFactor;
@@ -251,18 +255,16 @@ public class FastFourierTransformer impl
*
* @param dataRI the two dimensional array of real and imaginary parts of
* the data
- * @param type the type of normalization to be applied to the transformed
+ * @param normalization the normalization to be applied to the transformed
* data
- * @param inverse {@code true} if the inverse standard transform must be
- * performed
+ * @param type the type of transform (forward, inverse) to be performed
* @throws DimensionMismatchException if the number of rows of the specified
* array is not two, or the array is not rectangular
* @throws MathIllegalArgumentException if the number of data points is not
* a power of two
*/
public static void transformInPlace(final double[][] dataRI,
- final Normalization type, final boolean inverse) throws
- DimensionMismatchException, MathIllegalArgumentException {
+ final DftNormalization normalization, final TransformType type) {
if (dataRI.length != 2) {
throw new DimensionMismatchException(dataRI.length, 2);
@@ -295,14 +297,14 @@ public class FastFourierTransformer impl
dataR[1] = srcR0 - srcR1;
dataI[1] = srcI0 - srcI1;
- normalizeTransformedData(dataRI, type, inverse);
+ normalizeTransformedData(dataRI, normalization, type);
return;
}
bitReversalShuffle2(dataR, dataI);
// Do 4-term DFT.
- if (inverse) {
+ if (type == TransformType.INVERSE) {
for (int i0 = 0; i0 < n; i0 += 4) {
final int i1 = i0 + 1;
final int i2 = i0 + 2;
@@ -369,7 +371,7 @@ public class FastFourierTransformer impl
int logN0 = lastLogN0 + 1;
double wSubN0R = W_SUB_N_R[logN0];
double wSubN0I = W_SUB_N_I[logN0];
- if (inverse) {
+ if (type == TransformType.INVERSE) {
wSubN0I = -wSubN0I;
}
@@ -405,41 +407,37 @@ public class FastFourierTransformer impl
lastLogN0 = logN0;
}
- normalizeTransformedData(dataRI, type, inverse);
+ normalizeTransformedData(dataRI, normalization, type);
}
/**
- * 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
+ * @param type the type of transform (forward, inverse) to be performed
* @return the complex transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two
*/
- public Complex[] transform(double[] f) {
+ public Complex[] transform(final double[] f, final TransformType type) {
final double[][] dataRI = new double[][] {
MathArrays.copyOf(f, f.length), new double[f.length]
};
- transformInPlace(dataRI, type, false);
-
-// if (unitary) {
-// final double s = 1.0 / FastMath.sqrt(f.length);
-// TransformUtils.scaleArray(dataRI[0], s);
-// TransformUtils.scaleArray(dataRI[1], s);
-// }
+ transformInPlace(dataRI, normalization, type);
return TransformUtils.createComplexArray(dataRI);
}
/**
- * 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 complex transformed array
* @throws org.apache.commons.math.exception.NumberIsTooLargeException
* if the lower bound is greater than, or equal to the upper bound
@@ -448,98 +446,28 @@ public class FastFourierTransformer impl
* @throws MathIllegalArgumentException if the number of sample points
* {@code n} is not a power of two
*/
- public Complex[] transform(UnivariateFunction f,
- double min, double max, int n) {
+ public Complex[] 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 transform(data);
+ return transform(data, type);
}
/**
- * Returns the forward transform of the specified complex data set.
+ * Returns the (forward, inverse) transform of the specified complex data
+ * set.
*
* @param f the complex data array to be transformed
+ * @param type the type of transform (forward, inverse) to be performed
* @return the complex transformed array
* @throws MathIllegalArgumentException if the length of the data array is
* not a power of two
*/
- public Complex[] transform(Complex[] f) {
- final double[][] dataRI = TransformUtils.createRealImaginaryArray(f);
-
- transformInPlace(dataRI, type, false);
- // if (unitary) {
- // final double s = 1.0 / FastMath.sqrt(f.length);
- // TransformUtils.scaleArray(dataRI[0], s);
- // TransformUtils.scaleArray(dataRI[1], s);
- // }
-
- return TransformUtils.createComplexArray(dataRI);
- }
-
- /**
- * Returns the inverse transform of the specified real data set.
- *
- * @param f the real data array to be inversely transformed
- * @return the complex inversely transformed array
- * @throws MathIllegalArgumentException if the length of the data array is
- * not a power of two
- */
- public Complex[] inverseTransform(double[] f) {
- final double[][] dataRI = new double[][] {
- MathArrays.copyOf(f, f.length), new double[f.length]
- };
-
- transformInPlace(dataRI, type, true);
- // if (unitary) {
- // final double s = FastMath.sqrt(f.length);
- // TransformUtils.scaleArray(dataRI[0], s);
- // TransformUtils.scaleArray(dataRI[1], s);
- // }
-
- return TransformUtils.createComplexArray(dataRI);
- }
-
- /**
- * 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 complex inversely transformed array
- * @throws org.apache.commons.math.exception.NumberIsTooLargeException
- * 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 {@code n} is negative
- * @throws MathIllegalArgumentException if the number of sample points
- * {@code n} is not a power of two
- */
- public Complex[] inverseTransform(UnivariateFunction f,
- double min, double max, int n) {
- final double[] data = FunctionUtils.sample(f, min, max, n);
- return inverseTransform(data);
- }
-
- /**
- * Returns the inverse transform of the specified complex data set.
- *
- * @param f the complex data array to be inversely transformed
- * @return the complex inversely transformed array
- * @throws MathIllegalArgumentException if the length of the data array is
- * not a power of two
- */
- public Complex[] inverseTransform(Complex[] f) {
+ public Complex[] transform(final Complex[] f, final TransformType type) {
final double[][] dataRI = TransformUtils.createRealImaginaryArray(f);
- final double[] dataR = dataRI[0];
- final double[] dataI = dataRI[1];
- transformInPlace(dataRI, type, true);
-// if (unitary) {
-// final double s = FastMath.sqrt(f.length);
-// TransformUtils.scaleArray(dataR, s);
-// TransformUtils.scaleArray(dataI, s);
-// }
+ transformInPlace(dataRI, normalization, type);
return TransformUtils.createComplexArray(dataRI);
}
@@ -555,19 +483,20 @@ public class FastFourierTransformer impl
*
* @param mdca Multi-Dimensional Complex Array id est
* {@code Complex[][][][]}
- * @param forward {@link #inverseTransform} is performed if this is
- * {@code false}
+ * @param type the type of transform (forward, inverse) to be performed
* @return transform of {@code mdca} as a Multi-Dimensional Complex Array
* id est {@code Complex[][][][]}
* @throws IllegalArgumentException if any dimension is not a power of two
+ * @deprecated see MATH-736
*/
- public Object mdfft(Object mdca, boolean forward) {
+ @Deprecated
+ public Object mdfft(Object mdca, TransformType type) {
MultiDimensionalComplexMatrix mdcm = (MultiDimensionalComplexMatrix)
new MultiDimensionalComplexMatrix(mdca).clone();
int[] dimensionSize = mdcm.getDimensionSizes();
//cycle through each dimension
for (int i = 0; i < dimensionSize.length; i++) {
- mdfft(mdcm, forward, i, new int[0]);
+ mdfft(mdcm, type, i, new int[0]);
}
return mdcm.getArray();
}
@@ -576,14 +505,15 @@ public class FastFourierTransformer impl
* Performs one dimension of a multi-dimensional Fourier transform.
*
* @param mdcm input matrix
- * @param forward {@link #inverseTransform} is performed if this is
- * {@code false}
+ * @param type the type of transform (forward, inverse) to be performed
* @param d index of the dimension to process
* @param subVector recursion subvector
* @throws IllegalArgumentException if any dimension is not a power of two
+ * @deprecated see MATH-736
*/
+ @Deprecated
private void mdfft(MultiDimensionalComplexMatrix mdcm,
- boolean forward, int d, int[] subVector) {
+ TransformType type, int d, int[] subVector) {
int[] dimensionSize = mdcm.getDimensionSizes();
//if done
@@ -595,11 +525,7 @@ public class FastFourierTransformer impl
temp[i] = mdcm.get(subVector);
}
- if (forward) {
- temp = transform(temp);
- } else {
- temp = inverseTransform(temp);
- }
+ temp = transform(temp, type);
for (int i = 0; i < dimensionSize[d]; i++) {
subVector[d] = i;
@@ -612,12 +538,12 @@ public class FastFourierTransformer impl
//value is not important once the recursion is done.
//then an fft will be applied along the dimension d.
vector[d] = 0;
- mdfft(mdcm, forward, d, vector);
+ mdfft(mdcm, type, d, vector);
} else {
for (int i = 0; i < dimensionSize[subVector.length]; i++) {
vector[subVector.length] = i;
//further split along the next dimension
- mdfft(mdcm, forward, d, vector);
+ mdfft(mdcm, type, d, vector);
}
}
}
@@ -629,7 +555,10 @@ public class FastFourierTransformer impl
* eventually be replaced by jsr-83 of the java community process
* http://jcp.org/en/jsr/detail?id=83
* may require additional exception throws for other basic requirements.
+ *
+ * @deprecated see MATH-736
*/
+ @Deprecated
private static class MultiDimensionalComplexMatrix
implements Cloneable {
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=1242703&r1=1242702&r2=1242703&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 Fri Feb 10 08:46:40 2012
@@ -25,7 +25,7 @@ import org.apache.commons.math.exception
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.transform.FastFourierTransformer.Normalization;
+import org.apache.commons.math.transform.FastFourierTransformer.DftNormalization;
import org.apache.commons.math.util.ArithmeticUtils;
import org.apache.commons.math.util.FastMath;
@@ -294,8 +294,8 @@ public class FastSineTransformer impleme
x[n - i] = a - b;
}
FastFourierTransformer transformer;
- transformer = new FastFourierTransformer(Normalization.STANDARD);
- Complex[] y = transformer.transform(x);
+ transformer = new FastFourierTransformer(DftNormalization.STANDARD);
+ Complex[] y = transformer.transform(x, TransformType.FORWARD);
// reconstruct the FST result for the original array
transformed[0] = 0.0;
Added: commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/TransformType.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/TransformType.java?rev=1242703&view=auto
==============================================================================
--- commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/TransformType.java (added)
+++ commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/TransformType.java Fri Feb 10 08:46:40 2012
@@ -0,0 +1,31 @@
+/*
+ * 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.math.transform;
+
+/**
+ * This enumeration defines the type of transform which is to be computed.
+ *
+ * @version $Id Revision$
+ * @since 3.0
+ */
+public enum TransformType {
+ /** The type to be specified for forward transforms. */
+ FORWARD,
+
+ /** The type to be specified for inverse transforms. */
+ INVERSE;
+}
Propchange: commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/TransformType.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/math/trunk/src/main/java/org/apache/commons/math/transform/TransformType.java
------------------------------------------------------------------------------
svn:keywords = Id Revision
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=1242703&r1=1242702&r2=1242703&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 Fri Feb 10 08:46:40 2012
@@ -26,7 +26,7 @@ import org.apache.commons.math.complex.C
import org.apache.commons.math.exception.MathIllegalArgumentException;
import org.apache.commons.math.exception.NotStrictlyPositiveException;
import org.apache.commons.math.exception.NumberIsTooLargeException;
-import org.apache.commons.math.transform.FastFourierTransformer.Normalization;
+import org.apache.commons.math.transform.FastFourierTransformer.DftNormalization;
import org.apache.commons.math.util.FastMath;
import org.junit.Assert;
import org.junit.Test;
@@ -44,191 +44,123 @@ public final class FastFourierTransforme
private final static long SEED = 20110111L;
/*
- * Precondition checks for standard transform.
+ * Precondition checks.
*/
- @Test(expected = MathIllegalArgumentException.class)
- public void testStandardTransformComplexSizeNotAPowerOfTwo() {
- final int n = 127;
- final Complex[] x = createComplexData(n);
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.transform(x);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testStandardTransformRealSizeNotAPowerOfTwo() {
- final int n = 127;
- final double[] x = createRealData(n);
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.transform(x);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testStandardTransformFunctionSizeNotAPowerOfTwo() {
- final int n = 127;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.transform(f, 0.0, Math.PI, n);
- }
-
- @Test(expected = NotStrictlyPositiveException.class)
- public void testStandardTransformFunctionNotStrictlyPositiveNumberOfSamples() {
- final int n = -128;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.transform(f, 0.0, Math.PI, n);
- }
-
- @Test(expected = NumberIsTooLargeException.class)
- public void testStandardTransformFunctionInvalidBounds() {
- final int n = 128;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.transform(f, Math.PI, 0.0, n);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testStandardInverseTransformComplexSizeNotAPowerOfTwo() {
- final int n = 127;
- final Complex[] x = createComplexData(n);
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.inverseTransform(x);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testStandardInverseTransformRealSizeNotAPowerOfTwo() {
- final int n = 127;
- final double[] x = createRealData(n);
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.inverseTransform(x);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testStandardInverseTransformFunctionSizeNotAPowerOfTwo() {
- final int n = 127;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.inverseTransform(f, 0.0, Math.PI, n);
- }
-
- @Test(expected = NotStrictlyPositiveException.class)
- public void testStandardInverseTransformFunctionNotStrictlyPositiveNumberOfSamples() {
- final int n = -128;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.inverseTransform(f, 0.0, Math.PI, n);
- }
-
- @Test(expected = NumberIsTooLargeException.class)
- public void testStandardInverseTransformFunctionInvalidBounds() {
- final int n = 128;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.STANDARD);
- fft.transform(f, Math.PI, 0.0, n);
- }
-
- /*
- * Precondition checks for unitary transform.
- */
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testUnitaryTransformComplexSizeNotAPowerOfTwo() {
- final int n = 127;
- final Complex[] x = createComplexData(n);
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.transform(x);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testUnitaryTransformRealSizeNotAPowerOfTwo() {
- final int n = 127;
- final double[] x = createRealData(n);
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.transform(x);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testUnitaryTransformFunctionSizeNotAPowerOfTwo() {
- final int n = 127;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.transform(f, 0.0, Math.PI, n);
- }
-
- @Test(expected = NotStrictlyPositiveException.class)
- public void testUnitaryTransformFunctionNotStrictlyPositiveNumberOfSamples() {
- final int n = -128;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.transform(f, 0.0, Math.PI, n);
- }
-
- @Test(expected = NumberIsTooLargeException.class)
- public void testUnitaryTransformFunctionInvalidBounds() {
- final int n = 128;
- final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.transform(f, Math.PI, 0.0, n);
- }
-
- @Test(expected = MathIllegalArgumentException.class)
- public void testUnitaryInverseTransformComplexSizeNotAPowerOfTwo() {
+ @Test
+ public void testTransformComplexSizeNotAPowerOfTwo() {
final int n = 127;
final Complex[] x = createComplexData(n);
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.inverseTransform(x);
+ final FastFourierTransformer.DftNormalization[] norm;
+ norm = FastFourierTransformer.DftNormalization.values();
+ final TransformType[] type;
+ type = TransformType.values();
+ for (int i = 0; i < norm.length; i++) {
+ for (int j = 0; j < type.length; j++) {
+ final FastFourierTransformer fft;
+ fft = new FastFourierTransformer(norm[i]);
+ try {
+ fft.transform(x, type[j]);
+ Assert.fail(norm[i] + ", " + type[j] +
+ ": MathIllegalArgumentException was expected");
+ } catch (MathIllegalArgumentException e) {
+ // Expected behaviour
+ }
+ }
+ }
}
- @Test(expected = MathIllegalArgumentException.class)
- public void testUnitaryInverseTransformRealSizeNotAPowerOfTwo() {
+ @Test
+ public void testTransformRealSizeNotAPowerOfTwo() {
final int n = 127;
final double[] x = createRealData(n);
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.inverseTransform(x);
+ final FastFourierTransformer.DftNormalization[] norm;
+ norm = FastFourierTransformer.DftNormalization.values();
+ final TransformType[] type;
+ type = TransformType.values();
+ for (int i = 0; i < norm.length; i++) {
+ for (int j = 0; j < type.length; j++) {
+ final FastFourierTransformer fft;
+ fft = new FastFourierTransformer(norm[i]);
+ try {
+ fft.transform(x, type[j]);
+ Assert.fail(norm[i] + ", " + type[j] +
+ ": MathIllegalArgumentException was expected");
+ } catch (MathIllegalArgumentException e) {
+ // Expected behaviour
+ }
+ }
+ }
}
- @Test(expected = MathIllegalArgumentException.class)
- public void testUnitaryInverseTransformFunctionSizeNotAPowerOfTwo() {
+ @Test
+ public void testTransformFunctionSizeNotAPowerOfTwo() {
final int n = 127;
final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.inverseTransform(f, 0.0, Math.PI, n);
+ final FastFourierTransformer.DftNormalization[] norm;
+ norm = FastFourierTransformer.DftNormalization.values();
+ final TransformType[] type;
+ type = TransformType.values();
+ for (int i = 0; i < norm.length; i++) {
+ for (int j = 0; j < type.length; j++) {
+ final FastFourierTransformer fft;
+ fft = new FastFourierTransformer(norm[i]);
+ try {
+ fft.transform(f, 0.0, Math.PI, n, type[j]);
+ Assert.fail(norm[i] + ", " + type[j] +
+ ": MathIllegalArgumentException was expected");
+ } catch (MathIllegalArgumentException e) {
+ // Expected behaviour
+ }
+ }
+ }
}
- @Test(expected = NotStrictlyPositiveException.class)
- public void testUnitaryInverseTransformFunctionNotStrictlyPositiveNumberOfSamples() {
+ @Test
+ public void testTransformFunctionNotStrictlyPositiveNumberOfSamples() {
final int n = -128;
final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.inverseTransform(f, 0.0, Math.PI, n);
+ final FastFourierTransformer.DftNormalization[] norm;
+ norm = FastFourierTransformer.DftNormalization.values();
+ final TransformType[] type;
+ type = TransformType.values();
+ for (int i = 0; i < norm.length; i++) {
+ for (int j = 0; j < type.length; j++) {
+ final FastFourierTransformer fft;
+ fft = new FastFourierTransformer(norm[i]);
+ try {
+ fft.transform(f, 0.0, Math.PI, n, type[j]);
+ fft.transform(f, 0.0, Math.PI, n, type[j]);
+ Assert.fail(norm[i] + ", " + type[j] +
+ ": NotStrictlyPositiveException was expected");
+ } catch (NotStrictlyPositiveException e) {
+ // Expected behaviour
+ }
+ }
+ }
}
- @Test(expected = NumberIsTooLargeException.class)
- public void testUnitaryInverseTransformFunctionInvalidBounds() {
+ @Test
+ public void testTransformFunctionInvalidBounds() {
final int n = 128;
final UnivariateFunction f = new Sin();
- final FastFourierTransformer fft;
- fft = new FastFourierTransformer(Normalization.UNITARY);
- fft.transform(f, Math.PI, 0.0, n);
+ final FastFourierTransformer.DftNormalization[] norm;
+ norm = FastFourierTransformer.DftNormalization.values();
+ final TransformType[] type;
+ type = TransformType.values();
+ for (int i = 0; i < norm.length; i++) {
+ for (int j = 0; j < type.length; j++) {
+ final FastFourierTransformer fft;
+ fft = new FastFourierTransformer(norm[i]);
+ try {
+ fft.transform(f, Math.PI, 0.0, n, type[j]);
+ Assert.fail(norm[i] + ", " + type[j] +
+ ": NumberIsTooLargeException was expected");
+ } catch (NumberIsTooLargeException e) {
+ // Expected behaviour
+ }
+ }
+ }
}
/*
@@ -284,28 +216,32 @@ public final class FastFourierTransforme
}
private static void doTestTransformComplex(final int n, final double tol,
- final boolean forward, final boolean standard) {
+ final FastFourierTransformer.DftNormalization normalization,
+ final TransformType type) {
final FastFourierTransformer fft;
- if (standard) {
- fft = new FastFourierTransformer(Normalization.STANDARD);
- } else {
- fft = new FastFourierTransformer(Normalization.UNITARY);
- }
+ fft = new FastFourierTransformer(normalization);
final Complex[] x = createComplexData(n);
final Complex[] expected;
- final Complex[] actual;
final double s;
- if (forward) {
+ if (type==TransformType.FORWARD) {
expected = dft(x, -1);
- s = standard ? 1.0 : 1.0 / FastMath.sqrt(n);
- actual = fft.transform(x);
+ if (normalization == FastFourierTransformer.DftNormalization.STANDARD){
+ s = 1.0;
+ } else {
+ s = 1.0 / FastMath.sqrt(n);
+ }
} else {
expected = dft(x, 1);
- s = standard ? 1.0 / n : 1.0 / FastMath.sqrt(n);
- actual = fft.inverseTransform(x);
+ if (normalization == FastFourierTransformer.DftNormalization.STANDARD) {
+ s = 1.0 / n;
+ } else {
+ s = 1.0 / FastMath.sqrt(n);
+ }
}
+ final Complex[] actual = fft.transform(x, type);
for (int i = 0; i < n; i++) {
- final String msg = String.format("%d, %d", n, i);
+ final String msg;
+ msg = String.format("%s, %s, %d, %d", normalization, type, n, i);
final double re = s * expected[i].getReal();
Assert.assertEquals(msg, re, actual[i].getReal(),
tol * FastMath.abs(re));
@@ -316,32 +252,36 @@ public final class FastFourierTransforme
}
private static void doTestTransformReal(final int n, final double tol,
- final boolean forward, final boolean standard) {
+ final FastFourierTransformer.DftNormalization normalization,
+ final TransformType type) {
final FastFourierTransformer fft;
- if (standard) {
- fft = new FastFourierTransformer(Normalization.STANDARD);
- } else {
- fft = new FastFourierTransformer(Normalization.UNITARY);
- }
+ fft = new FastFourierTransformer(normalization);
final double[] x = createRealData(n);
final Complex[] xc = new Complex[n];
for (int i = 0; i < n; i++) {
xc[i] = new Complex(x[i], 0.0);
}
final Complex[] expected;
- final Complex[] actual;
final double s;
- if (forward) {
+ if (type == TransformType.FORWARD) {
expected = dft(xc, -1);
- s = standard ? 1.0 : 1.0 / FastMath.sqrt(n);
- actual = fft.transform(x);
+ if (normalization == FastFourierTransformer.DftNormalization.STANDARD) {
+ s = 1.0;
+ } else {
+ s = 1.0 / FastMath.sqrt(n);
+ }
} else {
expected = dft(xc, 1);
- s = standard ? 1.0 / n : 1.0 / FastMath.sqrt(n);
- actual = fft.inverseTransform(x);
+ if (normalization == FastFourierTransformer.DftNormalization.STANDARD) {
+ s = 1.0 / n;
+ } else {
+ s = 1.0 / FastMath.sqrt(n);
+ }
}
+ final Complex[] actual = fft.transform(x, type);
for (int i = 0; i < n; i++) {
- final String msg = String.format("%d, %d", n, i);
+ final String msg;
+ msg = String.format("%s, %s, %d, %d", normalization, type, n, i);
final double re = s * expected[i].getReal();
Assert.assertEquals(msg, re, actual[i].getReal(),
tol * FastMath.abs(re));
@@ -353,30 +293,33 @@ public final class FastFourierTransforme
private static void doTestTransformFunction(final UnivariateFunction f,
final double min, final double max, int n, final double tol,
- final boolean forward, final boolean standard) {
+ final FastFourierTransformer.DftNormalization normalization,
+ final TransformType type) {
final FastFourierTransformer fft;
- if (standard) {
- fft = new FastFourierTransformer(Normalization.STANDARD);
- } else {
- fft = new FastFourierTransformer(Normalization.UNITARY);
- }
+ fft = new FastFourierTransformer(normalization);
final Complex[] x = new Complex[n];
for (int i = 0; i < n; i++) {
final double t = min + i * (max - min) / n;
x[i] = new Complex(f.value(t));
}
final Complex[] expected;
- final Complex[] actual;
final double s;
- if (forward) {
+ if (type == TransformType.FORWARD) {
expected = dft(x, -1);
- s = standard ? 1.0 : 1.0 / FastMath.sqrt(n);
- actual = fft.transform(f, min, max, n);
+ if (normalization == FastFourierTransformer.DftNormalization.STANDARD) {
+ s = 1.0;
+ } else {
+ s = 1.0 / FastMath.sqrt(n);
+ }
} else {
expected = dft(x, 1);
- s = standard ? 1.0 / n : 1.0 / FastMath.sqrt(n);
- actual = fft.inverseTransform(f, min, max, n);
+ if (normalization == FastFourierTransformer.DftNormalization.STANDARD) {
+ s = 1.0 / n;
+ } else {
+ s = 1.0 / FastMath.sqrt(n);
+ }
}
+ final Complex[] actual = fft.transform(f, min, max, n, type);
for (int i = 0; i < n; i++) {
final String msg = String.format("%d, %d", n, i);
final double re = s * expected[i].getReal();
@@ -393,29 +336,41 @@ public final class FastFourierTransforme
*/
@Test
- public void testStandardTransformComplex() {
- final boolean forward = true;
- final boolean standard = true;
- doTestTransformComplex(2, 1.0E-15, forward, standard);
- doTestTransformComplex(4, 1.0E-14, forward, standard);
- doTestTransformComplex(8, 1.0E-14, forward, standard);
- doTestTransformComplex(16, 1.0E-13, forward, standard);
- doTestTransformComplex(32, 1.0E-13, forward, standard);
- doTestTransformComplex(64, 1.0E-12, forward, standard);
- doTestTransformComplex(128, 1.0E-12, forward, standard);
+ public void testTransformComplex() {
+ final FastFourierTransformer.DftNormalization[] norm;
+ norm = FastFourierTransformer.DftNormalization.values();
+ final TransformType[] type;
+ type = TransformType.values();
+ for (int i = 0; i < norm.length; i++) {
+ for (int j = 0; j < type.length; j++) {
+ doTestTransformComplex(2, 1.0E-15, norm[i], type[j]);
+ doTestTransformComplex(4, 1.0E-14, norm[i], type[j]);
+ doTestTransformComplex(8, 1.0E-14, norm[i], type[j]);
+ doTestTransformComplex(16, 1.0E-13, norm[i], type[j]);
+ doTestTransformComplex(32, 1.0E-13, norm[i], type[j]);
+ doTestTransformComplex(64, 1.0E-12, norm[i], type[j]);
+ doTestTransformComplex(128, 1.0E-12, norm[i], type[j]);
+ }
+ }
}
@Test
public void testStandardTransformReal() {
- final boolean forward = true;
- final boolean standard = true;
- doTestTransformReal(2, 1.0E-15, forward, standard);
- doTestTransformReal(4, 1.0E-14, forward, standard);
- doTestTransformReal(8, 1.0E-14, forward, standard);
- doTestTransformReal(16, 1.0E-13, forward, standard);
- doTestTransformReal(32, 1.0E-13, forward, standard);
- doTestTransformReal(64, 1.0E-13, forward, standard);
- doTestTransformReal(128, 1.0E-11, forward, standard);
+ final FastFourierTransformer.DftNormalization[] norm;
+ norm = FastFourierTransformer.DftNormalization.values();
+ final TransformType[] type;
+ type = TransformType.values();
+ for (int i = 0; i < norm.length; i++) {
+ for (int j = 0; j < type.length; j++) {
+ doTestTransformReal(2, 1.0E-15, norm[i], type[j]);
+ doTestTransformReal(4, 1.0E-14, norm[i], type[j]);
+ doTestTransformReal(8, 1.0E-14, norm[i], type[j]);
+ doTestTransformReal(16, 1.0E-13, norm[i], type[j]);
+ doTestTransformReal(32, 1.0E-13, norm[i], type[j]);
+ doTestTransformReal(64, 1.0E-13, norm[i], type[j]);
+ doTestTransformReal(128, 1.0E-11, norm[i], type[j]);
+ }
+ }
}
@Test
@@ -423,145 +378,21 @@ public final class FastFourierTransforme
final UnivariateFunction f = new Sinc();
final double min = -FastMath.PI;
final double max = FastMath.PI;
- final boolean forward = true;
- final boolean standard = true;
- doTestTransformFunction(f, min, max, 2, 1.0E-15, forward, standard);
- doTestTransformFunction(f, min, max, 4, 1.0E-14, forward, standard);
- doTestTransformFunction(f, min, max, 8, 1.0E-14, forward, standard);
- doTestTransformFunction(f, min, max, 16, 1.0E-13, forward, standard);
- doTestTransformFunction(f, min, max, 32, 1.0E-13, forward, standard);
- doTestTransformFunction(f, min, max, 64, 1.0E-12, forward, standard);
- doTestTransformFunction(f, min, max, 128, 1.0E-11, forward, standard);
- }
-
- @Test
- public void testStandardInverseTransformComplex() {
- final boolean forward = false;
- final boolean standard = true;
- doTestTransformComplex(2, 1.0E-15, forward, standard);
- doTestTransformComplex(4, 1.0E-14, forward, standard);
- doTestTransformComplex(8, 1.0E-14, forward, standard);
- doTestTransformComplex(16, 1.0E-13, forward, standard);
- doTestTransformComplex(32, 1.0E-13, forward, standard);
- doTestTransformComplex(64, 1.0E-12, forward, standard);
- doTestTransformComplex(128, 1.0E-12, forward, standard);
- }
-
- @Test
- public void testStandardInverseTransformReal() {
- final boolean forward = false;
- final boolean standard = true;
- doTestTransformReal(2, 1.0E-15, forward, standard);
- doTestTransformReal(4, 1.0E-14, forward, standard);
- doTestTransformReal(8, 1.0E-14, forward, standard);
- doTestTransformReal(16, 1.0E-13, forward, standard);
- doTestTransformReal(32, 1.0E-13, forward, standard);
- doTestTransformReal(64, 1.0E-12, forward, standard);
- doTestTransformReal(128, 1.0E-11, forward, standard);
- }
-
- @Test
- public void testStandardInverseTransformFunction() {
- final UnivariateFunction f = new Sinc();
- final double min = -FastMath.PI;
- final double max = FastMath.PI;
- final boolean forward = false;
- final boolean standard = true;
- doTestTransformFunction(f, min, max, 2, 1.0E-15, forward, standard);
- doTestTransformFunction(f, min, max, 4, 1.0E-14, forward, standard);
- doTestTransformFunction(f, min, max, 8, 1.0E-14, forward, standard);
- doTestTransformFunction(f, min, max, 16, 1.0E-13, forward, standard);
- doTestTransformFunction(f, min, max, 32, 1.0E-13, forward, standard);
- doTestTransformFunction(f, min, max, 64, 1.0E-12, forward, standard);
- doTestTransformFunction(f, min, max, 128, 1.0E-11, forward, standard);
- }
-
- /*
- * Tests of unitary transform (when data is valid).
- */
-
- @Test
- public void testUnitaryTransformComplex() {
- final boolean forward = true;
- final boolean standard = false;
- doTestTransformComplex(2, 1.0E-15, forward, standard);
- doTestTransformComplex(4, 1.0E-14, forward, standard);
- doTestTransformComplex(8, 1.0E-14, forward, standard);
- doTestTransformComplex(16, 1.0E-13, forward, standard);
- doTestTransformComplex(32, 1.0E-13, forward, standard);
- doTestTransformComplex(64, 1.0E-12, forward, standard);
- doTestTransformComplex(128, 1.0E-12, forward, standard);
- }
-
- @Test
- public void testUnitaryTransformReal() {
- final boolean forward = true;
- final boolean standard = false;
- doTestTransformReal(2, 1.0E-15, forward, standard);
- doTestTransformReal(4, 1.0E-14, forward, standard);
- doTestTransformReal(8, 1.0E-14, forward, standard);
- doTestTransformReal(16, 1.0E-13, forward, standard);
- doTestTransformReal(32, 1.0E-13, forward, standard);
- doTestTransformReal(64, 1.0E-13, forward, standard);
- doTestTransformReal(128, 1.0E-11, forward, standard);
- }
-
- @Test
- public void testUnitaryTransformFunction() {
- final UnivariateFunction f = new Sinc();
- final double min = -FastMath.PI;
- final double max = FastMath.PI;
- final boolean forward = true;
- final boolean standard = false;
- doTestTransformFunction(f, min, max, 2, 1.0E-15, forward, standard);
- doTestTransformFunction(f, min, max, 4, 1.0E-14, forward, standard);
- doTestTransformFunction(f, min, max, 8, 1.0E-14, forward, standard);
- doTestTransformFunction(f, min, max, 16, 1.0E-13, forward, standard);
- doTestTransformFunction(f, min, max, 32, 1.0E-13, forward, standard);
- doTestTransformFunction(f, min, max, 64, 1.0E-12, forward, standard);
- doTestTransformFunction(f, min, max, 128, 1.0E-11, forward, standard);
- }
-
- @Test
- public void testUnitaryInverseTransformComplex() {
- final boolean forward = false;
- final boolean standard = false;
- doTestTransformComplex(2, 1.0E-14, forward, standard);
- doTestTransformComplex(4, 1.0E-14, forward, standard);
- doTestTransformComplex(8, 1.0E-14, forward, standard);
- doTestTransformComplex(16, 1.0E-13, forward, standard);
- doTestTransformComplex(32, 1.0E-13, forward, standard);
- doTestTransformComplex(64, 1.0E-12, forward, standard);
- doTestTransformComplex(128, 1.0E-12, forward, standard);
- }
-
- @Test
- public void testUnitaryInverseTransformReal() {
- final boolean forward = false;
- final boolean standard = false;
- doTestTransformReal(2, 1.0E-15, forward, standard);
- doTestTransformReal(4, 1.0E-14, forward, standard);
- doTestTransformReal(8, 1.0E-14, forward, standard);
- doTestTransformReal(16, 1.0E-13, forward, standard);
- doTestTransformReal(32, 1.0E-13, forward, standard);
- doTestTransformReal(64, 1.0E-12, forward, standard);
- doTestTransformReal(128, 1.0E-11, forward, standard);
- }
-
- @Test
- public void testUnitaryInverseTransformFunction() {
- final UnivariateFunction f = new Sinc();
- final double min = -FastMath.PI;
- final double max = FastMath.PI;
- final boolean forward = false;
- final boolean standard = false;
- doTestTransformFunction(f, min, max, 2, 1.0E-15, forward, standard);
- doTestTransformFunction(f, min, max, 4, 1.0E-14, forward, standard);
- doTestTransformFunction(f, min, max, 8, 1.0E-14, forward, standard);
- doTestTransformFunction(f, min, max, 16, 1.0E-13, forward, standard);
- doTestTransformFunction(f, min, max, 32, 1.0E-13, forward, standard);
- doTestTransformFunction(f, min, max, 64, 1.0E-12, forward, standard);
- doTestTransformFunction(f, min, max, 128, 1.0E-11, forward, standard);
+ final FastFourierTransformer.DftNormalization[] norm;
+ norm = FastFourierTransformer.DftNormalization.values();
+ final TransformType[] type;
+ type = TransformType.values();
+ for (int i = 0; i < norm.length; i++) {
+ for (int j = 0; j < type.length; j++) {
+ doTestTransformFunction(f, min, max, 2, 1.0E-15, norm[i], type[j]);
+ doTestTransformFunction(f, min, max, 4, 1.0E-14, norm[i], type[j]);
+ doTestTransformFunction(f, min, max, 8, 1.0E-14, norm[i], type[j]);
+ doTestTransformFunction(f, min, max, 16, 1.0E-13, norm[i], type[j]);
+ doTestTransformFunction(f, min, max, 32, 1.0E-13, norm[i], type[j]);
+ doTestTransformFunction(f, min, max, 64, 1.0E-12, norm[i], type[j]);
+ doTestTransformFunction(f, min, max, 128, 1.0E-11, norm[i], type[j]);
+ }
+ }
}
/*
@@ -574,7 +405,7 @@ public final class FastFourierTransforme
@Test
public void testAdHocData() {
FastFourierTransformer transformer;
- transformer = new FastFourierTransformer(Normalization.STANDARD);
+ transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex result[]; double tolerance = 1E-12;
double x[] = {1.3, 2.4, 1.7, 4.1, 2.9, 1.7, 5.1, 2.7};
@@ -588,13 +419,13 @@ public final class FastFourierTransforme
new Complex(-2.6, -2.7),
new Complex(-2.09497474683058, -1.91507575950825)};
- result = transformer.transform(x);
+ result = transformer.transform(x, TransformType.FORWARD);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(y[i].getReal(), result[i].getReal(), tolerance);
Assert.assertEquals(y[i].getImaginary(), result[i].getImaginary(), 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].getReal(), tolerance);
Assert.assertEquals(0.0, result[i].getImaginary(), tolerance);
@@ -604,14 +435,14 @@ public final class FastFourierTransforme
TransformUtils.scaleArray(x2, 1.0 / FastMath.sqrt(x2.length));
Complex y2[] = y;
- transformer = new FastFourierTransformer(Normalization.UNITARY);
- result = transformer.transform(y2);
+ transformer = new FastFourierTransformer(DftNormalization.UNITARY);
+ result = transformer.transform(y2, TransformType.FORWARD);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(x2[i], result[i].getReal(), tolerance);
Assert.assertEquals(0.0, result[i].getImaginary(), tolerance);
}
- result = transformer.inverseTransform(x2);
+ result = transformer.transform(x2, TransformType.INVERSE);
for (int i = 0; i < result.length; i++) {
Assert.assertEquals(y2[i].getReal(), result[i].getReal(), tolerance);
Assert.assertEquals(y2[i].getImaginary(), result[i].getImaginary(), tolerance);
@@ -625,12 +456,12 @@ public final class FastFourierTransforme
public void testSinFunction() {
UnivariateFunction f = new SinFunction();
FastFourierTransformer transformer;
- transformer = new FastFourierTransformer(Normalization.STANDARD);
+ transformer = new FastFourierTransformer(DftNormalization.STANDARD);
Complex result[]; int N = 1 << 8;
double min, max, tolerance = 1E-12;
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(0.0, result[1].getReal(), tolerance);
Assert.assertEquals(-(N >> 1), result[1].getImaginary(), tolerance);
Assert.assertEquals(0.0, result[N-1].getReal(), tolerance);
@@ -641,7 +472,7 @@ public final class FastFourierTransforme
}
min = -FastMath.PI; max = FastMath.PI;
- result = transformer.inverseTransform(f, min, max, N);
+ result = transformer.transform(f, min, max, N, TransformType.INVERSE);
Assert.assertEquals(0.0, result[1].getReal(), tolerance);
Assert.assertEquals(-0.5, result[1].getImaginary(), tolerance);
Assert.assertEquals(0.0, result[N-1].getReal(), tolerance);
@@ -659,7 +490,7 @@ public final class FastFourierTransforme
@Test
public void test2DData() {
FastFourierTransformer transformer;
- transformer = new FastFourierTransformer(Normalization.STANDARD);
+ transformer = new FastFourierTransformer(DftNormalization.STANDARD);
double tolerance = 1E-12;
Complex[][] input = new Complex[][] {new Complex[] {new Complex(1, 0),
@@ -675,8 +506,8 @@ public final class FastFourierTransforme
FastMath.sqrt(goodOutput[i].length) *
FastMath.sqrt(goodOutput.length));
}
- Complex[][] output = (Complex[][])transformer.mdfft(input, true);
- Complex[][] output2 = (Complex[][])transformer.mdfft(output, false);
+ Complex[][] output = (Complex[][])transformer.mdfft(input, TransformType.FORWARD);
+ Complex[][] output2 = (Complex[][])transformer.mdfft(output, TransformType.INVERSE);
Assert.assertEquals(input.length, output.length);
Assert.assertEquals(input.length, output2.length);
@@ -687,6 +518,8 @@ 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);
@@ -700,7 +533,7 @@ public final class FastFourierTransforme
@Test
public void test2DDataUnitary() {
FastFourierTransformer transformer;
- transformer = new FastFourierTransformer(Normalization.UNITARY);
+ transformer = new FastFourierTransformer(DftNormalization.UNITARY);
double tolerance = 1E-12;
Complex[][] input = new Complex[][] {new Complex[] {new Complex(1, 0),
new Complex(2, 0)},
@@ -709,8 +542,8 @@ public final class FastFourierTransforme
Complex[][] goodOutput = new Complex[][] {new Complex[] {new Complex(5,
1.5), new Complex(-1, -.5)}, new Complex[] {new Complex(-2,
-1.5), new Complex(0, .5)}};
- Complex[][] output = (Complex[][])transformer.mdfft(input, true);
- Complex[][] output2 = (Complex[][])transformer.mdfft(output, false);
+ Complex[][] output = (Complex[][])transformer.mdfft(input, TransformType.FORWARD);
+ Complex[][] output2 = (Complex[][])transformer.mdfft(output, TransformType.INVERSE);
Assert.assertEquals(input.length, output.length);
Assert.assertEquals(input.length, output2.length);