Example usage for org.apache.commons.math.complex Complex Complex

List of usage examples for org.apache.commons.math.complex Complex Complex

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.math.complex.*
  5. Complex
  6. Complex

Introduction

In this page you can find the example usage for org.apache.commons.math.complex Complex Complex.

Prototype

public Complex(double real, double imaginary)

Source Link

Document

Create a complex number given the real and imaginary parts.

Usage

From source file:uk.ac.diamond.scisoft.analysis.dataset.MathsTest.java

@Test
public void testSubtraction() {
    AbstractDataset a, b, c = null, d = null;
    Complex zv = new Complex(-3.5, 0);
    final double dv = zv.getReal();
    long start;// w  ww.j ava 2 s  . c  om
    int n;

    for (String dn : classes.keySet()) {
        final int dtype = classes.get(dn);
        Random.seed(12735L);
        for (String en : classes.keySet()) {
            final int etype = classes.get(en);

            System.out.println("Subtracting " + dn + " to " + en);

            n = 32;
            for (int i = 0; i < SITER; i++) {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    a = Random.randn(n).imultiply(100);
                    a = a.cast(dtype);
                } else {
                    AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                    for (int j = 0; j < ISIZEA; j++) {
                        aa[j] = Random.randn(n).imultiply(100);
                    }
                    a = DatasetUtils.cast(aa, dtype);
                }
                if (etype < AbstractDataset.ARRAYINT8) {
                    b = Random.randn(n).imultiply(100);
                    b = b.cast(etype);
                } else {
                    AbstractDataset[] ab = new AbstractDataset[ISIZEB];
                    for (int j = 0; j < ISIZEB; j++) {
                        ab[j] = Random.randn(n).imultiply(100);
                    }
                    b = DatasetUtils.cast(ab, etype);
                }

                start = -System.nanoTime();
                try {
                    c = Maths.subtract(a, b);
                } catch (IllegalArgumentException e) {
                    System.out.println("Could not perform this operation: " + e.getMessage());
                    continue;
                }
                start += System.nanoTime();
                double ntime = ((double) start) / c.getSize();

                d = AbstractDataset.zeros(c);
                start = -System.nanoTime();
                IndexIterator ita = a.getIterator();
                IndexIterator itb = b.getIterator();
                int j = 0;
                if ((dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && (etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index))
                                .subtract((Complex) b.getObjectAbs(itb.index)));
                        j += is;
                    }
                } else if ((dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && !(etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index))
                                .subtract(new Complex(b.getElementDoubleAbs(itb.index), 0)));
                        j += is;
                    }
                } else if (!(dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && (etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, new Complex(a.getElementDoubleAbs(ita.index), 0)
                                .subtract((Complex) b.getObjectAbs(itb.index)));
                        j += is;
                    }
                } else {
                    if (dtype < AbstractDataset.ARRAYINT8 && etype < AbstractDataset.ARRAYINT8) {
                        while (ita.hasNext() && itb.hasNext()) {
                            d.setObjectAbs(j++, ((Number) a.getObjectAbs(ita.index)).doubleValue()
                                    - ((Number) b.getObjectAbs(itb.index)).doubleValue());
                        }
                    } else {
                        final double[] answer = new double[MAXISIZE];
                        final int is = d.getElementsPerItem();

                        if (a.getElementsPerItem() < is) {
                            while (ita.hasNext() && itb.hasNext()) {
                                final double da = a.getElementDoubleAbs(ita.index);
                                for (int k = 0; k < ISIZEB; k++) {
                                    answer[k] = da - b.getElementDoubleAbs(itb.index + k);
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        } else if (b.getElementsPerItem() < is) {
                            while (ita.hasNext() && itb.hasNext()) {
                                final double db = b.getElementDoubleAbs(itb.index);
                                for (int k = 0; k < ISIZEA; k++) {
                                    answer[k] = a.getElementDoubleAbs(ita.index + k) - db;
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        } else {
                            while (ita.hasNext() && itb.hasNext()) {
                                for (int k = 0; k < is; k++) {
                                    answer[k] = a.getElementDoubleAbs(ita.index + k)
                                            - b.getElementDoubleAbs(itb.index + k);
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        }
                    }
                }
                start += System.nanoTime();
                double otime = ((double) start) / d.getSize();

                System.out.printf("Time taken by sub for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                        100. * (otime - ntime) / otime);

                checkDatasets(a, b, c, d);

                n *= SSTEP;
            }
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Subtracting constant from " + dn);
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            c = Maths.subtract(a, dv);
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128) {
                final int is = d.getElementsPerItem();
                while (ita.hasNext()) {
                    d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index)).subtract(zv));
                    j += is;
                }
            } else {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    while (ita.hasNext()) {
                        d.setObjectAbs(j++, ((Number) a.getObjectAbs(ita.index)).doubleValue() - dv);
                    }
                } else {
                    final double[] answer = new double[ISIZEA];
                    while (ita.hasNext()) {
                        for (int k = 0; k < ISIZEA; k++) {
                            answer[k] = a.getElementDoubleAbs(ita.index + k) - dv;
                        }
                        d.setObjectAbs(j, answer);
                        j += ISIZEA;
                    }
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by add for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(a, dv, c, d);

            n *= SSTEP;
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Subtracting " + dn + " from constant");
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            c = Maths.subtract(dv, a);
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128) {
                final int is = d.getElementsPerItem();
                while (ita.hasNext()) {
                    d.setObjectAbs(j, zv.subtract((Complex) a.getObjectAbs(ita.index)));
                    j += is;
                }
            } else {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    while (ita.hasNext()) {
                        d.setObjectAbs(j++, dv - ((Number) a.getObjectAbs(ita.index)).doubleValue());
                    }
                } else {
                    final double[] answer = new double[ISIZEA];
                    while (ita.hasNext()) {
                        for (int k = 0; k < ISIZEA; k++) {
                            answer[k] = dv - a.getElementDoubleAbs(ita.index + k);
                        }
                        d.setObjectAbs(j, answer);
                        j += ISIZEA;
                    }
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by sub for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(dv, a, c, d);

            n *= SSTEP;
        }
    }
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.MathsTest.java

@Test
public void testMultiplication() {
    AbstractDataset a, b, c = null, d = null;
    Complex zv = new Complex(-3.5, 0);
    final double dv = zv.getReal();
    long start;/*from   w  ww  .  j a va  2  s.c o  m*/
    int n;

    for (String dn : classes.keySet()) {
        final int dtype = classes.get(dn);
        Random.seed(12735L);

        for (String en : classes.keySet()) {
            final int etype = classes.get(en);

            System.out.println("Multiplying " + dn + " by " + en);

            n = 32;
            for (int i = 0; i < SITER; i++) {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    a = Random.randn(n).imultiply(100);
                    a = a.cast(dtype);
                } else {
                    AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                    for (int j = 0; j < ISIZEA; j++) {
                        aa[j] = Random.randn(n).imultiply(100);
                    }
                    a = DatasetUtils.cast(aa, dtype);
                }
                if (etype < AbstractDataset.ARRAYINT8) {
                    b = Random.randn(n).imultiply(100);
                    b = b.cast(etype);
                } else {
                    AbstractDataset[] ab = new AbstractDataset[ISIZEB];
                    for (int j = 0; j < ISIZEB; j++) {
                        ab[j] = Random.randn(n).imultiply(100);
                    }
                    b = DatasetUtils.cast(ab, etype);
                }

                start = -System.nanoTime();
                try {
                    c = Maths.multiply(a, b);
                } catch (IllegalArgumentException e) {
                    System.out.println("Could not perform this operation: " + e.getMessage());
                    continue;
                }
                start += System.nanoTime();
                double ntime = ((double) start) / c.getSize();

                d = AbstractDataset.zeros(c);
                start = -System.nanoTime();
                IndexIterator ita = a.getIterator();
                IndexIterator itb = b.getIterator();
                int j = 0;
                if ((dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && (etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index))
                                .multiply((Complex) b.getObjectAbs(itb.index)));
                        j += is;
                    }
                } else if ((dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && !(etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index))
                                .multiply(b.getElementDoubleAbs(itb.index)));
                        j += is;
                    }
                } else if (!(dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && (etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, new Complex(a.getElementDoubleAbs(ita.index), 0)
                                .multiply((Complex) b.getObjectAbs(itb.index)));
                        j += is;
                    }
                } else {
                    if (dtype < AbstractDataset.ARRAYINT8 && etype < AbstractDataset.ARRAYINT8) {
                        while (ita.hasNext() && itb.hasNext()) {
                            d.setObjectAbs(j++, ((Number) a.getObjectAbs(ita.index)).doubleValue()
                                    * ((Number) b.getObjectAbs(itb.index)).doubleValue());
                        }
                    } else {
                        final double[] answer = new double[MAXISIZE];
                        final int is = d.getElementsPerItem();

                        if (a.getElementsPerItem() < is) {
                            while (ita.hasNext() && itb.hasNext()) {
                                final double da = a.getElementDoubleAbs(ita.index);
                                for (int k = 0; k < ISIZEB; k++) {
                                    answer[k] = da * b.getElementDoubleAbs(itb.index + k);
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        } else if (b.getElementsPerItem() < is) {
                            while (ita.hasNext() && itb.hasNext()) {
                                final double db = b.getElementDoubleAbs(itb.index);
                                for (int k = 0; k < ISIZEA; k++) {
                                    answer[k] = a.getElementDoubleAbs(ita.index + k) * db;
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        } else {
                            while (ita.hasNext() && itb.hasNext()) {
                                for (int k = 0; k < is; k++) {
                                    answer[k] = a.getElementDoubleAbs(ita.index + k)
                                            * b.getElementDoubleAbs(itb.index + k);
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        }
                    }
                }
                start += System.nanoTime();
                double otime = ((double) start) / d.getSize();

                System.out.printf("Time taken by mul for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                        100. * (otime - ntime) / otime);

                checkDatasets(a, b, c, d);

                n *= SSTEP;
            }
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Multiplying constant with " + dn);
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            c = Maths.multiply(a, dv);
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128) {
                final int is = d.getElementsPerItem();
                while (ita.hasNext()) {
                    d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index)).multiply(zv));
                    j += is;
                }
            } else {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    while (ita.hasNext()) {
                        d.setObjectAbs(j++, ((Number) a.getObjectAbs(ita.index)).doubleValue() * dv);
                    }
                } else {
                    final double[] answer = new double[ISIZEA];
                    while (ita.hasNext()) {
                        for (int k = 0; k < ISIZEA; k++) {
                            answer[k] = a.getElementDoubleAbs(ita.index + k) * dv;
                        }
                        d.setObjectAbs(j, answer);
                        j += ISIZEA;
                    }
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by mul for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(a, dv, c, d);

            n *= SSTEP;
        }
    }
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.MathsTest.java

@Test
public void testDivision() {
    AbstractDataset a, b, c = null, d = null;
    Complex zv = new Complex(-3.5, 0);
    final double dv = zv.getReal();
    long start;/*ww  w .j ava 2  s  .co m*/
    int n;

    for (String dn : classes.keySet()) {
        final int dtype = classes.get(dn);
        Random.seed(12735L);

        for (String en : classes.keySet()) {
            final int etype = classes.get(en);

            System.out.println("Dividing " + dn + " by " + en);

            n = 32;
            for (int i = 0; i < SITER; i++) {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    a = Random.randn(n).imultiply(100);
                    a = a.cast(dtype);
                } else {
                    AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                    for (int j = 0; j < ISIZEA; j++) {
                        aa[j] = Random.randn(n).imultiply(100);
                    }
                    a = DatasetUtils.cast(aa, dtype);
                }
                if (etype < AbstractDataset.ARRAYINT8) {
                    b = Random.randn(n).imultiply(100);
                    b = b.cast(etype);
                } else {
                    AbstractDataset[] ab = new AbstractDataset[ISIZEB];
                    for (int j = 0; j < ISIZEB; j++) {
                        ab[j] = Random.randn(n).imultiply(100);
                    }
                    b = DatasetUtils.cast(ab, etype);
                }

                start = -System.nanoTime();
                try {
                    c = Maths.divide(a, b);
                } catch (IllegalArgumentException e) {
                    System.out.println("Could not perform this operation: " + e.getMessage());
                    continue;
                }
                start += System.nanoTime();
                double ntime = ((double) start) / c.getSize();

                d = AbstractDataset.zeros(c);
                start = -System.nanoTime();
                IndexIterator ita = a.getIterator();
                IndexIterator itb = b.getIterator();
                int j = 0;
                if ((dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && (etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index))
                                .divide((Complex) b.getObjectAbs(itb.index)));
                        j += is;
                    }
                } else if ((dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && !(etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index))
                                .divide(new Complex(b.getElementDoubleAbs(itb.index), 0)));
                        j += is;
                    }
                } else if (!(dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && (etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, new Complex(a.getElementDoubleAbs(ita.index), 0)
                                .divide((Complex) b.getObjectAbs(itb.index)));
                        j += is;
                    }
                } else {
                    if (dtype < AbstractDataset.ARRAYINT8 && etype < AbstractDataset.ARRAYINT8) {
                        while (ita.hasNext() && itb.hasNext()) {
                            d.setObjectAbs(j++, ((Number) a.getObjectAbs(ita.index)).doubleValue()
                                    / ((Number) b.getObjectAbs(itb.index)).doubleValue());
                        }
                    } else {
                        final double[] answer = new double[MAXISIZE];
                        final int is = d.getElementsPerItem();
                        final int rtype = d.getDtype();

                        if (a.getElementsPerItem() < is) {
                            while (ita.hasNext() && itb.hasNext()) {
                                final double xa = a.getElementDoubleAbs(ita.index);
                                if (rtype == AbstractDataset.ARRAYFLOAT32
                                        || rtype == AbstractDataset.ARRAYFLOAT64) {
                                    for (int k = 0; k < ISIZEB; k++) {
                                        answer[k] = xa / b.getElementDoubleAbs(itb.index + k);
                                    }
                                } else {
                                    for (int k = 0; k < ISIZEB; k++) {
                                        final double v = xa / b.getElementDoubleAbs(itb.index + k);
                                        answer[k] = Double.isInfinite(v) || Double.isNaN(v) ? 0 : v;
                                    }
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        } else if (b.getElementsPerItem() < is) {
                            while (ita.hasNext() && itb.hasNext()) {
                                final double xb = b.getElementDoubleAbs(itb.index);
                                if (rtype == AbstractDataset.ARRAYFLOAT32
                                        || rtype == AbstractDataset.ARRAYFLOAT64) {
                                    for (int k = 0; k < ISIZEA; k++) {
                                        answer[k] = a.getElementDoubleAbs(ita.index + k) / xb;
                                    }
                                } else {
                                    if (xb == 0) {
                                        for (int k = 0; k < ISIZEA; k++) {
                                            answer[k] = 0;
                                        }
                                    } else {
                                        for (int k = 0; k < ISIZEA; k++) {
                                            answer[k] = a.getElementDoubleAbs(ita.index + k) / xb;
                                        }
                                    }
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        } else {
                            while (ita.hasNext() && itb.hasNext()) {
                                if (rtype == AbstractDataset.ARRAYFLOAT32
                                        || rtype == AbstractDataset.ARRAYFLOAT64) {
                                    double v;
                                    for (int k = 0; k < is; k++) {
                                        v = a.getElementDoubleAbs(ita.index + k)
                                                / b.getElementDoubleAbs(itb.index + k);
                                        answer[k] = Double.isInfinite(v) || Double.isNaN(v) ? 0 : v;
                                    }
                                } else {
                                    double v;
                                    for (int k = 0; k < is; k++) {
                                        v = a.getElementDoubleAbs(ita.index + k)
                                                / b.getElementDoubleAbs(itb.index + k);
                                        answer[k] = Double.isInfinite(v) || Double.isNaN(v) ? 0 : v;
                                    }
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        }
                    }
                }
                start += System.nanoTime();
                double otime = ((double) start) / d.getSize();

                System.out.printf("Time taken by div for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                        100. * (otime - ntime) / otime);

                checkDatasets(a, b, c, d);

                n *= SSTEP;
            }
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Dividing " + dn + " by constant");
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            c = Maths.divide(a, dv);
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128) {
                final int is = d.getElementsPerItem();
                while (ita.hasNext()) {
                    d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index)).divide(zv));
                    j += is;
                }
            } else {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    while (ita.hasNext()) {
                        d.setObjectAbs(j++, ((Number) a.getObjectAbs(ita.index)).doubleValue() / dv);
                    }
                } else {
                    final double[] answer = new double[ISIZEA];
                    while (ita.hasNext()) {
                        for (int k = 0; k < ISIZEA; k++) {
                            answer[k] = a.getElementDoubleAbs(ita.index + k) / dv;
                        }
                        d.setObjectAbs(j, answer);
                        j += ISIZEA;
                    }
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by div for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(a, dv, c, d);

            n *= SSTEP;
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Dividing constant by " + dn);
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            c = Maths.divide(dv, a);
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128) {
                final int is = d.getElementsPerItem();
                while (ita.hasNext()) {
                    d.setObjectAbs(j, zv.divide((Complex) a.getObjectAbs(ita.index)));
                    j += is;
                }
            } else {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    while (ita.hasNext()) {
                        d.setObjectAbs(j++, dv / ((Number) a.getObjectAbs(ita.index)).doubleValue());
                    }
                } else {
                    final double[] answer = new double[ISIZEA];
                    while (ita.hasNext()) {
                        for (int k = 0; k < ISIZEA; k++) {
                            answer[k] = dv / a.getElementDoubleAbs(ita.index + k);
                        }
                        d.setObjectAbs(j, answer);
                        j += ISIZEA;
                    }
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by div for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(dv, a, c, d);

            n *= SSTEP;
        }
    }
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.MathsTest.java

@Test
public void testRemainder() {
    AbstractDataset a, b, c = null, d = null;
    Complex zv = new Complex(-3.5, 0);
    final double dv = zv.getReal();
    long start;// w ww. j  a  v  a 2s  .  c o m
    int n;

    for (String dn : classes.keySet()) {
        final int dtype = classes.get(dn);
        Random.seed(12735L);

        for (String en : classes.keySet()) {
            final int etype = classes.get(en);

            System.out.println("Remaindering " + dn + " by " + en);

            n = 32;
            for (int i = 0; i < SITER; i++) {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    a = Random.randn(n).imultiply(100);
                    a = a.cast(dtype);
                } else {
                    AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                    for (int j = 0; j < ISIZEA; j++) {
                        aa[j] = Random.randn(n).imultiply(100);
                    }
                    a = DatasetUtils.cast(aa, dtype);
                }
                if (etype < AbstractDataset.ARRAYINT8) {
                    b = Random.randn(n).imultiply(100);
                    b = b.cast(etype);
                } else {
                    AbstractDataset[] ab = new AbstractDataset[ISIZEB];
                    for (int j = 0; j < ISIZEB; j++) {
                        ab[j] = Random.randn(n).imultiply(100);
                    }
                    b = DatasetUtils.cast(ab, etype);
                }

                start = -System.nanoTime();
                try {
                    c = Maths.remainder(a, b);
                } catch (IllegalArgumentException e) {
                    System.out.println("Could not perform this operation: " + e.getMessage());
                    continue;
                } catch (UnsupportedOperationException ue) {
                    System.out.println("Could not perform this operation: " + ue.getMessage());
                    continue;
                }
                start += System.nanoTime();
                double ntime = ((double) start) / c.getSize();

                d = AbstractDataset.zeros(c);
                start = -System.nanoTime();
                IndexIterator ita = a.getIterator();
                IndexIterator itb = b.getIterator();
                int j = 0;
                if (dtype < AbstractDataset.ARRAYINT8 && etype < AbstractDataset.ARRAYINT8) {
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j++, ((Number) a.getObjectAbs(ita.index)).doubleValue()
                                % ((Number) b.getObjectAbs(itb.index)).doubleValue());
                    }
                } else {
                    final double[] answer = new double[MAXISIZE];
                    final int is = d.getElementsPerItem();

                    if (a.getElementsPerItem() < is) {
                        while (ita.hasNext() && itb.hasNext()) {
                            final double xa = a.getElementDoubleAbs(ita.index);
                            for (int k = 0; k < ISIZEB; k++) {
                                answer[k] = xa % b.getElementDoubleAbs(itb.index + k);
                            }
                            d.setObjectAbs(j, answer);
                            j += is;
                        }
                    } else if (b.getElementsPerItem() < is) {
                        while (ita.hasNext() && itb.hasNext()) {
                            final double xb = b.getElementDoubleAbs(itb.index);
                            for (int k = 0; k < ISIZEA; k++) {
                                answer[k] = a.getElementDoubleAbs(ita.index + k) % xb;
                            }
                            d.setObjectAbs(j, answer);
                            j += is;
                        }
                    } else {
                        while (ita.hasNext() && itb.hasNext()) {
                            for (int k = 0; k < is; k++) {
                                answer[k] = a.getElementDoubleAbs(ita.index + k)
                                        % b.getElementDoubleAbs(itb.index + k);
                            }
                            d.setObjectAbs(j, answer);
                            j += is;
                        }
                    }
                }
                start += System.nanoTime();
                double otime = ((double) start) / d.getSize();

                System.out.printf("Time taken by rem for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                        100. * (otime - ntime) / otime);

                checkDatasets(a, b, c, d);

                n *= SSTEP;
            }
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Remaindering " + dn + " by constant");
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            try {
                c = Maths.remainder(a, dv);
            } catch (IllegalArgumentException e) {
                System.out.println("Could not perform this operation: " + e.getMessage());
                continue;
            } catch (UnsupportedOperationException ue) {
                System.out.println("Could not perform this operation: " + ue.getMessage());
                continue;
            }
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype < AbstractDataset.ARRAYINT8) {
                while (ita.hasNext()) {
                    d.setObjectAbs(j++, ((Number) a.getObjectAbs(ita.index)).doubleValue() % dv);
                }
            } else {
                final double[] answer = new double[ISIZEA];
                while (ita.hasNext()) {
                    for (int k = 0; k < ISIZEA; k++) {
                        answer[k] = a.getElementDoubleAbs(ita.index + k) % dv;
                    }
                    d.setObjectAbs(j, answer);
                    j += ISIZEA;
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by rem for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(a, dv, c, d);

            n *= SSTEP;
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Remaindering constant by " + dn);
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            try {
                c = Maths.remainder(dv, a);
            } catch (IllegalArgumentException e) {
                System.out.println("Could not perform this operation: " + e.getMessage());
                continue;
            } catch (UnsupportedOperationException ue) {
                System.out.println("Could not perform this operation: " + ue.getMessage());
                continue;
            }
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype < AbstractDataset.ARRAYINT8) {
                while (ita.hasNext()) {
                    d.setObjectAbs(j++, dv % ((Number) a.getObjectAbs(ita.index)).doubleValue());
                }
            } else {
                final double[] answer = new double[ISIZEA];
                while (ita.hasNext()) {
                    for (int k = 0; k < ISIZEA; k++) {
                        answer[k] = dv % a.getElementDoubleAbs(ita.index + k);
                    }
                    d.setObjectAbs(j, answer);
                    j += ISIZEA;
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by rem for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(dv, a, c, d);

            n *= SSTEP;
        }
    }
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.MathsTest.java

@Test
public void testPower() {
    AbstractDataset a, b, c = null, d = null;
    Complex zv = new Complex(-3.5, 0);
    final double dv = zv.getReal();
    long start;/*w w  w. j  a v a  2  s  .  c om*/
    int n;

    for (String dn : classes.keySet()) {
        final int dtype = classes.get(dn);
        Random.seed(12735L);

        for (String en : classes.keySet()) {
            final int etype = classes.get(en);

            System.out.println("Powering " + dn + " by " + en);

            n = 32;
            for (int i = 0; i < SITER; i++) {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    a = Random.randn(n).imultiply(100);
                    a = a.cast(dtype);
                } else {
                    AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                    for (int j = 0; j < ISIZEA; j++) {
                        aa[j] = Random.randn(n).imultiply(100);
                    }
                    a = DatasetUtils.cast(aa, dtype);
                }
                if (etype < AbstractDataset.ARRAYINT8) {
                    b = Random.randn(n).imultiply(100);
                    b = b.cast(etype);
                } else {
                    AbstractDataset[] ab = new AbstractDataset[ISIZEB];
                    for (int j = 0; j < ISIZEB; j++) {
                        ab[j] = Random.randn(n).imultiply(100);
                    }
                    b = DatasetUtils.cast(ab, etype);
                }

                start = -System.nanoTime();
                try {
                    c = Maths.power(a, b);
                } catch (IllegalArgumentException e) {
                    System.out.println("Could not perform this operation: " + e.getMessage());
                    continue;
                }
                start += System.nanoTime();
                double ntime = ((double) start) / c.getSize();

                d = AbstractDataset.zeros(c);
                start = -System.nanoTime();
                IndexIterator ita = a.getIterator();
                IndexIterator itb = b.getIterator();
                int j = 0;
                if ((dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && (etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j,
                                ((Complex) a.getObjectAbs(ita.index)).pow((Complex) b.getObjectAbs(itb.index)));
                        j += is;
                    }
                } else if ((dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && !(etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index))
                                .pow(new Complex(b.getElementDoubleAbs(itb.index), 0)));
                        j += is;
                    }
                } else if (!(dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128)
                        && (etype == AbstractDataset.COMPLEX64 || etype == AbstractDataset.COMPLEX128)) {
                    final int is = d.getElementsPerItem();
                    while (ita.hasNext() && itb.hasNext()) {
                        d.setObjectAbs(j, new Complex(a.getElementDoubleAbs(ita.index), 0)
                                .pow((Complex) b.getObjectAbs(itb.index)));
                        j += is;
                    }
                } else {
                    if (dtype < AbstractDataset.ARRAYINT8 && etype < AbstractDataset.ARRAYINT8) {
                        while (ita.hasNext() && itb.hasNext()) {
                            d.setObjectAbs(j++, Math.pow(((Number) a.getObjectAbs(ita.index)).doubleValue(),
                                    ((Number) b.getObjectAbs(itb.index)).doubleValue()));
                        }
                    } else {
                        final double[] answer = new double[MAXISIZE];
                        final int is = d.getElementsPerItem();
                        final int rtype = d.getDtype();

                        double v;
                        if (a.getElementsPerItem() < is) {
                            while (ita.hasNext() && itb.hasNext()) {
                                final double xa = a.getElementDoubleAbs(ita.index);
                                if (rtype == AbstractDataset.ARRAYFLOAT32
                                        || rtype == AbstractDataset.ARRAYFLOAT64) {
                                    for (int k = 0; k < ISIZEB; k++) {
                                        answer[k] = Math.pow(xa, b.getElementDoubleAbs(itb.index + k));
                                    }
                                } else {
                                    for (int k = 0; k < ISIZEB; k++) {
                                        v = Math.pow(xa, b.getElementDoubleAbs(itb.index + k));
                                        answer[k] = Double.isInfinite(v) || Double.isNaN(v) ? 0 : v;
                                    }
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        } else if (b.getElementsPerItem() < is) {
                            while (ita.hasNext() && itb.hasNext()) {
                                final double xb = b.getElementDoubleAbs(itb.index);
                                if (rtype == AbstractDataset.ARRAYFLOAT32
                                        || rtype == AbstractDataset.ARRAYFLOAT64) {
                                    for (int k = 0; k < ISIZEA; k++) {
                                        answer[k] = Math.pow(a.getElementDoubleAbs(ita.index + k), xb);
                                    }
                                } else {
                                    for (int k = 0; k < ISIZEA; k++) {
                                        v = Math.pow(a.getElementDoubleAbs(ita.index + k), xb);
                                        answer[k] = Double.isInfinite(v) || Double.isNaN(v) ? 0 : v;
                                    }
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        } else {
                            while (ita.hasNext() && itb.hasNext()) {
                                if (rtype == AbstractDataset.ARRAYFLOAT32
                                        || rtype == AbstractDataset.ARRAYFLOAT64) {
                                    for (int k = 0; k < is; k++) {
                                        answer[k] = Math.pow(a.getElementDoubleAbs(ita.index + k),
                                                b.getElementDoubleAbs(itb.index + k));
                                    }
                                } else {
                                    for (int k = 0; k < is; k++) {
                                        v = Math.pow(a.getElementDoubleAbs(ita.index + k),
                                                b.getElementDoubleAbs(itb.index + k));
                                        answer[k] = Double.isInfinite(v) || Double.isNaN(v) ? 0 : v;
                                    }
                                }
                                d.setObjectAbs(j, answer);
                                j += is;
                            }
                        }
                    }
                }
                start += System.nanoTime();
                double otime = ((double) start) / d.getSize();

                System.out.printf("Time taken by pow for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                        100. * (otime - ntime) / otime);

                checkDatasets(a, b, c, d);

                n *= SSTEP;
            }
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Powering " + dn + " by constant");
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            c = Maths.power(a, dv);
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128) {
                final int is = d.getElementsPerItem();
                while (ita.hasNext()) {
                    d.setObjectAbs(j, ((Complex) a.getObjectAbs(ita.index)).pow(zv));
                    j += is;
                }
            } else {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    while (ita.hasNext()) {
                        d.setObjectAbs(j++, Math.pow(((Number) a.getObjectAbs(ita.index)).doubleValue(), dv));
                    }
                } else {
                    final double[] answer = new double[ISIZEA];
                    while (ita.hasNext()) {
                        for (int k = 0; k < ISIZEA; k++) {
                            answer[k] = Math.pow(a.getElementDoubleAbs(ita.index + k), dv);
                        }
                        d.setObjectAbs(j, answer);
                        j += ISIZEA;
                    }
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by pow for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(a, dv, c, d);

            n *= SSTEP;
        }

        Random.seed(12735L);
        n = 32;
        System.out.println("Powering constant by " + dn);
        for (int i = 0; i < SITER; i++) {
            if (dtype < AbstractDataset.ARRAYINT8) {
                a = Random.randn(n);
                a.imultiply(100);
                a = a.cast(dtype);
            } else {
                AbstractDataset[] aa = new AbstractDataset[ISIZEA];
                for (int j = 0; j < ISIZEA; j++) {
                    aa[j] = Random.randn(n).imultiply(100);
                }
                a = DatasetUtils.cast(aa, dtype);
            }

            start = -System.nanoTime();
            c = Maths.power(dv, a);
            start += System.nanoTime();
            double ntime = ((double) start) / c.getSize();

            d = AbstractDataset.zeros(c);
            start = -System.nanoTime();
            IndexIterator ita = a.getIterator();
            int j = 0;
            if (dtype == AbstractDataset.COMPLEX64 || dtype == AbstractDataset.COMPLEX128) {
                final int is = d.getElementsPerItem();
                while (ita.hasNext()) {
                    d.setObjectAbs(j, zv.pow((Complex) a.getObjectAbs(ita.index)));
                    j += is;
                }
            } else {
                if (dtype < AbstractDataset.ARRAYINT8) {
                    while (ita.hasNext()) {
                        d.setObjectAbs(j++, Math.pow(dv, ((Number) a.getObjectAbs(ita.index)).doubleValue()));
                    }
                } else {
                    final double[] answer = new double[ISIZEA];
                    while (ita.hasNext()) {
                        for (int k = 0; k < ISIZEA; k++) {
                            answer[k] = Math.pow(dv, a.getElementDoubleAbs(ita.index + k));
                        }
                        d.setObjectAbs(j, answer);
                        j += ISIZEA;
                    }
                }
            }
            start += System.nanoTime();
            double otime = ((double) start) / d.getSize();

            System.out.printf("Time taken by pow for %s: %s; %s (%.1f%%)\n", n, otime, ntime,
                    100. * (otime - ntime) / otime);

            checkDatasets(dv, a, c, d);

            n *= SSTEP;
        }
    }
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.ShortDataset.java

@Override
public ShortDataset ipower(final Object b) {
    if (b instanceof AbstractDataset) {
        AbstractDataset bds = (AbstractDataset) b;
        checkCompatibility(bds);/* w  w  w.j  ava  2 s  .  c o  m*/
        // BOOLEAN_OMIT
        IndexIterator it1 = getIterator();
        IndexIterator it2 = bds.getIterator();
        // BOOLEAN_OMIT
        while (it1.hasNext() && it2.hasNext()) {
            final double v = Math.pow(data[it1.index], bds.getElementDoubleAbs(it2.index));
            if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST
                data[it1.index] = 0; // INT_ZEROTEST
            } else { // INT_ZEROTEST
                data[it1.index] = (short) (long) v; // PRIM_TYPE_LONG // ADD_CAST
            } // INT_ZEROTEST
        }
    } else {
        double vr = toReal(b);
        double vi = toImag(b);
        IndexIterator it1 = getIterator();
        // BOOLEAN_OMIT
        if (vi == 0.) {
            while (it1.hasNext()) {
                final double v = Math.pow(data[it1.index], vr);
                if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST
                    data[it1.index] = 0; // INT_ZEROTEST
                } else { // INT_ZEROTEST
                    data[it1.index] = (short) (long) v; // PRIM_TYPE_LONG // ADD_CAST
                } // INT_ZEROTEST
            }
        } else {
            Complex zv = new Complex(vr, vi);
            while (it1.hasNext()) {
                Complex zd = new Complex(data[it1.index], 0.);
                final double v = zd.pow(zv).getReal();
                if (Double.isInfinite(v) || Double.isNaN(v)) { // INT_ZEROTEST
                    data[it1.index] = 0; // INT_ZEROTEST
                } else { // INT_ZEROTEST
                    data[it1.index] = (short) (long) v; // PRIM_TYPE_LONG // ADD_CAST
                } // INT_ZEROTEST
            }
        }
    }
    setDirty();
    return this;
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.Stats.java

/**
 * @param a/* w  w  w  . java 2  s .  c  o  m*/
 * @return product of all items in dataset
 */
public static Object product(final AbstractDataset a) {
    int dtype = a.getDtype();

    if (a.isComplex()) {
        IndexIterator it = a.getIterator();
        double rv = 1, iv = 0;

        while (it.hasNext()) {
            final double r1 = a.getElementDoubleAbs(it.index);
            final double i1 = a.getElementDoubleAbs(it.index + 1);
            final double tv = r1 * rv - i1 * iv;
            iv = r1 * iv + i1 * rv;
            rv = tv;
        }

        return new Complex(rv, iv);
    }

    IndexIterator it = a.getIterator();
    final int is;
    final long[] lresults;
    final double[] dresults;

    switch (dtype) {
    case AbstractDataset.BOOL:
    case AbstractDataset.INT8:
    case AbstractDataset.INT16:
    case AbstractDataset.INT32:
    case AbstractDataset.INT64:
        long lresult = 1;
        while (it.hasNext()) {
            lresult *= a.getElementLongAbs(it.index);
        }
        return new Long(lresult);
    case AbstractDataset.ARRAYINT8:
    case AbstractDataset.ARRAYINT16:
    case AbstractDataset.ARRAYINT32:
    case AbstractDataset.ARRAYINT64:
        lresult = 1;
        is = a.getElementsPerItem();
        lresults = new long[is];
        for (int j = 0; j < is; j++) {
            lresults[j] = 1;
        }
        while (it.hasNext()) {
            for (int j = 0; j < is; j++)
                lresults[j] *= a.getElementLongAbs(it.index + j);
        }
        return lresults;
    case AbstractDataset.FLOAT32:
    case AbstractDataset.FLOAT64:
        double dresult = 1.;
        while (it.hasNext()) {
            dresult *= a.getElementDoubleAbs(it.index);
        }
        return Double.valueOf(dresult);
    case AbstractDataset.ARRAYFLOAT32:
    case AbstractDataset.ARRAYFLOAT64:
        is = a.getElementsPerItem();
        dresults = new double[is];
        for (int j = 0; j < is; j++) {
            dresults[j] = 1.;
        }
        while (it.hasNext()) {
            for (int j = 0; j < is; j++)
                dresults[j] *= a.getElementDoubleAbs(it.index + j);
        }
        return dresults;
    }

    return null;
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.Stats.java

/**
 * @param a/*  w  w  w. j  ava 2s .com*/
 * @param axis
 * @return product of items along axis in dataset
 */
public static AbstractDataset product(final AbstractDataset a, int axis) {
    axis = a.checkAxis(axis);
    final int dtype = a.getDtype();
    final int rank = a.getRank();
    final int[] oshape = a.getShape();
    final int is = a.getElementsPerItem();
    final int alen = oshape[axis];
    oshape[axis] = 1;

    int[] nshape = AbstractDataset.squeezeShape(oshape, false);

    AbstractDataset result = AbstractDataset.zeros(is, nshape, dtype);

    IndexIterator qiter = result.getIterator(true);
    int[] qpos = qiter.getPos();
    int[] spos = oshape;

    while (qiter.hasNext()) {
        int i = 0;
        for (; i < axis; i++) {
            spos[i] = qpos[i];
        }
        spos[i++] = 0;
        for (; i < rank; i++) {
            spos[i] = qpos[i - 1];
        }

        if (a.isComplex()) {
            double rv = 1, iv = 0;
            switch (dtype) {
            case AbstractDataset.COMPLEX64:
                ComplexFloatDataset af = (ComplexFloatDataset) a;
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    final float r1 = af.getReal(spos);
                    final float i1 = af.getImag(spos);
                    final double tv = r1 * rv - i1 * iv;
                    iv = r1 * iv + i1 * rv;
                    rv = tv;
                }
                break;
            case AbstractDataset.COMPLEX128:
                ComplexDoubleDataset ad = (ComplexDoubleDataset) a;
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    final double r1 = ad.getReal(spos);
                    final double i1 = ad.getImag(spos);
                    final double tv = r1 * rv - i1 * iv;
                    iv = r1 * iv + i1 * rv;
                    rv = tv;
                }
                break;
            }

            result.set(new Complex(rv, iv), qpos);
        } else {
            final long[] lresults;
            final double[] dresults;

            switch (dtype) {
            case AbstractDataset.BOOL:
            case AbstractDataset.INT8:
            case AbstractDataset.INT16:
            case AbstractDataset.INT32:
            case AbstractDataset.INT64:
                long lresult = 1;
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    lresult *= a.getInt(spos);
                }
                result.set(lresult, qpos);
                break;
            case AbstractDataset.ARRAYINT8:
                lresults = new long[is];
                for (int k = 0; k < is; k++) {
                    lresults[k] = 1;
                }
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    final byte[] va = (byte[]) a.getObject(spos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] *= va[k];
                    }
                }
                result.set(lresults, qpos);
                break;
            case AbstractDataset.ARRAYINT16:
                lresults = new long[is];
                for (int k = 0; k < is; k++) {
                    lresults[k] = 1;
                }
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    final short[] va = (short[]) a.getObject(spos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] *= va[k];
                    }
                }
                result.set(lresults, qpos);
                break;
            case AbstractDataset.ARRAYINT32:
                lresults = new long[is];
                for (int k = 0; k < is; k++) {
                    lresults[k] = 1;
                }
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    final int[] va = (int[]) a.getObject(spos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] *= va[k];
                    }
                }
                result.set(lresults, qpos);
                break;
            case AbstractDataset.ARRAYINT64:
                lresults = new long[is];
                for (int k = 0; k < is; k++) {
                    lresults[k] = 1;
                }
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    final long[] va = (long[]) a.getObject(spos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] *= va[k];
                    }
                }
                result.set(lresults, qpos);
                break;
            case AbstractDataset.FLOAT32:
            case AbstractDataset.FLOAT64:
                double dresult = 1.;
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    dresult *= a.getDouble(spos);
                }
                result.set(dresult, qpos);
                break;
            case AbstractDataset.ARRAYFLOAT32:
                dresults = new double[is];
                for (int k = 0; k < is; k++) {
                    dresults[k] = 1.;
                }
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    final float[] va = (float[]) a.getObject(spos);
                    for (int k = 0; k < is; k++) {
                        dresults[k] *= va[k];
                    }
                }
                result.set(dresults, qpos);
                break;
            case AbstractDataset.ARRAYFLOAT64:
                dresults = new double[is];
                for (int k = 0; k < is; k++) {
                    dresults[k] = 1.;
                }
                for (int j = 0; j < alen; j++) {
                    spos[axis] = j;
                    final double[] va = (double[]) a.getObject(spos);
                    for (int k = 0; k < is; k++) {
                        dresults[k] *= va[k];
                    }
                }
                result.set(dresults, qpos);
                break;
            }
        }
    }

    return result;
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.Stats.java

/**
 * @param a//w ww  .  j  ava 2  s. c om
 * @param axis
 * @return cumulative product of items along axis in dataset
 */
public static AbstractDataset cumulativeProduct(final AbstractDataset a, int axis) {
    axis = a.checkAxis(axis);
    int dtype = a.getDtype();
    int[] oshape = a.getShape();
    int alen = oshape[axis];
    oshape[axis] = 1;

    AbstractDataset result = AbstractDataset.zeros(a);
    PositionIterator pi = result.getPositionIterator(axis);

    int[] pos = pi.getPos();

    while (pi.hasNext()) {

        if (a.isComplex()) {
            double rv = 1, iv = 0;
            switch (dtype) {
            case AbstractDataset.COMPLEX64:
                ComplexFloatDataset af = (ComplexFloatDataset) a;
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final float r1 = af.getReal(pos);
                    final float i1 = af.getImag(pos);
                    final double tv = r1 * rv - i1 * iv;
                    iv = r1 * iv + i1 * rv;
                    rv = tv;
                    af.set((float) rv, (float) iv, pos);
                }
                break;
            case AbstractDataset.COMPLEX128:
                ComplexDoubleDataset ad = (ComplexDoubleDataset) a;
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final double r1 = ad.getReal(pos);
                    final double i1 = ad.getImag(pos);
                    final double tv = r1 * rv - i1 * iv;
                    iv = r1 * iv + i1 * rv;
                    rv = tv;
                    ad.set(rv, iv, pos);
                }
                break;
            }

            result.set(new Complex(rv, iv), pos);
        } else {
            final int is;
            final long[] lresults;
            final double[] dresults;

            switch (dtype) {
            case AbstractDataset.BOOL:
            case AbstractDataset.INT8:
            case AbstractDataset.INT16:
            case AbstractDataset.INT32:
            case AbstractDataset.INT64:
                long lresult = 1;
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    lresult *= a.getInt(pos);
                    result.set(lresult, pos);
                }
                break;
            case AbstractDataset.ARRAYINT8:
                is = a.getElementsPerItem();
                lresults = new long[is];
                for (int k = 0; k < is; k++) {
                    lresults[k] = 1;
                }
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final byte[] va = (byte[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] *= va[k];
                    }
                    result.set(lresults, pos);
                }
                break;
            case AbstractDataset.ARRAYINT16:
                is = a.getElementsPerItem();
                lresults = new long[is];
                for (int k = 0; k < is; k++) {
                    lresults[k] = 1;
                }
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final short[] va = (short[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] *= va[k];
                    }
                    result.set(lresults, pos);
                }
                break;
            case AbstractDataset.ARRAYINT32:
                is = a.getElementsPerItem();
                lresults = new long[is];
                for (int k = 0; k < is; k++) {
                    lresults[k] = 1;
                }
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final int[] va = (int[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] *= va[k];
                    }
                    result.set(lresults, pos);
                }
                break;
            case AbstractDataset.ARRAYINT64:
                is = a.getElementsPerItem();
                lresults = new long[is];
                for (int k = 0; k < is; k++) {
                    lresults[k] = 1;
                }
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final long[] va = (long[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] *= va[k];
                    }
                    result.set(lresults, pos);
                }
                break;
            case AbstractDataset.FLOAT32:
            case AbstractDataset.FLOAT64:
                double dresult = 1.;
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    dresult *= a.getDouble(pos);
                    result.set(dresult, pos);
                }
                break;
            case AbstractDataset.ARRAYFLOAT32:
                is = a.getElementsPerItem();
                dresults = new double[is];
                for (int k = 0; k < is; k++) {
                    dresults[k] = 1.;
                }
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final float[] va = (float[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        dresults[k] *= va[k];
                    }
                    result.set(dresults, pos);
                }
                break;
            case AbstractDataset.ARRAYFLOAT64:
                is = a.getElementsPerItem();
                dresults = new double[is];
                for (int k = 0; k < is; k++) {
                    dresults[k] = 1.;
                }
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final double[] va = (double[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        dresults[k] *= va[k];
                    }
                    result.set(dresults, pos);
                }
                break;
            }
        }
    }

    return result;
}

From source file:uk.ac.diamond.scisoft.analysis.dataset.Stats.java

/**
 * @param a/* w w  w  .  ja  va 2 s .co  m*/
 * @param axis
 * @return cumulative sum of items along axis in dataset
 */
public static AbstractDataset cumulativeSum(final AbstractDataset a, int axis) {
    axis = a.checkAxis(axis);
    int dtype = a.getDtype();
    int[] oshape = a.getShape();
    int alen = oshape[axis];
    oshape[axis] = 1;

    AbstractDataset result = AbstractDataset.zeros(a);
    PositionIterator pi = result.getPositionIterator(axis);

    int[] pos = pi.getPos();

    while (pi.hasNext()) {

        if (a.isComplex()) {
            double rv = 0, iv = 0;
            switch (dtype) {
            case AbstractDataset.COMPLEX64:
                ComplexFloatDataset af = (ComplexFloatDataset) a;
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    rv += af.getReal(pos);
                    iv += af.getImag(pos);
                    af.set((float) rv, (float) iv, pos);
                }
                break;
            case AbstractDataset.COMPLEX128:
                ComplexDoubleDataset ad = (ComplexDoubleDataset) a;
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    rv += ad.getReal(pos);
                    iv += ad.getImag(pos);
                    ad.set(rv, iv, pos);
                }
                break;
            }

            result.set(new Complex(rv, iv), pos);
        } else {
            final int is;
            final long[] lresults;
            final double[] dresults;

            switch (dtype) {
            case AbstractDataset.BOOL:
            case AbstractDataset.INT8:
            case AbstractDataset.INT16:
            case AbstractDataset.INT32:
            case AbstractDataset.INT64:
                long lresult = 0;
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    lresult += a.getInt(pos);
                    result.set(lresult, pos);
                }
                break;
            case AbstractDataset.ARRAYINT8:
                is = a.getElementsPerItem();
                lresults = new long[is];
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final byte[] va = (byte[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] += va[k];
                    }
                    result.set(lresults, pos);
                }
                break;
            case AbstractDataset.ARRAYINT16:
                is = a.getElementsPerItem();
                lresults = new long[is];
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final short[] va = (short[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] += va[k];
                    }
                    result.set(lresults, pos);
                }
                break;
            case AbstractDataset.ARRAYINT32:
                is = a.getElementsPerItem();
                lresults = new long[is];
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final int[] va = (int[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] += va[k];
                    }
                    result.set(lresults, pos);
                }
                break;
            case AbstractDataset.ARRAYINT64:
                is = a.getElementsPerItem();
                lresults = new long[is];
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final long[] va = (long[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        lresults[k] += va[k];
                    }
                    result.set(lresults, pos);
                }
                break;
            case AbstractDataset.FLOAT32:
            case AbstractDataset.FLOAT64:
                double dresult = 0.;
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    dresult += a.getDouble(pos);
                    result.set(dresult, pos);
                }
                break;
            case AbstractDataset.ARRAYFLOAT32:
                is = a.getElementsPerItem();
                dresults = new double[is];
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final float[] va = (float[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        dresults[k] += va[k];
                    }
                    result.set(dresults, pos);
                }
                break;
            case AbstractDataset.ARRAYFLOAT64:
                is = a.getElementsPerItem();
                dresults = new double[is];
                for (int j = 0; j < alen; j++) {
                    pos[axis] = j;
                    final double[] va = (double[]) a.getObject(pos);
                    for (int k = 0; k < is; k++) {
                        dresults[k] += va[k];
                    }
                    result.set(dresults, pos);
                }
                break;
            }
        }
    }

    return result;
}