commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From er...@apache.org
Subject [1/8] [math] MATH-1290
Date Mon, 23 May 2016 23:18:38 GMT
Repository: commons-math
Updated Branches:
  refs/heads/develop a8c6d43b5 -> c4c288a3e


http://git-wip-us.apache.org/repos/asf/commons-math/blob/3ab3653e/src/test/java/org/apache/commons/math4/complex/ComplexUtilsTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/complex/ComplexUtilsTest.java b/src/test/java/org/apache/commons/math4/complex/ComplexUtilsTest.java
index a0e9c6f..1b9d96e 100644
--- a/src/test/java/org/apache/commons/math4/complex/ComplexUtilsTest.java
+++ b/src/test/java/org/apache/commons/math4/complex/ComplexUtilsTest.java
@@ -1,5 +1,5 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
+* 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
@@ -18,12 +18,12 @@
 package org.apache.commons.math4.complex;
 
 import org.apache.commons.math4.TestUtils;
-import org.apache.commons.math4.complex.Complex;
-import org.apache.commons.math4.complex.ComplexUtils;
 import org.apache.commons.math4.exception.MathIllegalArgumentException;
 import org.apache.commons.math4.util.FastMath;
-import org.junit.Test;
+import org.apache.commons.math4.util.IntegerSequence;
+import org.apache.commons.math4.util.IntegerSequence.Range;
 import org.junit.Assert;
+import org.junit.Test;
 
 /**
  */
@@ -40,33 +40,168 @@ public class ComplexUtilsTest {
     private final Complex negInfNegInf = new Complex(negInf, negInf);
     private final Complex infNaN = new Complex(inf, nan);
 
+    private static Complex c[]; // complex array with real values even and imag
+                                // values odd
+    private static Complex cr[]; // complex array with real values consecutive
+    private static Complex ci[]; // complex array with imag values consecutive
+    private static double d[]; // real array with consecutive vals
+    private static double di[]; // real array with consecutive vals,
+                                // 'interleaved' length
+    private static float f[]; // real array with consecutive vals
+    private static float fi[]; // real array with consec vals, interleaved
+                               // length
+    private static double sr[]; // real component of split array, evens
+    private static double si[]; // imag component of split array, odds
+    private static float sfr[]; // real component of split array, float, evens
+    private static float sfi[]; // imag component of split array, float, odds
+    static Complex ans1, ans2; // answers to single value extraction methods
+    static Range range1, range2; // ranges used to test with
+                                             // IntegerRange
+    static Complex[] ansArrayc1r, ansArrayc1i, ansArrayc2r, ansArrayc2i, ansArrayc3, ansArrayc4;
// answers
+                                                                                        
        // to
+                                                                                        
        // range
+                                                                                        
        // extraction
+                                                                                        
        // methods
+    static double[] ansArrayd1r, ansArrayd2r, ansArrayd1i, ansArrayd2i, ansArraydi1, ansArraydi2;
+    static float[] ansArrayf1r, ansArrayf2r, ansArrayf1i, ansArrayf2i, ansArrayfi1, ansArrayfi2;
+    static String msg; // error message for AssertEquals
+    static Complex[][] c2d, cr2d, ci2d; // for 2d methods
+    static Complex[][][] c3d, cr3d, ci3d; // for 3d methods
+    static double[][] d2d, di2d, sr2d, si2d;
+    static double[][][] d3d, di3d, sr3d, si3d;
+    static float[][] f2d, fi2d, sfr2d, sfi2d;
+    static float[][][] f3d, fi3d, sfr3d, sfi3d;
+
+    private static void setArrays() { // initial setup method
+        c = new Complex[10];
+        cr = new Complex[10];
+        ci = new Complex[10];
+        d = new double[10];
+        f = new float[10];
+        di = new double[20];
+        fi = new float[20];
+        sr = new double[10];
+        si = new double[10];
+        sfr = new float[10];
+        sfi = new float[10];
+        c2d = new Complex[10][10];
+        cr2d = new Complex[10][10];
+        ci2d = new Complex[10][10];
+        c3d = new Complex[10][10][10];
+        cr3d = new Complex[10][10][10];
+        ci3d = new Complex[10][10][10];
+        d2d = new double[10][10];
+        d3d = new double[10][10][10];
+        f2d = new float[10][10];
+        f3d = new float[10][10][10];
+        sr2d = new double[10][10];
+        sr3d = new double[10][10][10];
+        si2d = new double[10][10];
+        si3d = new double[10][10][10];
+        sfr2d = new float[10][10];
+        sfr3d = new float[10][10][10];
+        sfi2d = new float[10][10];
+        sfi3d = new float[10][10][10];
+        di2d = new double[10][20];
+        di3d = new double[10][10][20];
+        fi2d = new float[10][20];
+        fi3d = new float[10][10][20];
+        range1 = IntegerSequence.range(3, 7);
+        range2 = IntegerSequence.range(3, 7, 2);
+        for (int i = 0; i < 20; i += 2) {
+            d[i / 2] = i / 2;
+            f[i / 2] = i / 2;
+            di[i] = i;
+            di[i + 1] = i + 1;
+            fi[i] = i;
+            fi[i + 1] = i + 1;
+            c[i / 2] = new Complex(i, i + 1);
+            cr[i / 2] = new Complex(i / 2);
+            ci[i / 2] = new Complex(0, i / 2);
+            sr[i / 2] = i;
+            si[i / 2] = i + 1;
+            sfr[i / 2] = i;
+            sfi[i / 2] = i + 1;
+        }
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 20; j += 2) {
+                d2d[i][j / 2] = 10 * i + j / 2;
+                f2d[i][j / 2] = 10 * i + j / 2;
+                sr2d[i][j / 2] = 10 * i + j;
+                si2d[i][j / 2] = 10 * i + j + 1;
+                sfr2d[i][j / 2] = 10 * i + j;
+                sfi2d[i][j / 2] = 10 * i + j + 1;
+                di2d[i][j] = 10 * i + j;
+                di2d[i][j + 1] = 10 * i + j + 1;
+                fi2d[i][j] = 10 * i + j;
+                fi2d[i][j + 1] = 10 * i + j + 1;
+                c2d[i][j / 2] = new Complex(10 * i + j, 10 * i + j + 1);
+                cr2d[i][j / 2] = new Complex(10 * i + j / 2);
+                ci2d[i][j / 2] = new Complex(0, 10 * i + j / 2);
+            }
+        }
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                for (int k = 0; k < 20; k += 2) {
+                    d3d[i][j][k / 2] = 100 * i + 10 * j + k / 2;
+                    f3d[i][j][k / 2] = 100 * i + 10 * j + k / 2;
+                    sr3d[i][j][k / 2] = 100 * i + 10 * j + k;
+                    si3d[i][j][k / 2] = 100 * i + 10 * j + k + 1;
+                    sfr3d[i][j][k / 2] = 100 * i + 10 * j + k;
+                    sfi3d[i][j][k / 2] = 100 * i + 10 * j + k + 1;
+                    di3d[i][j][k] = 100 * i + 10 * j + k;
+                    di3d[i][j][k + 1] = 100 * i + 10 * j + k + 1;
+                    fi3d[i][j][k] = 100 * i + 10 * j + k;
+                    fi3d[i][j][k + 1] = 100 * i + 10 * j + k + 1;
+                    c3d[i][j][k / 2] = new Complex(100 * i + 10 * j + k, 100 * i + 10 * j
+ k + 1);
+                    cr3d[i][j][k / 2] = new Complex(100 * i + 10 * j + k / 2);
+                    ci3d[i][j][k / 2] = new Complex(0, 100 * i + 10 * j + k / 2);
+                }
+            }
+        }
+        ansArrayc1r = new Complex[] { new Complex(3), new Complex(4), new Complex(5), new
Complex(6), new Complex(7) };
+        ansArrayc2r = new Complex[] { new Complex(3), new Complex(5), new Complex(7) };
+        ansArrayc1i = new Complex[] { new Complex(0, 3), new Complex(0, 4), new Complex(0,
5), new Complex(0, 6),
+                new Complex(0, 7) };
+        ansArrayc2i = new Complex[] { new Complex(0, 3), new Complex(0, 5), new Complex(0,
7) };
+        ansArrayc3 = new Complex[] { new Complex(6, 7), new Complex(8, 9), new Complex(10,
11), new Complex(12, 13),
+                new Complex(14, 15) };
+        ansArrayc4 = new Complex[] { new Complex(6, 7), new Complex(10, 11), new Complex(14,
15) };
+        ansArrayd1r = new double[] { 6, 8, 10, 12, 14 };
+        ansArrayd1i = new double[] { 7, 9, 11, 13, 15 };
+        ansArrayd2r = new double[] { 6, 10, 14 };
+        ansArrayd2i = new double[] { 7, 11, 15 };
+        ansArrayf1r = new float[] { 6, 8, 10, 12, 14 };
+        ansArrayf1i = new float[] { 7, 9, 11, 13, 15 };
+        ansArrayf2r = new float[] { 6, 10, 14 };
+        ansArrayf2i = new float[] { 7, 11, 15 };
+        ansArraydi1 = new double[] { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+        ansArrayfi1 = new float[] { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
+        ansArraydi2 = new double[] { 6, 7, 10, 11, 14, 15 };
+        ansArrayfi2 = new float[] { 6, 7, 10, 11, 14, 15 };
+        msg = "";
+    }
+
     @Test
     public void testPolar2Complex() {
-        TestUtils.assertEquals(Complex.ONE,
-                ComplexUtils.polar2Complex(1, 0), 10e-12);
-        TestUtils.assertEquals(Complex.ZERO,
-                ComplexUtils.polar2Complex(0, 1), 10e-12);
-        TestUtils.assertEquals(Complex.ZERO,
-                ComplexUtils.polar2Complex(0, -1), 10e-12);
-        TestUtils.assertEquals(Complex.I,
-                ComplexUtils.polar2Complex(1, pi/2), 10e-12);
-        TestUtils.assertEquals(Complex.I.negate(),
-                ComplexUtils.polar2Complex(1, -pi/2), 10e-12);
+        TestUtils.assertEquals(Complex.ONE, ComplexUtils.polar2Complex(1, 0), 10e-12);
+        TestUtils.assertEquals(Complex.ZERO, ComplexUtils.polar2Complex(0, 1), 10e-12);
+        TestUtils.assertEquals(Complex.ZERO, ComplexUtils.polar2Complex(0, -1), 10e-12);
+        TestUtils.assertEquals(Complex.I, ComplexUtils.polar2Complex(1, pi / 2), 10e-12);
+        TestUtils.assertEquals(Complex.I.negate(), ComplexUtils.polar2Complex(1, -pi / 2),
10e-12);
         double r = 0;
         for (int i = 0; i < 5; i++) {
-          r += i;
-          double theta = 0;
-          for (int j =0; j < 20; j++) {
-              theta += pi / 6;
-              TestUtils.assertEquals(altPolar(r, theta),
-                      ComplexUtils.polar2Complex(r, theta), 10e-12);
-          }
-          theta = -2 * pi;
-          for (int j =0; j < 20; j++) {
-              theta -= pi / 6;
-              TestUtils.assertEquals(altPolar(r, theta),
-                      ComplexUtils.polar2Complex(r, theta), 10e-12);
-          }
+            r += i;
+            double theta = 0;
+            for (int j = 0; j < 20; j++) {
+                theta += pi / 6;
+                TestUtils.assertEquals(altPolar(r, theta), ComplexUtils.polar2Complex(r,
theta), 10e-12);
+            }
+            theta = -2 * pi;
+            for (int j = 0; j < 20; j++) {
+                theta -= pi / 6;
+                TestUtils.assertEquals(altPolar(r, theta), ComplexUtils.polar2Complex(r,
theta), 10e-12);
+            }
         }
     }
 
@@ -74,7 +209,7 @@ public class ComplexUtilsTest {
         return Complex.I.multiply(new Complex(theta, 0)).exp().multiply(new Complex(r, 0));
     }
 
-    @Test(expected=MathIllegalArgumentException.class)
+    @Test(expected = MathIllegalArgumentException.class)
     public void testPolar2ComplexIllegalModulus() {
         ComplexUtils.polar2Complex(-1, 0);
     }
@@ -83,32 +218,382 @@ public class ComplexUtilsTest {
     public void testPolar2ComplexNaN() {
         TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(nan, 1));
         TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(1, nan));
-        TestUtils.assertSame(Complex.NaN,
-                ComplexUtils.polar2Complex(nan, nan));
+        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(nan, nan));
     }
 
     @Test
     public void testPolar2ComplexInf() {
         TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(1, inf));
-        TestUtils.assertSame(Complex.NaN,
-                ComplexUtils.polar2Complex(1, negInf));
+        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(1, negInf));
         TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(inf, inf));
-        TestUtils.assertSame(Complex.NaN,
-                ComplexUtils.polar2Complex(inf, negInf));
-        TestUtils.assertSame(infInf, ComplexUtils.polar2Complex(inf, pi/4));
+        TestUtils.assertSame(Complex.NaN, ComplexUtils.polar2Complex(inf, negInf));
+        TestUtils.assertSame(infInf, ComplexUtils.polar2Complex(inf, pi / 4));
         TestUtils.assertSame(infNaN, ComplexUtils.polar2Complex(inf, 0));
-        TestUtils.assertSame(infNegInf, ComplexUtils.polar2Complex(inf, -pi/4));
-        TestUtils.assertSame(negInfInf, ComplexUtils.polar2Complex(inf, 3*pi/4));
-        TestUtils.assertSame(negInfNegInf, ComplexUtils.polar2Complex(inf, 5*pi/4));
+        TestUtils.assertSame(infNegInf, ComplexUtils.polar2Complex(inf, -pi / 4));
+        TestUtils.assertSame(negInfInf, ComplexUtils.polar2Complex(inf, 3 * pi / 4));
+        TestUtils.assertSame(negInfNegInf, ComplexUtils.polar2Complex(inf, 5 * pi / 4));
     }
 
     @Test
-    public void testConvertToComplex() {
+    public void testCExtract() {
         final double[] real = new double[] { negInf, -123.45, 0, 1, 234.56, pi, inf };
-        final Complex[] complex = ComplexUtils.convertToComplex(real);
+        final Complex[] complex = ComplexUtils.real2Complex(real);
 
         for (int i = 0; i < real.length; i++) {
             Assert.assertEquals(real[i], complex[i].getReal(), 0d);
         }
     }
+
+    // EXTRACTION METHODS
+
+    @Test
+    public void testExtractionMethods() {
+        setArrays();
+        // Extract complex from real double array, index 3
+        TestUtils.assertSame(new Complex(3), ComplexUtils.extractComplexFromRealArray(d,
3));
+        // Extract complex from real float array, index 3
+        TestUtils.assertSame(new Complex(3), ComplexUtils.extractComplexFromRealArray(f,
3));
+        // Extract real double from complex array, index 3
+        TestUtils.assertSame(6, ComplexUtils.extractRealFromComplexArray(c, 3));
+        // Extract real float from complex array, index 3
+        TestUtils.assertSame(6, ComplexUtils.extractRealFloatFromComplexArray(c, 3));
+        // Extract complex from interleaved double array, index 3
+        TestUtils.assertSame(new Complex(6, 7), ComplexUtils.extractComplexFromInterleavedArray(d,
3));
+        // Extract complex from interleaved float array, index 3
+        TestUtils.assertSame(new Complex(6, 7), ComplexUtils.extractComplexFromInterleavedArray(f,
3));
+        // Extract interleaved double from complex array, index 3
+        TestUtils.assertEquals(msg, new double[] { 6, 7 }, ComplexUtils.extractInterleavedFromComplexArray(c,
3),
+                Math.ulp(1));
+        // Extract interleaved float from complex array, index 3
+        TestUtils.assertEquals(msg, new double[] { 6, 7 }, ComplexUtils.extractInterleavedFromComplexArray(c,
3),
+                Math.ulp(1));
+        if (!msg.equals("")) {
+            throw new RuntimeException(msg);
+        }
+    }
+    // REAL <-> COMPLEX
+
+    @Test
+    public void testRealToComplex() {
+        setArrays();
+        // Real double to complex, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc1r, ComplexUtils.real2Complex(d, 3, 7), Math.ulp(1));
+        // Real float to complex, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc1r, ComplexUtils.real2Complex(f, 3, 7), Math.ulp(1));
+        // Real double to complex, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc2r, ComplexUtils.real2Complex(d, 3, 7, 2), Math.ulp(1));
+        // Real float to complex, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc2r, ComplexUtils.real2Complex(f, 3, 7, 2), Math.ulp(1));
+        // Real double to complex, range 3-7, increment 1, using IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc1r, ComplexUtils.real2Complex(d, range1), Math.ulp(1));
+        // Real float to complex, range 3-7, increment 1, using IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc1r, ComplexUtils.real2Complex(f, range1), Math.ulp(1));
+        // Real double to complex, range 3-7, increment 2, using IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc2r, ComplexUtils.real2Complex(d, 3, 7, 2), Math.ulp(1));
+        // Real float to complex, range 3-7, increment 2, using IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc2r, ComplexUtils.real2Complex(f, 3, 7, 2), Math.ulp(1));
+        // Real double to complex, whole array
+        TestUtils.assertEquals(msg, cr, ComplexUtils.real2Complex(d), Math.ulp(1));
+        // Real float to complex, whole array
+        TestUtils.assertEquals(msg, cr, ComplexUtils.real2Complex(f), Math.ulp(1));
+        // 2d
+        for (int i = 0; i < 10; i++) {
+            // Real double to complex, 2d
+            TestUtils.assertEquals(msg, cr2d[i], ComplexUtils.real2Complex(d2d[i]), Math.ulp(1));
+            // Real float to complex, 2d
+            TestUtils.assertEquals(msg, cr2d[i], ComplexUtils.real2Complex(f2d[i]), Math.ulp(1));
+        }
+        // 3d
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                // Real double to complex, 3d
+                TestUtils.assertEquals(msg, cr3d[i][j], ComplexUtils.real2Complex(d3d[i][j]),
Math.ulp(1));
+                // Real float to complex, 3d
+                TestUtils.assertEquals(msg, cr3d[i][j], ComplexUtils.real2Complex(f3d[i][j]),
Math.ulp(1));
+            }
+        }
+        if (!msg.equals("")) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    @Test
+    public void testComplexToReal() {
+        setArrays();
+        // Real complex to double, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayd1r, ComplexUtils.complex2Real(c, 3, 7), Math.ulp(1));
+        // Real complex to float, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayf1r, ComplexUtils.complex2RealFloat(c, 3, 7),
Math.ulp(1));
+        // Real complex to double, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayd2r, ComplexUtils.complex2Real(c, 3, 7, 2), Math.ulp(1));
+        // Real complex to float, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayf2r, ComplexUtils.complex2RealFloat(c, 3, 7,
2), Math.ulp(1));
+        // Real complex to double, range 3-7, increment 1, using IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayd1r, ComplexUtils.complex2Real(c, range1), Math.ulp(1));
+        // Real complex to float, range 3-7, increment 1, using IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayf1r, ComplexUtils.complex2RealFloat(c, range1),
Math.ulp(1));
+        // Real complex to double, range 3-7, increment 2, using IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayd2r, ComplexUtils.complex2Real(c, 3, 7, 2), Math.ulp(1));
+        // Real complex to float, range 3-7, increment 2, using IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayf2r, ComplexUtils.complex2RealFloat(c, 3, 7,
2), Math.ulp(1));
+        // Real complex to double, whole array
+        TestUtils.assertEquals(msg, sr, ComplexUtils.complex2Real(c), Math.ulp(1));
+        // Real complex to float, whole array
+        TestUtils.assertEquals(msg, sfr, ComplexUtils.complex2RealFloat(c), Math.ulp(1));
+        // 2d
+        for (int i = 0; i < 10; i++) {
+            // Real complex to double, 2d
+            TestUtils.assertEquals(msg, sr2d[i], ComplexUtils.complex2Real(c2d[i]), Math.ulp(1));
+            // Real complex to float, 2d
+            TestUtils.assertEquals(msg, sfr2d[i], ComplexUtils.complex2RealFloat(c2d[i]),
Math.ulp(1));
+        }
+        // 3d
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                // Real complex to double, 3d
+                TestUtils.assertEquals(msg, sr3d[i][j], ComplexUtils.complex2Real(c3d[i][j]),
Math.ulp(1));
+                // Real complex to float, 3d
+                TestUtils.assertEquals(msg, sfr3d[i][j], ComplexUtils.complex2RealFloat(c3d[i][j]),
Math.ulp(1));
+            }
+        }
+        if (!msg.equals("")) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    // IMAGINARY <-> COMPLEX
+
+    @Test
+    public void testImaginaryToComplex() {
+        setArrays();
+        // Imaginary double to complex, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc1i, ComplexUtils.imaginary2Complex(d, 3, 7),
Math.ulp(1));
+        // Imaginary float to complex, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc1i, ComplexUtils.imaginary2Complex(f, 3, 7),
Math.ulp(1));
+        // Imaginary double to complex, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc2i, ComplexUtils.imaginary2Complex(d, 3, 7,
2), Math.ulp(1));
+        // Imaginary float to complex, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc2i, ComplexUtils.imaginary2Complex(f, 3, 7,
2), Math.ulp(1));
+        // Imaginary double to complex, range 3-7, increment 1, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc1i, ComplexUtils.imaginary2Complex(d, range1),
Math.ulp(1));
+        // Imaginary float to complex, range 3-7, increment 1, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc1i, ComplexUtils.imaginary2Complex(f, range1),
Math.ulp(1));
+        // Imaginary double to complex, range 3-7, increment 2, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc2i, ComplexUtils.imaginary2Complex(d, 3, 7,
2), Math.ulp(1));
+        // Imaginary float to complex, range 3-7, increment 2, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc2i, ComplexUtils.imaginary2Complex(f, 3, 7,
2), Math.ulp(1));
+        // Imaginary double to complex, whole array
+        TestUtils.assertEquals(msg, ci, ComplexUtils.imaginary2Complex(d), Math.ulp(1));
+        // Imaginary float to complex, whole array
+        TestUtils.assertEquals(msg, ci, ComplexUtils.imaginary2Complex(f), Math.ulp(1));
+        // 2d
+        for (int i = 0; i < 10; i++) {
+            // Imaginary double to complex, 2d
+            TestUtils.assertEquals(msg, ci2d[i], ComplexUtils.imaginary2Complex(d2d[i]),
Math.ulp(1));
+            // Imaginary float to complex, 2d
+            TestUtils.assertEquals(msg, ci2d[i], ComplexUtils.imaginary2Complex(f2d[i]),
Math.ulp(1));
+        }
+        // 3d
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                // Imaginary double to complex, 3d
+                TestUtils.assertEquals(msg, ci3d[i][j], ComplexUtils.imaginary2Complex(d3d[i][j]),
Math.ulp(1));
+                // Imaginary float to complex, 3d
+                TestUtils.assertEquals(msg, ci3d[i][j], ComplexUtils.imaginary2Complex(f3d[i][j]),
Math.ulp(1));
+            }
+        }
+        if (!msg.equals("")) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    @Test
+    public void testComplexToImaginary() {
+        setArrays();
+        // Imaginary complex to double, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayd1i, ComplexUtils.complex2Imaginary(c, 3, 7),
Math.ulp(1));
+        // Imaginary complex to float, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayf1i, ComplexUtils.complex2ImaginaryFloat(c, 3,
7), Math.ulp(1));
+        // Imaginary complex to double, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayd2i, ComplexUtils.complex2Imaginary(c, 3, 7,
2), Math.ulp(1));
+        // Imaginary complex to float, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayf2i, ComplexUtils.complex2ImaginaryFloat(c, 3,
7, 2), Math.ulp(1));
+        // Imaginary complex to double, range 3-7, increment 1, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayd1i, ComplexUtils.complex2Imaginary(c, range1),
Math.ulp(1));
+        // Imaginary complex to float, range 3-7, increment 1, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayf1i, ComplexUtils.complex2ImaginaryFloat(c, range1),
Math.ulp(1));
+        // Imaginary complex to double, range 3-7, increment 2, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayd2i, ComplexUtils.complex2Imaginary(c, 3, 7,
2), Math.ulp(1));
+        // Imaginary complex to float, range 3-7, increment 2, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayf2i, ComplexUtils.complex2ImaginaryFloat(c, 3,
7, 2), Math.ulp(1));
+        // Imaginary complex to double, whole array
+        TestUtils.assertEquals(msg, si, ComplexUtils.complex2Imaginary(c), Math.ulp(1));
+        // Imaginary complex to float, whole array
+        TestUtils.assertEquals(msg, sfi, ComplexUtils.complex2ImaginaryFloat(c), Math.ulp(1));
+        // 2d
+        for (int i = 0; i < 10; i++) {
+            // Imaginary complex to double, 2d
+            TestUtils.assertEquals(msg, si2d[i], ComplexUtils.complex2Imaginary(c2d[i]),
Math.ulp(1));
+            // Imaginary complex to float, 2d
+            TestUtils.assertEquals(msg, sfi2d[i], ComplexUtils.complex2ImaginaryFloat(c2d[i]),
Math.ulp(1));
+        }
+        // 3d
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                // Imaginary complex to double, 3d
+                TestUtils.assertEquals(msg, si3d[i][j], ComplexUtils.complex2Imaginary(c3d[i][j]),
Math.ulp(1));
+                // Imaginary complex to float, 3d
+                TestUtils.assertEquals(msg, sfi3d[i][j], ComplexUtils.complex2ImaginaryFloat(c3d[i][j]),
Math.ulp(1));
+            }
+        }
+        if (!msg.equals("")) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    // INTERLEAVED <-> COMPLEX
+
+    @Test
+    public void testInterleavedToComplex() {
+        setArrays();
+        // Interleaved double to complex, range 3-7, increment 1, entered as
+        // ints
+        TestUtils.assertEquals(msg, ansArrayc3, ComplexUtils.interleaved2Complex(di, 3, 7),
Math.ulp(1));
+        // Interleaved float to complex, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc3, ComplexUtils.interleaved2Complex(fi, 3, 7),
Math.ulp(1));
+        // Interleaved double to complex, range 3-7, increment 2, entered as
+        // ints
+        TestUtils.assertEquals(msg, ansArrayc4, ComplexUtils.interleaved2Complex(di, 3, 7,
2), Math.ulp(1));
+        // Interleaved float to complex, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayc4, ComplexUtils.interleaved2Complex(fi, 3, 7,
2), Math.ulp(1));
+        // Interleaved double to complex, range 3-7, increment 1, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc3, ComplexUtils.interleaved2Complex(di, range1),
Math.ulp(1));
+        // Interleaved float to complex, range 3-7, increment 1, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc3, ComplexUtils.interleaved2Complex(fi, range1),
Math.ulp(1));
+        // Interleaved double to complex, range 3-7, increment 2, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc4, ComplexUtils.interleaved2Complex(di, 3, 7,
2), Math.ulp(1));
+        // Interleaved float to complex, range 3-7, increment 2, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayc4, ComplexUtils.interleaved2Complex(fi, 3, 7,
2), Math.ulp(1));
+        // Interleaved double to complex, whole array
+        TestUtils.assertEquals(msg, c, ComplexUtils.interleaved2Complex(di), Math.ulp(1));
+        // Interleaved float to complex, whole array
+        TestUtils.assertEquals(msg, c, ComplexUtils.interleaved2Complex(fi), Math.ulp(1));
+        // 2d
+        for (int i = 0; i < 10; i++) {
+            // Interleaved double to complex, 2d
+            TestUtils.assertEquals(msg, c2d[i], ComplexUtils.interleaved2Complex(di2d[i]),
Math.ulp(1));
+            // Interleaved float to complex, 2d
+            TestUtils.assertEquals(msg, c2d[i], ComplexUtils.interleaved2Complex(fi2d[i]),
Math.ulp(1));
+        }
+        // 3d
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                // Interleaved double to complex, 3d
+                TestUtils.assertEquals(msg, c3d[i][j], ComplexUtils.interleaved2Complex(di3d[i][j]),
Math.ulp(1));
+                // Interleaved float to complex, 3d
+                TestUtils.assertEquals(msg, c3d[i][j], ComplexUtils.interleaved2Complex(fi3d[i][j]),
Math.ulp(1));
+            }
+        }
+        if (!msg.equals("")) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    @Test
+    public void testComplexToInterleaved() {
+        setArrays();
+        // Interleaved complex to double, range 3-7, increment 1, entered as
+        // ints
+        TestUtils.assertEquals(msg, ansArraydi1, ComplexUtils.complex2Interleaved(c, 3, 7),
Math.ulp(1));
+        // Interleaved complex to float, range 3-7, increment 1, entered as ints
+        TestUtils.assertEquals(msg, ansArrayfi1, ComplexUtils.complex2InterleavedFloat(c,
3, 7), Math.ulp(1));
+        // Interleaved complex to double, range 3-7, increment 2, entered as
+        // ints
+        TestUtils.assertEquals(msg, ansArraydi2, ComplexUtils.complex2Interleaved(c, 3, 7,
2), Math.ulp(1));
+        // Interleaved complex to float, range 3-7, increment 2, entered as ints
+        TestUtils.assertEquals(msg, ansArrayfi2, ComplexUtils.complex2InterleavedFloat(c,
3, 7, 2), Math.ulp(1));
+        // Interleaved complex to double, range 3-7, increment 1, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArraydi1, ComplexUtils.complex2Interleaved(c, range1),
Math.ulp(1));
+        // Interleaved complex to float, range 3-7, increment 1, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayfi1, ComplexUtils.complex2InterleavedFloat(c,
range1), Math.ulp(1));
+        // Interleaved complex to double, range 3-7, increment 2, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArraydi2, ComplexUtils.complex2Interleaved(c, 3, 7,
2), Math.ulp(1));
+        // Interleaved complex to float, range 3-7, increment 2, using
+        // IntegerSequence
+        TestUtils.assertEquals(msg, ansArrayfi2, ComplexUtils.complex2InterleavedFloat(c,
3, 7, 2), Math.ulp(1));
+        // Interleaved complex to double, whole array
+        TestUtils.assertEquals(msg, di, ComplexUtils.complex2Interleaved(c), Math.ulp(1));
+        // Interleaved complex to float, whole array
+        TestUtils.assertEquals(msg, fi, ComplexUtils.complex2InterleavedFloat(c), Math.ulp(1));
+        // 2d
+        for (int i = 0; i < 10; i++) {
+            // Interleaved complex to double, 2d
+            TestUtils.assertEquals(msg, di2d[i], ComplexUtils.complex2Interleaved(c2d[i]),
Math.ulp(1));
+            // Interleaved complex to float, 2d
+            TestUtils.assertEquals(msg, fi2d[i], ComplexUtils.complex2InterleavedFloat(c2d[i]),
Math.ulp(1));
+        }
+        // 3d
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                // Interleaved complex to double, 3d
+                TestUtils.assertEquals(msg, di3d[i][j], ComplexUtils.complex2Interleaved(c3d[i][j]),
Math.ulp(1));
+                // Interleaved complex to float, 3d
+                TestUtils.assertEquals(msg, fi3d[i][j], ComplexUtils.complex2InterleavedFloat(c3d[i][j]),
Math.ulp(1));
+            }
+        }
+        if (!msg.equals("")) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    // SPLIT TO COMPLEX
+    @Test
+    public void testSplit2Complex() {
+        setArrays();
+        // Split double to complex, whole array
+        TestUtils.assertEquals(msg, c, ComplexUtils.split2Complex(sr, si), Math.ulp(1));
+
+        // 2d
+        for (int i = 0; i < 10; i++) {
+            // Split double to complex, 2d
+            TestUtils.assertEquals(msg, c2d[i], ComplexUtils.split2Complex(sr2d[i], si2d[i]),
Math.ulp(1));
+        }
+        // 3d
+        for (int i = 0; i < 10; i++) {
+            for (int j = 0; j < 10; j++) {
+                // Split double to complex, 3d
+                TestUtils.assertEquals(msg, c3d[i][j], ComplexUtils.split2Complex(sr3d[i][j],
si3d[i][j]), Math.ulp(1));
+            }
+        }
+        if (!msg.equals("")) {
+            throw new RuntimeException(msg);
+        }
+    }
+
+    // INITIALIZATION METHODS
+
+    @Test
+    public void testInitialize() {
+        Complex[] c = new Complex[10];
+        ComplexUtils.initialize(c);
+        for (Complex cc : c) {
+            TestUtils.assertEquals(new Complex(0, 0), cc, Math.ulp(0));
+        }
+    }
+
 }


Mime
View raw message