Java MathArrays.checkNonNegative方法代码示例

import org.apache.commons.math3.util.MathArrays; //导入方法依赖的package包/类
/**
 * Checks to make sure that the input long[][] array is rectangular,
 * has at least 2 rows and 2 columns, and has all non-negative entries.
 *
 * @param in input 2-way table to check
 * @throws NullArgumentException if the array is null
 * @throws DimensionMismatchException if the array is not valid
 * @throws NotPositiveException if the array contains any negative entries
 */
private void checkArray(final long[][] in)
    throws NullArgumentException, DimensionMismatchException,
    NotPositiveException {

    if (in.length < 2) {
        throw new DimensionMismatchException(in.length, 2);
    }

    if (in[0].length < 2) {
        throw new DimensionMismatchException(in[0].length, 2);
    }

    MathArrays.checkRectangular(in);
    MathArrays.checkNonNegative(in);

}
 

import org.apache.commons.math3.util.MathArrays; //导入方法依赖的package包/类
/**
 * Computes the <a href="http://en.wikipedia.org/wiki/G-test">G statistic
 * for Goodness of Fit</a> comparing {@code observed} and {@code expected}
 * frequency counts.
 *
 * <p>This statistic can be used to perform a G test (Log-Likelihood Ratio
 * Test) evaluating the null hypothesis that the observed counts follow the
 * expected distribution.</p>
 *
 * <p><strong>Preconditions</strong>: <ul>
 * <li>Expected counts must all be positive. </li>
 * <li>Observed counts must all be &ge; 0. </li>
 * <li>The observed and expected arrays must have the same length and their
 * common length must be at least 2. </li></ul></p>
 *
 * <p>If any of the preconditions are not met, a
 * {@code MathIllegalArgumentException} is thrown.</p>
 *
 * <p><strong>Note:</strong>This implementation rescales the
 * {@code expected} array if necessary to ensure that the sum of the
 * expected and observed counts are equal.</p>
 *
 * @param observed array of observed frequency counts
 * @param expected array of expected frequency counts
 * @return G-Test statistic
 * @throws NotPositiveException if {@code observed} has negative entries
 * @throws NotStrictlyPositiveException if {@code expected} has entries that
 * are not strictly positive
 * @throws DimensionMismatchException if the array lengths do not match or
 * are less than 2.
 */
public double g(final double[] expected, final long[] observed)
        throws NotPositiveException, NotStrictlyPositiveException,
        DimensionMismatchException {

    if (expected.length < 2) {
        throw new DimensionMismatchException(expected.length, 2);
    }
    if (expected.length != observed.length) {
        throw new DimensionMismatchException(expected.length, observed.length);
    }
    MathArrays.checkPositive(expected);
    MathArrays.checkNonNegative(observed);

    double sumExpected = 0d;
    double sumObserved = 0d;
    for (int i = 0; i < observed.length; i++) {
        sumExpected += expected[i];
        sumObserved += observed[i];
    }
    double ratio = 1d;
    boolean rescale = false;
    if (FastMath.abs(sumExpected - sumObserved) > 10E-6) {
        ratio = sumObserved / sumExpected;
        rescale = true;
    }
    double sum = 0d;
    for (int i = 0; i < observed.length; i++) {
        final double dev = rescale ?
                FastMath.log((double) observed[i] / (ratio * expected[i])) :
                    FastMath.log((double) observed[i] / expected[i]);
        sum += ((double) observed[i]) * dev;
    }
    return 2d * sum;
}