commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From celes...@apache.org
Subject svn commit: r1213157 - in /commons/proper/math/trunk/src: main/java/org/apache/commons/math/transform/FastSineTransformer.java test/java/org/apache/commons/math/transform/FastSineTransformerTest.java
Date Mon, 12 Dec 2011 07:19:23 GMT
Author: celestin
Date: Mon Dec 12 07:19:23 2011
New Revision: 1213157

URL: http://svn.apache.org/viewvc?rev=1213157&view=rev
Log:
In transform.FastSineTransformer, replaced the pair transform2() / inverseTransform2() with
two factory methods: create() and createOrthogonal() (MATH-677).

Modified:
    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/FastSineTransformerTest.java

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=1213157&r1=1213156&r2=1213157&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
Mon Dec 12 07:19:23 2011
@@ -40,162 +40,138 @@ import org.apache.commons.math.util.Fast
  * @since 1.2
  */
 public class FastSineTransformer implements RealTransformer {
-
-    /** Construct a default transformer. */
-    public FastSineTransformer() {
-        super();
-    }
-
     /**
-     * Transform the given real data set.
-     * <p>
-     * The formula is F<sub>n</sub> = &sum;<sub>k=0</sub><sup>N-1</sup>
f<sub>k</sub> sin(&pi; nk/N)
-     * </p>
+     * {@code true} if the orthogonal version of the DCT should be used.
      *
-     * @param f the real data array to be transformed
-     * @return the real transformed array
-     * @throws IllegalArgumentException if any parameters are invalid
+     * @see #create()
+     * @see #createOrthogonal()
      */
-    public double[] transform(double[] f)
-        throws IllegalArgumentException {
-        return fst(f);
-    }
+    private final boolean orthogonal;
 
     /**
-     * Transform the given real function, sampled on the given interval.
-     * <p>
-     * The formula is F<sub>n</sub> = &sum;<sub>k=0</sub><sup>N-1</sup>
f<sub>k</sub> sin(&pi; nk/N)
-     * </p>
+     * Creates a new instance of this class, with various normalization
+     * conventions.
      *
-     * @param f the function to be sampled and transformed
-     * @param min the lower bound for the interval
-     * @param max the upper bound for the interval
-     * @param n the number of sample points
-     * @return the real transformed array
-     * @throws IllegalArgumentException if any parameters are invalid
+     * @param orthogonal {@code false} if the DST is <em>not</em> to be scaled,
+     * {@code true} if it is to be scaled so as to make the transform
+     * orthogonal.
+     * @see #create()
+     * @see #createOrthogonal()
      */
-    public double[] transform(UnivariateFunction f,
-                              double min, double max, int n)
-        throws IllegalArgumentException {
-
-        double[] data = FastFourierTransformer.sample(f, min, max, n);
-        data[0] = 0.0;
-        return fst(data);
+    private FastSineTransformer(final boolean orthogonal) {
+        this.orthogonal = orthogonal;
     }
 
     /**
-     * Transform the given real data set.
      * <p>
-     * The formula is F<sub>n</sub> = &radic;(2/N) &sum;<sub>k=0</sub><sup>N-1</sup>
f<sub>k</sub> sin(&pi; nk/N)
+     * Returns a new instance of this class. The returned transformer uses the
+     * normalizing conventions described below.
+     * <ul>
+     * <li>Forward transform:
+     * y<sub>n</sub> = &sum;<sub>k=0</sub><sup>N-1</sup>
+     * x<sub>k</sub> sin(&pi; nk / N),</li>
+     * <li>Inverse transform:
+     * x<sub>k</sub> = (2 / N) &sum;<sub>n=0</sub><sup>N-1</sup>
+     * y<sub>n</sub> sin(&pi; nk / N),</li>
+     * </ul>
+     * where N is the size of the data sample.
      * </p>
      *
-     * @param f the real data array to be transformed
-     * @return the real transformed array
-     * @throws IllegalArgumentException if any parameters are invalid
+     * @return a new DST transformer, with "standard" normalizing conventions
      */
-    public double[] transform2(double[] f) throws IllegalArgumentException {
-
-        double scalingCoefficient = FastMath.sqrt(2.0 / f.length);
-        return FastFourierTransformer.scaleArray(fst(f), scalingCoefficient);
+    public static FastSineTransformer create() {
+        return new FastSineTransformer(false);
     }
 
     /**
-     * Transform the given real function, sampled on the given interval.
      * <p>
-     * The formula is F<sub>n</sub> = &radic;(2/N) &sum;<sub>k=0</sub><sup>N-1</sup>
f<sub>k</sub> sin(&pi; nk/N)
+     * Returns a new instance of this class. The returned transformer uses the
+     * normalizing conventions described below.
+     * <ul>
+     * <li>Forward transform:
+     * y<sub>n</sub> = &radic;(2 / N) &sum;<sub>k=0</sub><sup>N-1</sup>
+     * x<sub>k</sub> sin(&pi; nk / N),</li>
+     * <li>Inverse transform:
+     * x<sub>k</sub> = &radic;(2 / N) &sum;<sub>n=0</sub><sup>N-1</sup>
+     * y<sub>n</sub> sin(&pi; nk / N),</li>
+     * </ul>
+     * which make the transform orthogonal. N is the size of the data sample.
      * </p>
      *
-     * @param f the function to be sampled and transformed
-     * @param min the lower bound for the interval
-     * @param max the upper bound for the interval
-     * @param n the number of sample points
-     * @return the real transformed array
-     * @throws IllegalArgumentException if any parameters are invalid
+     * @return a new DST transformer, with "orthogonal" normalizing conventions
      */
-    public double[] transform2(
-        UnivariateFunction f, double min, double max, int n)
-        throws IllegalArgumentException {
-
-        double[] data = FastFourierTransformer.sample(f, min, max, n);
-        data[0] = 0.0;
-        double scalingCoefficient = FastMath.sqrt(2.0 / n);
-        return FastFourierTransformer.scaleArray(fst(data), scalingCoefficient);
+    public static FastSineTransformer createOrthogonal() {
+        return new FastSineTransformer(true);
     }
 
     /**
-     * Inversely transform the given real data set.
-     * <p>
-     * The formula is f<sub>k</sub> = (2/N) &sum;<sub>n=0</sub><sup>N-1</sup>
F<sub>n</sub> sin(&pi; nk/N)
-     * </p>
+     * {@inheritDoc}
      *
-     * @param f the real data array to be inversely transformed
-     * @return the real inversely transformed array
-     * @throws IllegalArgumentException if any parameters are invalid
+     * The first element of the specified data set is required to be {@code 0}.
      */
-    public double[] inverseTransform(double[] f) throws IllegalArgumentException {
-
-        double scalingCoefficient = 2.0 / f.length;
-        return FastFourierTransformer.scaleArray(fst(f), scalingCoefficient);
+    public double[] transform(double[] f) throws IllegalArgumentException {
+        if (orthogonal){
+            final double s = FastMath.sqrt(2.0 / f.length);
+            return FastFourierTransformer.scaleArray(fst(f), s);
+        }
+        return fst(f);
     }
 
     /**
-     * Inversely transform the given real function, sampled on the given interval.
-     * <p>
-     * The formula is f<sub>k</sub> = (2/N) &sum;<sub>n=0</sub><sup>N-1</sup>
F<sub>n</sub> sin(&pi; nk/N)
-     * </p>
+     * {@inheritDoc}
      *
-     * @param f the function to be sampled and inversely transformed
-     * @param min the lower bound for the interval
-     * @param max the upper bound for the interval
-     * @param n the number of sample points
-     * @return the real inversely transformed array
-     * @throws IllegalArgumentException if any parameters are invalid
+     * This implementation enforces {@code f(x) = 0.0} at {@code x = 0.0}.
      */
-    public double[] inverseTransform(UnivariateFunction f, double min, double max, int n)
-        throws IllegalArgumentException {
+    public double[] transform(UnivariateFunction f,
+        double min, double max, int n) throws IllegalArgumentException {
 
-        double[] data = FastFourierTransformer.sample(f, min, max, n);
+        final double[] data = FastFourierTransformer.sample(f, min, max, n);
         data[0] = 0.0;
-        double scalingCoefficient = 2.0 / n;
-        return FastFourierTransformer.scaleArray(fst(data), scalingCoefficient);
+        if (orthogonal) {
+            final double s = FastMath.sqrt(2.0 / n);
+            return FastFourierTransformer.scaleArray(fst(data), s);
+        }
+        return fst(data);
     }
 
     /**
-     * Inversely transform the given real data set.
-     * <p>
-     * The formula is f<sub>k</sub> = &radic;(2/N) &sum;<sub>n=0</sub><sup>N-1</sup>
F<sub>n</sub> sin(&pi; nk/N)
-     * </p>
+     * {@inheritDoc}
      *
-     * @param f the real data array to be inversely transformed
-     * @return the real inversely transformed array
-     * @throws IllegalArgumentException if any parameters are invalid
+     * The first element of the specified data set is required to be {@code 0}.
      */
-    public double[] inverseTransform2(double[] f) throws IllegalArgumentException {
+    public double[] inverseTransform(double[] f)
+        throws IllegalArgumentException {
 
-        return transform2(f);
+        if (orthogonal) {
+            return transform(f);
+        }
+        final double s = 2.0 / f.length;
+        return FastFourierTransformer.scaleArray(fst(f), s);
     }
 
     /**
-     * Inversely transform the given real function, sampled on the given interval.
-     * <p>
-     * The formula is f<sub>k</sub> = &radic;(2/N) &sum;<sub>n=0</sub><sup>N-1</sup>
F<sub>n</sub> sin(&pi; nk/N)
-     * </p>
+     * {@inheritDoc}
      *
-     * @param f the function to be sampled and inversely transformed
-     * @param min the lower bound for the interval
-     * @param max the upper bound for the interval
-     * @param n the number of sample points
-     * @return the real inversely transformed array
-     * @throws IllegalArgumentException if any parameters are invalid
+     * This implementation enforces {@code f(x) = 0.0} at {@code x = 0.0}.
      */
-    public double[] inverseTransform2(UnivariateFunction f, double min, double max, int n)
+    public double[] inverseTransform(UnivariateFunction f,
+        double min, double max, int n)
         throws IllegalArgumentException {
 
-        return transform2(f, min, max, n);
+        if (orthogonal) {
+            return transform(f, min, max, n);
+        }
+
+        final double[] data = FastFourierTransformer.sample(f, min, max, n);
+        data[0] = 0.0;
+        final double s = 2.0 / n;
+
+        return FastFourierTransformer.scaleArray(fst(data), s);
     }
 
     /**
-     * Perform the FST algorithm (including inverse).
+     * Perform the FST algorithm (including inverse). The first element of the
+     * data set is required to be {@code 0}.
      *
      * @param f the real data array to be transformed
      * @return the real transformed array

Modified: commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java?rev=1213157&r1=1213156&r2=1213157&view=diff
==============================================================================
--- commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java
(original)
+++ commons/proper/math/trunk/src/test/java/org/apache/commons/math/transform/FastSineTransformerTest.java
Mon Dec 12 07:19:23 2011
@@ -36,7 +36,7 @@ public final class FastSineTransformerTe
      */
     @Test
     public void testAdHocData() {
-        FastSineTransformer transformer = new FastSineTransformer();
+        FastSineTransformer transformer = FastSineTransformer.create();
         double result[], tolerance = 1E-12;
 
         double x[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 };
@@ -55,13 +55,14 @@ public final class FastSineTransformerTe
         }
 
         FastFourierTransformer.scaleArray(x, FastMath.sqrt(x.length / 2.0));
+        transformer = FastSineTransformer.createOrthogonal();
 
-        result = transformer.transform2(y);
+        result = transformer.transform(y);
         for (int i = 0; i < result.length; i++) {
             Assert.assertEquals(x[i], result[i], tolerance);
         }
 
-        result = transformer.inverseTransform2(x);
+        result = transformer.inverseTransform(x);
         for (int i = 0; i < result.length; i++) {
             Assert.assertEquals(y[i], result[i], tolerance);
         }
@@ -73,7 +74,7 @@ public final class FastSineTransformerTe
     @Test
     public void testSinFunction() {
         UnivariateFunction f = new SinFunction();
-        FastSineTransformer transformer = new FastSineTransformer();
+        FastSineTransformer transformer = FastSineTransformer.create();
         double min, max, result[], tolerance = 1E-12; int N = 1 << 8;
 
         min = 0.0; max = 2.0 * FastMath.PI;
@@ -97,7 +98,7 @@ public final class FastSineTransformerTe
     @Test
     public void testParameters() throws Exception {
         UnivariateFunction f = new SinFunction();
-        FastSineTransformer transformer = new FastSineTransformer();
+        FastSineTransformer transformer = FastSineTransformer.create();
 
         try {
             // bad interval



Mime
View raw message