@Override public Double summarize(NumericColumn<?> column) { return StatUtils.mean(removeMissing(column)); } };
/** * Computes a <a href="http://www.itl.nist.gov/div898/handbook/prc/section2/prc22.htm#formula"> * t statistic </a> given observed values and a comparison constant. * <p> * This statistic can be used to perform a one sample t-test for the mean. * </p><p> * <strong>Preconditions</strong>: <ul> * <li>The observed array length must be at least 2. * </li></ul></p> * * @param mu comparison constant * @param observed array of values * @return t statistic * @throws NullArgumentException if <code>observed</code> is <code>null</code> * @throws NumberIsTooSmallException if the length of <code>observed</code> is < 2 */ public double t(final double mu, final double[] observed) throws NullArgumentException, NumberIsTooSmallException { checkSampleData(observed); // No try-catch or advertised exception because args have just been checked return t(StatUtils.mean(observed), mu, StatUtils.variance(observed), observed.length); }
return tTest(StatUtils.mean(sample), mu, StatUtils.variance(sample), sample.length);
private void computeStats(int len) { average = StatUtils.mean(window, 0, len); variance = StatUtils.variance(window, average, 0, len); stddev = FastMath.sqrt(variance); recomputeCounter = 0; }
@Override public boolean isPrematureBreak(SearchStrategy.DiscoveredSolution discoveredSolution) { if (discoveredSolution.isAccepted()) { lastAccepted = discoveredSolution.getSolution(); solutionValues[currentIteration] = discoveredSolution.getSolution().getCost(); } else { if (lastAccepted != null) { solutionValues[currentIteration] = lastAccepted.getCost(); } else solutionValues[currentIteration] = Integer.MAX_VALUE; } if (currentIteration == (noIterations - 1)) { double mean = StatUtils.mean(solutionValues); double stdDev = new StandardDeviation(true).evaluate(solutionValues, mean); double variationCoefficient = stdDev / mean; if (variationCoefficient < variationCoefficientThreshold) { return true; } } return false; }
@Override public double reduce(double[] data) { return StatUtils.mean(data); } };
@Override public Double summarize(NumericColumn<?> column) { return StatUtils.mean(removeMissing(column)); } };
public static double avg(double[] population) { mean = StatUtils.mean(population); return mean; }
private double calcMean(final double stateValuesArray[]) { return StatUtils.mean(stateValuesArray); }
/** * Calculates the arithmetic mean. * * @param fittedData * If {@code true}, calculation is performed on polynomial fitted * values, otherwise from sampled data * * @return the mean of intersection counts */ public double getMean(final boolean fittedData) { if (fittedData) { validateFit(); return StatUtils.mean(fCounts); } return StatUtils.mean(inputCounts); }
public static double sharpe(double[] dailyReturns) { return StatUtils.mean(dailyReturns) / Math.sqrt(StatUtils.variance(dailyReturns)) * Math.sqrt(250); }
private void computeStats(int len) { average = StatUtils.mean(window, 0, len); variance = StatUtils.variance(window, average, 0, len); stddev = FastMath.sqrt(variance); recomputeCounter = 0; }
/** * 1-sample t-test confidence interval */ public double[] confidenceInterval(final double[] sample, final double alpha) { return confidenceInterval(StatUtils.mean(sample), StatUtils.variance(sample), sample.length, alpha); }
public static double[][] zScoreNormalize(double[][] inputTemp) { double[] input = new double[inputTemp.length]; for (int i = 0; i < inputTemp.length; i++) { input[i] = inputTemp[i][1]; } double mean = StatUtils.mean(input); double std = FastMath.sqrt(StatUtils.variance(input)); for(int i = 0; i < input.length; i++) { if (std == 0) inputTemp[i][1] = 0; else inputTemp[i][1] = (input[i] - mean) / std; } return inputTemp; }
public double[][] zScoreNormalize(double[][] inputTemp) { double[] input = new double[inputTemp.length]; for (int i = 0; i < inputTemp.length; i++) { input[i] = inputTemp[i][1]; } double mean = StatUtils.mean(input); double std = FastMath.sqrt(StatUtils.variance(input)); for(int i = 0; i < input.length; i++) { if (std == 0) inputTemp[i][1] = 0; else inputTemp[i][1] = (input[i] - mean) / std; } return inputTemp; }
@Override public boolean apply(@Nullable Scenario scenario) { final List<Double> loads = newArrayList(relative ? Metrics .measureRelativeLoad(scenario) : Metrics.measureLoad(scenario)); final int toAdd = desiredLoadList.size() - loads.size(); for (int j = 0; j < toAdd; j++) { loads.add(0d); } final double[] deviations = abs(subtract( Doubles.toArray(desiredLoadList), Doubles.toArray(loads))); final double mean = StatUtils.mean(deviations); final double max = Doubles.max(deviations); return max <= maxMax && mean <= maxMean; }