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

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

Introduction

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

Prototype

public Complex pow(Complex x) 

Source Link

Document

Returns of value of this complex number raised to the power of x.

Usage

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

/**
 * @param a//  ww  w  . jav  a2 s. c om
 * @param b
 * @return a**b, raise a to power of b
 */
public static AbstractDataset power(final Object a, final Object b) {
    AbstractDataset result = null;
    final int is;

    if (a instanceof AbstractDataset) {
        if (b instanceof AbstractDataset) {
            return power((AbstractDataset) a, (AbstractDataset) b);
        }

        final AbstractDataset ds = (AbstractDataset) a;
        final int dt = AbstractDataset.getBestDType(ds.getDtype(),
                AbstractDataset.getDTypeFromClass(b.getClass()));
        result = AbstractDataset.zeros(ds, dt);
        final IndexIterator it1 = ds.getIterator();

        double dvr, dvi;
        dvr = AbstractDataset.toReal(b);

        switch (dt) {
        case AbstractDataset.INT8:
            final byte[] i8data = ((ByteDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                i8data[i++] = (byte) Math.pow(ds.getElementDoubleAbs(it1.index), dvr);
            }
            break;
        case AbstractDataset.INT16:
            final short[] i16data = ((ShortDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                i16data[i++] = (short) Math.pow(ds.getElementDoubleAbs(it1.index), dvr);
            }
            break;
        case AbstractDataset.INT32:
            final int[] i32data = ((IntegerDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                i32data[i++] = (int) Math.pow(ds.getElementDoubleAbs(it1.index), dvr);
            }
            break;
        case AbstractDataset.INT64:
            final long[] i64data = ((LongDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                i64data[i++] = (long) Math.pow(ds.getElementDoubleAbs(it1.index), dvr);
            }
            break;
        case AbstractDataset.ARRAYINT8:
            is = result.getElementsPerItem();
            final byte[] ai8data = ((CompoundByteDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    ai8data[i++] = (byte) Math.pow(ds.getElementDoubleAbs(it1.index + j), dvr);
                }
            }
            break;
        case AbstractDataset.ARRAYINT16:
            is = result.getElementsPerItem();
            final short[] ai16data = ((CompoundShortDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    ai16data[i++] = (short) Math.pow(ds.getElementDoubleAbs(it1.index + j), dvr);
                }
            }
            break;
        case AbstractDataset.ARRAYINT32:
            is = result.getElementsPerItem();
            final int[] ai32data = ((CompoundIntegerDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    ai32data[i++] = (int) Math.pow(ds.getElementDoubleAbs(it1.index + j), dvr);
                }
            }
            break;
        case AbstractDataset.ARRAYINT64:
            is = result.getElementsPerItem();
            final long[] ai64data = ((CompoundLongDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    ai64data[i++] = (long) Math.pow(ds.getElementDoubleAbs(it1.index + j), dvr);
                }
            }
            break;
        case AbstractDataset.FLOAT32:
            dvi = AbstractDataset.toImag(b);
            if (dvi == 0) {
                final float[] f32data = ((FloatDataset) result).getData();

                for (int i = 0; it1.hasNext();) {
                    f32data[i++] = (float) Math.pow(ds.getElementDoubleAbs(it1.index), dvr);
                }
            } else {
                result = new ComplexFloatDataset(ds.getShape());
                final float[] c64data = ((ComplexFloatDataset) result).getData();
                final Complex p = new Complex(dvr, dvi);

                for (int i = 0; it1.hasNext();) {
                    Complex tz = new Complex(ds.getElementDoubleAbs(it1.index),
                            ds.getElementDoubleAbs(it1.index + 1)).pow(p);

                    c64data[i++] = (float) tz.getReal();
                    c64data[i++] = (float) tz.getImaginary();
                }
            }
            break;
        case AbstractDataset.FLOAT64:
            dvi = AbstractDataset.toImag(b);
            if (dvi == 0) {
                result = new DoubleDataset(ds.getShape());
                final double[] f64data = ((DoubleDataset) result).getData();

                for (int i = 0; it1.hasNext();) {
                    f64data[i++] = Math.pow(ds.getElementDoubleAbs(it1.index), dvr);
                }
            } else {
                result = new ComplexDoubleDataset(ds.getShape());
                final double[] c128data = ((ComplexDoubleDataset) result).getData();
                final Complex p = new Complex(dvr, dvi);

                for (int i = 0; it1.hasNext();) {
                    Complex tz = new Complex(ds.getElementDoubleAbs(it1.index),
                            ds.getElementDoubleAbs(it1.index + 1)).pow(p);

                    c128data[i++] = tz.getReal();
                    c128data[i++] = tz.getImaginary();
                }
            }
            break;
        case AbstractDataset.ARRAYFLOAT32:
            is = result.getElementsPerItem();
            final float[] a32data = ((CompoundFloatDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    a32data[i++] = (float) Math.pow(ds.getElementDoubleAbs(it1.index + j), dvr);
                }
            }
            break;
        case AbstractDataset.ARRAYFLOAT64:
            is = result.getElementsPerItem();
            final double[] a64data = ((CompoundDoubleDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    a64data[i++] = Math.pow(ds.getElementDoubleAbs(it1.index + j), dvr);
                }
            }
            break;
        case AbstractDataset.COMPLEX64:
            dvi = AbstractDataset.toImag(b);
            final float[] c64data = ((ComplexFloatDataset) result).getData();
            final Complex p64 = new Complex(dvr, dvi);

            for (int i = 0; it1.hasNext();) {
                Complex tz = new Complex(ds.getElementDoubleAbs(it1.index),
                        ds.getElementDoubleAbs(it1.index + 1)).pow(p64);

                c64data[i++] = (float) tz.getReal();
                c64data[i++] = (float) tz.getImaginary();
            }
            break;
        case AbstractDataset.COMPLEX128:
            dvi = AbstractDataset.toImag(b);
            final double[] c128data = ((ComplexDoubleDataset) result).getData();
            final Complex p128 = new Complex(dvr, dvi);

            for (int i = 0; it1.hasNext();) {
                Complex tz = new Complex(ds.getElementDoubleAbs(it1.index),
                        ds.getElementDoubleAbs(it1.index + 1)).pow(p128);

                c128data[i++] = tz.getReal();
                c128data[i++] = tz.getImaginary();
            }
            break;
        default:
            throw new UnsupportedOperationException("power does not support this dataset type");
        }

        // set the name based on the changes made
        result.setName(bracketIfNecessary(ds).append("**").append(b).toString());
    } else {
        if (!(b instanceof AbstractDataset)) {
            throw new IllegalArgumentException("Both arguments are not datasets");
        }

        final AbstractDataset ds = (AbstractDataset) b;
        final int dt = AbstractDataset.getBestDType(ds.getDtype(),
                AbstractDataset.getDTypeFromClass(a.getClass()));
        result = AbstractDataset.zeros(ds, dt);
        IndexIterator it1 = ds.getIterator();

        double dvr, dvi;
        dvr = AbstractDataset.toReal(a);

        switch (dt) {
        case AbstractDataset.INT8:
            final byte[] i8data = ((ByteDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                i8data[i++] = (byte) Math.pow(dvr, ds.getElementDoubleAbs(it1.index));
            }
            break;
        case AbstractDataset.INT16:
            final short[] i16data = ((ShortDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                i16data[i++] = (short) Math.pow(dvr, ds.getElementDoubleAbs(it1.index));
            }
            break;
        case AbstractDataset.INT32:
            final int[] i32data = ((IntegerDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                i32data[i++] = (int) Math.pow(dvr, ds.getElementDoubleAbs(it1.index));
            }
            break;
        case AbstractDataset.INT64:
            final long[] i64data = ((LongDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                i64data[i++] = (long) Math.pow(dvr, ds.getElementDoubleAbs(it1.index));
            }
            break;
        case AbstractDataset.ARRAYINT8:
            is = result.getElementsPerItem();
            final byte[] ai8data = ((CompoundByteDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    ai8data[i++] = (byte) Math.pow(dvr, ds.getElementDoubleAbs(it1.index + j));
                }
            }
            break;
        case AbstractDataset.ARRAYINT16:
            is = result.getElementsPerItem();
            final short[] ai16data = ((CompoundShortDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    ai16data[i++] = (short) Math.pow(dvr, ds.getElementDoubleAbs(it1.index + j));
                }
            }
            break;
        case AbstractDataset.ARRAYINT32:
            is = result.getElementsPerItem();
            final int[] ai32data = ((CompoundIntegerDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    ai32data[i++] = (int) Math.pow(dvr, ds.getElementDoubleAbs(it1.index + j));
                }
            }
            break;
        case AbstractDataset.ARRAYINT64:
            is = result.getElementsPerItem();
            final long[] ai64data = ((CompoundLongDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    ai64data[i++] = (long) Math.pow(dvr, ds.getElementDoubleAbs(it1.index + j));
                }
            }
            break;
        case AbstractDataset.FLOAT32:
            dvi = AbstractDataset.toImag(a);
            if (dvi == 0) {
                final float[] f32data = ((FloatDataset) result).getData();

                for (int i = 0; it1.hasNext();) {
                    f32data[i++] = (float) Math.pow(dvr, ds.getElementDoubleAbs(it1.index));
                }
            } else {
                result = new ComplexFloatDataset(ds.getShape());
                final float[] c64data = ((ComplexFloatDataset) result).getData();
                final Complex b64 = new Complex(dvr, dvi);

                for (int i = 0; it1.hasNext();) {
                    Complex tz = b64.pow(new Complex(ds.getElementDoubleAbs(it1.index),
                            ds.getElementDoubleAbs(it1.index + 1)));

                    c64data[i++] = (float) tz.getReal();
                    c64data[i++] = (float) tz.getImaginary();
                }
            }
            break;
        case AbstractDataset.FLOAT64:
            dvi = AbstractDataset.toImag(a);
            if (dvi == 0) {
                final double[] f64data = ((DoubleDataset) result).getData();

                for (int i = 0; it1.hasNext();) {
                    f64data[i++] = Math.pow(dvr, ds.getElementDoubleAbs(it1.index));
                }
            } else {
                result = new ComplexDoubleDataset(ds.getShape());
                final double[] c128data = ((ComplexDoubleDataset) result).getData();
                final Complex b128 = new Complex(dvr, dvi);

                for (int i = 0; it1.hasNext();) {
                    Complex tz = b128.pow(new Complex(ds.getElementDoubleAbs(it1.index),
                            ds.getElementDoubleAbs(it1.index + 1)));

                    c128data[i++] = tz.getReal();
                    c128data[i++] = tz.getImaginary();
                }
            }
            break;
        case AbstractDataset.ARRAYFLOAT32:
            is = result.getElementsPerItem();
            final float[] a32data = ((CompoundFloatDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    a32data[i++] = (float) Math.pow(dvr, ds.getElementDoubleAbs(it1.index + j));
                }
            }
            break;
        case AbstractDataset.ARRAYFLOAT64:
            is = result.getElementsPerItem();
            final double[] a64data = ((CompoundDoubleDataset) result).getData();

            for (int i = 0; it1.hasNext();) {
                for (int j = 0; j < is; j++) {
                    a64data[i++] = Math.pow(dvr, ds.getElementDoubleAbs(it1.index + j));
                }
            }
            break;
        case AbstractDataset.COMPLEX64:
            dvi = AbstractDataset.toImag(a);
            final float[] c64data = ((ComplexFloatDataset) result).getData();
            final Complex b64 = new Complex(dvr, dvi);

            for (int i = 0; it1.hasNext();) {
                Complex tz = b64.pow(
                        new Complex(ds.getElementDoubleAbs(it1.index), ds.getElementDoubleAbs(it1.index + 1)));

                c64data[i++] = (float) tz.getReal();
                c64data[i++] = (float) tz.getImaginary();
            }
            break;
        case AbstractDataset.COMPLEX128:
            dvi = AbstractDataset.toImag(a);
            final double[] c128data = ((ComplexDoubleDataset) result).getData();
            final Complex b128 = new Complex(dvr, dvi);

            for (int i = 0; it1.hasNext();) {
                Complex tz = b128.pow(
                        new Complex(ds.getElementDoubleAbs(it1.index), ds.getElementDoubleAbs(it1.index + 1)));

                c128data[i++] = tz.getReal();
                c128data[i++] = tz.getImaginary();
            }
            break;
        default:
            throw new UnsupportedOperationException("power does not support this dataset type");
        }

        // set the name based on the changes made
        result.setName(new StringBuilder(a.toString()).append("**").append(bracketIfNecessary(ds)).toString());
    }

    return result;
}

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;/*ww w . j av  a 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("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);/*ww  w  . jav a 2s.  co  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;
}