You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by lu...@apache.org on 2015/10/29 20:24:48 UTC

[1/2] [math] Added various utility methods for Complex[] data.

Repository: commons-math
Updated Branches:
  refs/heads/complex-and-primitive-arrays [created] 1888acc21


http://git-wip-us.apache.org/repos/asf/commons-math/blob/1888acc2/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..ffe265b 100644
--- a/src/test/java/org/apache/commons/math4/complex/ComplexUtilsTest.java
+++ b/src/test/java/org/apache/commons/math4/complex/ComplexUtilsTest.java
@@ -22,6 +22,7 @@ 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.apache.commons.math4.util.IntegerSequence;
 import org.junit.Test;
 import org.junit.Assert;
 
@@ -40,6 +41,141 @@ 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 Iterable<Integer> 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,
@@ -103,12 +239,534 @@ public class ComplexUtilsTest {
     }
 
     @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));
+            }
+        }
+
 }


[2/2] [math] Added various utility methods for Complex[] data.

Posted by lu...@apache.org.
Added various utility methods for Complex[] data.

The methods allow easy conversion of Complex[] data and primitive arrays
of complex interleaved data.

Github: closes #18


Project: http://git-wip-us.apache.org/repos/asf/commons-math/repo
Commit: http://git-wip-us.apache.org/repos/asf/commons-math/commit/1888acc2
Tree: http://git-wip-us.apache.org/repos/asf/commons-math/tree/1888acc2
Diff: http://git-wip-us.apache.org/repos/asf/commons-math/diff/1888acc2

Branch: refs/heads/complex-and-primitive-arrays
Commit: 1888acc218fa8a40ec8f80a8aef5d5036db892d8
Parents: 8ed2209
Author: Eric Barnhill <er...@gmail.com>
Authored: Thu Oct 29 20:17:25 2015 +0100
Committer: Luc Maisonobe <lu...@apache.org>
Committed: Thu Oct 29 20:17:25 2015 +0100

----------------------------------------------------------------------
 pom.xml                                         |    3 +
 src/changes/changes.xml                         |    4 +
 .../math4/analysis/solvers/LaguerreSolver.java  |    6 +-
 .../commons/math4/complex/ComplexUtils.java     | 1941 +++++++++++++++++-
 .../commons/math4/util/IntegerSequence.java     |   14 +
 .../org/apache/commons/math4/TestUtils.java     |   68 +
 .../commons/math4/complex/ComplexUtilsTest.java |  662 +++++-
 7 files changed, 2688 insertions(+), 10 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/commons-math/blob/1888acc2/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 81ec75f..c1abe49 100644
--- a/pom.xml
+++ b/pom.xml
@@ -161,6 +161,9 @@
       <name>Matt Adereth</name>
     </contributor>
     <contributor>
+      <name>Eric Barnhill</name>
+    </contributor>
+    <contributor>
       <name>Jared Becksfort</name>
     </contributor>
     <contributor>

http://git-wip-us.apache.org/repos/asf/commons-math/blob/1888acc2/src/changes/changes.xml
----------------------------------------------------------------------
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index 55a8fcb..7adb398 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -54,6 +54,10 @@ If the output is not quite correct, check for invisible trailing spaces!
     </release>
 
     <release version="4.0" date="XXXX-XX-XX" description="">
+      <action dev="luc" type="add" due-to="Eric Barnhill">
+        Added various utility methods for easy conversion between Complex[] data
+        and primitive arrays of complex interleaved data.
+      </action>
       <action dev="oertl" type="fix" issue="MATH-1285" due-to="Pim van der Hoorn "> <!-- backported to 3.6 -->
         Updated reference in ZipfDistribution's javadoc.
       </action>

http://git-wip-us.apache.org/repos/asf/commons-math/blob/1888acc2/src/main/java/org/apache/commons/math4/analysis/solvers/LaguerreSolver.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/analysis/solvers/LaguerreSolver.java b/src/main/java/org/apache/commons/math4/analysis/solvers/LaguerreSolver.java
index d21f69a..e9dba5a 100644
--- a/src/main/java/org/apache/commons/math4/analysis/solvers/LaguerreSolver.java
+++ b/src/main/java/org/apache/commons/math4/analysis/solvers/LaguerreSolver.java
@@ -150,7 +150,7 @@ public class LaguerreSolver extends AbstractPolynomialSolver {
      */
     private double laguerre(double lo, double hi,
                             double fLo, double fHi) {
-        final Complex c[] = ComplexUtils.convertToComplex(getCoefficients());
+        final Complex c[] = ComplexUtils.real2Complex(getCoefficients());
 
         final Complex initial = new Complex(0.5 * (lo + hi), 0);
         final Complex z = complexSolver.solve(c, initial);
@@ -196,7 +196,7 @@ public class LaguerreSolver extends AbstractPolynomialSolver {
               Double.NEGATIVE_INFINITY,
               Double.POSITIVE_INFINITY,
               initial);
-        return complexSolver.solveAll(ComplexUtils.convertToComplex(coefficients),
+        return complexSolver.solveAll(ComplexUtils.real2Complex(coefficients),
                                       new Complex(initial, 0d));
     }
 
@@ -226,7 +226,7 @@ public class LaguerreSolver extends AbstractPolynomialSolver {
               Double.NEGATIVE_INFINITY,
               Double.POSITIVE_INFINITY,
               initial);
-        return complexSolver.solve(ComplexUtils.convertToComplex(coefficients),
+        return complexSolver.solve(ComplexUtils.real2Complex(coefficients),
                                    new Complex(initial, 0d));
     }
 

http://git-wip-us.apache.org/repos/asf/commons-math/blob/1888acc2/src/main/java/org/apache/commons/math4/complex/ComplexUtils.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/complex/ComplexUtils.java b/src/main/java/org/apache/commons/math4/complex/ComplexUtils.java
index 493374f..36557f5 100644
--- a/src/main/java/org/apache/commons/math4/complex/ComplexUtils.java
+++ b/src/main/java/org/apache/commons/math4/complex/ComplexUtils.java
@@ -18,8 +18,10 @@
 package org.apache.commons.math4.complex;
 
 import org.apache.commons.math4.exception.MathIllegalArgumentException;
+import org.apache.commons.math4.exception.OutOfRangeException;
 import org.apache.commons.math4.exception.util.LocalizedFormats;
 import org.apache.commons.math4.util.FastMath;
+import org.apache.commons.math4.util.IntegerSequence;
 
 /**
  * Static implementations of common
@@ -67,20 +69,1949 @@ public class ComplexUtils {
     }
 
     /**
-     * Convert an array of primitive doubles to an array of {@code Complex} objects.
+     * Returns double from array {@code real[]} at entry {@code index} as a {@code Complex}.
+     *
+     * @param real Array of real numbers.
+     * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex extractComplexFromRealArray(double[] real, int index) {
+        return new Complex(real[index]);
+    }
+
+    /**
+     * Returns float from array {@code real[]} at entry {@code index} as a {@code Complex}.
+     *
+     * @param real Array of real numbers.
+     * * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex extractComplexFromRealArray(float[] real, int index) {
+        return new Complex(real[index]);
+    }
+
+    /**
+     * Returns double from array {@code imaginary[]} at entry {@code index} as a {@code Complex}.
+     *
+     * @param imaginary Array of imaginary numbers.
+     * * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex extractComplexFromImaginaryArray(double[] imaginary, int index) {
+        return new Complex(0, imaginary[index]);
+    }
+
+    /**
+     * Returns float from array {@code imaginary[]} at entry {@code index} as a {@code Complex}.
+     *
+     * @param imaginary Array of imaginary numbers.
+     * * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex extractComplexFromImaginaryArray(float[] imaginary, int index) {
+        return new Complex(0, imaginary[index]);
+    }
+
+    /**
+     * Returns real component of Complex from array {@code complex[]}
+     * at entry {@code index} as a {@code double}.
+     *
+     * @param complex Array of complex numbers.
+     * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static double extractRealFromComplexArray(Complex[] complex, int index) {
+        return complex[index].getReal();
+    }
+
+    /**
+     * Returns real component of array {@code complex[]} at entry {@code index} as a {@code float}.
+     *
+     * @param complex Array of complex numbers.
+     * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static float extractRealFloatFromComplexArray(Complex[] complex, int index) {
+        return (float)complex[index].getReal();
+    }
+
+    /**
+     * Returns imaginary component of Complex from array {@code complex[]}
+     * at entry {@code index} as a {@code double}.
+     *
+     * @param complex Array of complex numbers.
+     * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static double extractImaginaryFromComplexArray(Complex[] complex, int index) {
+        return complex[index].getImaginary();
+    }
+
+    /**
+     * Returns imaginary component of array {@code complex[]} at entry {@code index} as a {@code float}.
+     *
+     * @param complex Array of complex numbers.
+     * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static float extractImaginaryFloatFromComplexArray(Complex[] complex, int index) {
+        return (float)complex[index].getImaginary();
+    }
+
+    /**
+     * Returns Complex object from interleaved {@code double[]} array {@code Complex[]} at entry {@code index}.
+     *
+     * @param d {@code double[]} of interleaved complex numbers alternating real and imaginary values
+     * @param index Location in the array. This is the location by complex number, e.g.
+     * index number 5 in the {@code double[]} array will return a {@code new Complex(d[10], d[11])}
+     * @return size 2 {@code double[]} array.
+     *
+     * @since 4.0
+     */
+    public static Complex extractComplexFromInterleavedArray(double[] d, int index) {
+        return new Complex(d[index*2], d[index*2+1]);
+    }
+
+    /**
+     * Returns Complex object from interleaved {@code float[]} array {@code Complex[]} at entry {@code index}.
+     *
+     * @param f {@code float[]} of interleaved complex numbers alternating real and imaginary values
+     * @param index Location in the array. This is the location by complex number, e.g.
+     * index number 5 in the {@code float[]} array will return a new {@code Complex(d[10], d[11])}
+     * @return size 2 {@code float[]} array.
+     *
+     * @since 4.0
+     */
+    public static Complex extractComplexFromInterleavedArray(float[] f, int index) {
+        return new Complex(f[index*2], f[index*2+1]);
+    }
+
+    /**
+     * Returns values of Complex object from array {@code Complex[]} at entry {@code index} as a
+     * size 2 {@code double} of the form {real, imag}.
+     *
+     * @param complex Array of complex numbers.
+     * @param index Location in the array.
+     * @return size 2 {@code double[]} array.
+     *
+     * @since 4.0
+     */
+    public static double[] extractInterleavedFromComplexArray(Complex[] complex, int index) {
+        return new double[]{complex[index].getReal(), complex[index].getImaginary()};
+    }
+
+    /**
+     * Returns Complex object from array {@code Complex[]} at entry {@code index} as a
+     * size 2 {@code float} of the form {real, imag}.
+     *
+     * @param complex Array of complex numbers.
+     * @param index Location in the array.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static float[] extractInterleavedFloatFromComplexArray(Complex[] complex, int index) {
+        return new float[]{(float)complex[index].getReal(), (float)complex[index].getImaginary()};
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end}.
+     *
+     * @param real Array of real numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] real2Complex(double[] real, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromRealArray(real, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end}.
+     *
+     * @param real Array of real numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] real2Complex(float[] real, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromRealArray(real, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param real Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] real2Complex(double[] real, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromRealArray(real, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param real Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] real2Complex(float[] real, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromRealArray(real, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects
+     * for the {@code IntegerSequence} range.
+     *
+     * @param real Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] real2Complex(double[] real, Iterable<Integer> range) {
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromRealArray(real, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects
+     * for the {@code IntegerSequence} range.
+     *
+     * @param real Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] real2Complex(float[] real, Iterable<Integer> range) {
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromRealArray(real, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects.
+     *
+     * @param real Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] real2Complex(double[] real) {
+        int index = 0;
+        final Complex c[] = new Complex[real.length];
+        for (double d : real) {
+            c[index] = new Complex(d);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects.
      *
      * @param real Array of numbers to be converted to their {@code Complex}
      * equivalent.
      * @return an array of {@code Complex} objects.
      *
-     * @since 3.1
+     * @since 4.0
      */
-    public static Complex[] convertToComplex(double[] real) {
+    public static Complex[] real2Complex(float[] real) {
+        int index = 0;
         final Complex c[] = new Complex[real.length];
-        for (int i = 0; i < real.length; i++) {
-            c[i] = new Complex(real[i], 0);
+        for (float d : real) {
+            c[index] = new Complex(d);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 2D real array {@code double[][]}
+     * to a 2d array of {@code Complex} objects.
+     *
+     * @param d 2d {@code double[][]}
+     * @return 2d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][] real2Complex(double[][] d) {
+        int width = d.length;
+        int height = d[0].length;
+        Complex[][] c = new Complex[width][height];
+        for (int n = 0; n < width; n++) {
+            c[n] = ComplexUtils.real2Complex(d[n]);
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 2D real array {@code double[][][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 3d complex interleaved {@code double[][][]}
+     * @return 3d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][][] real2Complex(double[][][] d) {
+        int width = d.length;
+        int height = d[0].length;
+        int depth = d[0].length;
+        Complex[][][] c = new Complex[width][height][depth];
+        for (int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                c[x][y] = ComplexUtils.real2Complex(d[x][y]);
+            }
+        }
+        return c;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code double[]} array
+     * for the range {@code start} - {@code end}.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param start Start index.
+     * @param end End index.
+     * @return a {@code double[]} array of the real component.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Real(Complex[] c, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            d[index] = extractRealFromComplexArray(c, i);
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code float[]} array
+     * for the range {@code start} - {@code end}.
+     *
+     * @param c Array of Complex objects
+     * @param start Start index.
+     * @param end End index.
+     * @return a {@code float[]} array of the real component.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2RealFloat(Complex[] c, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            f[index] = extractRealFloatFromComplexArray(c, i);
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code double[]} array
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return a {@code double[]} array of the real component.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Real(Complex[] c, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            d[index] = extractRealFromComplexArray(c, i);
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code float[]} array
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return a {@code float[]} array of the real component.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2RealFloat(Complex[] c, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            f[index] = extractRealFloatFromComplexArray(c, i);
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code double[]} array
+     * for the {@code IntegerSequence} range.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return a {@code double[]} array of the real component.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Real(Complex[] c, Iterable<Integer> range) {
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            d[index] = extractRealFromComplexArray(c, i);
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code float[]} array
+     * for the {@code IntegerSequence} range.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return a {@code float[]} array of the real component.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2RealFloat(Complex[] c, Iterable<Integer> range) {
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            f[index] = extractRealFloatFromComplexArray(c, i);
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @return a {@code double[]} array of the real component.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Real(Complex[] c) {
+        int index = 0;
+        final double d[] = new double[c.length];
+        for (Complex cc : c) {
+            d[index] = cc.getReal();
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @return a {@code float[]} array of the real component.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2RealFloat(Complex[] c) {
+        int index = 0;
+        final float f[] = new float[c.length];
+        for (Complex cc : c) {
+            f[index] = (float)cc.getReal();
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts real component a 2D array of {@code Complex} objects
+     * to a 2d double array.
+     *
+     * @param c 2d array of {@code Complex} objects
+     * @return double[][] of real component
+     * @since 4.0
+     */
+    public static double[][] complex2Real(Complex[][] c) {
+        int width = c.length;
+        int height = c[0].length;
+        double[][] d = new double[width][height];
+        for (int n = 0; n < width; n++) {
+            d[n] = ComplexUtils.complex2Real(c[n]);
+        }
+        return d;
+    }
+
+    /**
+     * Converts a 3D interleaved complex array {@code double[][][]}
+     * to an array of {@code Complex} objects. Interleaving is in final level of array,
+     * i.e. for double [x][y][z] z is interleaved.
+     *
+     * @param c 3d complex interleaved {@code double[][][]}
+     * @return 3d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static double[][][] complex2Real(Complex[][][] c) {
+        int width = c.length;
+        int height = c[0].length;
+        int depth = c[0].length;
+        double[][][] d = new double[width][height][depth];
+        for (int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                d[x][y] = ComplexUtils.complex2Real(c[x][y]);
+            }
         }
+        return d;
+    }
 
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end}.
+     *
+     * @param imaginary Array of imaginary numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] imaginary2Complex(double[] imaginary, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromImaginaryArray(imaginary, i);
+            index++;
+        }
         return c;
     }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end}.
+     *
+     * @param imaginary Array of imaginary numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] imaginary2Complex(float[] imaginary, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromImaginaryArray(imaginary, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param imaginary Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] imaginary2Complex(double[] imaginary, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromImaginaryArray(imaginary, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param imaginary Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] imaginary2Complex(float[] imaginary, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromImaginaryArray(imaginary, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects
+     * for the {@code IntegerSequence} range.
+     *
+     * @param imaginary Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] imaginary2Complex(double[] imaginary, Iterable<Integer> range) {
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromImaginaryArray(imaginary, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects
+     * for the {@code IntegerSequence} range.
+     *
+     * @param imaginary Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] imaginary2Complex(float[] imaginary, Iterable<Integer> range) {
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromImaginaryArray(imaginary, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects.
+     *
+     * @param imaginary Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] imaginary2Complex(double[] imaginary) {
+        int index = 0;
+        final Complex c[] = new Complex[imaginary.length];
+        for (double d : imaginary) {
+            c[index] = new Complex(0, d);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects.
+     *
+     * @param imaginary Array of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] imaginary2Complex(float[] imaginary) {
+        int index = 0;
+        final Complex c[] = new Complex[imaginary.length];
+        for (float d : imaginary) {
+            c[index] = new Complex(0, d);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 2D imaginary array {@code double[][]}
+     * to a 2d array of {@code Complex} objects.
+     *
+     * @param d 2d {@code double[][]}
+     * @return 2d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][] imaginary2Complex(double[][] d) {
+        int width = d.length;
+        int height = d[0].length;
+        Complex[][] c = new Complex[width][height];
+        for (int n = 0; n < width; n++) {
+            c[n] = ComplexUtils.imaginary2Complex(d[n]);
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 3D imaginary array {@code double[][][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 3d complex imaginary {@code double[][][]}
+     * @return 3d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][][] imaginary2Complex(double[][][] d) {
+        int width = d.length;
+        int height = d[0].length;
+        int depth = d[0].length;
+        Complex[][][] c = new Complex[width][height][depth];
+        for (int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                c[x][y] = ComplexUtils.imaginary2Complex(d[x][y]);
+            }
+        }
+        return c;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code double[]} array
+     * for the range {@code start} - {@code end}.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param start Start index.
+     * @param end End index.
+     * @return a {@code double[]} array of the imaginary component.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Imaginary(Complex[] c, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            d[index] = extractImaginaryFromComplexArray(c, i);
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code float[]} array
+     * for the range {@code start} - {@code end}.
+     *
+     * @param c Array of Complex objects
+     * @param start Start index.
+     * @param end End index.
+     * @return a {@code float[]} array of the imaginary component.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2ImaginaryFloat(Complex[] c, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            f[index] = extractImaginaryFloatFromComplexArray(c, i);
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code double[]} array
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return a {@code double[]} array of the imaginary component.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Imaginary(Complex[] c, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            d[index] = extractImaginaryFromComplexArray(c, i);
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code float[]} array
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return a {@code float[]} array of the imaginary component.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2ImaginaryFloat(Complex[] c, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            f[index] = extractImaginaryFloatFromComplexArray(c, i);
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code double[]} array
+     * for the {@code IntegerSequence} range.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return a {@code double[]} array of the imaginary component.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Imaginary(Complex[] c, Iterable<Integer> range) {
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            d[index] = extractImaginaryFromComplexArray(c, i);
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to a {@code float[]} array
+     * for the {@code IntegerSequence} range.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return a {@code float[]} array of the imaginary component.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2ImaginaryFloat(Complex[] c, Iterable<Integer> range) {
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            f[index] = extractImaginaryFloatFromComplexArray(c, i);
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts a {@code double[]} array to an array of {@code Complex} objects.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @return a {@code double[]} array of the imaginary component.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Imaginary(Complex[] c) {
+        int index = 0;
+        final double d[] = new double[c.length];
+        for (Complex cc : c) {
+            d[index] = cc.getImaginary();
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts a {@code float[]} array to an array of {@code Complex} objects.
+     *
+     * @param c Array of {@code Complex} objects.
+     * @return a {@code float[]} array of the imaginary component.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2ImaginaryFloat(Complex[] c) {
+        int index = 0;
+        final float f[] = new float[c.length];
+        for (Complex cc : c) {
+            f[index] = (float)cc.getImaginary();
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts imaginary component a 2D array of {@code Complex} objects
+     * to a 2d double array.
+     *
+     * @param c 2d array of {@code Complex} objects
+     * @return double[][] of imaginary component
+     * @since 4.0
+     */
+    public static double[][] complex2Imaginary(Complex[][] c) {
+        int width = c.length;
+        int height = c[0].length;
+        double[][] d = new double[width][height];
+        for (int n = 0; n < width; n++) {
+            d[n] = ComplexUtils.complex2Imaginary(c[n]);
+        }
+        return d;
+    }
+
+    /**
+     * Converts a 3D interleaved complex array {@code double[][][]}
+     * to an array of {@code Complex} objects. Interleaving is in final level of array,
+     * i.e. for double [x][y][z] z is interleaved.
+     *
+     * @param c 3d complex interleaved {@code double[][][]}
+     * @return 3d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static double[][][] complex2Imaginary(Complex[][][] c) {
+        int width = c.length;
+        int height = c[0].length;
+        int depth = c[0].length;
+        double[][][] d = new double[width][height][depth];
+        for (int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                d[x][y] = ComplexUtils.complex2Imaginary(c[x][y]);
+            }
+        }
+        return d;
+    }
+
+    // INTERLEAVED METHODS
+
+    /**
+     * Converts a complex interleaved {@code double[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end}.
+     *
+     * @param interleaved {@code double[]} of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] interleaved2Complex(double[] interleaved, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromInterleavedArray(interleaved, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a complex interleaved {@code float[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end}.
+     *
+     * @param interleaved {@code float[]} of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] interleaved2Complex(float[] interleaved, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromInterleavedArray(interleaved, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a complex interleaved {@code double[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param interleaved {@code double[]} of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] interleaved2Complex(double[] interleaved, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromInterleavedArray(interleaved, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a complex interleaved {@code float[]} array to an array of {@code Complex} objects
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param interleaved {@code float[]} of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] interleaved2Complex(float[] interleaved, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromInterleavedArray(interleaved, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a complex interleaved {@code double[]} array to an array of {@code Complex} objects
+     * for the {@code IntegerSequence} range.
+     *
+     * @param interleaved {@code double[]} of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] interleaved2Complex(double[] interleaved, Iterable<Integer> range) {
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromInterleavedArray(interleaved, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a complex interleaved {@code float[]} array to an array of {@code Complex} objects
+     * for the {@code IntegerSequence} range.
+     *
+     * @param interleaved {@code float[]} of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] interleaved2Complex(float[] interleaved, Iterable<Integer> range) {
+        int index = 0;
+        final Complex c[] = new Complex[IntegerSequence.size(range)];
+        for (Integer i : range) {
+            c[index] = extractComplexFromInterleavedArray(interleaved, i);
+            index++;
+        }
+        return c;
+    }
+
+    /**
+     * Converts a complex interleaved {@code double[]} array to an array of {@code Complex} objects
+     *
+     * @param interleaved {@code double[]} of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] interleaved2Complex(double[] interleaved) {
+        final int length = interleaved.length/2;
+        final Complex c[] = new Complex[length];
+        for (int n = 0; n < length; n++) {
+            c[n] = new Complex(interleaved[n*2], interleaved[n*2+1]);
+        }
+        return c;
+    }
+
+    /**
+     * Converts a complex interleaved {@code float[]} array to an array of {@code Complex} objects
+     *
+     * @param interleaved {@code float[]} of numbers to be converted to their {@code Complex}
+     * equivalent.
+     * @return an array of {@code Complex} objects.
+     *
+     * @since 4.0
+     */
+    public static Complex[] interleaved2Complex(float[] interleaved) {
+        final int length = interleaved.length/2;
+        final Complex c[] = new Complex[length];
+        for (int n = 0; n < length; n++) {
+            c[n] = new Complex(interleaved[n*2], interleaved[n*2+1]);
+        }
+        return c;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to an interleaved complex {@code double[]} array
+     * for the range {@code start} - {@code end}.
+     *
+     * @param c Array of Complex objects.
+     * @param start Start index.
+     * @param end End index.
+     * @return a complex interleaved {@code double[]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Interleaved(Complex[] c, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)*2];
+        for (Integer i : range) {
+            int real = index*2;
+            int imag = index*2+1;
+            d[real] = c[i].getReal();
+            d[imag] = c[i].getImaginary();
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to an interleaved complex {@code float[]} array
+     * for the range {@code start} - {@code end}.
+     *
+     * @param c Array of Complex objects.
+     * @param start Start index.
+     * @param end End index.
+     * @return a complex interleaved {@code float[]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2InterleavedFloat(Complex[] c, int start, int end) {
+        Iterable<Integer> range = IntegerSequence.range(start, end);
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)*2];
+        for (Integer i : range) {
+            int real = index*2;
+            int imag = index*2+1;
+            f[real] = (float)c[i].getReal();
+            f[imag] = (float)c[i].getImaginary();
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to an interleaved complex {@code double[]} array
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param c Array of Complex objects.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return a complex interleaved {@code double[]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Interleaved(Complex[] c, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)*2];
+        for (Integer i : range) {
+            int real = index*2;
+            int imag = index*2+1;
+            d[real] = c[i].getReal();
+            d[imag] = c[i].getImaginary();
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to an interleaved complex {@code float[]} array
+     * for the range {@code start} - {@code end} by {@code increment}.
+     *
+     * @param c Array of Complex objects.
+     * @param start Start index.
+     * @param end End index.
+     * @param increment Range increment.
+     * @return a complex interleaved {@code float[]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2InterleavedFloat(Complex[] c, int start, int end, int increment) {
+        Iterable<Integer> range = IntegerSequence.range(start, end, increment);
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)*2];
+        for (Integer i : range) {
+            int real = index*2;
+            int imag = index*2+1;
+            f[real] = (float)c[i].getReal();
+            f[imag] = (float)c[i].getImaginary();
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to an interleaved complex {@code double[]} array
+     * for the {@code IntegerSequence} range.
+     *
+     * @param c Array of Complex objects.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return a complex interleaved {@code double[]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Interleaved(Complex[] c, Iterable<Integer> range) {
+        int index = 0;
+        final double d[] = new double[IntegerSequence.size(range)*2];
+        for (Integer i : range) {
+            int real = index*2;
+            int imag = index*2+1;
+            d[real] = c[i].getReal();
+            d[imag] = c[i].getImaginary();
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to an interleaved complex {@code float[]} array
+     * for the {@code IntegerSequence} range.
+     *
+     * @param c Array of Complex objects.
+     * @param range an {@code Iterable<Integer>} object returned by {@code IntegerSequence.range()}
+     * @return a complex interleaved {@code float[]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2InterleavedFloat(Complex[] c, Iterable<Integer> range) {
+        int index = 0;
+        final float f[] = new float[IntegerSequence.size(range)*2];
+        for (Integer i : range) {
+            int real = index*2;
+            int imag = index*2+1;
+            f[real] = (float)c[i].getReal();
+            f[imag] = (float)c[i].getImaginary();
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to an interleaved complex {@code double[]} array
+     *
+     * @param c Array of Complex objects.
+     * @return a complex interleaved {@code double[]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static double[] complex2Interleaved(Complex[] c) {
+        int index = 0;
+        final double d[] = new double[c.length*2];
+        for (Complex cc : c) {
+            int real = index*2;
+            int imag = index*2+1;
+            d[real] = cc.getReal();
+            d[imag] = cc.getImaginary();
+            index++;
+        }
+        return d;
+    }
+
+    /**
+     * Converts an array of {@code Complex} objects to an interleaved complex {@code float[]} array
+     *
+     * @param c Array of Complex objects.
+     * @return a complex interleaved {@code float[]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static float[] complex2InterleavedFloat(Complex[] c) {
+        int index = 0;
+        final float f[] = new float[c.length*2];
+        for (Complex cc : c) {
+            int real = index*2;
+            int imag = index*2+1;
+            f[real] = (float)cc.getReal();
+            f[imag] = (float)cc.getImaginary();
+            index++;
+        }
+        return f;
+    }
+
+    /**
+     * Converts a 2D array of {@code Complex} objects
+     * to an interleaved complex {@code double[][]} array.
+     *
+     * @param c 2D Array of Complex objects.
+     * @param interleavedDim Depth level of the array to interleave.
+     * @return a complex interleaved {@code double[][]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static double[][] complex2Interleaved(Complex[][] c, int interleavedDim) {
+        if (interleavedDim > 1 || interleavedDim < 0) {
+            throw new OutOfRangeException(
+                  interleavedDim, 0, 1);
+        }
+        final int width = c.length;
+        final int height = c[0].length;
+        double[][] d;
+        if (interleavedDim == 0) {
+            d = new double[2*width][height];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    d[x*2][y] = c[x][y].getReal();
+                    d[x*2+1][y] = c[x][y].getImaginary();
+                }
+            }
+        } else {
+            d = new double[width][2*height];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    d[x][y*2] = c[x][y].getReal();
+                    d[x][y*2+1] = c[x][y].getImaginary();
+                }
+            }
+        }
+        return d;
+    }
+
+    /**
+     * Converts a 2D array of {@code Complex} objects
+     * to an interleaved complex {@code double[][]} array.
+     * The first depth level of the array is interleaved.
+     *
+     * @param c 2D Array of Complex objects.
+     * @return a complex interleaved {@code double[][]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static double[][] complex2Interleaved(Complex[][] c) {
+        return complex2Interleaved(c, 1);
+    }
+
+    /**
+     * Converts a 3D array of {@code Complex} objects
+     * to an interleaved complex {@code double[][][]} array.
+     *
+     * @param c 3D Array of Complex objects.
+     * @param interleavedDim Depth level of the array to interleave.
+     * @return a complex interleaved {@code double[][][]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static double[][][] complex2Interleaved(Complex[][][] c, int interleavedDim) {
+        if (interleavedDim > 2 || interleavedDim < 0) {
+            throw new OutOfRangeException(
+                  interleavedDim, 0, 2);
+        }
+        int width = c.length;
+        int height = c[0].length;
+        int depth = c[0].length;
+        double[][][] d;
+        if (interleavedDim == 0) {
+            d = new double[2*width][height][depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        d[x*2][y][z] = c[x][y][z].getReal();
+                        d[x*2+1][y][z] = c[x][y][z].getImaginary();
+                    }
+                }
+            }
+        } else if (interleavedDim == 1) {
+            d = new double[width][2*height][depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        d[x][y][z] = c[x][y][z].getReal();
+                        d[x][y*2][z] = c[x][y][z].getImaginary();
+                    }
+                }
+            }
+        } else {
+            d = new double[width][height][2*depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        d[x][y][z*2] = c[x][y][z].getReal();
+                        d[x][y][z*2+1] = c[x][y][z].getImaginary();
+                    }
+                }
+            }
+        }
+        return d;
+    }
+
+    /**
+     * Converts a 3D array of {@code Complex} objects
+     * to an interleaved complex {@code double[][]} array.
+     * The first depth level of the array is interleaved.
+     *
+     * @param c 3D Array of Complex objects.
+     * @return a complex interleaved {@code double[][]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static double[][][] complex2Interleaved(Complex[][][] c) {
+        return complex2Interleaved(c, 2);
+    }
+
+    /**
+     * Converts a 2D array of {@code Complex} objects
+     * to an interleaved complex {@code float[][]} array.
+     *
+     * @param c 2D Array of Complex objects.
+     * @param interleavedDim Depth level of the array to interleave.
+     * @return a complex interleaved {@code float[][]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static float[][] complex2InterleavedFloat(Complex[][] c, int interleavedDim) {
+        if (interleavedDim > 1 || interleavedDim < 0) {
+            throw new OutOfRangeException(
+                  interleavedDim, 0, 1);
+        }
+        final int width = c.length;
+        final int height = c[0].length;
+        float[][] d;
+        if (interleavedDim == 0) {
+            d = new float[2*width][height];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    d[x*2][y] = (float)c[x][y].getReal();
+                    d[x*2+1][y] = (float)c[x][y].getImaginary();
+                }
+            }
+        } else {
+            d = new float[width][2*height];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    d[x][y*2] = (float)c[x][y].getReal();
+                    d[x][y*2+1] = (float)c[x][y].getImaginary();
+                }
+            }
+        }
+        return d;
+    }
+
+    /**
+     * Converts a 2D array of {@code Complex} objects
+     * to an interleaved complex {@code float[][]} array.
+     * The first depth level of the array is interleaved.
+     *
+     * @param c 2D Array of Complex objects.
+     *
+     * @return a complex interleaved {@code float[][]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static float[][] complex2InterleavedFloat(Complex[][] c) {
+        return complex2InterleavedFloat(c, 1);
+    }
+
+    /**
+     * Converts a 3D array of {@code Complex} objects
+     * to an interleaved complex {@code float[][][]} array.
+     *
+     * @param c 3D Array of Complex objects.
+     * @param interleavedDim Depth level of the array to interleave.
+     * @return a complex interleaved {@code float[][][]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static float[][][] complex2InterleavedFloat(Complex[][][] c, int interleavedDim) {
+        if (interleavedDim > 2 || interleavedDim < 0) {
+            throw new OutOfRangeException(
+                  interleavedDim, 0, 2);
+        }
+        int width = c.length;
+        int height = c[0].length;
+        int depth = c[0].length;
+        float[][][] d;
+        if (interleavedDim == 0) {
+            d = new float[2*width][height][depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        d[x*2][y][z] = (float)c[x][y][z].getReal();
+                        d[x*2+1][y][z] = (float)c[x][y][z].getImaginary();
+                    }
+                }
+            }
+        } else if (interleavedDim == 1) {
+            d = new float[width][2*height][depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        d[x][y][z] = (float)c[x][y][z].getReal();
+                        d[x][y*2][z] = (float)c[x][y][z].getImaginary();
+                    }
+                }
+            }
+        } else {
+            d = new float[width][height][2*depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        d[x][y][z*2] = (float)c[x][y][z].getReal();
+                        d[x][y][z*2+1] = (float)c[x][y][z].getImaginary();
+                    }
+                }
+            }
+        }
+        return d;
+    }
+
+    /**
+     * Converts a 3D array of {@code Complex} objects
+     * to an interleaved complex {@code float[][]} array.
+     * The first depth level of the array is interleaved.
+     *
+     * @param c 2D Array of Complex objects.
+     *
+     * @return a complex interleaved {@code float[][]} alternating real and imaginary values.
+     *
+     * @since 4.0
+     */
+    public static float[][][] complex2InterleavedFloat(Complex[][][] c) {
+        return complex2InterleavedFloat(c, 2);
+    }
+
+    /**
+     * Converts a 2D interleaved complex array {@code double[][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 2d complex interleaved {@code double[][]}
+     * @param interleavedDim Depth level of the array to interleave.
+     * @return 2d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][] interleaved2Complex(double[][] d, int interleavedDim) {
+        if (interleavedDim > 1 || interleavedDim < 0) {
+            throw new OutOfRangeException(
+                  interleavedDim, 0, 1);
+        }
+        int width = d.length;
+        int height = d[0].length;
+        Complex[][] c;
+        if (interleavedDim == 0) {
+            c = new Complex[width/2][height];
+            for (int x = 0; x < width/2; x++) {
+                for (int y = 0; y < height; y++) {
+                    c[x][y] = new Complex(d[x*2][y], d[x*2+1][y]);
+                }
+            }
+        } else {
+            c = new Complex[width][height/2];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height/2; y++) {
+                    c[x][y] = new Complex(d[x][y*2], d[x][y*2+1]);
+                }
+            }
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 2D interleaved complex array {@code double[][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 2d complex interleaved {@code double[][]}
+     * @return 2d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][] interleaved2Complex(double[][] d) {
+        return interleaved2Complex(d,1);
+    }
+
+    /**
+     * Converts a 3D interleaved complex array {@code double[][][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 3d complex interleaved {@code double[][][]}
+     * @param interleavedDim Depth level of the array to interleave.
+     * @return 3d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][][] interleaved2Complex(double[][][] d, int interleavedDim) {
+        if (interleavedDim > 2 || interleavedDim < 0) {
+            throw new OutOfRangeException(
+                  interleavedDim, 0, 2);
+        }
+        int width = d.length;
+        int height = d[0].length;
+        int depth = d[0].length;
+        Complex[][][] c;
+        if (interleavedDim == 0) {
+            c = new Complex[width/2][height][depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        c[x][y][z] = new Complex(d[x/2][y][z], d[x/2+1][y][z]);
+                    }
+                }
+            }
+        } else if (interleavedDim == 1) {
+            c = new Complex[width][height/2][depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        c[x][y][z] = new Complex(d[x][y/2][z], d[x][y/2+1][z]);
+                    }
+                }
+            }
+        } else {
+            c = new Complex[width][height][depth/2];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        c[x][y][z] = new Complex(d[x][y][z/2], d[x][y][z/2+1]);
+                    }
+                }
+            }
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 3D interleaved complex array {@code double[][][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 3d complex interleaved {@code double[][][]}
+     * @return 3d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][][] interleaved2Complex(double[][][] d) {
+        return interleaved2Complex(d,2);
+    }
+
+    /**
+     * Converts a 2D interleaved complex array {@code float[][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 2d complex interleaved {@code float[][]}
+     * @param interleavedDim Depth level of the array to interleave.
+     * @return 2d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][] interleaved2Complex(float[][] d, int interleavedDim) {
+        if (interleavedDim > 1 || interleavedDim < 0) {
+            throw new OutOfRangeException(
+                  interleavedDim, 0, 1);
+        }
+        int width = d.length;
+        int height = d[0].length;
+        Complex[][] c;
+        if (interleavedDim == 0) {
+            c = new Complex[width/2][height];
+            for (int x = 0; x < width/2; x++) {
+                for (int y = 0; y < height; y++) {
+                    c[x][y] = new Complex(d[x*2][y], d[x*2+1][y]);
+                }
+            }
+        } else {
+            c = new Complex[width][height/2];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height/2; y++) {
+                    c[x][y] = new Complex(d[x][y*2], d[x][y*2+1]);
+                }
+            }
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 2D interleaved complex array {@code float[][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 2d complex interleaved {@code float[][]}
+     * @return 2d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][] interleaved2Complex(float[][] d) {
+        return interleaved2Complex(d,1);
+    }
+
+    /**
+     * Converts a 3D interleaved complex array {@code float[][][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 3d complex interleaved {@code float[][][]}
+     * @param interleavedDim Depth level of the array to interleave.
+     * @return 3d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][][] interleaved2Complex(float[][][] d, int interleavedDim) {
+        if (interleavedDim > 2 || interleavedDim < 0) {
+            throw new OutOfRangeException(
+                  interleavedDim, 0, 2);
+        }
+        int width = d.length;
+        int height = d[0].length;
+        int depth = d[0].length;
+        Complex[][][] c;
+        if (interleavedDim == 0) {
+            c = new Complex[width/2][height][depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        c[x][y][z] = new Complex(d[x/2][y][z], d[x/2+1][y][z]);
+                    }
+                }
+            }
+        } else if (interleavedDim == 1) {
+            c = new Complex[width][height/2][depth];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth; z++) {
+                        c[x][y][z] = new Complex(d[x][y/2][z], d[x][y/2+1][z]);
+                    }
+                }
+            }
+        } else {
+            c = new Complex[width][height][depth/2];
+            for (int x = 0; x < width; x++) {
+                for (int y = 0; y < height; y++) {
+                    for (int z = 0; z < depth/2; z++) {
+                        c[x][y][z] = new Complex(d[x][y][z*2], d[x][y][z*2+1]);
+                    }
+                }
+            }
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 3D interleaved complex array {@code float[][][]}
+     * to an array of {@code Complex} objects.
+     *
+     * @param d 3d complex interleaved {@code float[][][]}
+     * @return 3d array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][][] interleaved2Complex(float[][][] d) {
+        return interleaved2Complex(d,2);
+    }
+
+    // SPLIT METHODS
+
+    /**
+     * Converts a split complex array {@code double[] r, double[] i}
+     * to an array of {@code Complex} objects.
+     *
+     * @param real real component
+     * @param imag imaginary component
+     * @return array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[] split2Complex(double[] real, double[] imag) {
+        int length = real.length;
+        Complex[] c = new Complex[length];
+        for (int n = 0; n < length; n++) {
+            c[n] = new Complex(real[n], imag[n]);
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 2d split complex array {@code double[][] r, double[][] i}
+     * to a 2d array of {@code Complex} objects.
+     *
+     * @param real real component
+     * @param imag imaginary component
+     * @return array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][] split2Complex(double[][] real, double[][] imag) {
+        int width = real.length;
+        int height = real[0].length;
+        Complex[][] c = new Complex[width][height];
+        for (int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                c[x][y] = new Complex(real[x][y], imag[x][y]);
+            }
+        }
+        return c;
+    }
+
+    /**
+     * Converts a 3d split complex array {@code double[][][] r, double[][][] i}
+     * to a 3d array of {@code Complex} objects.
+     *
+     * @param real real component
+     * @param imag imaginary component
+     * @return array of {@code Complex} objects
+     *
+     * @since 4.0
+     */
+    public static Complex[][][] split2Complex(double[][][] real, double[][][] imag) {
+        int width = real.length;
+        int height = real[0].length;
+        int depth = real[0][0].length;
+        Complex[][][] c = new Complex[width][height][depth];
+        for (int x = 0; x < width; x++) {
+            for (int y = 0; y < height; y++) {
+                for (int z = 0; z < depth; z++) {
+                    c[x][y][z] = new Complex(real[x][y][z], imag[x][y][z]);
+                }
+            }
+        }
+        return c;
+    }
+
+    // MISC
+
+    /** Initialize an one-dimension array of complex with {@link Complex#ZERO}.
+     * @param c array to initialize
+     * @return the initialized array, in fluent-style API
+     * @since 4.0
+     */
+    public static Complex[] initialize(Complex[] c) {
+        for (int i : IntegerSequence.range(0, c.length-1)) {
+            c[i] = Complex.ZERO;
+        }
+        return c;
+    }
+
+    /** Initialize an two-dimension array of complex with {@link Complex#ZERO}.
+     * @param c array to initialize
+     * @return the initialized array, in fluent-style API
+     * @since 4.0
+     */
+    public static Complex[][] initialize(Complex[][] c) {
+        for (int i: IntegerSequence.range(0, c.length-1)) {
+            for (int j : IntegerSequence.range(0, c[0].length-1)) {
+                c[i][j] = Complex.ZERO;
+            }
+        }
+        return c;
+    }
+
+    /** Initialize an three-dimension array of complex with {@link Complex#ZERO}.
+     * @param c array to initialize
+     * @return the initialized array, in fluent-style API
+     * @since 4.0
+     */
+    public static Complex[][][] initialize(Complex[][][] c) {
+        for (int i: IntegerSequence.range(0, c.length-1)) {
+            for (int j : IntegerSequence.range(0, c[0].length-1)) {
+                for (int k: IntegerSequence.range(0, c[1].length-1)) {
+                    c[i][j][k] = Complex.ZERO;
+                }
+            }
+        }
+        return c;
+    }
+
 }

http://git-wip-us.apache.org/repos/asf/commons-math/blob/1888acc2/src/main/java/org/apache/commons/math4/util/IntegerSequence.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/util/IntegerSequence.java b/src/main/java/org/apache/commons/math4/util/IntegerSequence.java
index 1a16b0c..9887f03 100644
--- a/src/main/java/org/apache/commons/math4/util/IntegerSequence.java
+++ b/src/main/java/org/apache/commons/math4/util/IntegerSequence.java
@@ -73,6 +73,20 @@ public class IntegerSequence {
         };
     }
 
+
+    /**
+     * Compute the size of a range
+     * @param range range to analyze
+     * @return size of the range
+     */
+    public static int size(Iterable<Integer> range) {
+        int n = 0;
+        for (@SuppressWarnings("unused") Integer i : range) {
+            n++;
+        }
+        return n;
+    }
+
     /**
      * Utility that increments a counter until a maximum is reached, at
      * which point, the instance will by default throw a

http://git-wip-us.apache.org/repos/asf/commons-math/blob/1888acc2/src/test/java/org/apache/commons/math4/TestUtils.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/math4/TestUtils.java b/src/test/java/org/apache/commons/math4/TestUtils.java
index 109e64d..68a0138 100644
--- a/src/test/java/org/apache/commons/math4/TestUtils.java
+++ b/src/test/java/org/apache/commons/math4/TestUtils.java
@@ -365,6 +365,74 @@ public class TestUtils {
         }
     }
 
+    /** verifies that two arrays are close (sup norm) */
+    public static void assertEquals(String msg, float[] expected, float[] observed, float tolerance) {
+        StringBuilder out = new StringBuilder(msg);
+        if (expected.length != observed.length) {
+            out.append("\n Arrays not same length. \n");
+            out.append("expected has length ");
+            out.append(expected.length);
+            out.append(" observed length = ");
+            out.append(observed.length);
+            Assert.fail(out.toString());
+        }
+        boolean failure = false;
+        for (int i=0; i < expected.length; i++) {
+            if (!Precision.equalsIncludingNaN(expected[i], observed[i], tolerance)) {
+                failure = true;
+                out.append("\n Elements at index ");
+                out.append(i);
+                out.append(" differ. ");
+                out.append(" expected = ");
+                out.append(expected[i]);
+                out.append(" observed = ");
+                out.append(observed[i]);
+            }
+        }
+        if (failure) {
+            Assert.fail(out.toString());
+        }
+    }
+
+    /** verifies that two arrays are close (sup norm) */
+    public static void assertEquals(String msg, Complex[] expected, Complex[] observed, double tolerance) {
+        StringBuilder out = new StringBuilder(msg);
+        if (expected.length != observed.length) {
+            out.append("\n Arrays not same length. \n");
+            out.append("expected has length ");
+            out.append(expected.length);
+            out.append(" observed length = ");
+            out.append(observed.length);
+            Assert.fail(out.toString());
+        }
+        boolean failure = false;
+        for (int i=0; i < expected.length; i++) {
+            if (!Precision.equalsIncludingNaN(expected[i].getReal(), observed[i].getReal(), tolerance)) {
+                failure = true;
+                out.append("\n Real elements at index ");
+                out.append(i);
+                out.append(" differ. ");
+                out.append(" expected = ");
+                out.append(expected[i].getReal());
+                out.append(" observed = ");
+                out.append(observed[i].getReal());
+            }
+            if (!Precision.equalsIncludingNaN(expected[i].getImaginary(), observed[i].getImaginary(), tolerance)) {
+                failure = true;
+                out.append("\n Imaginary elements at index ");
+                out.append(i);
+                out.append(" differ. ");
+                out.append(" expected = ");
+                out.append(expected[i].getImaginary());
+                out.append(" observed = ");
+                out.append(observed[i].getImaginary());
+            }
+        }
+        if (failure) {
+            Assert.fail(out.toString());
+        }
+    }
+
     /** verifies that two arrays are equal */
     public static <T extends FieldElement<T>> void assertEquals(T[] m, T[] n) {
         if (m.length != n.length) {