Return-Path: X-Original-To: apmail-commons-commits-archive@minotaur.apache.org Delivered-To: apmail-commons-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id 6F4059D3E for ; Fri, 10 Feb 2012 08:47:29 +0000 (UTC) Received: (qmail 64739 invoked by uid 500); 10 Feb 2012 08:47:26 -0000 Delivered-To: apmail-commons-commits-archive@commons.apache.org Received: (qmail 64395 invoked by uid 500); 10 Feb 2012 08:47:16 -0000 Mailing-List: contact commits-help@commons.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@commons.apache.org Delivered-To: mailing list commits@commons.apache.org Received: (qmail 64339 invoked by uid 99); 10 Feb 2012 08:47:11 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 10 Feb 2012 08:47:11 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=5.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Fri, 10 Feb 2012 08:47:03 +0000 Received: from eris.apache.org (localhost [127.0.0.1]) by eris.apache.org (Postfix) with ESMTP id 54B2823888D2 for ; Fri, 10 Feb 2012 08:46:41 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r1242703 - in /commons/proper/math/trunk/src: main/java/org/apache/commons/math/transform/ test/java/org/apache/commons/math/transform/ Date: Fri, 10 Feb 2012 08:46:41 -0000 To: commits@commons.apache.org From: celestin@apache.org X-Mailer: svnmailer-1.0.8-patched Message-Id: <20120210084641.54B2823888D2@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org 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);