Apache
/
commons-math
mirror of https://github.com/apache/commons-math.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merged TTest implementation and interface, removed use of MathException. 

JIRA: MATH-488, MATH-739

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1243304 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Thomas Neidhart 2012-02-12 19:44:21 +00:00
parent 36a3920924
commit a436c93ce3
5 changed files with 653 additions and 1279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

622
src/main/java/org/apache/commons/math/stat/inference/TTest.java
View File

@ -16,11 +16,20 @@
*/
package org.apache.commons.math.stat.inference;
import org.apache.commons.math.MathException;
import org.apache.commons.math.distribution.TDistribution;
import org.apache.commons.math.exception.DimensionMismatchException;
import org.apache.commons.math.exception.MaxCountExceededException;
import org.apache.commons.math.exception.NoDataException;
import org.apache.commons.math.exception.NullArgumentException;
import org.apache.commons.math.exception.NumberIsTooSmallException;
import org.apache.commons.math.exception.OutOfRangeException;
import org.apache.commons.math.exception.util.LocalizedFormats;
import org.apache.commons.math.stat.StatUtils;
import org.apache.commons.math.stat.descriptive.StatisticalSummary;
import org.apache.commons.math.util.FastMath;
/**
* An interface for Student's t-tests.
* An implementation for Student's t-tests.
* <p>
* Tests can be:<ul>
* <li>One-sample or two-sample</li>
@ -39,12 +48,13 @@ import org.apache.commons.math.stat.descriptive.StatisticalSummary;
* (e.g. tests at the 95% level use <code>alpha=0.05</code>).</p>
* <p>
* Input to tests can be either <code>double[]</code> arrays or
* {@link StatisticalSummary} instances.</p>
*
* {@link StatisticalSummary} instances.</p><p>
* Uses commons-math {@link org.apache.commons.math.distribution.TDistribution}
* implementation to estimate exact p-values.</p>
*
* @version $Id$
*/
public interface TTest {
public class TTest {
/**
* Computes a paired, 2-sample t-statistic based on the data in the input
* arrays. The t-statistic returned is equivalent to what would be returned by
@ -61,12 +71,24 @@ public interface TTest {
* @param sample1 array of sample data values
* @param sample2 array of sample data values
* @return t statistic
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if the statistic can not be computed do to a
* convergence or other numerical error.
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NoDataException if the arrays are empty
* @throws DimensionMismatchException if the length of the arrays is not equal
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
*/
double pairedT(double[] sample1, double[] sample2)
throws IllegalArgumentException, MathException;
public double pairedT(final double[] sample1, final double[] sample2)
throws NullArgumentException, NoDataException,
DimensionMismatchException, NumberIsTooSmallException {
checkSampleData(sample1);
checkSampleData(sample2);
double meanDifference = StatUtils.meanDifference(sample1, sample2);
return t(meanDifference, 0,
StatUtils.varianceDifference(sample1, sample2, meanDifference),
sample1.length);
}
/**
* Returns the <i>observed significance level</i>, or
* <i> p-value</i>, associated with a paired, two-sample, two-tailed t-test
@ -97,11 +119,23 @@ public interface TTest {
* @param sample1 array of sample data values
* @param sample2 array of sample data values
* @return p-value for t-test
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error occurs computing the p-value
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NoDataException if the arrays are empty
* @throws DimensionMismatchException if the length of the arrays is not equal
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
double pairedTTest(double[] sample1, double[] sample2)
throws IllegalArgumentException, MathException;
public double pairedTTest(final double[] sample1, final double[] sample2)
throws NullArgumentException, NoDataException, DimensionMismatchException,
NumberIsTooSmallException, MaxCountExceededException {
double meanDifference = StatUtils.meanDifference(sample1, sample2);
return tTest(meanDifference, 0,
StatUtils.varianceDifference(sample1, sample2, meanDifference),
sample1.length);
}
/**
* Performs a paired t-test evaluating the null hypothesis that the
* mean of the paired differences between <code>sample1</code> and
@ -123,7 +157,7 @@ public interface TTest {
* <li>The input array lengths must be the same and their common length
* must be at least 2.
* </li>
* <li> <code> 0 < alpha < 0.5 </code>
* <li> <code> 0 &lt; alpha &lt; 0.5 </code>
* </li></ul></p>
*
* @param sample1 array of sample data values
@ -131,14 +165,23 @@ public interface TTest {
* @param alpha significance level of the test
* @return true if the null hypothesis can be rejected with
* confidence 1 - alpha
* @throws IllegalArgumentException if the preconditions are not met
* @throws MathException if an error occurs performing the test
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NoDataException if the arrays are empty
* @throws DimensionMismatchException if the length of the arrays is not equal
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
* @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
boolean pairedTTest(
double[] sample1,
double[] sample2,
double alpha)
throws IllegalArgumentException, MathException;
public boolean pairedTTest(final double[] sample1, final double[] sample2,
final double alpha)
throws NullArgumentException, NoDataException, DimensionMismatchException,
NumberIsTooSmallException, OutOfRangeException, MaxCountExceededException {
checkSignificanceLevel(alpha);
return pairedTTest(sample1, sample2) < alpha;
}
/**
* 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.
@ -152,10 +195,18 @@ public interface TTest {
* @param mu comparison constant
* @param observed array of values
* @return t statistic
* @throws IllegalArgumentException if input array length is less than 2
* @throws NullArgumentException if <code>observed</code> is <code>null</code>
* @throws NumberIsTooSmallException if the length of <code>observed</code> is &lt; 2
*/
double t(double mu, double[] observed)
throws IllegalArgumentException;
public double t(final double mu, final double[] observed)
throws NullArgumentException, NumberIsTooSmallException {
checkSampleData(observed);
return t(StatUtils.mean(observed), mu, StatUtils.variance(observed),
observed.length);
}
/**
* Computes a <a href="http://www.itl.nist.gov/div898/handbook/prc/section2/prc22.htm#formula">
* t statistic </a> to use in comparing the mean of the dataset described by
@ -164,16 +215,24 @@ public interface TTest {
* This statistic can be used to perform a one sample t-test for the mean.
* </p><p>
* <strong>Preconditions</strong>: <ul>
* <li><code>observed.getN() > = 2</code>.
* <li><code>observed.getN() &ge; 2</code>.
* </li></ul></p>
*
* @param mu comparison constant
* @param sampleStats DescriptiveStatistics holding sample summary statitstics
* @return t statistic
* @throws IllegalArgumentException if the precondition is not met
* @throws NullArgumentException if <code>sampleStats</code> is <code>null</code>
* @throws NumberIsTooSmallException if the number of samples is &lt; 2
*/
double t(double mu, StatisticalSummary sampleStats)
throws IllegalArgumentException;
public double t(final double mu, final StatisticalSummary sampleStats)
throws NullArgumentException, NumberIsTooSmallException {
checkSampleData(sampleStats);
return t(sampleStats.getMean(), mu, sampleStats.getVariance(),
sampleStats.getN());
}
/**
* Computes a 2-sample t statistic, under the hypothesis of equal
* subpopulation variances. To compute a t-statistic without the
@ -182,7 +241,7 @@ public interface TTest {
* This statistic can be used to perform a (homoscedastic) two-sample
* t-test to compare sample means.</p>
* <p>
* The t-statisitc is</p>
* The t-statistic is</p>
* <p>
* &nbsp;&nbsp;<code> t = (m1 - m2) / (sqrt(1/n1 +1/n2) sqrt(var))</code>
* </p><p>
@ -205,10 +264,20 @@ public interface TTest {
* @param sample1 array of sample data values
* @param sample2 array of sample data values
* @return t statistic
* @throws IllegalArgumentException if the precondition is not met
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
*/
double homoscedasticT(double[] sample1, double[] sample2)
throws IllegalArgumentException;
public double homoscedasticT(final double[] sample1, final double[] sample2)
throws NullArgumentException, NumberIsTooSmallException {
checkSampleData(sample1);
checkSampleData(sample2);
return homoscedasticT(StatUtils.mean(sample1), StatUtils.mean(sample2),
StatUtils.variance(sample1), StatUtils.variance(sample2),
sample1.length, sample2.length);
}
/**
* Computes a 2-sample t statistic, without the hypothesis of equal
* subpopulation variances. To compute a t-statistic assuming equal
@ -217,7 +286,7 @@ public interface TTest {
* This statistic can be used to perform a two-sample t-test to compare
* sample means.</p>
* <p>
* The t-statisitc is</p>
* The t-statistic is</p>
* <p>
* &nbsp;&nbsp; <code> t = (m1 - m2) / sqrt(var1/n1 + var2/n2)</code>
* </p><p>
@ -235,10 +304,20 @@ public interface TTest {
* @param sample1 array of sample data values
* @param sample2 array of sample data values
* @return t statistic
* @throws IllegalArgumentException if the precondition is not met
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
*/
double t(double[] sample1, double[] sample2)
throws IllegalArgumentException;
public double t(final double[] sample1, final double[] sample2)
throws NullArgumentException, NumberIsTooSmallException {
checkSampleData(sample1);
checkSampleData(sample2);
return t(StatUtils.mean(sample1), StatUtils.mean(sample2),
StatUtils.variance(sample1), StatUtils.variance(sample2),
sample1.length, sample2.length);
}
/**
* Computes a 2-sample t statistic </a>, comparing the means of the datasets
* described by two {@link StatisticalSummary} instances, without the
@ -249,7 +328,7 @@ public interface TTest {
* This statistic can be used to perform a two-sample t-test to compare
* sample means.</p>
* <p>
* The returned t-statisitc is</p>
* The returned t-statistic is</p>
* <p>
* &nbsp;&nbsp; <code> t = (m1 - m2) / sqrt(var1/n1 + var2/n2)</code>
* </p><p>
@ -268,12 +347,21 @@ public interface TTest {
* @param sampleStats1 StatisticalSummary describing data from the first sample
* @param sampleStats2 StatisticalSummary describing data from the second sample
* @return t statistic
* @throws IllegalArgumentException if the precondition is not met
* @throws NullArgumentException if the sample statistics are <code>null</code>
* @throws NumberIsTooSmallException if the number of samples is &lt; 2
*/
double t(
StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
throws IllegalArgumentException;
public double t(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2)
throws NullArgumentException, NumberIsTooSmallException {
checkSampleData(sampleStats1);
checkSampleData(sampleStats2);
return t(sampleStats1.getMean(), sampleStats2.getMean(),
sampleStats1.getVariance(), sampleStats2.getVariance(),
sampleStats1.getN(), sampleStats2.getN());
}
/**
* Computes a 2-sample t statistic, comparing the means of the datasets
* described by two {@link StatisticalSummary} instances, under the
@ -284,7 +372,7 @@ public interface TTest {
* This statistic can be used to perform a (homoscedastic) two-sample
* t-test to compare sample means.</p>
* <p>
* The t-statisitc returned is</p>
* The t-statistic returned is</p>
* <p>
* &nbsp;&nbsp;<code> t = (m1 - m2) / (sqrt(1/n1 +1/n2) sqrt(var))</code>
* </p><p>
@ -307,12 +395,21 @@ public interface TTest {
* @param sampleStats1 StatisticalSummary describing data from the first sample
* @param sampleStats2 StatisticalSummary describing data from the second sample
* @return t statistic
* @throws IllegalArgumentException if the precondition is not met
* @throws NullArgumentException if the sample statistics are <code>null</code>
* @throws NumberIsTooSmallException if the number of samples is &lt; 2
*/
double homoscedasticT(
StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
throws IllegalArgumentException;
public double homoscedasticT(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2)
throws NullArgumentException, NumberIsTooSmallException {
checkSampleData(sampleStats1);
checkSampleData(sampleStats2);
return homoscedasticT(sampleStats1.getMean(), sampleStats2.getMean(),
sampleStats1.getVariance(), sampleStats2.getVariance(),
sampleStats1.getN(), sampleStats2.getN());
}
/**
* Returns the <i>observed significance level</i>, or
* <i>p-value</i>, associated with a one-sample, two-tailed t-test
@ -336,11 +433,20 @@ public interface TTest {
* @param mu constant value to compare sample mean against
* @param sample array of sample data values
* @return p-value
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error occurs computing the p-value
* @throws NullArgumentException if the sample array is <code>null</code>
* @throws NumberIsTooSmallException if the length of the array is &lt; 2
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
double tTest(double mu, double[] sample)
throws IllegalArgumentException, MathException;
public double tTest(final double mu, final double[] sample)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
checkSampleData(sample);
return tTest(StatUtils.mean(sample), mu, StatUtils.variance(sample),
sample.length);
}
/**
* Performs a <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda353.htm">
* two-sided t-test</a> evaluating the null hypothesis that the mean of the population from
@ -373,11 +479,20 @@ public interface TTest {
* @param sample array of sample data values
* @param alpha significance level of the test
* @return p-value
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error computing the p-value
* @throws NullArgumentException if the sample array is <code>null</code>
* @throws NumberIsTooSmallException if the length of the array is &lt; 2
* @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
* @throws MaxCountExceededException if an error computing the p-value
*/
boolean tTest(double mu, double[] sample, double alpha)
throws IllegalArgumentException, MathException;
public boolean tTest(final double mu, final double[] sample, final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
checkSignificanceLevel(alpha);
return tTest(mu, sample) < alpha;
}
/**
* Returns the <i>observed significance level</i>, or
* <i>p-value</i>, associated with a one-sample, two-tailed t-test
@ -403,11 +518,20 @@ public interface TTest {
* @param mu constant value to compare sample mean against
* @param sampleStats StatisticalSummary describing sample data
* @return p-value
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error occurs computing the p-value
* @throws NullArgumentException if <code>sampleStats</code> is <code>null</code>
* @throws NumberIsTooSmallException if the number of samples is &lt; 2
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
double tTest(double mu, StatisticalSummary sampleStats)
throws IllegalArgumentException, MathException;
public double tTest(final double mu, final StatisticalSummary sampleStats)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
checkSampleData(sampleStats);
return tTest(sampleStats.getMean(), mu, sampleStats.getVariance(),
sampleStats.getN());
}
/**
* Performs a <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda353.htm">
* two-sided t-test</a> evaluating the null hypothesis that the mean of the
@ -441,14 +565,21 @@ public interface TTest {
* @param sampleStats StatisticalSummary describing sample data values
* @param alpha significance level of the test
* @return p-value
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error occurs computing the p-value
* @throws NullArgumentException if <code>sampleStats</code> is <code>null</code>
* @throws NumberIsTooSmallException if the number of samples is &lt; 2
* @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
boolean tTest(
double mu,
StatisticalSummary sampleStats,
double alpha)
throws IllegalArgumentException, MathException;
public boolean tTest(final double mu, final StatisticalSummary sampleStats,
final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
checkSignificanceLevel(alpha);
return tTest(mu, sampleStats) < alpha;
}
/**
* Returns the <i>observed significance level</i>, or
* <i>p-value</i>, associated with a two-sample, two-tailed t-test
@ -482,11 +613,22 @@ public interface TTest {
* @param sample1 array of sample data values
* @param sample2 array of sample data values
* @return p-value for t-test
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error occurs computing the p-value
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
double tTest(double[] sample1, double[] sample2)
throws IllegalArgumentException, MathException;
public double tTest(final double[] sample1, final double[] sample2)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
checkSampleData(sample1);
checkSampleData(sample2);
return tTest(StatUtils.mean(sample1), StatUtils.mean(sample2),
StatUtils.variance(sample1), StatUtils.variance(sample2),
sample1.length, sample2.length);
}
/**
* Returns the <i>observed significance level</i>, or
* <i>p-value</i>, associated with a two-sample, two-tailed t-test
@ -517,13 +659,24 @@ public interface TTest {
* @param sample1 array of sample data values
* @param sample2 array of sample data values
* @return p-value for t-test
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error occurs computing the p-value
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
double homoscedasticTTest(
double[] sample1,
double[] sample2)
throws IllegalArgumentException, MathException;
public double homoscedasticTTest(final double[] sample1, final double[] sample2)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
checkSampleData(sample1);
checkSampleData(sample2);
return homoscedasticTTest(StatUtils.mean(sample1),
StatUtils.mean(sample2),
StatUtils.variance(sample1),
StatUtils.variance(sample2),
sample1.length, sample2.length);
}
/**
* Performs a
* <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda353.htm">
@ -571,14 +724,21 @@ public interface TTest {
* @param alpha significance level of the test
* @return true if the null hypothesis can be rejected with
* confidence 1 - alpha
* @throws IllegalArgumentException if the preconditions are not met
* @throws MathException if an error occurs performing the test
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
* @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
boolean tTest(
double[] sample1,
double[] sample2,
double alpha)
throws IllegalArgumentException, MathException;
public boolean tTest(final double[] sample1, final double[] sample2,
final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
checkSignificanceLevel(alpha);
return tTest(sample1, sample2) < alpha;
}
/**
* Performs a
* <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda353.htm">
@ -627,14 +787,21 @@ public interface TTest {
* @param alpha significance level of the test
* @return true if the null hypothesis can be rejected with
* confidence 1 - alpha
* @throws IllegalArgumentException if the preconditions are not met
* @throws MathException if an error occurs performing the test
* @throws NullArgumentException if the arrays are <code>null</code>
* @throws NumberIsTooSmallException if the length of the arrays is &lt; 2
* @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
boolean homoscedasticTTest(
double[] sample1,
double[] sample2,
double alpha)
throws IllegalArgumentException, MathException;
public boolean homoscedasticTTest(final double[] sample1, final double[] sample2,
final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
checkSignificanceLevel(alpha);
return homoscedasticTTest(sample1, sample2) < alpha;
}
/**
* Returns the <i>observed significance level</i>, or
* <i>p-value</i>, associated with a two-sample, two-tailed t-test
@ -646,7 +813,7 @@ public interface TTest {
* equal in favor of the two-sided alternative that they are different.
* For a one-sided test, divide the returned value by 2.</p>
* <p>
* The test does not assume that the underlying popuation variances are
* The test does not assume that the underlying population variances are
* equal and it uses approximated degrees of freedom computed from the
* sample data to compute the p-value. To perform the test assuming
* equal variances, use
@ -666,13 +833,23 @@ public interface TTest {
* @param sampleStats1 StatisticalSummary describing data from the first sample
* @param sampleStats2 StatisticalSummary describing data from the second sample
* @return p-value for t-test
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error occurs computing the p-value
* @throws NullArgumentException if the sample statistics are <code>null</code>
* @throws NumberIsTooSmallException if the number of samples is &lt; 2
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
double tTest(
StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
throws IllegalArgumentException, MathException;
public double tTest(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
checkSampleData(sampleStats1);
checkSampleData(sampleStats2);
return tTest(sampleStats1.getMean(), sampleStats2.getMean(),
sampleStats1.getVariance(), sampleStats2.getVariance(),
sampleStats1.getN(), sampleStats2.getN());
}
/**
* Returns the <i>observed significance level</i>, or
* <i>p-value</i>, associated with a two-sample, two-tailed t-test
@ -703,13 +880,25 @@ public interface TTest {
* @param sampleStats1 StatisticalSummary describing data from the first sample
* @param sampleStats2 StatisticalSummary describing data from the second sample
* @return p-value for t-test
* @throws IllegalArgumentException if the precondition is not met
* @throws MathException if an error occurs computing the p-value
* @throws NullArgumentException if the sample statistics are <code>null</code>
* @throws NumberIsTooSmallException if the number of samples is &lt; 2
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
double homoscedasticTTest(
StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
throws IllegalArgumentException, MathException;
public double homoscedasticTTest(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
checkSampleData(sampleStats1);
checkSampleData(sampleStats2);
return homoscedasticTTest(sampleStats1.getMean(),
sampleStats2.getMean(),
sampleStats1.getVariance(),
sampleStats2.getVariance(),
sampleStats1.getN(), sampleStats2.getN());
}
/**
* Performs a
* <a href="http://www.itl.nist.gov/div898/handbook/eda/section3/eda353.htm">
@ -760,12 +949,221 @@ public interface TTest {
* @param alpha significance level of the test
* @return true if the null hypothesis can be rejected with
* confidence 1 - alpha
* @throws IllegalArgumentException if the preconditions are not met
* @throws MathException if an error occurs performing the test
* @throws NullArgumentException if the sample statistics are <code>null</code>
* @throws NumberIsTooSmallException if the number of samples is &lt; 2
* @throws OutOfRangeException if <code>alpha</code> is not in the range (0, 0.5]
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
boolean tTest(
StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2,
double alpha)
throws IllegalArgumentException, MathException;
public boolean tTest(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2,
final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
checkSignificanceLevel(alpha);
return tTest(sampleStats1, sampleStats2) < alpha;
}
//----------------------------------------------- Protected methods
/**
* Computes approximate degrees of freedom for 2-sample t-test.
*
* @param v1 first sample variance
* @param v2 second sample variance
* @param n1 first sample n
* @param n2 second sample n
* @return approximate degrees of freedom
*/
protected double df(double v1, double v2, double n1, double n2) {
return (((v1 / n1) + (v2 / n2)) * ((v1 / n1) + (v2 / n2))) /
((v1 * v1) / (n1 * n1 * (n1 - 1d)) + (v2 * v2) /
(n2 * n2 * (n2 - 1d)));
}
/**
* Computes t test statistic for 1-sample t-test.
*
* @param m sample mean
* @param mu constant to test against
* @param v sample variance
* @param n sample n
* @return t test statistic
*/
protected double t(final double m, final double mu,
final double v, final double n) {
return (m - mu) / FastMath.sqrt(v / n);
}
/**
* Computes t test statistic for 2-sample t-test.
* <p>
* Does not assume that subpopulation variances are equal.</p>
*
* @param m1 first sample mean
* @param m2 second sample mean
* @param v1 first sample variance
* @param v2 second sample variance
* @param n1 first sample n
* @param n2 second sample n
* @return t test statistic
*/
protected double t(final double m1, final double m2,
final double v1, final double v2,
final double n1, final double n2) {
return (m1 - m2) / FastMath.sqrt((v1 / n1) + (v2 / n2));
}
/**
* Computes t test statistic for 2-sample t-test under the hypothesis
* of equal subpopulation variances.
*
* @param m1 first sample mean
* @param m2 second sample mean
* @param v1 first sample variance
* @param v2 second sample variance
* @param n1 first sample n
* @param n2 second sample n
* @return t test statistic
*/
protected double homoscedasticT(final double m1, final double m2,
final double v1, final double v2,
final double n1, final double n2) {
final double pooledVariance = ((n1 - 1) * v1 + (n2 -1) * v2 ) / (n1 + n2 - 2);
return (m1 - m2) / FastMath.sqrt(pooledVariance * (1d / n1 + 1d / n2));
}
/**
* Computes p-value for 2-sided, 1-sample t-test.
*
* @param m sample mean
* @param mu constant to test against
* @param v sample variance
* @param n sample n
* @return p-value
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
protected double tTest(final double m, final double mu,
final double v, final double n)
throws MaxCountExceededException {
double t = FastMath.abs(t(m, mu, v, n));
TDistribution distribution = new TDistribution(n - 1);
return 2.0 * distribution.cumulativeProbability(-t);
}
/**
* Computes p-value for 2-sided, 2-sample t-test.
* <p>
* Does not assume subpopulation variances are equal. Degrees of freedom
* are estimated from the data.</p>
*
* @param m1 first sample mean
* @param m2 second sample mean
* @param v1 first sample variance
* @param v2 second sample variance
* @param n1 first sample n
* @param n2 second sample n
* @return p-value
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
protected double tTest(final double m1, final double m2,
final double v1, final double v2,
final double n1, final double n2)
throws MaxCountExceededException {
final double t = FastMath.abs(t(m1, m2, v1, v2, n1, n2));
final double degreesOfFreedom = df(v1, v2, n1, n2);
TDistribution distribution = new TDistribution(degreesOfFreedom);
return 2.0 * distribution.cumulativeProbability(-t);
}
/**
* Computes p-value for 2-sided, 2-sample t-test, under the assumption
* of equal subpopulation variances.
* <p>
* The sum of the sample sizes minus 2 is used as degrees of freedom.</p>
*
* @param m1 first sample mean
* @param m2 second sample mean
* @param v1 first sample variance
* @param v2 second sample variance
* @param n1 first sample n
* @param n2 second sample n
* @return p-value
* @throws MaxCountExceededException if an error occurs computing the p-value
*/
protected double homoscedasticTTest(double m1, double m2,
double v1, double v2,
double n1, double n2)
throws MaxCountExceededException {
final double t = FastMath.abs(homoscedasticT(m1, m2, v1, v2, n1, n2));
final double degreesOfFreedom = n1 + n2 - 2;
TDistribution distribution = new TDistribution(degreesOfFreedom);
return 2.0 * distribution.cumulativeProbability(-t);
}
/**
* Check significance level.
*
* @param alpha significance level
* @throws OutOfRangeException if the significance level is out of bounds.
*/
private void checkSignificanceLevel(final double alpha)
throws OutOfRangeException {
if (alpha <= 0 || alpha > 0.5) {
throw new OutOfRangeException(LocalizedFormats.SIGNIFICANCE_LEVEL,
alpha, 0.0, 0.5);
}
}
/**
* Check sample data.
*
* @param data Sample data.
* @throws NullArgumentException if {@code data} is {@code null}.
* @throws NumberIsTooSmallException if there is not enough sample data.
*/
private void checkSampleData(final double[] data)
throws NullArgumentException, NumberIsTooSmallException {
if (data == null) {
throw new NullArgumentException();
}
if (data.length < 2) {
throw new NumberIsTooSmallException(
LocalizedFormats.INSUFFICIENT_DATA_FOR_T_STATISTIC,
data.length, 2, true);
}
}
/**
* Check sample data.
*
* @param stat Statistical summary.
* @throws NullArgumentException if {@code data} is {@code null}.
* @throws NumberIsTooSmallException if there is not enough sample data.
*/
private void checkSampleData(final StatisticalSummary stat)
throws NullArgumentException, NumberIsTooSmallException {
if (stat == null) {
throw new NullArgumentException();
}
if (stat.getN() < 2) {
throw new NumberIsTooSmallException(
LocalizedFormats.INSUFFICIENT_DATA_FOR_T_STATISTIC,
stat.getN(), 2, true);
}
}
}

1042
src/main/java/org/apache/commons/math/stat/inference/TTestImpl.java
View File

File diff suppressed because it is too large Load Diff

115
src/main/java/org/apache/commons/math/stat/inference/TestUtils.java
View File

@ -17,13 +17,14 @@
package org.apache.commons.math.stat.inference;
import java.util.Collection;
import org.apache.commons.math.MathException;
import org.apache.commons.math.exception.ConvergenceException;
import org.apache.commons.math.exception.DimensionMismatchException;
import org.apache.commons.math.exception.MaxCountExceededException;
import org.apache.commons.math.exception.NoDataException;
import org.apache.commons.math.exception.NotPositiveException;
import org.apache.commons.math.exception.NotStrictlyPositiveException;
import org.apache.commons.math.exception.NullArgumentException;
import org.apache.commons.math.exception.NumberIsTooSmallException;
import org.apache.commons.math.exception.OutOfRangeException;
import org.apache.commons.math.exception.ZeroException;
import org.apache.commons.math.stat.descriptive.StatisticalSummary;
@ -38,7 +39,7 @@ import org.apache.commons.math.stat.descriptive.StatisticalSummary;
public class TestUtils {
/** Singleton TTest instance. */
private static final TTest T_TEST = new TTestImpl();
private static final TTest T_TEST = new TTest();
/** Singleton ChiSquareTest instance. */
private static final ChiSquareTest CHI_SQUARE_TEST = new ChiSquareTest();
@ -58,168 +59,182 @@ public class TestUtils {
/**
* @see org.apache.commons.math.stat.inference.TTest#homoscedasticT(double[], double[])
*/
public static double homoscedasticT(double[] sample1, double[] sample2)
throws IllegalArgumentException {
public static double homoscedasticT(final double[] sample1, final double[] sample2)
throws NullArgumentException, NumberIsTooSmallException {
return T_TEST.homoscedasticT(sample1, sample2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#homoscedasticT(org.apache.commons.math.stat.descriptive.StatisticalSummary, org.apache.commons.math.stat.descriptive.StatisticalSummary)
*/
public static double homoscedasticT(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
throws IllegalArgumentException {
public static double homoscedasticT(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2)
throws NullArgumentException, NumberIsTooSmallException {
return T_TEST.homoscedasticT(sampleStats1, sampleStats2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#homoscedasticTTest(double[], double[], double)
*/
public static boolean homoscedasticTTest(double[] sample1, double[] sample2,
double alpha)
throws IllegalArgumentException, MathException {
public static boolean homoscedasticTTest(final double[] sample1, final double[] sample2,
final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
return T_TEST.homoscedasticTTest(sample1, sample2, alpha);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#homoscedasticTTest(double[], double[])
*/
public static double homoscedasticTTest(double[] sample1, double[] sample2)
throws IllegalArgumentException, MathException {
public static double homoscedasticTTest(final double[] sample1, final double[] sample2)
throws NullArgumentException, NumberIsTooSmallException, MaxCountExceededException {
return T_TEST.homoscedasticTTest(sample1, sample2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#homoscedasticTTest(org.apache.commons.math.stat.descriptive.StatisticalSummary, org.apache.commons.math.stat.descriptive.StatisticalSummary)
*/
public static double homoscedasticTTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
throws IllegalArgumentException, MathException {
public static double homoscedasticTTest(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2)
throws NullArgumentException, NumberIsTooSmallException, MaxCountExceededException {
return T_TEST.homoscedasticTTest(sampleStats1, sampleStats2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#pairedT(double[], double[])
*/
public static double pairedT(double[] sample1, double[] sample2)
throws IllegalArgumentException, MathException {
public static double pairedT(final double[] sample1, final double[] sample2)
throws NullArgumentException, NoDataException,
DimensionMismatchException, NumberIsTooSmallException {
return T_TEST.pairedT(sample1, sample2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#pairedTTest(double[], double[], double)
*/
public static boolean pairedTTest(double[] sample1, double[] sample2,
double alpha)
throws IllegalArgumentException, MathException {
public static boolean pairedTTest(final double[] sample1, final double[] sample2,
final double alpha)
throws NullArgumentException, NoDataException, DimensionMismatchException,
NumberIsTooSmallException, OutOfRangeException, MaxCountExceededException {
return T_TEST.pairedTTest(sample1, sample2, alpha);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#pairedTTest(double[], double[])
*/
public static double pairedTTest(double[] sample1, double[] sample2)
throws IllegalArgumentException, MathException {
public static double pairedTTest(final double[] sample1, final double[] sample2)
throws NullArgumentException, NoDataException, DimensionMismatchException,
NumberIsTooSmallException, MaxCountExceededException {
return T_TEST.pairedTTest(sample1, sample2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#t(double, double[])
*/
public static double t(double mu, double[] observed)
throws IllegalArgumentException {
public static double t(final double mu, final double[] observed)
throws NullArgumentException, NumberIsTooSmallException {
return T_TEST.t(mu, observed);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#t(double, org.apache.commons.math.stat.descriptive.StatisticalSummary)
*/
public static double t(double mu, StatisticalSummary sampleStats)
throws IllegalArgumentException {
public static double t(final double mu, final StatisticalSummary sampleStats)
throws NullArgumentException, NumberIsTooSmallException {
return T_TEST.t(mu, sampleStats);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#t(double[], double[])
*/
public static double t(double[] sample1, double[] sample2)
throws IllegalArgumentException {
public static double t(final double[] sample1, final double[] sample2)
throws NullArgumentException, NumberIsTooSmallException {
return T_TEST.t(sample1, sample2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#t(org.apache.commons.math.stat.descriptive.StatisticalSummary, org.apache.commons.math.stat.descriptive.StatisticalSummary)
*/
public static double t(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
throws IllegalArgumentException {
public static double t(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2)
throws NullArgumentException, NumberIsTooSmallException {
return T_TEST.t(sampleStats1, sampleStats2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#tTest(double, double[], double)
*/
public static boolean tTest(double mu, double[] sample, double alpha)
throws IllegalArgumentException, MathException {
public static boolean tTest(final double mu, final double[] sample, final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
return T_TEST.tTest(mu, sample, alpha);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#tTest(double, double[])
*/
public static double tTest(double mu, double[] sample)
throws IllegalArgumentException, MathException {
public static double tTest(final double mu, final double[] sample)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
return T_TEST.tTest(mu, sample);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#tTest(double, org.apache.commons.math.stat.descriptive.StatisticalSummary, double)
*/
public static boolean tTest(double mu, StatisticalSummary sampleStats,
double alpha)
throws IllegalArgumentException, MathException {
public static boolean tTest(final double mu, final StatisticalSummary sampleStats,
final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
return T_TEST.tTest(mu, sampleStats, alpha);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#tTest(double, org.apache.commons.math.stat.descriptive.StatisticalSummary)
*/
public static double tTest(double mu, StatisticalSummary sampleStats)
throws IllegalArgumentException, MathException {
public static double tTest(final double mu, final StatisticalSummary sampleStats)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
return T_TEST.tTest(mu, sampleStats);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#tTest(double[], double[], double)
*/
public static boolean tTest(double[] sample1, double[] sample2, double alpha)
throws IllegalArgumentException, MathException {
public static boolean tTest(final double[] sample1, final double[] sample2,
final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
return T_TEST.tTest(sample1, sample2, alpha);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#tTest(double[], double[])
*/
public static double tTest(double[] sample1, double[] sample2)
throws IllegalArgumentException, MathException {
public static double tTest(final double[] sample1, final double[] sample2)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
return T_TEST.tTest(sample1, sample2);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#tTest(org.apache.commons.math.stat.descriptive.StatisticalSummary, org.apache.commons.math.stat.descriptive.StatisticalSummary, double)
*/
public static boolean tTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2, double alpha)
throws IllegalArgumentException, MathException {
public static boolean tTest(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2,
final double alpha)
throws NullArgumentException, NumberIsTooSmallException,
OutOfRangeException, MaxCountExceededException {
return T_TEST.tTest(sampleStats1, sampleStats2, alpha);
}
/**
* @see org.apache.commons.math.stat.inference.TTest#tTest(org.apache.commons.math.stat.descriptive.StatisticalSummary, org.apache.commons.math.stat.descriptive.StatisticalSummary)
*/
public static double tTest(StatisticalSummary sampleStats1,
StatisticalSummary sampleStats2)
throws IllegalArgumentException, MathException {
public static double tTest(final StatisticalSummary sampleStats1,
final StatisticalSummary sampleStats2)
throws NullArgumentException, NumberIsTooSmallException,
MaxCountExceededException {
return T_TEST.tTest(sampleStats1, sampleStats2);
}

78
src/test/java/org/apache/commons/math/stat/inference/TTestTest.java
View File

@ -17,7 +17,9 @@
package org.apache.commons.math.stat.inference;
import org.apache.commons.math.exception.MathIllegalArgumentException;
import org.apache.commons.math.exception.NullArgumentException;
import org.apache.commons.math.exception.NumberIsTooSmallException;
import org.apache.commons.math.exception.OutOfRangeException;
import org.apache.commons.math.stat.descriptive.SummaryStatistics;
import org.junit.Assert;
import org.junit.Before;
@ -30,7 +32,7 @@ import org.junit.Test;
*/
public class TTestTest {
protected TTest testStatistic = new TTestImpl();
protected TTest testStatistic = new TTest();
private double[] tooShortObs = { 1.0 };
private double[] emptyObs = {};
@ -66,55 +68,55 @@ public class TTestTest {
try {
testStatistic.t(mu, (double[]) null);
Assert.fail("arguments too short, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("arguments too short, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
try {
testStatistic.t(mu, (SummaryStatistics) null);
Assert.fail("arguments too short, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("arguments too short, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
try {
testStatistic.t(mu, emptyObs);
Assert.fail("arguments too short, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("arguments too short, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.t(mu, emptyStats);
Assert.fail("arguments too short, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("arguments too short, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.t(mu, tooShortObs);
Assert.fail("insufficient data to compute t statistic, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data to compute t statistic, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.tTest(mu, tooShortObs);
Assert.fail("insufficient data to perform t test, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data to perform t test, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.t(mu, tooShortStats);
Assert.fail("insufficient data to compute t statistic, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data to compute t statistic, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.tTest(mu, tooShortStats);
Assert.fail("insufficient data to perform t test, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data to perform t test, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
}
@ -143,15 +145,15 @@ public class TTestTest {
try {
testStatistic.tTest(0d, oneSidedP, 95);
Assert.fail("alpha out of range, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("alpha out of range, OutOfRangeException expected");
} catch (OutOfRangeException ex) {
// expected
}
try {
testStatistic.tTest(0d, oneSidedPStats, 95);
Assert.fail("alpha out of range, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("alpha out of range, OutOfRangeException expected");
} catch (OutOfRangeException ex) {
// expected
}
@ -190,57 +192,57 @@ public class TTestTest {
try {
testStatistic.tTest(sample1, sample2, .95);
Assert.fail("alpha out of range, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("alpha out of range, OutOfRangeException expected");
} catch (OutOfRangeException ex) {
// expected
}
try {
testStatistic.tTest(sampleStats1, sampleStats2, .95);
Assert.fail("alpha out of range, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("alpha out of range, OutOfRangeException expected");
} catch (OutOfRangeException ex) {
// expected
}
try {
testStatistic.tTest(sample1, tooShortObs, .01);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.tTest(sampleStats1, tooShortStats, .01);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.tTest(sample1, tooShortObs);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.tTest(sampleStats1, tooShortStats);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.t(sample1, tooShortObs);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
testStatistic.t(sampleStats1, tooShortStats);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
}

75
src/test/java/org/apache/commons/math/stat/inference/TestUtilsTest.java
View File

@ -20,9 +20,10 @@ import java.util.ArrayList;
import java.util.List;
import org.apache.commons.math.exception.DimensionMismatchException;
import org.apache.commons.math.exception.MathIllegalArgumentException;
import org.apache.commons.math.exception.NotPositiveException;
import org.apache.commons.math.exception.NotStrictlyPositiveException;
import org.apache.commons.math.exception.NullArgumentException;
import org.apache.commons.math.exception.NumberIsTooSmallException;
import org.apache.commons.math.exception.OutOfRangeException;
import org.apache.commons.math.stat.descriptive.SummaryStatistics;
import org.junit.Assert;
@ -218,55 +219,55 @@ public class TestUtilsTest {
try {
TestUtils.t(mu, (double[]) null);
Assert.fail("arguments too short, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("arguments too short, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
try {
TestUtils.t(mu, (SummaryStatistics) null);
Assert.fail("arguments too short, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("arguments too short, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
try {
TestUtils.t(mu, emptyObs);
Assert.fail("arguments too short, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("arguments too short, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
TestUtils.t(mu, emptyStats);
Assert.fail("arguments too short, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("arguments too short, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
TestUtils.t(mu, tooShortObs);
Assert.fail("insufficient data to compute t statistic, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data to compute t statistic, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
TestUtils.tTest(mu, tooShortObs);
Assert.fail("insufficient data to perform t test, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data to perform t test, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
TestUtils.t(mu, (SummaryStatistics) null);
Assert.fail("insufficient data to compute t statistic, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data to compute t statistic, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
try {
TestUtils.tTest(mu, (SummaryStatistics) null);
Assert.fail("insufficient data to perform t test, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data to perform t test, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
}
@ -295,15 +296,15 @@ public class TestUtilsTest {
try {
TestUtils.tTest(0d, oneSidedP, 95);
Assert.fail("alpha out of range, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("alpha out of range, OutOfRangeException expected");
} catch (OutOfRangeException ex) {
// expected
}
try {
TestUtils.tTest(0d, oneSidedPStats, 95);
Assert.fail("alpha out of range, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("alpha out of range, OutOfRangeException expected");
} catch (OutOfRangeException ex) {
// expected
}
@ -342,57 +343,57 @@ public class TestUtilsTest {
try {
TestUtils.tTest(sample1, sample2, .95);
Assert.fail("alpha out of range, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("alpha out of range, OutOfRangeException expected");
} catch (OutOfRangeException ex) {
// expected
}
try {
TestUtils.tTest(sampleStats1, sampleStats2, .95);
Assert.fail("alpha out of range, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("alpha out of range, OutOfRangeException expected");
} catch (OutOfRangeException ex) {
// expected
}
try {
TestUtils.tTest(sample1, tooShortObs, .01);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
TestUtils.tTest(sampleStats1, (SummaryStatistics) null, .01);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
try {
TestUtils.tTest(sample1, tooShortObs);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
TestUtils.tTest(sampleStats1, (SummaryStatistics) null);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
try {
TestUtils.t(sample1, tooShortObs);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NumberIsTooSmallException expected");
} catch (NumberIsTooSmallException ex) {
// expected
}
try {
TestUtils.t(sampleStats1, (SummaryStatistics) null);
Assert.fail("insufficient data, MathIllegalArgumentException expected");
} catch (MathIllegalArgumentException ex) {
Assert.fail("insufficient data, NullArgumentException expected");
} catch (NullArgumentException ex) {
// expected
}
}