| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.commons.math4.legacy.stat; |
| |
| import java.util.List; |
| |
| import org.apache.commons.math4.legacy.exception.DimensionMismatchException; |
| import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException; |
| import org.apache.commons.math4.legacy.exception.NoDataException; |
| import org.apache.commons.math4.legacy.exception.NotPositiveException; |
| import org.apache.commons.math4.legacy.exception.NullArgumentException; |
| import org.apache.commons.math4.legacy.exception.NumberIsTooSmallException; |
| import org.apache.commons.math4.legacy.exception.util.LocalizedFormats; |
| import org.apache.commons.math4.legacy.stat.descriptive.DescriptiveStatistics; |
| import org.apache.commons.math4.legacy.stat.descriptive.UnivariateStatistic; |
| import org.apache.commons.math4.legacy.stat.descriptive.moment.GeometricMean; |
| import org.apache.commons.math4.legacy.stat.descriptive.moment.Mean; |
| import org.apache.commons.math4.legacy.stat.descriptive.moment.Variance; |
| import org.apache.commons.math4.legacy.stat.descriptive.rank.Max; |
| import org.apache.commons.math4.legacy.stat.descriptive.rank.Min; |
| import org.apache.commons.math4.legacy.stat.descriptive.rank.Percentile; |
| import org.apache.commons.math4.legacy.stat.descriptive.summary.Product; |
| import org.apache.commons.math4.legacy.stat.descriptive.summary.Sum; |
| import org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfLogs; |
| import org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfSquares; |
| |
| /** |
| * StatUtils provides static methods for computing statistics based on data |
| * stored in double[] arrays. |
| */ |
| public final class StatUtils { |
| |
| /** sum. */ |
| private static final UnivariateStatistic SUM = new Sum(); |
| |
| /** sumSq. */ |
| private static final UnivariateStatistic SUM_OF_SQUARES = new SumOfSquares(); |
| |
| /** prod. */ |
| private static final UnivariateStatistic PRODUCT = new Product(); |
| |
| /** sumLog. */ |
| private static final UnivariateStatistic SUM_OF_LOGS = new SumOfLogs(); |
| |
| /** min. */ |
| private static final UnivariateStatistic MIN = new Min(); |
| |
| /** max. */ |
| private static final UnivariateStatistic MAX = new Max(); |
| |
| /** mean. */ |
| private static final UnivariateStatistic MEAN = new Mean(); |
| |
| /** variance. */ |
| private static final Variance VARIANCE = new Variance(); |
| |
| /** percentile. */ |
| private static final Percentile PERCENTILE = new Percentile(); |
| |
| /** geometric mean. */ |
| private static final GeometricMean GEOMETRIC_MEAN = new GeometricMean(); |
| |
| /** |
| * Private Constructor. |
| */ |
| private StatUtils() { |
| } |
| |
| /** |
| * Returns the sum of the values in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the input array is null. |
| * |
| * @param values array of values to sum |
| * @return the sum of the values or <code>Double.NaN</code> if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double sum(final double[] values) throws MathIllegalArgumentException { |
| return SUM.evaluate(values); |
| } |
| |
| /** |
| * Returns the sum of the entries in the specified portion of |
| * the input array, or <code>Double.NaN</code> if the designated subarray is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the sum of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double sum(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return SUM.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the sum of the squares of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * |
| * @param values input array |
| * @return the sum of the squared values or <code>Double.NaN</code> if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double sumSq(final double[] values) throws MathIllegalArgumentException { |
| return SUM_OF_SQUARES.evaluate(values); |
| } |
| |
| /** |
| * Returns the sum of the squares of the entries in the specified portion of |
| * the input array, or <code>Double.NaN</code> if the designated subarray |
| * is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the sum of the squares of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double sumSq(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return SUM_OF_SQUARES.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the product of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * |
| * @param values the input array |
| * @return the product of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double product(final double[] values) throws MathIllegalArgumentException { |
| return PRODUCT.evaluate(values); |
| } |
| |
| /** |
| * Returns the product of the entries in the specified portion of |
| * the input array, or <code>Double.NaN</code> if the designated subarray |
| * is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the product of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double product(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return PRODUCT.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the sum of the natural logs of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfLogs}. |
| * |
| * @param values the input array |
| * @return the sum of the natural logs of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double sumLog(final double[] values) throws MathIllegalArgumentException { |
| return SUM_OF_LOGS.evaluate(values); |
| } |
| |
| /** |
| * Returns the sum of the natural logs of the entries in the specified portion of |
| * the input array, or <code>Double.NaN</code> if the designated subarray is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.summary.SumOfLogs}. |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the sum of the natural logs of the values or Double.NaN if |
| * length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double sumLog(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return SUM_OF_LOGS.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the arithmetic mean of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Mean} for |
| * details on the computing algorithm. |
| * |
| * @param values the input array |
| * @return the mean of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double mean(final double[] values) throws MathIllegalArgumentException { |
| return MEAN.evaluate(values); |
| } |
| |
| /** |
| * Returns the arithmetic mean of the entries in the specified portion of |
| * the input array, or <code>Double.NaN</code> if the designated subarray |
| * is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Mean Mean} for |
| * details on the computing algorithm. |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the mean of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double mean(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return MEAN.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the geometric mean of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.GeometricMean GeometricMean} |
| * for details on the computing algorithm. |
| * |
| * @param values the input array |
| * @return the geometric mean of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double geometricMean(final double[] values) throws MathIllegalArgumentException { |
| return GEOMETRIC_MEAN.evaluate(values); |
| } |
| |
| /** |
| * Returns the geometric mean of the entries in the specified portion of |
| * the input array, or <code>Double.NaN</code> if the designated subarray |
| * is empty. |
| * <p> |
| * Throws <code>IllegalArgumentException</code> if the array is null. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.GeometricMean GeometricMean} |
| * for details on the computing algorithm. |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the geometric mean of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double geometricMean(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return GEOMETRIC_MEAN.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the variance of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * This method returns the bias-corrected sample variance (using {@code n - 1} in |
| * the denominator). Use {@link #populationVariance(double[])} for the non-bias-corrected |
| * population variance. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Variance Variance} for |
| * details on the computing algorithm. |
| * <p> |
| * Returns 0 for a single-value (i.e. length = 1) sample. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null. |
| * |
| * @param values the input array |
| * @return the variance of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double variance(final double[] values) throws MathIllegalArgumentException { |
| return VARIANCE.evaluate(values); |
| } |
| |
| /** |
| * Returns the variance of the entries in the specified portion of |
| * the input array, or <code>Double.NaN</code> if the designated subarray |
| * is empty. |
| * <p> |
| * This method returns the bias-corrected sample variance (using {@code n - 1} in |
| * the denominator). Use {@link #populationVariance(double[], int, int)} for the non-bias-corrected |
| * population variance. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Variance Variance} for |
| * details on the computing algorithm. |
| * <p> |
| * Returns 0 for a single-value (i.e. length = 1) sample. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null or the |
| * array index parameters are not valid. |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the variance of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double variance(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return VARIANCE.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the variance of the entries in the specified portion of |
| * the input array, using the precomputed mean value. Returns |
| * <code>Double.NaN</code> if the designated subarray is empty. |
| * <p> |
| * This method returns the bias-corrected sample variance (using {@code n - 1} in |
| * the denominator). Use {@link #populationVariance(double[], double, int, int)} for |
| * the non-bias-corrected population variance. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Variance Variance} for |
| * details on the computing algorithm. |
| * <p> |
| * The formula used assumes that the supplied mean value is the arithmetic |
| * mean of the sample data, not a known population parameter. This method |
| * is supplied only to save computation when the mean has already been |
| * computed. |
| * <p> |
| * Returns 0 for a single-value (i.e. length = 1) sample. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null or the |
| * array index parameters are not valid. |
| * |
| * @param values the input array |
| * @param mean the precomputed mean value |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the variance of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double variance(final double[] values, final double mean, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return VARIANCE.evaluate(values, mean, begin, length); |
| } |
| |
| /** |
| * Returns the variance of the entries in the input array, using the |
| * precomputed mean value. Returns <code>Double.NaN</code> if the array |
| * is empty. |
| * <p> |
| * This method returns the bias-corrected sample variance (using {@code n - 1} in |
| * the denominator). Use {@link #populationVariance(double[], double)} for the |
| * non-bias-corrected population variance. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Variance Variance} for |
| * details on the computing algorithm. |
| * <p> |
| * The formula used assumes that the supplied mean value is the arithmetic |
| * mean of the sample data, not a known population parameter. This method |
| * is supplied only to save computation when the mean has already been |
| * computed. |
| * <p> |
| * Returns 0 for a single-value (i.e. length = 1) sample. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null. |
| * |
| * @param values the input array |
| * @param mean the precomputed mean value |
| * @return the variance of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double variance(final double[] values, final double mean) throws MathIllegalArgumentException { |
| return VARIANCE.evaluate(values, mean); |
| } |
| |
| /** |
| * Returns the <a href="http://en.wikibooks.org/wiki/Statistics/Summary/Variance"> |
| * population variance</a> of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Variance Variance} for |
| * details on the formula and computing algorithm. |
| * <p> |
| * Returns 0 for a single-value (i.e. length = 1) sample. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null. |
| * |
| * @param values the input array |
| * @return the population variance of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double populationVariance(final double[] values) throws MathIllegalArgumentException { |
| return new Variance(false).evaluate(values); |
| } |
| |
| /** |
| * Returns the <a href="http://en.wikibooks.org/wiki/Statistics/Summary/Variance"> |
| * population variance</a> of the entries in the specified portion of |
| * the input array, or <code>Double.NaN</code> if the designated subarray |
| * is empty. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Variance Variance} for |
| * details on the computing algorithm. |
| * <p> |
| * Returns 0 for a single-value (i.e. length = 1) sample. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null or the |
| * array index parameters are not valid. |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the population variance of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double populationVariance(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return new Variance(false).evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the <a href="http://en.wikibooks.org/wiki/Statistics/Summary/Variance"> |
| * population variance</a> of the entries in the specified portion of |
| * the input array, using the precomputed mean value. Returns |
| * <code>Double.NaN</code> if the designated subarray is empty. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Variance Variance} for |
| * details on the computing algorithm. |
| * <p> |
| * The formula used assumes that the supplied mean value is the arithmetic |
| * mean of the sample data, not a known population parameter. This method |
| * is supplied only to save computation when the mean has already been |
| * computed. |
| * <p> |
| * Returns 0 for a single-value (i.e. length = 1) sample. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null or the |
| * array index parameters are not valid. |
| * |
| * @param values the input array |
| * @param mean the precomputed mean value |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the population variance of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double populationVariance(final double[] values, final double mean, |
| final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return new Variance(false).evaluate(values, mean, begin, length); |
| } |
| |
| /** |
| * Returns the <a href="http://en.wikibooks.org/wiki/Statistics/Summary/Variance"> |
| * population variance</a> of the entries in the input array, using the precomputed |
| * mean value. Returns <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.moment.Variance Variance} for |
| * details on the computing algorithm. |
| * <p> |
| * The formula used assumes that the supplied mean value is the arithmetic |
| * mean of the sample data, not a known population parameter. This method is |
| * supplied only to save computation when the mean has already been computed. |
| * <p> |
| * Returns 0 for a single-value (i.e. length = 1) sample. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null. |
| * |
| * @param values the input array |
| * @param mean the precomputed mean value |
| * @return the population variance of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double populationVariance(final double[] values, final double mean) |
| throws MathIllegalArgumentException { |
| return new Variance(false).evaluate(values, mean); |
| } |
| |
| /** |
| * Returns the maximum of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null. |
| * <ul> |
| * <li>The result is <code>NaN</code> iff all values are <code>NaN</code> |
| * (i.e. <code>NaN</code> values have no impact on the value of the statistic).</li> |
| * <li>If any of the values equals <code>Double.POSITIVE_INFINITY</code>, |
| * the result is <code>Double.POSITIVE_INFINITY.</code></li> |
| * </ul> |
| * |
| * @param values the input array |
| * @return the maximum of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double max(final double[] values) throws MathIllegalArgumentException { |
| return MAX.evaluate(values); |
| } |
| |
| /** |
| * Returns the maximum of the entries in the specified portion of the input array, |
| * or <code>Double.NaN</code> if the designated subarray is empty. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null or |
| * the array index parameters are not valid. |
| * <ul> |
| * <li>The result is <code>NaN</code> iff all values are <code>NaN</code> |
| * (i.e. <code>NaN</code> values have no impact on the value of the statistic).</li> |
| * <li>If any of the values equals <code>Double.POSITIVE_INFINITY</code>, |
| * the result is <code>Double.POSITIVE_INFINITY.</code></li> |
| * </ul> |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the maximum of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double max(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return MAX.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns the minimum of the entries in the input array, or |
| * <code>Double.NaN</code> if the array is empty. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null. |
| * <ul> |
| * <li>The result is <code>NaN</code> iff all values are <code>NaN</code> |
| * (i.e. <code>NaN</code> values have no impact on the value of the statistic).</li> |
| * <li>If any of the values equals <code>Double.NEGATIVE_INFINITY</code>, |
| * the result is <code>Double.NEGATIVE_INFINITY.</code></li> |
| * </ul> |
| * |
| * @param values the input array |
| * @return the minimum of the values or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if the array is null |
| */ |
| public static double min(final double[] values) throws MathIllegalArgumentException { |
| return MIN.evaluate(values); |
| } |
| |
| /** |
| * Returns the minimum of the entries in the specified portion of the input array, |
| * or <code>Double.NaN</code> if the designated subarray is empty. |
| * <p> |
| * Throws <code>MathIllegalArgumentException</code> if the array is null or |
| * the array index parameters are not valid. |
| * <ul> |
| * <li>The result is <code>NaN</code> iff all values are <code>NaN</code> |
| * (i.e. <code>NaN</code> values have no impact on the value of the statistic).</li> |
| * <li>If any of the values equals <code>Double.NEGATIVE_INFINITY</code>, |
| * the result is <code>Double.NEGATIVE_INFINITY.</code></li> |
| * </ul> |
| * |
| * @param values the input array |
| * @param begin index of the first array element to include |
| * @param length the number of elements to include |
| * @return the minimum of the values or Double.NaN if length = 0 |
| * @throws MathIllegalArgumentException if the array is null or the array index |
| * parameters are not valid |
| */ |
| public static double min(final double[] values, final int begin, final int length) |
| throws MathIllegalArgumentException { |
| return MIN.evaluate(values, begin, length); |
| } |
| |
| /** |
| * Returns an estimate of the <code>p</code>th percentile of the values |
| * in the <code>values</code> array. |
| * <ul> |
| * <li>Returns <code>Double.NaN</code> if <code>values</code> has length |
| * <code>0</code></li> |
| * <li>Returns (for any value of <code>p</code>) <code>values[0]</code> |
| * if <code>values</code> has length <code>1</code></li> |
| * <li>Throws <code>IllegalArgumentException</code> if <code>values</code> |
| * is null or p is not a valid quantile value (p must be greater than 0 |
| * and less than or equal to 100)</li> |
| * </ul> |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.rank.Percentile Percentile} |
| * for a description of the percentile estimation algorithm used. |
| * |
| * @param values input array of values |
| * @param p the percentile value to compute |
| * @return the percentile value or Double.NaN if the array is empty |
| * @throws MathIllegalArgumentException if <code>values</code> is null or p is invalid |
| */ |
| public static double percentile(final double[] values, final double p) throws MathIllegalArgumentException { |
| return PERCENTILE.evaluate(values,p); |
| } |
| |
| /** |
| * Returns an estimate of the <code>p</code>th percentile of the values |
| * in the <code>values</code> array, starting with the element in (0-based) |
| * position <code>begin</code> in the array and including <code>length</code> |
| * values. |
| * <ul> |
| * <li>Returns <code>Double.NaN</code> if <code>length = 0</code></li> |
| * <li>Returns (for any value of <code>p</code>) <code>values[begin]</code> |
| * if <code>length = 1 </code></li> |
| * <li>Throws <code>MathIllegalArgumentException</code> if <code>values</code> |
| * is null, <code>begin</code> or <code>length</code> is invalid, or |
| * <code>p</code> is not a valid quantile value (p must be greater than 0 |
| * and less than or equal to 100)</li> |
| * </ul> |
| * <p> |
| * See {@link org.apache.commons.math4.legacy.stat.descriptive.rank.Percentile Percentile} |
| * for a description of the percentile estimation algorithm used. |
| * |
| * @param values array of input values |
| * @param p the percentile to compute |
| * @param begin the first (0-based) element to include in the computation |
| * @param length the number of array elements to include |
| * @return the percentile value |
| * @throws MathIllegalArgumentException if the parameters are not valid or the input array is null |
| */ |
| public static double percentile(final double[] values, final int begin, final int length, final double p) |
| throws MathIllegalArgumentException { |
| return PERCENTILE.evaluate(values, begin, length, p); |
| } |
| |
| /** |
| * Returns the sum of the (signed) differences between corresponding elements of the |
| * input arrays -- i.e., sum(sample1[i] - sample2[i]). |
| * |
| * @param sample1 the first array |
| * @param sample2 the second array |
| * @return sum of paired differences |
| * @throws DimensionMismatchException if the arrays do not have the same (positive) length. |
| * @throws NoDataException if the sample arrays are empty. |
| */ |
| public static double sumDifference(final double[] sample1, final double[] sample2) |
| throws DimensionMismatchException, NoDataException { |
| |
| int n = sample1.length; |
| if (n != sample2.length) { |
| throw new DimensionMismatchException(n, sample2.length); |
| } |
| if (n <= 0) { |
| throw new NoDataException(LocalizedFormats.INSUFFICIENT_DIMENSION); |
| } |
| double result = 0; |
| for (int i = 0; i < n; i++) { |
| result += sample1[i] - sample2[i]; |
| } |
| return result; |
| } |
| |
| /** |
| * Returns the mean of the (signed) differences between corresponding elements of the |
| * input arrays -- i.e., sum(sample1[i] - sample2[i]) / sample1.length. |
| * |
| * @param sample1 the first array |
| * @param sample2 the second array |
| * @return mean of paired differences |
| * @throws DimensionMismatchException if the arrays do not have the same (positive) length. |
| * @throws NoDataException if the sample arrays are empty. |
| */ |
| public static double meanDifference(final double[] sample1, final double[] sample2) |
| throws DimensionMismatchException, NoDataException { |
| return sumDifference(sample1, sample2) / sample1.length; |
| } |
| |
| /** |
| * Returns the variance of the (signed) differences between corresponding elements of the |
| * input arrays -- i.e., var(sample1[i] - sample2[i]). |
| * |
| * @param sample1 the first array |
| * @param sample2 the second array |
| * @param meanDifference the mean difference between corresponding entries |
| * @return variance of paired differences |
| * @throws DimensionMismatchException if the arrays do not have the same length. |
| * @throws NumberIsTooSmallException if the arrays length is less than 2. |
| * @see #meanDifference(double[],double[]) |
| */ |
| public static double varianceDifference(final double[] sample1, final double[] sample2, double meanDifference) |
| throws DimensionMismatchException, NumberIsTooSmallException { |
| |
| double sum1 = 0d; |
| double sum2 = 0d; |
| double diff = 0d; |
| int n = sample1.length; |
| if (n != sample2.length) { |
| throw new DimensionMismatchException(n, sample2.length); |
| } |
| if (n < 2) { |
| throw new NumberIsTooSmallException(n, 2, true); |
| } |
| for (int i = 0; i < n; i++) { |
| diff = sample1[i] - sample2[i]; |
| sum1 += (diff - meanDifference) *(diff - meanDifference); |
| sum2 += diff - meanDifference; |
| } |
| return (sum1 - (sum2 * sum2 / n)) / (n - 1); |
| } |
| |
| /** |
| * Normalize (standardize) the sample, so it is has a mean of 0 and a standard deviation of 1. |
| * |
| * @param sample Sample to normalize. |
| * @return normalized (standardized) sample. |
| * @since 2.2 |
| */ |
| public static double[] normalize(final double[] sample) { |
| DescriptiveStatistics stats = new DescriptiveStatistics(); |
| |
| // Add the data from the series to stats |
| for (int i = 0; i < sample.length; i++) { |
| stats.addValue(sample[i]); |
| } |
| |
| // Compute mean and standard deviation |
| double mean = stats.getMean(); |
| double standardDeviation = stats.getStandardDeviation(); |
| |
| // initialize the standardizedSample, which has the same length as the sample |
| double[] standardizedSample = new double[sample.length]; |
| |
| for (int i = 0; i < sample.length; i++) { |
| // z = (x- mean)/standardDeviation |
| standardizedSample[i] = (sample[i] - mean) / standardDeviation; |
| } |
| return standardizedSample; |
| } |
| |
| /** |
| * Returns the sample mode(s). |
| * <p> |
| * The mode is the most frequently occurring value in the sample. |
| * If there is a unique value with maximum frequency, this value is returned |
| * as the only element of the output array. Otherwise, the returned array |
| * contains the maximum frequency elements in increasing order. |
| * <p> |
| * For example, if {@code sample} is {0, 12, 5, 6, 0, 13, 5, 17}, |
| * the returned array will have length two, with 0 in the first element and |
| * 5 in the second. |
| * <p> |
| * NaN values are ignored when computing the mode - i.e., NaNs will never |
| * appear in the output array. If the sample includes only NaNs or has |
| * length 0, an empty array is returned. |
| * |
| * @param sample input data |
| * @return array of array of the most frequently occurring element(s) sorted in ascending order. |
| * @throws MathIllegalArgumentException if the indices are invalid or the array is null |
| * @since 3.3 |
| */ |
| public static double[] mode(double[] sample) throws MathIllegalArgumentException { |
| if (sample == null) { |
| throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY); |
| } |
| return getMode(sample, 0, sample.length); |
| } |
| |
| /** |
| * Returns the sample mode(s). |
| * <p> |
| * The mode is the most frequently occurring value in the sample. |
| * If there is a unique value with maximum frequency, this value is returned |
| * as the only element of the output array. Otherwise, the returned array |
| * contains the maximum frequency elements in increasing order. |
| * <p> |
| * For example, if {@code sample} is {0, 12, 5, 6, 0, 13, 5, 17}, |
| * the returned array will have length two, with 0 in the first element and |
| * 5 in the second. |
| * <p> |
| * NaN values are ignored when computing the mode - i.e., NaNs will never |
| * appear in the output array. If the sample includes only NaNs or has |
| * length 0, an empty array is returned. |
| * |
| * @param sample input data |
| * @param begin index (0-based) of the first array element to include |
| * @param length the number of elements to include |
| * @return array of array of the most frequently occurring element(s) sorted in ascending order. |
| * @throws MathIllegalArgumentException if the indices are invalid or the array is null |
| * @since 3.3 |
| */ |
| public static double[] mode(double[] sample, final int begin, final int length) { |
| if (sample == null) { |
| throw new NullArgumentException(LocalizedFormats.INPUT_ARRAY); |
| } |
| |
| if (begin < 0) { |
| throw new NotPositiveException(LocalizedFormats.START_POSITION, Integer.valueOf(begin)); |
| } |
| |
| if (length < 0) { |
| throw new NotPositiveException(LocalizedFormats.LENGTH, Integer.valueOf(length)); |
| } |
| |
| return getMode(sample, begin, length); |
| } |
| |
| /** |
| * Private helper method. |
| * Assumes parameters have been validated. |
| * @param values input data |
| * @param begin index (0-based) of the first array element to include |
| * @param length the number of elements to include |
| * @return array of array of the most frequently occurring element(s) sorted in ascending order. |
| */ |
| private static double[] getMode(double[] values, final int begin, final int length) { |
| // Add the values to the frequency table |
| Frequency<Double> freq = new Frequency<>(); |
| for (int i = begin; i < begin + length; i++) { |
| final double value = values[i]; |
| if (!Double.isNaN(value)) { |
| freq.addValue(Double.valueOf(value)); |
| } |
| } |
| List<Double> list = freq.getMode(); |
| // Convert the list to an array of primitive double |
| return list.stream().mapToDouble(Double::doubleValue).toArray(); |
| } |
| |
| } |
