import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public static double pchisq(final double q, final double df, boolean lowerTail, boolean logP) {
  if(df == 0) {
    return p(new ChisquareZeroDfDistribution(), q, lowerTail, logP);
  } else {
    return p(new ChiSquaredDistributionImpl(df), q, lowerTail, logP);
  }
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public static double qchisq(final double p, final double df, boolean lowerTail, boolean logP) {
  if(df == 0) {
    return q(new ChisquareZeroDfDistribution(), p, lowerTail, logP);
  } else {
    return q(new ChiSquaredDistributionImpl(df), p, lowerTail, logP);
  }
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
/**
 * @param counts array representation of 2-way table
 * @return p-value
 * @throws MathIllegalArgumentException if preconditions are not met
 * @throws MathException if an error occurs computing the p-value
 */
public double chiSquareTest(long[][] counts)
throws MathException {
    checkArray(counts);
    double df = ((double) counts.length -1) * ((double) counts[0].length - 1);
    distribution = new ChiSquaredDistributionImpl(df);
    return 1 - distribution.cumulativeProbability(chiSquare(counts));
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public void testNextChiSquare() throws Exception {
    double[] quartiles = TestUtils.getDistributionQuartiles(new ChiSquaredDistributionImpl(12));
    long[] counts = new long[4];
    randomData.reSeed(1000);
    for (int i = 0; i < 1000; i++) {
        double value = randomData.nextChiSquare(12);
        TestUtils.updateCounts(value, counts, quartiles);
    }
    TestUtils.assertChiSquareAccept(expected, counts, 0.001);
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
@Test
public void testNextChiSquare() throws Exception {
    double[] quartiles = TestUtils.getDistributionQuartiles(new ChiSquaredDistributionImpl(12));
    long[] counts = new long[4];
    randomData.reSeed(1000);
    for (int i = 0; i < 1000; i++) {
        double value = randomData.nextChiSquare(12);
        TestUtils.updateCounts(value, counts, quartiles);
    }
    TestUtils.assertChiSquareAccept(expected, counts, 0.001);
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public static double pchisq(@Recycle double q, @Recycle double df, boolean lowerTail, boolean logP) {
  if(df == 0) {
    return p(new ChisquareZeroDfDistribution(), q, lowerTail, logP);
  } else {
    return p(new ChiSquaredDistributionImpl(df), q, lowerTail, logP);
  }
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public static double qchisq(@Recycle double p, @Recycle double df, boolean lowerTail, boolean logP) {
  if(df == 0) {
    return q(new ChisquareZeroDfDistribution(), p, lowerTail, logP);
  } else {
    return q(new ChiSquaredDistributionImpl(df), p, lowerTail, logP);
  }
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
/**
 * Construct a ChiSquareTestImpl 
 */
public ChiSquareTestImpl() {
    this(new ChiSquaredDistributionImpl(1.0));
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public static double dchisq(final double x, final double df, boolean log) {
  return d(new ChiSquaredDistributionImpl(df), x, log);
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
/**
 * Construct a ChiSquareTestImpl
 */
public ChiSquareTestImpl() {
    this(new ChiSquaredDistributionImpl(1.0));
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public double criticalValue(double alpha) throws MathException {
    ChiSquaredDistribution XS = new ChiSquaredDistributionImpl(k - 1);
    return XS.inverseCumulativeProbability(1.0 - alpha);
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public double criticalValue(double alpha) throws MathException {
    ChiSquaredDistribution XS = new ChiSquaredDistributionImpl(m - 1);
    return XS.inverseCumulativeProbability(1.0 - alpha);
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
public static double dchisq(@Recycle double x, @Recycle double df, boolean log) {
  return d(new ChiSquaredDistributionImpl(df), x, log);
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
/**
 * @param observed1 array of observed frequency counts of the first data set
 * @param observed2 array of observed frequency counts of the second data set
 * @return p-value
 * @throws MathIllegalArgumentException if preconditions are not met
 * @throws MathException if an error occurs computing the p-value
 * @since 1.2
 */
public double chiSquareTestDataSetsComparison(long[] observed1, long[] observed2)
    throws MathException {
    distribution = new ChiSquaredDistributionImpl((double) observed1.length - 1);
    return 1 - distribution.cumulativeProbability(
            chiSquareDataSetsComparison(observed1, observed2));
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
/**
 * Generates a random value from the {@link ChiSquaredDistributionImpl ChiSquare Distribution}.
 * This implementation uses {@link #nextInversionDeviate(ContinuousDistribution) inversion}
 * to generate random values.
 *
 * @param df the degrees of freedom of the ChiSquare distribution
 * @return random value sampled from the ChiSquare(df) distribution
 * @throws MathException if an error occurs generating the random value
 * @since 2.2
 */
public double nextChiSquare(double df) throws MathException {
    return nextInversionDeviate(new ChiSquaredDistributionImpl(df));
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
/**
 * Returns whether the test statistic S indicates a signficantly different
 * configuration given significance level alpha.
 * 
 * @param S
 * @param alpha
 * @return
 * @throws MathException
 */
public boolean isFamilyTestSignificant(double S, double alpha) throws MathException {
    ChiSquaredDistribution XS = new ChiSquaredDistributionImpl(k - 1);
    return S > XS.inverseCumulativeProbability(1.0 - alpha);
}
 

import org.apache.commons.math.distribution.ChiSquaredDistributionImpl; //导入依赖的package包/类
/**
 * Return whether the family-wise test statistic value T indicates
 * significant differences at level alpha.
 * 
 * @param T
 *            test statistic value returned by
 *            <code>familyTestStatistic()</code>
 * @param alpha
 *            significance level
 * @return
 * @throws MathException
 */
public boolean isFamilyTestSignificant(double T, double alpha) throws MathException {
    ChiSquaredDistribution XS = new ChiSquaredDistributionImpl(m - 1);
    //System.out.println("T-value: " + T + " >? Quantile: " + XS.inverseCumulativeProbability(1.0 - alpha));
    return T > XS.inverseCumulativeProbability(1.0 - alpha);
}