Java EmpiricalDistribution类代码示例

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
/**
 * Calculate the frequencies of each interval of a column.
 *
 * @param column Column of which the frequencies are to be calculated.
 * @param intervals Number of intervals to be split.
 */
protected List<SortedMap<?, Integer>> calculateIntervalFreqs(int column, int intervals) {
    SortedMap<Integer, Integer> frequencies = new TreeMap<Integer, Integer>();
    double[] data = new double[this.columnData.get(column).size()];
    // Create an array from the column data.
    for (int row = 0; row < columnData.get(column).size(); row++) {
        if (this.columnData.get(column).get(row) != null &&
                !MLConstants.MISSING_VALUES.contains(this.columnData.get(column).get(row))) {
            data[row] = Double.parseDouble(this.columnData.get(column).get(row));
        }
    }
    // Create equal partitions.
    this.histogram[column] = new EmpiricalDistribution(intervals);
    this.histogram[column].load(data);

    // Get the frequency of each partition.
    int bin = 0;
    for (SummaryStatistics stats : this.histogram[column].getBinStats()) {
        frequencies.put(bin++, (int) stats.getN());
    }
    this.graphFrequencies.set(column, frequencies);

    return graphFrequencies;
}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
private void printTaskHistogram(ArrayList<DTask> tasks) {

        double[] data = new double[tasks.size()];
        for (int i=0; i<tasks.size(); i++) {
            data[i] = tasks.get(i).getTime();
        }

        EmpiricalDistribution d = new EmpiricalDistribution(30);
        d.load(data);

        for (SummaryStatistics stats : d.getBinStats()) {
            StringBuilder buf = new StringBuilder();
            for (int i=0, len=Math.round(stats.getN()/50f); i<len; i++) {
                buf.append('#');
            }
            System.err.println(buf);
        }
    }
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
public static AbstractRealDistribution createDayMockDistribution(final int seed) {
    final EmpiricalDistribution dayDistributionMock = new EmpiricalDistribution(new Well19937c(seed));

    int[] demandsOverDay = new int[]{/* 0 */9,/* 1 */6,/* 2 */6,
    /* 3 */6,/* 4 */7,/* 5 */12,/* 6 */25,/* 7 */37,/* 8 */49,
    /* 9 */38,/* 10 */30,/* 11 */30,/* 12 */30,/* 13 */30,/* 14 */31,
    /* 15 */36,/* 16 */45,/* 17 */41,/* 18 */31,/* 19 */27,/* 20 */25,/* 21 */22,/* 22 */18,/* 23 */11};

    List<Double> dayHourDistribution = Lists.newArrayList();

    int day = 0;
    for (int demand : demandsOverDay) {
        double hourInMillis = Duration.standardHours(day).getMillis();
        for (int i = 0; i < demand; i++) {
            dayHourDistribution.add(hourInMillis);
        }
        day++;
    }

    dayDistributionMock.load(Doubles.toArray(dayHourDistribution));

    return dayDistributionMock;

}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
private Histogram(HistogramBuilder histogramBuilder){
    this.data = histogramBuilder.data;
    this.width = histogramBuilder.width;
    this.bins = histogramBuilder.bins;

    // Create a distribution of data for bins number of bins
    dist = new EmpiricalDistribution(bins);
    dist.load(data.getSecond());
}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
/** Create empirical distribution from given samples.
 * 
 * @param samples Samples (does not need to be distinct) to use.
 * @return Empirical distribution built from the samples.
 */
public static EmpiricalDistribution makeEmpirical(double[] samples) {
	/* Be deterministic for now. */
	RandomGenerator gen = new JDKRandomGenerator();
	gen.setSeed(0);
	
	EmpiricalDistribution result = new EmpiricalDistribution(samples.length / 10 + 1, gen);
	result.load(samples);
	
	return result;
}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
private EmpiricalDistribution getDistribution(final Collection<Long> listValues) {
	double[] values = new double[listValues.size()];
	int j = 0;
	for (Long measurements : listValues) {
		values[j] = measurements.doubleValue();
		j++;
	}
	EmpiricalDistribution distribution = new EmpiricalDistribution(listValues.size() > 20 ? listValues.size() / 20 : 1);
	distribution.load(values);
	return distribution;
}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
public static AbstractRealDistribution createDayMockDistribution(final int seed) {
    int intermediateStepsCount = 60;
    final EmpiricalDistribution dayDistributionMock = new EmpiricalDistribution(24 * intermediateStepsCount, new Well19937c(seed));

    int[] demandsOverDay = new int[]{/* 0 */9,/* 1 */6,/* 2 */6,
    /* 3 */6,/* 4 */7,/* 5 */12,/* 6 */25,/* 7 */37,/* 8 */49,
    /* 9 */38,/* 10 */30,/* 11 */30,/* 12 */30,/* 13 */30,/* 14 */31,
    /* 15 */36,/* 16 */45,/* 17 */41,/* 18 */31,/* 19 */27,/* 20 */25,/* 21 */22,/* 22 */18,/* 23 */11};


    List<Double> dayHourDistribution = Lists.newArrayList();

    int hour = 0;
    for (int i = 0; i < demandsOverDay.length - 1; ++i) {

        double startHourInMillis = Duration.standardHours(hour).getMillis();
        double endHourInMillis = Duration.standardHours(hour + 1).getMillis();

        double demandsStep = ((double) (demandsOverDay[hour] -
                demandsOverDay[(hour + 1) % 24])) / intermediateStepsCount;
        double timeStep = (endHourInMillis - startHourInMillis) / intermediateStepsCount;

        for (int j = 0; j < intermediateStepsCount; ++j) {
            int demands = (int) (demandsOverDay[i] + demandsStep * j);
            for (int k = 0; k < demands; ++k)
                dayHourDistribution.add(startHourInMillis + j * timeStep);
        }

        hour++;
    }

    dayDistributionMock.load(Doubles.toArray(dayHourDistribution));

    return dayDistributionMock;

}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
public static BinnedData doBins(IDocument<?> o)
{
  // collate the values into an array
  double[] data = new double[o.size()];
  
  // Add the data from the array
  Iterator<Double> oIter = o.getIndexIterator();
  int ctr = 0;
  while(oIter.hasNext())
  {
    data[ctr++] = oIter.next();
  }
  
  // Get a DescriptiveStatistics instance
  DescriptiveStatistics stats = new DescriptiveStatistics(data);

  // also do some frequency binning
  double range = stats.getMax() - stats.getMin();

  // aah, double-check we don't have zero range
  final int binCount;
  final int maxRange = 30;
  if (range > maxRange)
  {
    binCount = maxRange;
  }
  else
  {
    binCount = (int) Math.max(2, range);
  }

  BinnedData res = new BinnedData();

  if (range > THRESHOLD_VALUE)
  {

    long[] histogram = new long[binCount];
    EmpiricalDistribution distribution = new EmpiricalDistribution(binCount);
    distribution.load(data);

    int k = 0;
    for (SummaryStatistics sStats : distribution.getBinStats())
    {
      histogram[k++] = sStats.getN();
    }

    long rangeSoFar = (long) stats.getMin();
    long rangeStep = (long) (range / binCount);
    for (int i = 0; i < histogram.length; i++)
    {
      long l = histogram[i];
      res.add(new Bin(rangeSoFar, rangeSoFar + rangeStep, l));
      rangeSoFar += rangeStep;
    }
  }
  return res;
}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
public static BinnedData binTheseValues(double[] data)
{
  // Get a DescriptiveStatistics instance
  DescriptiveStatistics stats = new DescriptiveStatistics(data);

  // also do some frequency binning
  double range = stats.getMax() - stats.getMin();

  // aah, double-check we don't have zero range
  final int binCount;
  if (range > DEFAULT_NUM_BINS)
  {
    binCount = DEFAULT_NUM_BINS;
  }
  else if(range > MIN_NUM_BINS)
  {
    binCount = (int) range;
  }
  else 
  {
    binCount = MIN_NUM_BINS;
  }

  BinnedData res = new BinnedData();

  if (range > THRESHOLD_VALUE)
  {

    long[] histogram = new long[binCount];
    EmpiricalDistribution distribution = new EmpiricalDistribution(binCount);
    distribution.load(data);

    int k = 0;
    for (SummaryStatistics sStats : distribution.getBinStats())
    {
      histogram[k++] = sStats.getN();
    }

    double rangeSoFar = stats.getMin();
    double rangeStep = range / binCount;
    for (int i = 0; i < histogram.length; i++)
    {
      long l = histogram[i];
      res.add(new Bin(rangeSoFar, rangeSoFar + rangeStep, l));
      rangeSoFar += rangeStep;
    }
  }
  return res;
}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
/**
 * Runs the main execution of the test, i.e.useKieker the execution where performance measures are counted.
 * 
 * @param testCase Runnable that should be run
 * @param name Name of the test
 * @param tr Where the results should be saved
 * @param executionTimes How often the test should be executed
 * @throws Throwable
 */
private void runMainExecution(final String name, final TestResult tr, final int executionTimes) throws Throwable {
	int executions;
	String firstPart = "--- Starting execution " + name + " ";
	String endPart = "/" + executionTimes + " ---";
	for (executions = 1; executions <= executionTimes; executions++) {
		LOG.debug(firstPart + executions + endPart);
		setUp();
		tr.startCollection();
		KoPeMeStaticRigorTestcase.super.runTest();
		tr.stopCollection();
		tearDown();
		tr.getValue(TimeDataCollector.class.getName());
		tr.setRealExecutions(executions);
		LOG.debug("--- Stopping execution " + executions + endPart);
		if (Thread.interrupted()) {
			return;
		} else {
			LOG.trace("Nicht interrupted!");
		}
	}
	LOG.debug("Executions: " + (executions - 1));
	tr.setRealExecutions(executions - 1);
	for (String collector : tr.getKeys()) {
		List<Long> values = new ArrayList<>(tr.getValues(collector).values());
		EmpiricalDistribution distribution = getDistribution(values);
		Set<Long> outliers = new HashSet<>();
		for (long measurement : values) {
			try {
				double cdfValue = distribution.cumulativeProbability(measurement);
				final boolean isOutlier = cdfValue > CDF_BOUNDARY;
				if (isOutlier) {
					outliers.add(measurement);
				}
			} catch (NotStrictlyPositiveException ne) {
				LOG.debug("Harter Ausreißer: " + measurement);
			}

		}
		for (long outlier : outliers) {
			values.remove(outlier);
		}
		tr.setValues(collector, values);
	}
}
 

import org.apache.commons.math3.random.EmpiricalDistribution; //导入依赖的package包/类
public Statistics(List<Integer> list) {
	scores = intsToDoubles(list);
	DescriptiveStatistics dStats = new DescriptiveStatistics(scores);

	summaryStatistics.put("min", dStats.getMin()); // Minimum
	summaryStatistics.put("q1", dStats.getPercentile(25)); // Lower Quartile (Q1)
	summaryStatistics.put("q2", dStats.getPercentile(50)); // Middle Quartile (Median - Q2)
	summaryStatistics.put("q3", dStats.getPercentile(75)); // High Quartile (Q3)
	summaryStatistics.put("max", dStats.getMax()); // Maxiumum

	summaryStatistics.put("mean", dStats.getMean()); // Mean
	summaryStatistics.put("sd", dStats.getStandardDeviation()); // Standard Deviation

	EmpiricalDistribution distribution = new EmpiricalDistribution(NUM_BINS);
	distribution.load(scores);
	List<SummaryStatistics> binStats = distribution.getBinStats();
	double[] upperBounds = distribution.getUpperBounds();

	Double lastUpperBound = upperBounds[0];
	bins.add(new Pair<Pair<Double, Double>, Long>(new Pair<Double, Double>(summaryStatistics.get("min"), lastUpperBound), binStats.get(0).getN()));
	for (int i = 1; i < binStats.size(); i++) {
		bins.add(new Pair<Pair<Double, Double>, Long>(new Pair<Double, Double>(lastUpperBound, upperBounds[i]), binStats.get(i).getN()));
		lastUpperBound = upperBounds[i];
	}

	if (list.size() > 5 && dStats.getStandardDeviation() > 0) // Only remove outliers if relatively normal
	{
		double mean = dStats.getMean();
		double stDev = dStats.getStandardDeviation();
		NormalDistribution normalDistribution = new NormalDistribution(mean, stDev);

		Iterator<Integer> listIterator = list.iterator();
		double significanceLevel = .50 / list.size(); // Chauvenet's Criterion for Outliers
		while (listIterator.hasNext()) {
			int num = listIterator.next();
			double pValue = normalDistribution.cumulativeProbability(num);
			if (pValue < significanceLevel) {
				outliers.add(num);
				listIterator.remove();
			}
		}

		if (list.size() != dStats.getN()) // If and only if outliers have been removed
		{
			double[] significantData = intsToDoubles(list);
			dStats = new DescriptiveStatistics(significantData);

			summaryStatistics.put("min", dStats.getMin());
			summaryStatistics.put("max", dStats.getMax());
			summaryStatistics.put("mean", dStats.getMean());
			summaryStatistics.put("sd", dStats.getStandardDeviation());
		}
	}
}