Example usage for org.apache.commons.math.stat.descriptive DescriptiveStatistics clear

List of usage examples for org.apache.commons.math.stat.descriptive DescriptiveStatistics clear

Introduction

In this page you can find the example usage for org.apache.commons.math.stat.descriptive DescriptiveStatistics clear.

Prototype

public void clear() 

Source Link

Document

Resets all statistics and storage

Usage

From source file:graticules2wld.Main.java

/**
 * @param args//  ww  w  . j av  a 2 s.  co  m
 * @throws Exception
 */
public static void main(String[] args) throws Exception {

    /* parse the command line arguments */
    // create the command line parser
    CommandLineParser parser = new PosixParser();

    // create the Options
    Options options = new Options();
    options.addOption("x", "originx", true, "x component of projected coordinates of upper left pixel");
    options.addOption("y", "originy", true, "y component of projected coordinates of upper left pixel");
    options.addOption("u", "tometers", true, "multiplication factor to get source units into meters");
    options.addOption("h", "help", false, "prints this usage page");
    options.addOption("d", "debug", false, "prints debugging information to stdout");

    double originNorthing = 0;
    double originEasting = 0;

    String inputFileName = null;
    String outputFileName = null;

    try {
        // parse the command line arguments
        CommandLine line = parser.parse(options, args);

        if (line.hasOption("help"))
            printUsage(0); // print usage then exit using a non error exit status

        if (line.hasOption("debug"))
            debug = true;

        // these arguments are required
        if (!line.hasOption("originy") || !line.hasOption("originx"))
            printUsage(1);

        originNorthing = Double.parseDouble(line.getOptionValue("originy"));
        originEasting = Double.parseDouble(line.getOptionValue("originx"));

        if (line.hasOption("tometers"))
            unitsToMeters = Double.parseDouble(line.getOptionValue("tometers"));

        // two args should be left. the input csv file name and the output wld file name.
        String[] iofiles = line.getArgs();
        if (iofiles.length < 2) {
            printUsage(1);
        }

        inputFileName = iofiles[0];
        outputFileName = iofiles[1];
    } catch (ParseException exp) {
        System.err.println("Unexpected exception:" + exp.getMessage());
        System.exit(1);
    }

    // try to open the input file for reading and the output file for writing
    File graticulesCsvFile;
    BufferedReader csvReader = null;

    File wldFile;
    BufferedWriter wldWriter = null;

    try {
        graticulesCsvFile = new File(inputFileName);
        csvReader = new BufferedReader(new FileReader(graticulesCsvFile));
    } catch (IOException exp) {
        System.err.println("Could not open input file for reading: " + inputFileName);
        System.exit(1);
    }

    try {
        wldFile = new File(outputFileName);
        wldWriter = new BufferedWriter(new FileWriter(wldFile));
    } catch (IOException exp) {
        System.err.println("Could not open output file for writing: " + outputFileName);
        System.exit(1);
    }

    // list of lon graticules and lat graticules
    ArrayList<Graticule> lonGrats = new ArrayList<Graticule>();
    ArrayList<Graticule> latGrats = new ArrayList<Graticule>();

    // read the source CSV and convert its information into the two ArrayList<Graticule> data structures
    readCSV(csvReader, lonGrats, latGrats);

    // we now need to start finding the world file paramaters
    DescriptiveStatistics stats = new DescriptiveStatistics();

    // find theta and phi
    for (Graticule g : latGrats) {
        stats.addValue(g.angle());
    }

    double theta = stats.getMean(); // we use the mean of the lat angles as theta
    if (debug)
        System.out.println("theta range = " + Math.toDegrees(stats.getMax() - stats.getMin()));
    stats.clear();

    for (Graticule g : lonGrats) {
        stats.addValue(g.angle());
    }

    double phi = stats.getMean(); // ... and the mean of the lon angles for phi
    if (debug)
        System.out.println("phi range = " + Math.toDegrees(stats.getMax() - stats.getMin()));
    stats.clear();

    // print these if in debug mode
    if (debug) {
        System.out.println("theta = " + Math.toDegrees(theta) + "deg");
        System.out.println("phi = " + Math.toDegrees(phi) + "deg");
    }

    // find x and y (distance beteen pixels in map units)
    Collections.sort(latGrats);
    Collections.sort(lonGrats);
    int prevMapValue = 0; //fixme: how to stop warning about not being initilised?
    Line2D prevGratPixelSys = new Line2D.Double();

    boolean first = true;
    for (Graticule g : latGrats) {
        if (!first) {
            int deltaMapValue = Math.abs(g.realValue() - prevMapValue);
            double deltaPixelValue = (g.l.ptLineDist(prevGratPixelSys.getP1())
                    + (g.l.ptLineDist(prevGratPixelSys.getP2()))) / 2;

            double delta = deltaMapValue / deltaPixelValue;
            stats.addValue(delta);
        } else {
            first = false;
            prevMapValue = g.realValue();
            prevGratPixelSys = (Line2D) g.l.clone();
        }
    }

    double y = stats.getMean();
    if (debug)
        System.out.println("y range = " + (stats.getMax() - stats.getMin()));
    stats.clear();

    first = true;
    for (Graticule g : lonGrats) {
        if (!first) {
            int deltaMapValue = g.realValue() - prevMapValue;
            double deltaPixelValue = (g.l.ptLineDist(prevGratPixelSys.getP1())
                    + (g.l.ptLineDist(prevGratPixelSys.getP2()))) / 2;

            double delta = deltaMapValue / deltaPixelValue;
            stats.addValue(delta);
        } else {
            first = false;
            prevMapValue = g.realValue();
            prevGratPixelSys = (Line2D) g.l.clone();
        }
    }

    double x = stats.getMean();
    if (debug)
        System.out.println("x range = " + (stats.getMax() - stats.getMin()));
    stats.clear();

    if (debug) {
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }

    SimpleRegression regression = new SimpleRegression();

    // C, F are translation terms: x, y map coordinates of the center of the upper-left pixel
    for (Graticule g : latGrats) {
        // find perp dist to pixel space 0,0
        Double perpPixelDist = g.l.ptLineDist(new Point2D.Double(0, 0));

        // find the map space distance from this graticule to the center of the 0,0 pixel
        Double perpMapDist = perpPixelDist * y; // perpMapDist / perpPixelDist = y

        regression.addData(perpMapDist, g.realValue());
    }

    double F = regression.getIntercept();
    regression.clear();

    for (Graticule g : lonGrats) {
        // find perp dist to pixel space 0,0
        Double perpPixelDist = g.l.ptLineDist(new Point2D.Double(0, 0));

        // find the map space distance from this graticule to the center of the 0,0 pixel
        Double perpMapDist = perpPixelDist * x; // perpMapDist / perpPixelDist = x

        regression.addData(perpMapDist, g.realValue());
    }

    double C = regression.getIntercept();
    regression.clear();

    if (debug) {
        System.out.println("Upper Left pixel has coordinates " + C + ", " + F);
    }

    // convert to meters
    C *= unitsToMeters;
    F *= unitsToMeters;

    // C,F store the projected (in map units) coordinates of the upper left pixel.
    // originNorthing,originEasting is the offset we need to apply to 0,0 to push the offsets into our global coordinate system 
    C = originEasting + C;
    F = originNorthing + F;

    // calculate the affine transformation matrix elements
    double D = -1 * x * unitsToMeters * Math.sin(theta);
    double A = x * unitsToMeters * Math.cos(theta);
    double B = y * unitsToMeters * Math.sin(phi); // if should be negative, it'll formed by negative sin
    double E = -1 * y * unitsToMeters * Math.cos(phi);

    /*
     * Line 1: A: pixel size in the x-direction in map units/pixel
     * Line 2: D: rotation about y-axis
     * Line 3: B: rotation about x-axis
     * Line 4: E: pixel size in the y-direction in map units, almost always negative[3]
     * Line 5: C: x-coordinate of the center of the upper left pixel
     * Line 6: F: y-coordinate of the center of the upper left pixel
     */
    if (debug) {
        System.out.println("A = " + A);
        System.out.println("D = " + D);
        System.out.println("B = " + B);
        System.out.println("E = " + E);
        System.out.println("C = " + C);
        System.out.println("F = " + F);

        // write the world file
        System.out.println();
        System.out.println("World File:");
        System.out.println(A);
        System.out.println(D);
        System.out.println(B);
        System.out.println(E);
        System.out.println(C);
        System.out.println(F);
    }

    // write to the .wld file
    wldWriter.write(A + "\n");
    wldWriter.write(D + "\n");
    wldWriter.write(B + "\n");
    wldWriter.write(E + "\n");
    wldWriter.write(C + "\n");
    wldWriter.write(F + "\n");

    wldWriter.close();
}

From source file:guineu.modules.dataanalysis.variationCoefficient.VariationCoefficientTask.java

private double getvariationCoefficient(Dataset dataset) {
    DescriptiveStatistics superStats = new DescriptiveStatistics();
    DescriptiveStatistics stats = new DescriptiveStatistics();
    for (PeakListRow row : dataset.getRows()) {
        stats.clear();
        for (String experimentName : dataset.getAllColumnNames()) {
            Object value = row.getPeak(experimentName);
            if (value != null && value instanceof Double) {
                stats.addValue((Double) value);
            } else {

                try {
                    stats.addValue(Double.valueOf((String) value));
                } catch (Exception e) {
                }// w ww  . j  a  v  a2 s . c  o m
            }
        }
        if (stats.getMean() > 0) {
            double value = stats.getStandardDeviation() / stats.getMean();
            superStats.addValue(value);
        }
    }
    return superStats.getMean();
}

From source file:guineu.modules.dataanalysis.Media.mediaFilterTask.java

public double[] getSTDDev(Dataset dataset) {
    DescriptiveStatistics stats = new DescriptiveStatistics();
    double[] median = new double[dataset.getNumberRows()];
    int numRows = 0;
    for (PeakListRow peak : dataset.getRows()) {
        stats.clear();
        for (String nameExperiment : dataset.getAllColumnNames()) {
            try {
                stats.addValue((Double) peak.getPeak(nameExperiment));
            } catch (Exception e) {
            }// w w  w.j  av a 2 s  .c  om
        }
        double[] values = stats.getSortedValues();
        median[numRows++] = values[values.length / 2];
    }
    return median;
}

From source file:guineu.modules.dataanalysis.kstest.KSTestTask.java

public void run() {
    try {//from  w w w .jav  a2 s.c  o m
        final Rengine rEngine;
        try {
            rEngine = RUtilities.getREngine();
        } catch (Throwable t) {

            throw new IllegalStateException(
                    "Kolmogorov-Smirnov test requires R but it couldn't be loaded (" + t.getMessage() + ')');
        }
        synchronized (RUtilities.R_SEMAPHORE) {

            DescriptiveStatistics stats = new DescriptiveStatistics();
            // assing the values to the matrix
            for (int row = 0; row < dataset.getNumberRows(); row++) {
                rEngine.eval("x <- vector(mode=\"numeric\",length=" + dataset.getNumberCols() + ")");
                stats.clear();
                PeakListRow peakListRow = dataset.getRow(row);
                for (int c = 0; c < dataset.getNumberCols(); c++) {
                    int r = c + 1;
                    double value = (Double) peakListRow.getPeak(dataset.getAllColumnNames().get(c));
                    rEngine.eval("x[" + r + "] <- " + value);
                    stats.addValue(value);
                }

                rEngine.eval("y <- rnorm(" + dataset.getNumberCols() + ", mean= " + stats.getMean() + ", sd = "
                        + stats.getStandardDeviation() + ")");

                rEngine.eval("result <- ks.test(x,y)");
                long e = rEngine.rniParse("result$p.value", 1);
                long r = rEngine.rniEval(e, 0);
                REXP x = new REXP(rEngine, r);
                double pValue = x.asDouble();
                dataset.getRow(row).setVar("setPValue", pValue);
                if (peakListRow.getID() == 68) {
                    rEngine.eval("write.csv(x, \"x.csv\"");
                }
            }

        }
        rEngine.end();
        setStatus(TaskStatus.FINISHED);
    } catch (Exception ex) {
        Logger.getLogger(KSTestTask.class.getName()).log(Level.SEVERE, null, ex);
        setStatus(TaskStatus.ERROR);
    }
}

From source file:net.sf.mzmine.modules.peaklistmethods.dataanalysis.heatmaps.HeatMapTask.java

private void scale(double[][] peakList) {
    DescriptiveStatistics stdDevStats = new DescriptiveStatistics();

    for (int columns = 0; columns < peakList.length; columns++) {
        stdDevStats.clear();
        for (int row = 0; row < peakList[columns].length; row++) {
            if (!Double.isInfinite(peakList[columns][row]) && !Double.isNaN(peakList[columns][row])) {
                stdDevStats.addValue(peakList[columns][row]);
            }// ww w. j  av a  2 s. c  o m
        }

        double stdDev = stdDevStats.getStandardDeviation();

        for (int row = 0; row < peakList[columns].length; row++) {
            if (stdDev != 0) {
                peakList[columns][row] = peakList[columns][row] / stdDev;
            }
        }
    }
}

From source file:guineu.modules.filter.Alignment.centering.mean.MeanCenteringTask.java

private void normalize(Dataset data) {
    DescriptiveStatistics stats = new DescriptiveStatistics();
    for (String nameExperiment : data.getAllColumnNames()) {
        for (PeakListRow row : data.getRows()) {
            Object value = row.getPeak(nameExperiment);
            if (value != null && value instanceof Double) {
                stats.addValue((Double) value);
            }/*from w  w  w  . j a v a  2 s  .co m*/
        }
        for (PeakListRow row : data.getRows()) {
            Object value = row.getPeak(nameExperiment);
            if (value != null && value instanceof Double) {
                row.setPeak(nameExperiment, Math.abs((Double) value - stats.getMean()));
            }
        }
        stats.clear();
    }
}

From source file:guineu.modules.filter.Alignment.normalizationSTD.STDNormalizationTask.java

private void normalize(Dataset data) {
    DescriptiveStatistics stats = new DescriptiveStatistics();
    for (String nameExperiment : data.getAllColumnNames()) {
        for (PeakListRow row : data.getRows()) {
            Object value = row.getPeak(nameExperiment);
            if (value != null && value instanceof Double) {
                stats.addValue((Double) value);
            }// ww w  . j a va 2 s  .co m
        }
        for (PeakListRow row : data.getRows()) {
            Object value = row.getPeak(nameExperiment);
            if (value != null && value instanceof Double) {
                row.setPeak(nameExperiment, (Double) value / stats.getStandardDeviation());
            }
        }
        stats.clear();
    }
}

From source file:net.sf.mzmine.modules.peaklistmethods.dataanalysis.heatmaps.HeatMapTask.java

private double[][] groupingDataset(UserParameter selectedParameter, String referenceGroup) {
    // Collect all data files
    Vector<RawDataFile> allDataFiles = new Vector<RawDataFile>();
    DescriptiveStatistics meanControlStats = new DescriptiveStatistics();
    DescriptiveStatistics meanGroupStats = new DescriptiveStatistics();
    allDataFiles.addAll(Arrays.asList(peakList.getRawDataFiles()));

    // Determine the reference group and non reference group (the rest of
    // the samples) for raw data files
    List<RawDataFile> referenceDataFiles = new ArrayList<RawDataFile>();
    List<RawDataFile> nonReferenceDataFiles = new ArrayList<RawDataFile>();

    List<String> groups = new ArrayList<String>();
    MZmineProject project = MZmineCore.getCurrentProject();

    for (RawDataFile rawDataFile : allDataFiles) {

        Object paramValue = project.getParameterValue(selectedParameter, rawDataFile);
        if (!groups.contains(String.valueOf(paramValue))) {
            groups.add(String.valueOf(paramValue));
        }//w w  w.  j  a v  a  2s  . com
        if (String.valueOf(paramValue).equals(referenceGroup)) {

            referenceDataFiles.add(rawDataFile);
        } else {

            nonReferenceDataFiles.add(rawDataFile);
        }
    }

    int numRows = 0;
    for (int row = 0; row < peakList.getNumberOfRows(); row++) {

        if (!onlyIdentified || (onlyIdentified && peakList.getRow(row).getPeakIdentities().length > 0)) {
            numRows++;
        }
    }

    // Create a new aligned peak list with all the samples if the reference
    // group has to be shown or with only
    // the non reference group if not.
    double[][] dataMatrix = new double[groups.size() - 1][numRows];
    pValueMatrix = new String[groups.size() - 1][numRows];

    // data files that should be in the heat map
    List<RawDataFile> shownDataFiles = nonReferenceDataFiles;

    for (int row = 0, rowIndex = 0; row < peakList.getNumberOfRows(); row++) {
        PeakListRow rowPeak = peakList.getRow(row);
        if (!onlyIdentified || (onlyIdentified && rowPeak.getPeakIdentities().length > 0)) {
            // Average area or height of the reference group
            meanControlStats.clear();
            for (int column = 0; column < referenceDataFiles.size(); column++) {

                if (rowPeak.getPeak(referenceDataFiles.get(column)) != null) {

                    if (area) {

                        meanControlStats.addValue(rowPeak.getPeak(referenceDataFiles.get(column)).getArea());
                    } else {

                        meanControlStats.addValue(rowPeak.getPeak(referenceDataFiles.get(column)).getHeight());
                    }

                }
            }

            // Divide the area or height of each peak by the average of the
            // area or height of the reference peaks in each row
            int columnIndex = 0;
            for (int column = 0; column < groups.size(); column++) {
                String group = groups.get(column);
                meanGroupStats.clear();
                if (!group.equals(referenceGroup)) {

                    for (int dataColumn = 0; dataColumn < shownDataFiles.size(); dataColumn++) {

                        Object paramValue = project.getParameterValue(selectedParameter,
                                shownDataFiles.get(dataColumn));
                        if (rowPeak.getPeak(shownDataFiles.get(dataColumn)) != null
                                && String.valueOf(paramValue).equals(group)) {

                            Feature peak = rowPeak.getPeak(shownDataFiles.get(dataColumn));

                            if (!Double.isInfinite(peak.getArea()) && !Double.isNaN(peak.getArea())) {

                                if (area) {

                                    meanGroupStats.addValue(peak.getArea());
                                } else {

                                    meanGroupStats.addValue(peak.getHeight());
                                }
                            }

                        }
                    }

                    double value = meanGroupStats.getMean() / meanControlStats.getMean();
                    if (meanGroupStats.getN() > 1 && meanControlStats.getN() > 1) {
                        pValueMatrix[columnIndex][rowIndex] = this.getPvalue(meanGroupStats, meanControlStats);
                    } else {
                        pValueMatrix[columnIndex][rowIndex] = "";
                    }

                    if (log) {

                        value = Math.log(value);
                    }
                    dataMatrix[columnIndex++][rowIndex] = value;
                }
            }
            rowIndex++;
        }
    }

    // Scale the data dividing the peak area/height by the standard
    // deviation of each column
    if (scale) {
        scale(dataMatrix);
    }

    // Create two arrays: row and column names
    rowNames = new String[dataMatrix[0].length];
    colNames = new String[groups.size() - 1];

    int columnIndex = 0;
    for (String group : groups) {

        if (!group.equals(referenceGroup)) {

            colNames[columnIndex++] = group;
        }
    }
    for (int row = 0, rowIndex = 0; row < peakList.getNumberOfRows(); row++) {
        if (!onlyIdentified || (onlyIdentified && peakList.getRow(row).getPeakIdentities().length > 0)) {
            if (peakList.getRow(row).getPeakIdentities() != null
                    && peakList.getRow(row).getPeakIdentities().length > 0) {

                rowNames[rowIndex++] = peakList.getRow(row).getPreferredPeakIdentity().getName();
            } else {

                rowNames[rowIndex++] = "Unknown";
            }
        }
    }

    return dataMatrix;
}

From source file:org.openehealth.ipf.commons.test.performance.processingtime.ProcessingTimeDescriptiveStatistics.java

@Override
public void reset() {
    for (DescriptiveStatistics s : statisticsByMeasurementName.values()) {
        s.clear();
    }/*  w  ww.  j  ava 2  s  .  com*/
    statisticsByMeasurementName.clear();
}

From source file:org.processmining.analysis.performance.dottedchart.model.DottedChartModel.java

public void calculateStatisticsLogical() {
    String key = null;/* ww  w.  j a va 2 s.  c  o  m*/
    AbstractLogUnit item, itemOld;

    DescriptiveStatistics overallDS = timeStatistics.get(0);
    overallDS.clear();
    overallStatistics.clear();

    int index = -1;
    for (Iterator itSets = getItemMap().keySet().iterator(); itSets.hasNext();) {
        key = (String) itSets.next();
        index++;
        DescriptiveStatistics tempDS = timeStatistics.get(index + 1);
        tempDS.clear();
        if (typeHashMap.equals(ST_INST) && !instanceIDs.contains(key))
            continue;
        LogUnitList tempLogUnitList = (LogUnitList) getItemMap().get(key);

        itemOld = null;
        // iterate through items
        ArrayList<AbstractLogUnit> abst = tempLogUnitList.getEvents();
        TreeSet treeSet = new TreeSet<AbstractLogUnit>(abst);

        for (Iterator itItm = treeSet.iterator(); itItm.hasNext();) {
            item = (AbstractLogUnit) itItm.next();
            if (eventTypeToKeep != null && (!eventTypeToKeep.contains(item.getType())
                    || !instanceIDs.contains(item.getProcessInstance().getName())))
                continue;
            if (itemOld == null) {
                itemOld = item;
            } else {
                double temp = (double) item.getCurrentTimeStamp().getTime()
                        - (double) itemOld.getCurrentTimeStamp().getTime();
                overallStatistics.addValue(temp);
                tempDS.addValue(temp);
                itemOld = item;
            }
        }
        if (tempLogUnitList.getRightBoundaryTimestamp(eventTypeToKeep, instanceIDs) == null
                || tempLogUnitList.getLeftBoundaryTimestamp(eventTypeToKeep, instanceIDs) == null)
            overallDS.addValue(0);
        else
            overallDS.addValue((tempLogUnitList.getRightBoundaryTimestamp(eventTypeToKeep, instanceIDs)
                    .getTime()
                    - tempLogUnitList.getLeftBoundaryTimestamp(eventTypeToKeep, instanceIDs).getTime()));
    }
}