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

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

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.math.stat.descriptive.*
  5. DescriptiveStatistics
  6. getValues

Introduction

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

Prototype

public double[] getValues()

Source Link

Document

Returns the current set of values in an array of double primitives.

Usage

From source file:guineu.modules.dataanalysis.wilcoxontest.WilcoxonTestTask.java

public double[] Ttest(int mol) throws IllegalArgumentException {
    DescriptiveStatistics stats1 = new DescriptiveStatistics();
    DescriptiveStatistics stats2 = new DescriptiveStatistics();
    double[] values = new double[3];
    String parameter1 = "";

    if (parameter == null) {
        for (int i = 0; i < group1.length; i++) {
            try {
                stats1.addValue((Double) this.dataset.getRow(mol).getPeak(group1[i]));
            } catch (Exception e) {
                e.printStackTrace();//ww w  .  j a v a  2 s.  c  om
            }
        }
        for (int i = 0; i < group2.length; i++) {
            try {
                stats2.addValue((Double) this.dataset.getRow(mol).getPeak(group2[i]));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    } else {
        try {
            // Determine groups for selected raw data files
            List<String> availableParameterValues = dataset.getParameterAvailableValues(parameter);

            int numberOfGroups = availableParameterValues.size();

            if (numberOfGroups > 1) {
                parameter1 = availableParameterValues.get(0);
                String parameter2 = availableParameterValues.get(1);

                for (String sampleName : dataset.getAllColumnNames()) {
                    if (dataset.getParametersValue(sampleName, parameter) != null
                            && dataset.getParametersValue(sampleName, parameter).equals(parameter1)) {
                        try {
                            stats1.addValue((Double) this.dataset.getRow(mol).getPeak(sampleName));
                        } catch (Exception e) {
                        }
                    } else if (dataset.getParametersValue(sampleName, parameter) != null
                            && dataset.getParametersValue(sampleName, parameter).equals(parameter2)) {
                        try {
                            stats2.addValue((Double) this.dataset.getRow(mol).getPeak(sampleName));
                        } catch (Exception e) {
                        }
                    }
                }
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    try {
        final Rengine rEngine;
        try {
            rEngine = RUtilities.getREngine();
        } catch (Throwable t) {

            throw new IllegalStateException(
                    "Wilcoxon test requires R but it couldn't be loaded (" + t.getMessage() + ')');
        }
        synchronized (RUtilities.R_SEMAPHORE) {
            rEngine.eval("x <- 0");
            rEngine.eval("y <- 0");
            long group1 = rEngine.rniPutDoubleArray(stats1.getValues());
            rEngine.rniAssign("x", group1, 0);

            long group2 = rEngine.rniPutDoubleArray(stats2.getValues());
            rEngine.rniAssign("y", group2, 0);
            /* if(mol == 1){
             rEngine.eval("write.csv(x, \"x.csv\")");
             rEngine.eval("write.csv(y, \"y.csv\")");
             }*/
            rEngine.eval("result <- 0");

            rEngine.eval("result <- wilcox.test(as.numeric(t(x)),as.numeric(t(y)))");
            long e = rEngine.rniParse("result$p.value", 1);
            long r = rEngine.rniEval(e, 0);
            REXP x = new REXP(rEngine, r);

            values[0] = x.asDouble();
        }

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

    values[1] = stats1.getMean();
    values[2] = stats2.getMean();
    return values;
}

From source file:org.datacleaner.beans.NumberAnalyzer.java

@Override
public NumberAnalyzerResult getResult() {
    CrosstabDimension measureDimension = new CrosstabDimension(DIMENSION_MEASURE);
    measureDimension.addCategory(MEASURE_ROW_COUNT);
    measureDimension.addCategory(MEASURE_NULL_COUNT);
    measureDimension.addCategory(MEASURE_HIGHEST_VALUE);
    measureDimension.addCategory(MEASURE_LOWEST_VALUE);
    measureDimension.addCategory(MEASURE_SUM);
    measureDimension.addCategory(MEASURE_MEAN);
    measureDimension.addCategory(MEASURE_GEOMETRIC_MEAN);
    measureDimension.addCategory(MEASURE_STANDARD_DEVIATION);
    measureDimension.addCategory(MEASURE_VARIANCE);
    measureDimension.addCategory(MEASURE_SECOND_MOMENT);
    measureDimension.addCategory(MEASURE_SUM_OF_SQUARES);

    if (descriptiveStatistics) {
        measureDimension.addCategory(MEASURE_MEDIAN);
        measureDimension.addCategory(MEASURE_PERCENTILE25);
        measureDimension.addCategory(MEASURE_PERCENTILE75);
        measureDimension.addCategory(MEASURE_SKEWNESS);
        measureDimension.addCategory(MEASURE_KURTOSIS);
    }//from  ww  w . j a  va  2 s.co m

    CrosstabDimension columnDimension = new CrosstabDimension(DIMENSION_COLUMN);
    for (InputColumn<? extends Number> column : _columns) {
        columnDimension.addCategory(column.getName());
    }

    Crosstab<Number> crosstab = new Crosstab<Number>(Number.class, columnDimension, measureDimension);
    for (InputColumn<? extends Number> column : _columns) {
        CrosstabNavigator<Number> nav = crosstab.navigate().where(columnDimension, column.getName());
        NumberAnalyzerColumnDelegate delegate = _columnDelegates.get(column);

        StatisticalSummary s = delegate.getStatistics();
        int nullCount = delegate.getNullCount();

        nav.where(measureDimension, MEASURE_NULL_COUNT).put(nullCount);

        if (nullCount > 0) {
            addAttachment(nav, delegate.getNullAnnotation(), column);
        }

        int numRows = delegate.getNumRows();
        nav.where(measureDimension, MEASURE_ROW_COUNT).put(numRows);

        long nonNullCount = s.getN();

        if (nonNullCount > 0) {
            final double highestValue = s.getMax();
            final double lowestValue = s.getMin();
            final double sum = s.getSum();
            final double mean = s.getMean();
            final double standardDeviation = s.getStandardDeviation();
            final double variance = s.getVariance();

            final double geometricMean;
            final double secondMoment;
            final double sumOfSquares;
            if (descriptiveStatistics) {
                final DescriptiveStatistics descriptiveStats = (DescriptiveStatistics) s;
                geometricMean = descriptiveStats.getGeometricMean();
                sumOfSquares = descriptiveStats.getSumsq();
                secondMoment = new SecondMoment().evaluate(descriptiveStats.getValues());
            } else {
                final SummaryStatistics summaryStats = (SummaryStatistics) s;
                geometricMean = summaryStats.getGeometricMean();
                secondMoment = summaryStats.getSecondMoment();
                sumOfSquares = summaryStats.getSumsq();
            }

            nav.where(measureDimension, MEASURE_HIGHEST_VALUE).put(highestValue);
            addAttachment(nav, delegate.getMaxAnnotation(), column);

            nav.where(measureDimension, MEASURE_LOWEST_VALUE).put(lowestValue);
            addAttachment(nav, delegate.getMinAnnotation(), column);

            nav.where(measureDimension, MEASURE_SUM).put(sum);
            nav.where(measureDimension, MEASURE_MEAN).put(mean);
            nav.where(measureDimension, MEASURE_GEOMETRIC_MEAN).put(geometricMean);
            nav.where(measureDimension, MEASURE_STANDARD_DEVIATION).put(standardDeviation);
            nav.where(measureDimension, MEASURE_VARIANCE).put(variance);
            nav.where(measureDimension, MEASURE_SUM_OF_SQUARES).put(sumOfSquares);
            nav.where(measureDimension, MEASURE_SECOND_MOMENT).put(secondMoment);

            if (descriptiveStatistics) {
                final DescriptiveStatistics descriptiveStatistics = (DescriptiveStatistics) s;
                final double kurtosis = descriptiveStatistics.getKurtosis();
                final double skewness = descriptiveStatistics.getSkewness();
                final double median = descriptiveStatistics.getPercentile(50.0);
                final double percentile25 = descriptiveStatistics.getPercentile(25.0);
                final double percentile75 = descriptiveStatistics.getPercentile(75.0);

                nav.where(measureDimension, MEASURE_MEDIAN).put(median);
                nav.where(measureDimension, MEASURE_PERCENTILE25).put(percentile25);
                nav.where(measureDimension, MEASURE_PERCENTILE75).put(percentile75);
                nav.where(measureDimension, MEASURE_SKEWNESS).put(skewness);
                nav.where(measureDimension, MEASURE_KURTOSIS).put(kurtosis);
            }
        }
    }
    return new NumberAnalyzerResult(_columns, crosstab);
}

From source file:org.matsim.contrib.common.stats.Histogram.java

/**
 * Creates a histogram from the values in <tt>stats</tt> discretized with <tt>discretizer</tt>. Correctly handles
 * {@link DescriptivePiStatistics} objects.
 *
 * @param stats       a descriptive statistics object
 * @param discretizer a discretizer//  www  .ja v  a2 s .c o m
 * @return a double-double map where the key denotes the bin and the value the bin height.
 */
public static TDoubleDoubleHashMap createHistogram(DescriptiveStatistics stats, Discretizer discretizer,
        boolean reweight) {
    if (stats instanceof DescriptivePiStatistics)
        return createHistogram((DescriptivePiStatistics) stats, discretizer, reweight);
    else
        return createHistogram(stats.getValues(), discretizer, reweight);
}

From source file:org.matsim.contrib.socnetgen.sna.graph.analysis.AnalyzerTask.java

protected TDoubleDoubleHashMap writeHistograms(DescriptiveStatistics stats, String name, int bins, int minsize)
        throws IOException {
    double[] values = stats.getValues();
    if (values.length > 0) {
        TDoubleDoubleHashMap hist = Histogram.createHistogram(stats,
                FixedSampleSizeDiscretizer.create(values, minsize, bins), true);
        StatsWriter.writeHistogram(hist, name, "p",
                String.format("%1$s/%2$s.n%3$s.nonorm.txt", getOutputDirectory(), name, values.length / bins));
        Histogram.normalize(hist);/*from  ww w  .j  a va2 s .  co m*/
        StatsWriter.writeHistogram(hist, name, "p",
                String.format("%1$s/%2$s.n%3$s.txt", getOutputDirectory(), name, values.length / bins));

        return hist;
    } else {
        logger.warn("Cannot create histogram. No samples.");
        return null;
    }
}

From source file:org.matsim.contrib.socnetgen.sna.graph.analysis.AnalyzerTask.java

protected TDoubleDoubleHashMap writeCumulativeHistograms(DescriptiveStatistics stats, String name, int bins,
        int minsize) throws IOException {
    double[] values = stats.getValues();
    if (values.length > 0) {
        TDoubleDoubleHashMap hist = Histogram.createHistogram(stats,
                FixedSampleSizeDiscretizer.create(values, minsize, bins), false);
        hist = Histogram.createCumulativeHistogram(hist);
        Histogram.normalizeCumulative(hist);
        Histogram.complementary(hist);//from  w  w  w . ja  va2s. c o m
        StatsWriter.writeHistogram(hist, name, "P",
                String.format("%1$s/%2$s.n%3$s.cum.txt", getOutputDirectory(), name, values.length / bins));

        return hist;
    } else {
        logger.warn("Cannot create histogram. No samples.");
        return null;
    }
}

From source file:org.matsim.contrib.socnetgen.sna.graph.spatial.analysis.AcceptancePropaCategoryTask.java

@Override
public void analyze(Graph graph, Map<String, DescriptiveStatistics> statsMap) {
    Accessibility access = module;/*from  w  ww .  j a v a2  s . c o m*/
    Set<Vertex> vertices = new HashSet<Vertex>();
    for (Vertex v : graph.getVertices()) {
        Point p = ((SpatialVertex) v).getPoint();
        if (p != null) {
            vertices.add(v);
        }
    }

    TObjectDoubleHashMap<Vertex> normValues = access.values(vertices);
    AttributePartition partitioner = new AttributePartition(
            FixedSampleSizeDiscretizer.create(normValues.values(), 1, 2));
    TDoubleObjectHashMap<?> partitions = partitioner.partition(normValues);
    TDoubleObjectIterator<?> it = partitions.iterator();

    AcceptanceProbability propa = new AcceptanceProbability();

    Map<String, TDoubleDoubleHashMap> histograms = new HashMap<String, TDoubleDoubleHashMap>();
    Map<String, DescriptiveStatistics> distributions = new HashMap<String, DescriptiveStatistics>();
    double sum = 0;

    for (int i = 0; i < partitions.size(); i++) {
        it.advance();
        double key = it.key();
        Set<SpatialVertex> partition = (Set<SpatialVertex>) it.value();
        System.out.println("Partition size = " + partition.size() + "; key = " + key);
        DescriptiveStatistics distr = propa.distribution(partition, destinations);
        try {
            double[] values = distr.getValues();
            System.out.println("Num samples = " + values.length);
            if (values.length > 0) {
                TDoubleDoubleHashMap hist = Histogram.createHistogram(distr,
                        FixedSampleSizeDiscretizer.create(values, 1, 50), true);
                sum += Histogram.sum(hist);
                histograms.put(String.format("p_accept-cat%1$.4f", key), hist);
                distributions.put(String.format("p_accept-cat%1$.4f", key), distr);
            }
            writeHistograms(distr, new LinLogDiscretizer(1000.0, 2),
                    String.format("p_accept-cat%1$.4f.log", key), true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    for (Entry<String, TDoubleDoubleHashMap> entry : histograms.entrySet()) {
        String key = entry.getKey();
        TDoubleDoubleHashMap histogram = entry.getValue();
        Histogram.normalize(histogram, sum);
        try {
            StatsWriter.writeHistogram(histogram, "d", "p",
                    String.format("%1$s/%2$s.txt", getOutputDirectory(), key));
        } catch (IOException e) {
            e.printStackTrace();
        }

        histogram = Histogram.createCumulativeHistogram(histogram);
        Histogram.complementary(histogram);
        try {
            StatsWriter.writeHistogram(histogram, "d", "p",
                    String.format("%1$s/%2$s.cum.txt", getOutputDirectory(), key));
        } catch (IOException e) {
            e.printStackTrace();
        }

        DescriptiveStatistics stats = distributions.get(key);
        writeRawData(stats, key);
    }
}

From source file:org.matsim.contrib.socnetgen.sna.graph.spatial.analysis.AccessibilityTask.java

@Override
public void analyze(Graph graph, Map<String, DescriptiveStatistics> results) {
    Accessibility access = new Accessibility(function);

    DescriptiveStatistics stats = access.statistics(graph.getVertices());
    try {/* www  .  ja  v a 2  s . co m*/
        Discretizer disc = new LinearDiscretizer(stats.getValues(), 74);
        writeHistograms(stats, disc, "A", false);
        writeHistograms(stats, "A", 74, 1);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

From source file:org.matsim.contrib.socnetgen.sna.graph.spatial.analysis.EdgeLengthCategoryTask.java

@Override
public void analyze(Graph graph, Map<String, DescriptiveStatistics> statsMap) {
    Accessibility access = module;//from   ww w .j  a v a  2s. c  om

    Set<Vertex> vertices = new HashSet<Vertex>();
    for (Vertex v : graph.getVertices()) {
        Point p = ((SpatialVertex) v).getPoint();
        if (p != null) {
            vertices.add(v);
        }
    }

    TObjectDoubleHashMap<Vertex> normValues = access.values(vertices);

    AttributePartition partitioner = new AttributePartition(
            FixedSampleSizeDiscretizer.create(normValues.values(), 1, 2));
    TDoubleObjectHashMap<?> partitions = partitioner.partition(normValues);
    TDoubleObjectIterator<?> it = partitions.iterator();

    EdgeLength propa = new EdgeLength();

    Map<String, TDoubleDoubleHashMap> histograms = new HashMap<String, TDoubleDoubleHashMap>();
    Map<String, DescriptiveStatistics> distributions = new HashMap<String, DescriptiveStatistics>();
    double sum = 0;

    for (int i = 0; i < partitions.size(); i++) {
        it.advance();
        double key = it.key();
        Set<SpatialVertex> partition = (Set<SpatialVertex>) it.value();
        System.out.println("Partition size = " + partition.size() + "; key = " + key);
        Set<SpatialEdge> edges = new HashSet<SpatialEdge>();
        for (SpatialVertex v : partition) {
            edges.addAll(v.getEdges());
        }
        DescriptiveStatistics distr = propa.statistics(edges);
        try {
            double[] values = distr.getValues();
            System.out.println("Num samples = " + values.length);
            if (values.length > 0) {
                TDoubleDoubleHashMap hist = Histogram.createHistogram(distr,
                        FixedSampleSizeDiscretizer.create(values, 1, 50), true);
                sum += Histogram.sum(hist);
                histograms.put(String.format("d-cat%1$.4f", key), hist);
                distributions.put(String.format("d-cat%1$.4f", key), distr);
            }
            writeHistograms(distr, new LinLogDiscretizer(1000.0, 2), String.format("d-cat%1$.4f.log", key),
                    true);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    for (Entry<String, TDoubleDoubleHashMap> entry : histograms.entrySet()) {
        String key = entry.getKey();
        TDoubleDoubleHashMap histogram = entry.getValue();
        Histogram.normalize(histogram, sum);
        try {
            StatsWriter.writeHistogram(histogram, "d", "p",
                    String.format("%1$s/%2$s.txt", getOutputDirectory(), key));
        } catch (IOException e) {
            e.printStackTrace();
        }

        histogram = Histogram.createCumulativeHistogram(histogram);
        Histogram.complementary(histogram);
        try {
            StatsWriter.writeHistogram(histogram, "d", "p",
                    String.format("%1$s/%2$s.cum.txt", getOutputDirectory(), key));
        } catch (IOException e) {
            e.printStackTrace();
        }

        DescriptiveStatistics stats = distributions.get(key);
        writeRawData(stats, key);
    }
}

From source file:playground.johannes.coopsim.analysis.TrajectoryAnalyzerTask.java

protected void writeHistograms(DescriptiveStatistics stats, String name, int bins, int minsize)
        throws IOException {
    double[] values = stats.getValues();
    if (values.length > 0) {
        if (overwrite) {
            logger.warn("Overwriting stratification!");
            bins = overwriteBins;// w  w  w.ja v a2s  . c om
            minsize = overwriteMinsize;
        }

        TDoubleDoubleHashMap hist = Histogram.createHistogram(stats,
                FixedSampleSizeDiscretizer.create(values, minsize, bins), true);
        Histogram.normalize(hist);
        TXTWriter.writeMap(hist, name, "p", String.format("%1$s/%2$s.strat.txt", getOutputDirectory(), name));
    } else {
        logger.debug("Cannot create histogram. No samples.");
    }
}

From source file:playground.johannes.coopsim.analysis.TripDistanceTaskLeisure.java

@Override
public void analyze(Set<Trajectory> trajectories, Map<String, DescriptiveStatistics> results) {

    DescriptiveStatistics stats = new TripDistanceMeanLeisure(facilities, calculator).statistics(trajectories);
    String key = "d_trip_leisure";
    results.put(key, stats);//from  w  ww  . j  a va 2s  .co m
    try {
        writeHistograms(stats, key, 50, 50);

        double[] values = stats.getValues();
        LinearDiscretizer lin = new LinearDiscretizer(500.0);
        DescriptiveStatistics linStats = new DescriptiveStatistics();
        for (double d : values)
            linStats.addValue(lin.discretize(d));

        //         TrajectoryAnalyzerTask.overwriteStratification(50, 1);
        writeHistograms(linStats, key + ".lin", 50, 50);
        //         TrajectoryAnalyzerTask.overwriteStratification(30, 1);
    } catch (IOException e) {
        e.printStackTrace();
    }

}