Java DescriptiveStatistics.getPercentile方法代码示例

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
@Override
public Data process(Data item) {
    int[][] singlePulses = (int[][]) item.get(singlePulsesKey);
    double[] arrivalTimes = new double[singlePulses.length];

    for (int pix = 0; pix < singlePulses.length; pix++) {
        if (singlePulses[pix].length == 0) {
            arrivalTimes[pix] = 0.; // use zero instead of NaN - plotter likes no NaN
        } else {
            DescriptiveStatistics stat = new DescriptiveStatistics();
            for (int slice : singlePulses[pix]) {
                stat.addValue((double) slice);
            }
            arrivalTimes[pix] = stat.getPercentile(50);
        }
    }
    item.put(arrivalTimeKey, arrivalTimes);
    return item;
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
@Test
public void testQuantiles() {
    Random r = new Random(0);
    List<DataPoint> points = new ArrayList<>();
    DescriptiveStatistics stats = new DescriptiveStatistics();
    Distribution distribution = null;
    for(int i = 0; i < 100;++i) {
        double val = r.nextDouble()*1000;
        DataPoint dp = (new DataPoint(i, val, null, "foo"));
        points.add(dp);
        stats.addValue(val);
        if(distribution == null) {
            distribution = new Distribution(dp, ScalingFunctions.NONE, new GlobalStatistics());
        }
        else {
            distribution.addDataPoint(dp, ScalingFunctions.NONE);
        }
    }
    double realMedian = stats.getPercentile(50);
    double approxMedian = distribution.getMedian();
    System.out.println("mean and std dev: " + stats.getMean() + ", " + Math.sqrt(stats.getVariance()));
    System.out.println("Real : " + realMedian + ", approx: " + approxMedian);
    Assert.assertTrue(Math.abs(realMedian - approxMedian) < 5);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
public void getDescStats(double[] values){
	DescriptiveStatistics stats = new DescriptiveStatistics();
	for( int i = 0; i < values.length; i++) {
	        stats.addValue(values[i]);
	}
	double mean = stats.getMean();
	double std = stats.getStandardDeviation();
	double median = stats.getPercentile(50);
	System.out.println(mean + "\t" + std + "\t" + median);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
private static int medianMisMatch (String matchLine) {
	DescriptiveStatistics stats = new DescriptiveStatistics();
	for (int i=0; i<matchLine.length(); i++) {
		if  (matchLine.substring(i, i+1).equals(" ")) {
			stats.addValue(i+1);
		}
	}
	double median = 100 * (double) stats.getPercentile(50) / (double) matchLine.length();
	return (int) median;
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
private boolean isOutlierByModifiedZScore(DescriptiveStatistics stats, double value)
{
    double median = stats.getPercentile(50);
    double medianAbsoluteDeviation = new DescriptiveStatistics(
        Arrays.stream(stats.getValues()).map(v -> Math.abs(v - median)).toArray()).getPercentile(50);
    double modifiedZScore = 0.6745 * (value - median) / medianAbsoluteDeviation;

    return Math.abs(modifiedZScore) > 3.5;
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
private boolean isOutlierByInterquartileRange(DescriptiveStatistics stats, double value)
{
    double quartile1 = stats.getPercentile(25);
    double quartile3 = stats.getPercentile(75);
    double iqr = quartile3 - quartile1;
    double lowerBound = quartile1 - (iqr * 1.5);
    double upperBound = quartile3 + (iqr * 1.5);

    return (value < lowerBound || value > upperBound);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
@Override
public DescriptiveStatistics label(final Serializable[] preds, final Object[] expected, final double[] weights,
		final ISamples<?, ?> samples, final int labelIndex) {
	final DescriptiveStatistics stats = new DescriptiveStatistics();
	for (int i = 0; i < preds.length; ++i) {
		final double[] predAndAct = toDouble(preds[i], expected[i]);
		stats.addValue(Math.abs(predAndAct[0] - predAndAct[1]));
	}
	return new DescriptiveStatistics(new double[] { stats.getPercentile(50) });
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
private double prediction(final DescriptiveStatistics stats) {
	switch (nodePrediction) {
	case "mean":
		return stats.getMean();
	case "median":
		return stats.getPercentile(50);
	case "meandian":
		return (stats.getMean() + stats.getPercentile(50)) / 2;
	default:
		throw new IllegalArgumentException(nodePrediction);
	}
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
@Override
public float getResult() {
    if (count == 0)
        return Float.NaN;
    
    double[] primitiveValues = new double[floatValues.size()];
    for (int i = 0; i < floatValues.size(); i++)
        primitiveValues[i] = floatValues.get(i);
    DescriptiveStatistics stats = new DescriptiveStatistics(primitiveValues);
    
    return (float) stats.getPercentile(50);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
public double getIQR(ArrayList<Float> arrayList) {
    double[] vals = new double[arrayList.size()];
    for (int i = 0; i < arrayList.size(); i++) {
        vals[i] = (double)arrayList.get(i);
    }
    DescriptiveStatistics ds = new DescriptiveStatistics(vals);
    double fq = ds.getPercentile(25);
    double tq = ds.getPercentile(75);
    return (tq - fq);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
private Double apply(ITimeSeriesUnivariate t) {
	List<Double> vals = t.getValues();
	double[] da = new double[vals.size()];
	for (int i = 0; i < vals.size(); i++) {
		da[i] = vals.get(i);
	}
	DescriptiveStatistics ds = new DescriptiveStatistics(da);
	return ds.getPercentile(50);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
private Double apply(ITimeSeriesUnivariate t) {
	List<Double> vals = t.getValues();
	double[] da = new double[vals.size()];
	for (int i = 0; i < vals.size(); i++) {
		da[i] = vals.get(i);
	}
	DescriptiveStatistics ds = new DescriptiveStatistics(da);
	return ds.getPercentile(75);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
private Double apply(ITimeSeriesUnivariate t) {
	List<Double> vals = t.getValues();
	double[] da = new double[vals.size()];
	for (int i = 0; i < vals.size(); i++) {
		da[i] = vals.get(i);
	}
	DescriptiveStatistics ds = new DescriptiveStatistics(da);
	return ds.getPercentile(25);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
private Double getMedian(final String feature) {
	final DescriptiveStatistics stat = stats.get(feature);
	return stat == null ? null : stat.getPercentile(50);
}
 

import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics; //导入方法依赖的package包/类
@Override
public Data process(Data item) {
    Utils.isKeyValid(item, "NPIX", Integer.class);
    npix = (Integer) item.get("NPIX");

    Utils.mapContainsKeys(item, dataKey);

    int[][] data = (int[][]) item.get(dataKey);

    double[] mean = new double[npix];
    double[] median = new double[npix];
    double[] mode = new double[npix];
    double[] std = new double[npix];
    double[] kurtosis = new double[npix];
    double[] skewness = new double[npix];
    double[] min = new double[npix];
    double[] max = new double[npix];
    double[] quantil25 = new double[npix];
    double[] quantil75 = new double[npix];

    for (int pix = 0; pix < npix; pix++) {
        double[] values = Utils.toDoubleArray(data[pix]);


        ///FIXME: fill nans instead of continue
        if (values.length == 0) {
            continue;
        }

        DescriptiveStatistics stats = new DescriptiveStatistics(values);
        mean[pix] = stats.getMean();
        min[pix] = stats.getMin();
        max[pix] = stats.getMax();
        std[pix] = stats.getStandardDeviation();
        skewness[pix] = stats.getSkewness();
        kurtosis[pix] = stats.getKurtosis();
        quantil25[pix] = stats.getPercentile(0.25);
        quantil75[pix] = stats.getPercentile(0.75);
        median[pix] = stats.getPercentile(0.5);

        double[] modeArray = StatUtils.mode(values);
        mode[pix] = modeArray[0];
    }

    item.put(outputKey + "_mean", mean);
    item.put(outputKey + "_median", median);
    item.put(outputKey + "_mode", mode);
    item.put(outputKey + "_std", std);
    item.put(outputKey + "_kurtosis", kurtosis);
    item.put(outputKey + "_skewness", skewness);
    item.put(outputKey + "_min", min);
    item.put(outputKey + "_max", max);
    item.put(outputKey + "_quantil25", quantil25);
    item.put(outputKey + "_quantil75", quantil75);


    return item;
}