Example usage for org.apache.commons.math3.stat.descriptive.rank Percentile evaluate

List of usage examples for org.apache.commons.math3.stat.descriptive.rank Percentile evaluate

  1. HOME
  2. Java
  3. org.apache.commons
  4. org.apache.commons.math3.stat.descriptive.rank.*
  5. Percentile
  6. evaluate

Introduction

In this page you can find the example usage for org.apache.commons.math3.stat.descriptive.rank Percentile evaluate.

Prototype

public double evaluate(final double p) throws MathIllegalArgumentException

Source Link

Document

Returns the result of evaluating the statistic over the stored data.

Usage

From source file:com.mgmtp.perfload.perfalyzer.binning.MeasuringResponseTimesBinningStrategy.java

@Override
public void aggregateData(final ChannelManager channelManager) throws IOException {
    WritableByteChannel quantilesChannel = channelManager.getChannel("quantiles");
    writeQuantilesHeader(quantilesChannel);

    int i = 0;//from  ww  w .j a  v a 2  s.  c  o  m
    for (Entry<String, UriMeasurings> entry : measuringsMap.entrySet()) {
        UriMeasurings measurings = entry.getValue();
        String uri = measurings.uriAlias;
        if (measurings.responseTimes.isEmpty()) {
            continue;
        }

        Percentile percentile = new Percentile();
        double[] responseTimes = Doubles.toArray(measurings.responseTimes);
        percentile.setData(responseTimes);

        // each uri is mapped to a key which is simple a number that is left-padded for better sorting
        String mappingKey = leftPad(String.valueOf(i++), 3, '0');

        StrBuilder sb = new StrBuilder(150);
        appendEscapedAndQuoted(sb, DELIMITER, mappingKey);
        appendEscapedAndQuoted(sb, DELIMITER, measurings.type);
        appendEscapedAndQuoted(sb, DELIMITER, uri);
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(responseTimes.length));
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(measurings.errorCount));
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(Doubles.min(responseTimes)));
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(percentile.evaluate(10d)));
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(percentile.evaluate(50d)));
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(percentile.evaluate(90d)));
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(Doubles.max(responseTimes)));
        writeLineToChannel(quantilesChannel, sb.toString(), Charsets.UTF_8);

        // write response time distributions
        WritableByteChannel distributionChannel = channelManager.getChannel("distribution_" + mappingKey);
        writeDistributionHeader(distributionChannel);

        for (Entry<Long, MutableInt> e : measurings.responseDistributions.entrySet()) {
            sb = new StrBuilder();
            appendEscapedAndQuoted(sb, DELIMITER, e.getKey());
            appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(e.getValue()));
            writeLineToChannel(distributionChannel, sb.toString(), Charsets.UTF_8);
        }
    }

    writeExecutionAggregatedResponseTimesHeader(channelManager.getChannel("aggregatedResponseTimes"));
    if (!perExecutionResponseTimes.isEmpty()) {
        BinManager executionsPerMinuteBinManager = new BinManager(startOfFirstBin,
                PerfAlyzerConstants.BIN_SIZE_MILLIS_1_MINUTE);
        BinManager executionsPerTenMinutesBinManager = new BinManager(startOfFirstBin,
                PerfAlyzerConstants.BIN_SIZE_MILLIS_10_MINUTES);
        BinManager medianExecutionBinManager = new BinManager(startOfFirstBin,
                PerfAlyzerConstants.BIN_SIZE_MILLIS_30_SECONDS);

        List<ExecutionMeasurings> values = newArrayList(perExecutionResponseTimes.values());

        for (ExecutionMeasurings execMeasurings : values) {
            long timestampMillis = execMeasurings.timestampMillis;
            executionsPerMinuteBinManager.addValue(timestampMillis);
            executionsPerTenMinutesBinManager.addValue(timestampMillis);
            medianExecutionBinManager.addValue(timestampMillis,
                    execMeasurings.sumResponseTimes.doubleValue() / 1000);
        }

        executionsPerMinuteBinManager.toCsv(channelManager.getChannel("execMin"), "time", "count",
                intNumberFormat);
        executionsPerTenMinutesBinManager.toCsv(channelManager.getChannel("exec10Min"), "time", "count",
                intNumberFormat);
        medianExecutionBinManager.toCsv(channelManager.getChannel("executions"), "time", "median",
                intNumberFormat, AggregationType.MEDIAN);

        double[] sumResponseTimes = values.stream().mapToDouble(input -> input.sumResponseTimes.doubleValue())
                .toArray();

        StrBuilder sb = new StrBuilder(150);
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(Doubles.min(sumResponseTimes) / 1000));
        appendEscapedAndQuoted(sb, DELIMITER,
                intNumberFormat.format(StatUtils.percentile(sumResponseTimes, 50d) / 1000));
        appendEscapedAndQuoted(sb, DELIMITER, intNumberFormat.format(Doubles.max(sumResponseTimes) / 1000));
        writeLineToChannel(channelManager.getChannel("aggregatedResponseTimes"), sb.toString(), Charsets.UTF_8);
    }
}

From source file:ch.unil.genescore.pathway.GeneSetLibrary.java

License:asdf

public void computeApproxChi2Values() {

    Percentile perc = new Percentile();
    EffTestCalculator effCalc = new EffTestCalculator();
    effCalc.addGeneIds(genes_);/*from   w  w  w  .j  av  a 2  s.c om*/
    effCalc.addMetaGeneIds(metaGenes_);
    effCalc.setGeneSets(geneSets_);
    effCalc.initializeGeneVals();

    int nrOfLoops = 10000;
    double[] mins = new double[nrOfLoops];
    for (int i = 0; i < nrOfLoops; i++) {
        mins[i] = effCalc.calcMinVal();
    }
    perc.setData(mins);
    double p1 = perc.evaluate(1);
    double p5 = perc.evaluate(5);
    double p10 = perc.evaluate(10);
    double p15 = perc.evaluate(15);
    //double w1 = perc.evaluate(1.0/50);
    System.out.println(p1);
    System.out.println(p5);
    System.out.println(p10);
    System.out.println(p15);
    System.out.println("asdf");

}

From source file:org.apache.mahout.classifier.df.split.OptIgSplit.java

/**
 * @return an array of values to split the numeric feature's values on when
 *  building candidate splits. When input size is <= MAX_NUMERIC_SPLITS + 1, it will
 *  return the averages between success values as split points. When larger, it will
 *  return MAX_NUMERIC_SPLITS approximate percentiles through the data.
 *//*from   w w  w. j  av a 2  s  . com*/
private static double[] chooseNumericSplitPoints(double[] values) {
    if (values.length <= 1) {
        return values;
    }
    if (values.length <= MAX_NUMERIC_SPLITS + 1) {
        double[] splitPoints = new double[values.length - 1];
        for (int i = 1; i < values.length; i++) {
            splitPoints[i - 1] = (values[i] + values[i - 1]) / 2.0;
        }
        return splitPoints;
    }
    Percentile distribution = new Percentile();
    distribution.setData(values);
    double[] percentiles = new double[MAX_NUMERIC_SPLITS];
    for (int i = 0; i < percentiles.length; i++) {
        double p = 100.0 * ((i + 1.0) / (MAX_NUMERIC_SPLITS + 1.0));
        percentiles[i] = distribution.evaluate(p);
    }
    return percentiles;
}

From source file:org.apache.solr.client.solrj.io.eval.PercentileEvaluator.java

@Override
public Object doWork(Object first, Object second) throws IOException {
    if (null == first) {
        throw new IOException(String.format(Locale.ROOT,
                "Invalid expression %s - null found for the first value", toExpression(constructingFactory)));
    }// ww  w  .  j a v a  2  s . c o m
    if (null == second) {
        throw new IOException(String.format(Locale.ROOT,
                "Invalid expression %s - null found for the second value", toExpression(constructingFactory)));
    }
    if (!(first instanceof List<?>)) {
        throw new IOException(String.format(Locale.ROOT,
                "Invalid expression %s - found type %s for the first value, expecting a List",
                toExpression(constructingFactory), first.getClass().getSimpleName()));
    }
    if (!(second instanceof Number)) {
        throw new IOException(String.format(Locale.ROOT,
                "Invalid expression %s - found type %s for the second value, expecting a Number",
                toExpression(constructingFactory), first.getClass().getSimpleName()));
    }

    Percentile percentile = new Percentile();
    percentile
            .setData(((List<?>) first).stream().mapToDouble(value -> ((Number) value).doubleValue()).toArray());
    return percentile.evaluate(((Number) second).doubleValue());
}

From source file:org.drugis.mtc.summary.QuantileSummary.java

private double calculateQuantile(int i, Percentile q) {
    double p = getProbability(i);
    return q.evaluate(p * 100);
}

From source file:org.hawkular.metrics.core.impl.cassandra.GaugeBucketedOutputMapper.java

@Override
protected GaugeBucketDataPoint newPointInstance(long from, long to, List<GaugeData> gaugeDatas) {
    double[] values = new double[gaugeDatas.size()];
    for (ListIterator<GaugeData> iterator = gaugeDatas.listIterator(); iterator.hasNext();) {
        GaugeData gaugeData = iterator.next();
        values[iterator.previousIndex()] = gaugeData.getValue();
    }//from  w w  w.  j  a  va  2s  .c  o m

    Percentile percentile = new Percentile();
    percentile.setData(values);

    return new GaugeBucketDataPoint.Builder(from, to).setMin(new Min().evaluate(values))
            .setAvg(new Mean().evaluate(values)).setMedian(percentile.evaluate(50.0))
            .setMax(new Max().evaluate(values)).setPercentile95th(percentile.evaluate(95.0)).build();
}

From source file:org.hawkular.metrics.core.impl.cassandra.NumericBucketedOutputMapper.java

@Override
protected NumericBucketDataPoint newPointInstance(long from, long to, List<NumericData> numericDatas) {
    double[] values = new double[numericDatas.size()];
    for (ListIterator<NumericData> iterator = numericDatas.listIterator(); iterator.hasNext();) {
        NumericData numericData = iterator.next();
        values[iterator.previousIndex()] = numericData.getValue();
    }/*from w w w .ja va  2s . co m*/

    Percentile percentile = new Percentile();
    percentile.setData(values);

    return new NumericBucketDataPoint.Builder(from, to).setMin(new Min().evaluate(values))
            .setAvg(new Mean().evaluate(values)).setMedian(percentile.evaluate(50.0))
            .setMax(new Max().evaluate(values)).setPercentile95th(percentile.evaluate(95.0)).build();
}

From source file:org.hawkular.metrics.core.impl.GaugeBucketedOutputMapper.java

@Override
protected GaugeBucketDataPoint newPointInstance(long from, long to, List<DataPoint<Double>> dataPoints) {
    double[] values = new double[dataPoints.size()];
    for (ListIterator<DataPoint<Double>> iterator = dataPoints.listIterator(); iterator.hasNext();) {
        DataPoint<Double> gaugeData = iterator.next();
        values[iterator.previousIndex()] = gaugeData.getValue();
    }/*w  w w  . j  av a 2 s . com*/

    Percentile percentile = new Percentile();
    percentile.setData(values);

    return new GaugeBucketDataPoint.Builder(from, to).setMin(new Min().evaluate(values))
            .setAvg(new Mean().evaluate(values)).setMedian(percentile.evaluate(50.0))
            .setMax(new Max().evaluate(values)).setPercentile95th(percentile.evaluate(95.0)).build();
}

From source file:org.jpmml.evaluator.DoubleVector.java

public double percentile(int percentile) {

    if (this.values == null) {
        throw new IllegalStateException();
    }//from ww  w .  j  av a  2  s. c  o m

    double[] data = new double[this.size];

    System.arraycopy(this.values, 0, data, 0, data.length);

    Arrays.sort(data);

    Percentile statistic = new Percentile();
    statistic.setData(data);

    return statistic.evaluate(percentile);
}

From source file:org.jpmml.evaluator.functions.PercentileFunction.java

static private Double evaluate(Collection<?> values, int quantile) {
    List<Double> doubleValues = Lists.newArrayList();

    for (Object value : values) {
        Double doubleValue = (Double) TypeUtil.parseOrCast(DataType.DOUBLE, value);

        doubleValues.add(doubleValue);//from  w  w w  .j a v a2 s  .com
    }

    double[] data = Doubles.toArray(doubleValues);

    // The data must be (at least partially) ordered
    Arrays.sort(data);

    Percentile percentile = new Percentile();
    percentile.setData(data);

    return percentile.evaluate(quantile);
}