Example usage for org.apache.commons.lang ArrayUtils toPrimitive

Introduction

In this page you can find the example usage for org.apache.commons.lang ArrayUtils toPrimitive.

Prototype

public static boolean[] toPrimitive(Boolean[] array) 

Source Link

Document

Converts an array of object Booleans to primitives.

Usage

From source file:ubic.gemma.loader.expression.geo.DataUpdater.java

/**
 * @param ee/*  w w  w . j a va 2 s  . c o m*/
 * @param countEEMatrix
 * @param readLength
 * @param isPairedReads
 */
private void addTotalCountInformation(ExpressionExperiment ee, ExpressionDataDoubleMatrix countEEMatrix,
        Integer readLength, Boolean isPairedReads) {
    for (BioAssay ba : ee.getBioAssays()) {
        Double[] col = countEEMatrix.getColumn(ba);
        double librarySize = DescriptiveWithMissing.sum(new DoubleArrayList(ArrayUtils.toPrimitive(col)));

        log.info(ba + " total library size=" + librarySize);

        ba.setDescription(ba.getDescription() + " totalCounts=" + Math.floor(librarySize));
        ba.setSequenceReadLength(readLength);
        ba.setSequencePairedReads(isPairedReads);
        ba.setSequenceReadCount((int) Math.floor(librarySize));

        bioAssayService.update(ba);

    }
}

---

From source file:ubic.gemma.persistence.service.association.coexpression.CoexpressionServiceImpl.java

private Map<Long, List<Double>> computeRelativeRanks(TreeMap<Integer, Map<Long, Integer>> forRanks) {
    Map<Long, List<Double>> relRanks = new HashMap<>();
    for (Integer support : forRanks.keySet()) {

        // low ranks = low node degree = good.
        Map<Long, Double> rt = Rank.rankTransform(forRanks.get(support));

        double max = DescriptiveWithMissing.max(new DoubleArrayList(
                ArrayUtils.toPrimitive(new ArrayList<>(rt.values()).toArray(new Double[] {}))));

        for (Long g : rt.keySet()) {
            double relRank = rt.get(g) / max;

            if (!relRanks.containsKey(g)) {
                relRanks.put(g, new ArrayList<Double>());
            }/*from  ww w  .  ja  v a  2  s .co  m*/

            // the ranks are in order.
            relRanks.get(g).add(relRank);
        }
    }
    return relRanks;
}

---

From source file:ubic.gemma.persistence.service.expression.experiment.GeeqServiceImpl.java

private double[] getLowerTriCormat(DoubleMatrix<BioAssay, BioAssay> cormat) {
    if (cormat == null || cormat.rows() == 0) {
        return new double[] {};
    }/*from  w w  w.  j  a v a  2  s.  c o m*/
    double[] corTri = this.getLowerTriangle(cormat.getRawMatrix());

    // We have to remove NaNs, some cormats have them (we notify user about this in the outlier score)
    // this is not very efficient, but the DoubleMatrix does not have a method to get an array of Doubles (not doubles)
    Double[] doubleArray = ArrayUtils.toObject(corTri);
    List<Double> list = new ArrayList<>(Arrays.asList(doubleArray));
    //noinspection StatementWithEmptyBody // because java standard libraries suck, we have to iterate like this to remove all NaNs, not just the first one.
    while (list.remove(Double.NaN)) {
    }

    return ArrayUtils.toPrimitive(list.toArray(new Double[0]));
}

---

From source file:ubic.gemma.visualization.ExpressionDataMatrixVisualizationServiceImpl.java

/**
 * @param expressionDataMatrix//  w w w.j a  v  a 2 s . c o m
 * @return ColorMatrix
 */
private ColorMatrix<String, String> createColorMatrix(ExpressionDataMatrix<Double> expressionDataMatrix) {

    Collection<BioAssay> colElements = new LinkedHashSet<BioAssay>();

    if (expressionDataMatrix == null || expressionDataMatrix.rows() == 0) {
        throw new IllegalArgumentException("ExpressionDataMatrix apparently has no data");
    }

    // because the matrix is already created, we cannot reorder the rows at this point.
    List<BioMaterial> ordering = ExpressionDataMatrixColumnSort.orderByExperimentalDesign(expressionDataMatrix);

    double[][] data = new double[expressionDataMatrix.rows()][];
    for (int i = 0; i < expressionDataMatrix.rows(); i++) {
        Double[] row = expressionDataMatrix.getRow(i);

        // Put the columns in the designated ordering.
        double[] rtmp = ArrayUtils.toPrimitive(row);
        data[i] = new double[rtmp.length];
        int m = 0;
        for (BioMaterial bm : ordering) {
            int j = expressionDataMatrix.getColumnIndex(bm);
            data[i][m] = rtmp[j];
            m++;
        }
    }

    for (BioMaterial bm : ordering) {
        int j = expressionDataMatrix.getColumnIndex(bm);
        Collection<BioAssay> bas = expressionDataMatrix.getBioAssaysForColumn(j);
        colElements.add(bas.iterator().next());// this is temporary.
    }

    return createColorMatrix(data, expressionDataMatrix.getRowElements(), colElements);
}

---

From source file:uk.ac.diamond.scisoft.analysis.rcp.inspector.InspectionTab.java

protected Dataset slicedAndReorderData(IMonitor monitor, Slice[] slices, boolean[] average, int[] order,
        IMetadata meta) {/*from   www . j  a va 2s  .co  m*/
    Dataset reorderedData = null;
    Dataset slicedData = null;

    if (ArrayUtils.contains(average, true)) {
        Dataset averagedData = null;
        Dataset averagedError = null;
        List<Integer> axs = new ArrayList<Integer>();
        int[] slicesShape = new int[slices.length];
        int resDim = 0;
        for (int idx = 0; idx < slices.length; idx++) {
            slicesShape[idx] = slices[idx].getNumSteps();
            if (!average[idx]) {
                axs.add(idx);
                if (slicesShape[idx] > 1)
                    resDim++;
            }
        }

        // For 1D data preload last averaged dimension into memory to reduce number of data slicing calls 
        int meanAxis = -1;
        if (resDim == 1) {
            meanAxis = slicesShape.length - 1;
            while (meanAxis >= 0 && !average[meanAxis])
                meanAxis--;
            if (meanAxis != -1)
                axs.add(meanAxis);
        }

        PositionIterator pitr = new PositionIterator(slicesShape,
                ArrayUtils.toPrimitive(axs.toArray(new Integer[0])));
        int sliceIdx = 0;
        while (pitr.hasNext()) {
            int[] ppos = pitr.getPos();
            Slice[] tmpSlices = new Slice[slices.length];
            for (int idx = 0; idx < ppos.length; idx++) {
                if (axs.contains(idx)) {
                    tmpSlices[idx] = slices[idx].clone();
                } else {
                    Integer step = slices[idx].getStep();
                    Integer start = slices[idx].getStart() == null ? step * ppos[idx]
                            : slices[idx].getStart() + step * ppos[idx];
                    Integer stop = start + step;
                    tmpSlices[idx] = new Slice(start, stop, step);
                }
            }

            Dataset tmpSlice = DatasetUtils.convertToDataset(dataset.getSlice(tmpSlices));
            Dataset errSlice = tmpSlice.getErrorBuffer(); // TODO remove when done internally
            tmpSlice.setError(null);
            if (meanAxis != -1) {
                int[] tmpShape = tmpSlice.getShape();
                tmpShape[meanAxis] = 1;
                tmpSlice = tmpSlice.mean(meanAxis);
                tmpSlice.setShape(tmpShape);
                if (errSlice != null) {
                    int[] errShape = errSlice.getShape();
                    if (errShape[meanAxis] > 1) {
                        errShape[meanAxis] = 1;
                        Dataset n = errSlice.count(meanAxis);
                        errSlice = errSlice.mean(meanAxis);
                        errSlice.idivide(n);
                        errSlice.setShape(errShape);
                    }
                }
            }

            if (averagedData != null)
                averagedData.iadd(tmpSlice);
            else
                averagedData = tmpSlice;

            if (errSlice != null) {
                if (averagedError != null)
                    averagedError.iadd(errSlice);
                else
                    averagedError = errSlice;
            }
            sliceIdx++;
        }
        if (averagedData == null)
            return null;
        slicedData = averagedData.idivide(sliceIdx);
        if (averagedError != null) {
            slicedData.setErrorBuffer(averagedError.idivide(sliceIdx * sliceIdx));
        }
    } else {
        slicedData = sliceData(monitor, slices);
    }

    if (slicedData == null)
        return null;

    reorderedData = slicedData.getTransposedView(order);
    reorderedData.squeeze();
    if (reorderedData.getSize() < 1)
        return null;

    // Possible fix to http://jira.diamond.ac.uk/browse/DAWNSCI-333
    // ensures that file name appears in plot.
    final StringBuilder name = new StringBuilder();
    name.append(slicedData.getName());
    String path = meta == null ? null : meta.getFilePath();
    if (path != null) {
        File file = new File(path);
        final String fname = file.getName();
        if (fname.length() != 0 && !name.toString().contains(fname)) {
            name.append(" (");
            name.append(fname);
            name.append(")");
        }
    }

    reorderedData.setName(name.toString());

    return reorderedData;
}

---

From source file:uk.ac.diamond.scisoft.analysis.rcp.inspector.InspectionTab.java

private void pushImages(final IMonitor monitor, final Slice[] slices, final int[] order) {
    // work out slicing result
    final int[] shape = dataset.getShape();

    //      System.err.printf("Shape: %s; slicing: [%s]; order: %s\n", Arrays.toString(shape), Slice.createString(slices), Arrays.toString(order));

    int rank = shape.length;
    int ns = slices.length;
    // dimensions for iterating over (order.length == slices.length)
    int ids = ns > 3 ? 2 : 1;

    final List<Integer> gridDimNumber = new ArrayList<Integer>();
    final int[] gridShape = new int[ids];
    for (int i = 0; i < ids; i++) {
        // After dimension reordering, first two dimensions should be an image size
        // followed by grid dimensions
        int o = order[i + 2];
        gridDimNumber.add(o);/*ww  w  .ja va 2s. c o  m*/
        gridShape[i] = slices[o].getNumSteps();
    }

    try {
        //         System.err.printf("Grid: %s\n", Arrays.toString(gridShape));
        if (ids == 1) {
            SDAPlotter.setupNewImageGrid(explorerName, gridShape[0]);
        } else {
            SDAPlotter.setupNewImageGrid(explorerName, gridShape[1], gridShape[0]);
        }
    } catch (Exception e) {
        logger.warn("Problem with setting up image explorer", e);
    }

    // use position iterator ignoring first set of slicing axes
    int[] start = new int[rank];
    int[] stop = new int[rank];
    int[] step = new int[rank];
    Slice.convertFromSlice(slices, shape, start, stop, step);

    List<Integer> ignoreAxesList = new ArrayList<Integer>(Arrays.asList(ArrayUtils.toObject(order)));
    ignoreAxesList.removeAll(gridDimNumber);
    int[] ignoreAxes = ArrayUtils.toPrimitive(ignoreAxesList.toArray(new Integer[0]));
    PositionIterator it = new PositionIterator(shape, start.clone(), stop.clone(), step, ignoreAxes);
    int[] pos = it.getPos();

    int dimGridX = gridDimNumber.get(0);
    int gridX0 = start[dimGridX];
    int dimGridY = (ids == 1) ? -1 : gridDimNumber.get(1);
    int gridY0 = (ids == 1) ? -1 : start[dimGridY];

    try {
        setInspectionRunning();
        boolean memoryOK = true;
        while (!memoryOK || it.hasNext()) { // short-cut iteration when low on memory
            try {
                for (int i = 0; i < ids; i++) {
                    int o = gridDimNumber.get(i);
                    int b = pos[o];
                    start[o] = b;
                    stop[o] = b + 1;
                }
                Dataset slicedData = sliceData(monitor, start, stop, step);
                if (slicedData == null)
                    return;
                //               System.err.printf("Pos %s; start %s; stop %s; step %s; ", Arrays.toString(pos), Arrays.toString(start), Arrays.toString(stop), Arrays.toString(step));
                //               System.err.printf("Shape %s\n", Arrays.toString(slicedData.getShape()));

                Dataset reorderedData = slicedData.getTransposedView(order);

                reorderedData.setName(slicedData.getName());
                reorderedData.squeeze();
                if (reorderedData.getSize() < 1)
                    return;

                reorderedData.setName(dataset.getName() + Arrays.toString(pos));
                if (!canContinueInspection()) {
                    return;
                }

                if (explorer.isStopped()) {
                    stopInspection();
                    return;
                }

                if (ids == 1) {
                    SDAPlotter.plotImageToGrid(explorerName, reorderedData, true);
                } else {
                    int gridX = pos[dimGridX] - gridX0;
                    int gridY = pos[dimGridY] - gridY0;
                    SDAPlotter.plotImageToGrid(explorerName, reorderedData, gridX, gridY, true);
                }

                if (!memoryOK)
                    logger.warn("... memory reduction successful");
                memoryOK = true;
            } catch (OutOfMemoryError e) {
                if (!memoryOK) // only allow one GC per slice
                    throw e;
                memoryOK = false;
                logger.warn("Ran out of memory: attempting to reduce memory used...");
                System.gc();
                // try again after memory reduction
            }
        }
    } catch (Exception e) {
        logger.warn("Problem with sending data to image explorer", e);
    } finally {
        stopInspection();
    }
}

---

From source file:uk.ac.diamond.scisoft.analysis.rcp.plotting.sideplot.xyPointList.java

public xyPointList(Double[] x, Double[] y) {
    xlist = ArrayUtils.toPrimitive(x);
    ylist = ArrayUtils.toPrimitive(y);
}

---

From source file:uk.ac.diamond.scisoft.ncd.calibration.CalibrationMethods.java

@SuppressWarnings("unused")
private Amount<Length> estimateCameraLength(LinkedHashMap<IPeak, HKL> indexedPeaks) {
    ArrayList<Double> cameraLen = new ArrayList<Double>();
    CombinationGenerator<Entry<IPeak, HKL>> combinations = new CombinationGenerator<Entry<IPeak, HKL>>(
            indexedPeaks.entrySet(), 2);
    for (List<Entry<IPeak, HKL>> comb : combinations) {
        Entry<IPeak, HKL> peak1 = comb.get(0);
        Entry<IPeak, HKL> peak2 = comb.get(1);
        //double q1 = regression.predict(peak1.getPosition());
        //double q2 = regression.predict(peak2.getPosition());
        Amount<ScatteringVector> q1 = Constants.two_.divide(peak1.getValue().getD())
                .to(ScatteringVector.UNIT);
        Amount<ScatteringVector> q2 = Constants.two_.divide(peak2.getValue().getD())
                .to(ScatteringVector.UNIT);
        Amount<Length> dist = pixelSize.times(peak2.getKey().getPosition() - peak1.getKey().getPosition())
                .times(Constants.two_).divide(wavelength.times(q2.minus(q1))).to(Length.UNIT);
        cameraLen.add(dist.doubleValue(SI.MILLIMETRE));
        //logger.info("Camera length from " + indexedPeaks.get(peak2).toString() + " and " + indexedPeaks.get(peak1).toString() + "is {} mm", dist);
    }/*from w  w w. ja  va  2 s .  c  o m*/
    double[] cameraLenArray = ArrayUtils.toPrimitive(cameraLen.toArray(new Double[] {}));
    double mcl = StatUtils.mean(cameraLenArray);
    double std = Math.sqrt(StatUtils.variance(cameraLenArray));
    meanCameraLength = Amount.valueOf(mcl, std, SI.MILLIMETRE);

    logger.info("Camera length: {}", meanCameraLength.to(SI.METRE));
    return meanCameraLength;
}

---

From source file:uk.ac.diamond.scisoft.ncd.calibration.CalibrationMethods.java

private Amount<Length> estimateCameraLengthSingle(LinkedHashMap<IPeak, HKL> indexedPeaks) {
    ArrayList<Double> cameraLen = new ArrayList<Double>();
    for (Entry<IPeak, HKL> peak : indexedPeaks.entrySet()) {
        double peakPos = peak.getKey().getPosition();
        Amount<ScatteringVector> q = Amount.valueOf(regression.predict(peakPos), unit.inverse())
                .to(ScatteringVector.UNIT);
        Amount<Length> dist = pixelSize.times(peakPos).times(Constants.two_).divide(wavelength.times(q))
                .to(Length.UNIT);// ww  w.j  a  v a 2  s .  com
        cameraLen.add(dist.doubleValue(SI.MILLIMETRE));
    }
    double[] cameraLenArray = ArrayUtils.toPrimitive(cameraLen.toArray(new Double[] {}));
    double mcl = StatUtils.mean(cameraLenArray);
    double std = Math.sqrt(StatUtils.variance(cameraLenArray));
    meanCameraLength = Amount.valueOf(mcl, std, SI.MILLIMETRE);

    logger.info("Camera length: {}", meanCameraLength.to(SI.METRE));
    return meanCameraLength;
}

---

From source file:uk.ac.diamond.scisoft.ncd.core.utils.NcdDataUtils.java

/**
 * Method for generating all combination of elements supplied in the input array
 * /*from w  w w . j  av a  2  s  .  c  om*/
 * @param input
 *          Array containing arrays of elements.
 *          Resulting combinations will pick single element from every input array. 
 * @return
 *          Array containing all combinations of the input elements with only one element
 *          picked from every input array at a time.
 */
public static ArrayList<int[]> generateCombinations(final ArrayList<int[]> input) {
    ArrayList<int[]> result = new ArrayList<int[]>();
    @SuppressWarnings("unchecked")
    ArrayList<int[]> tmpInput = (ArrayList<int[]>) input.clone();
    int[] first = tmpInput.remove(0);
    for (int i = 0; i < first.length; i++) {
        if (!tmpInput.isEmpty()) {
            ArrayList<int[]> recursive = generateCombinations(tmpInput);
            for (int j = 0; j < recursive.size(); j++) {
                ArrayList<Integer> tmp = new ArrayList<Integer>();
                tmp.add(first[i]);
                tmp.addAll(Arrays.asList(ArrayUtils.toObject(recursive.get(j))));
                result.add(ArrayUtils.toPrimitive(tmp.toArray(new Integer[] {})));
            }
        } else {
            ArrayList<Integer> tmp = new ArrayList<Integer>();
            tmp.add(first[i]);
            result.add(ArrayUtils.toPrimitive(tmp.toArray(new Integer[] {})));
        }
    }
    return result;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• »