org.apache.commons.math.stat.inference

## Class TTestImpl

- java.lang.Object
- - org.apache.commons.math.stat.inference.TTestImpl

All Implemented Interfaces:
  TTest

    public class TTestImpl
    extends java.lang.Object
    implements TTest

Implements t-test statistics defined in the `TTest` interface.

Uses commons-math `TDistributionImpl` implementation to estimate exact p-values.

Version:
  $Revision: 1042336 $ $Date: 2010-12-05 13:40:48 +0100 (dim. 05 déc. 2010) $

### Field Summary

Fields
`private TDistribution` `distribution` Deprecated. in 2.2 (to be removed in 3.0).

### Constructor Summary

Constructors
Constructor and Description
`TTestImpl()` Default constructor.
`TTestImpl(TDistribution t)` Deprecated. in 2.2 (to be removed in 3.0).

### Method Summary

Methods
`private void` `checkSampleData(double[] data)` Check sample data.
`private void` `checkSampleData(StatisticalSummary stat)` Check sample data.
`private void` `checkSignificanceLevel(double alpha)` Check significance level.
`protected double` `df(double v1, double v2, double n1, double n2)` Computes approximate degrees of freedom for 2-sample t-test.
`double` `homoscedasticT(double[] sample1, double[] sample2)` Computes a 2-sample t statistic, under the hypothesis of equal subpopulation variances.
`protected double` `homoscedasticT(double m1, double m2, double v1, double v2, double n1, double n2)` Computes t test statistic for 2-sample t-test under the hypothesis of equal subpopulation variances.
`double` `homoscedasticT(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)` Computes a 2-sample t statistic, comparing the means of the datasets described by two `StatisticalSummary` instances, under the assumption of equal subpopulation variances.
`double` `homoscedasticTTest(double[] sample1, double[] sample2)` Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the input arrays, under the assumption that the two samples are drawn from subpopulations with equal variances.
`boolean` `homoscedasticTTest(double[] sample1, double[] sample2, double alpha)` Performs a two-sided t-test evaluating the null hypothesis that `sample1` and `sample2` are drawn from populations with the same mean, with significance level `alpha`, assuming that the subpopulation variances are equal.
`protected double` `homoscedasticTTest(double m1, double m2, double v1, double v2, double n1, double n2)` Computes p-value for 2-sided, 2-sample t-test, under the assumption of equal subpopulation variances.
`double` `homoscedasticTTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)` Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the datasets described by two StatisticalSummary instances, under the hypothesis of equal subpopulation variances.
`double` `pairedT(double[] sample1, double[] sample2)` Computes a paired, 2-sample t-statistic based on the data in the input arrays.
`double` `pairedTTest(double[] sample1, double[] sample2)` Returns the observed significance level, or p-value, associated with a paired, two-sample, two-tailed t-test based on the data in the input arrays.
`boolean` `pairedTTest(double[] sample1, double[] sample2, double alpha)` Performs a paired t-test evaluating the null hypothesis that the mean of the paired differences between `sample1` and `sample2` is 0 in favor of the two-sided alternative that the mean paired difference is not equal to 0, with significance level `alpha`.
`void` `setDistribution(TDistribution value)` Deprecated. in 2.2 (to be removed in 3.0).
`double` `t(double[] sample1, double[] sample2)` Computes a 2-sample t statistic, without the hypothesis of equal subpopulation variances.
`double` `t(double mu, double[] observed)` Computes a t statistic given observed values and a comparison constant.
`protected double` `t(double m, double mu, double v, double n)` Computes t test statistic for 1-sample t-test.
`protected double` `t(double m1, double m2, double v1, double v2, double n1, double n2)` Computes t test statistic for 2-sample t-test.
`double` `t(double mu, StatisticalSummary sampleStats)` Computes a t statistic to use in comparing the mean of the dataset described by `sampleStats` to `mu`.
`double` `t(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)` Computes a 2-sample t statistic , comparing the means of the datasets described by two `StatisticalSummary` instances, without the assumption of equal subpopulation variances.
`double` `tTest(double[] sample1, double[] sample2)` Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the input arrays.
`boolean` `tTest(double[] sample1, double[] sample2, double alpha)` Performs a two-sided t-test evaluating the null hypothesis that `sample1` and `sample2` are drawn from populations with the same mean, with significance level `alpha`.
`double` `tTest(double mu, double[] sample)` Returns the observed significance level, or p-value, associated with a one-sample, two-tailed t-test comparing the mean of the input array with the constant `mu`.
`boolean` `tTest(double mu, double[] sample, double alpha)` Performs a two-sided t-test evaluating the null hypothesis that the mean of the population from which `sample` is drawn equals `mu`.
`protected double` `tTest(double m, double mu, double v, double n)` Computes p-value for 2-sided, 1-sample t-test.
`protected double` `tTest(double m1, double m2, double v1, double v2, double n1, double n2)` Computes p-value for 2-sided, 2-sample t-test.
`double` `tTest(double mu, StatisticalSummary sampleStats)` Returns the observed significance level, or p-value, associated with a one-sample, two-tailed t-test comparing the mean of the dataset described by `sampleStats` with the constant `mu`.
`boolean` `tTest(double mu, StatisticalSummary sampleStats, double alpha)` Performs a two-sided t-test evaluating the null hypothesis that the mean of the population from which the dataset described by `stats` is drawn equals `mu`.
`double` `tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2)` Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the datasets described by two StatisticalSummary instances.
`boolean` `tTest(StatisticalSummary sampleStats1, StatisticalSummary sampleStats2, double alpha)` Performs a two-sided t-test evaluating the null hypothesis that `sampleStats1` and `sampleStats2` describe datasets drawn from populations with the same mean, with significance level `alpha`.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### distribution

    @Deprecated
    private TDistribution distribution

Deprecated. in 2.2 (to be removed in 3.0).
Distribution used to compute inference statistics.

### Constructor Detail

#### TTestImpl

    public TTestImpl()

Default constructor.

#### TTestImpl

    @Deprecated
    public TTestImpl(TDistribution t)

Deprecated. in 2.2 (to be removed in 3.0).
Create a test instance using the given distribution for computing inference statistics.

Parameters:
  `t` - distribution used to compute inference statistics.
Since:
  1.2

### Method Detail

#### pairedT

    public double pairedT(double[] sample1,
                 double[] sample2)
                   throws java.lang.IllegalArgumentException,
                          MathException

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 computing the one-sample t-statistic `t(double, double[])`, with `mu = 0` and the sample array consisting of the (signed) differences between corresponding entries in `sample1` and `sample2.`

Preconditions:

- The input arrays must have the same length and their common length must be at least 2.

Specified by:
  `pairedT` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
Returns:
  t statistic
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if the statistic can not be computed do to a convergence or other numerical error.

#### pairedTTest

    public double pairedTTest(double[] sample1,
                     double[] sample2)
                       throws java.lang.IllegalArgumentException,
                              MathException

Returns the observed significance level, or p-value, associated with a paired, two-sample, two-tailed t-test based on the data in the input arrays.

The number returned is the smallest significance level at which one can reject the null hypothesis that the mean of the paired differences is 0 in favor of the two-sided alternative that the mean paired difference is not equal to 0. For a one-sided test, divide the returned value by 2.

This test is equivalent to a one-sample t-test computed using `tTest(double, double[])` with `mu = 0` and the sample array consisting of the signed differences between corresponding elements of `sample1` and `sample2.`

Usage Note:
The validity of the p-value depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The input array lengths must be the same and their common length must be at least 2.

Specified by:
  `pairedTTest` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
Returns:
  p-value for t-test
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error occurs computing the p-value

#### pairedTTest

    public boolean pairedTTest(double[] sample1,
                      double[] sample2,
                      double alpha)
                        throws java.lang.IllegalArgumentException,
                               MathException

Performs a paired t-test evaluating the null hypothesis that the mean of the paired differences between `sample1` and `sample2` is 0 in favor of the two-sided alternative that the mean paired difference is not equal to 0, with significance level `alpha`.

Returns `true` iff the null hypothesis can be rejected with confidence `1 - alpha`. To perform a 1-sided test, use `alpha * 2`

Usage Note:
The validity of the test depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The input array lengths must be the same and their common length must be at least 2.
- `0 < alpha < 0.5`

Specified by:
  `pairedTTest` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
  `alpha` - significance level of the test
Returns:
  true if the null hypothesis can be rejected with confidence 1 - alpha
Throws:
  `java.lang.IllegalArgumentException` - if the preconditions are not met
  `MathException` - if an error occurs performing the test

#### t

    public double t(double mu,
           double[] observed)
             throws java.lang.IllegalArgumentException

Computes a t statistic given observed values and a comparison constant.

This statistic can be used to perform a one sample t-test for the mean.

Preconditions:

- The observed array length must be at least 2.

Specified by:
  `t` in interface `TTest`
Parameters:
  `mu` - comparison constant
  `observed` - array of values
Returns:
  t statistic
Throws:
  `java.lang.IllegalArgumentException` - if input array length is less than 2

#### t

    public double t(double mu,
           StatisticalSummary sampleStats)
             throws java.lang.IllegalArgumentException

Computes a t statistic to use in comparing the mean of the dataset described by `sampleStats` to `mu`.

This statistic can be used to perform a one sample t-test for the mean.

Preconditions:

- `observed.getN() > = 2`.

Specified by:
  `t` in interface `TTest`
Parameters:
  `mu` - comparison constant
  `sampleStats` - DescriptiveStatistics holding sample summary statitstics
Returns:
  t statistic
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met

#### homoscedasticT

    public double homoscedasticT(double[] sample1,
                        double[] sample2)
                          throws java.lang.IllegalArgumentException

Computes a 2-sample t statistic, under the hypothesis of equal subpopulation variances. To compute a t-statistic without the equal variances hypothesis, use `t(double[], double[])`.

This statistic can be used to perform a (homoscedastic) two-sample t-test to compare sample means.

The t-statisitc is

`t = (m1 - m2) / (sqrt(1/n1 +1/n2) sqrt(var))`

where `n1` is the size of first sample; `n2` is the size of second sample; `m1` is the mean of first sample; `m2` is the mean of second sample

and `var` is the pooled variance estimate:

`var = sqrt(((n1 - 1)var1 + (n2 - 1)var2) / ((n1-1) + (n2-1)))`

with `var1``` the variance of the first sample and `var2` the variance of the second sample.

Preconditions:

- The observed array lengths must both be at least 2.

Specified by:
  `homoscedasticT` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
Returns:
  t statistic
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met

#### t

    public double t(double[] sample1,
           double[] sample2)
             throws java.lang.IllegalArgumentException

Computes a 2-sample t statistic, without the hypothesis of equal subpopulation variances. To compute a t-statistic assuming equal variances, use `homoscedasticT(double[], double[])`.

This statistic can be used to perform a two-sample t-test to compare sample means.

The t-statisitc is

`t = (m1 - m2) / sqrt(var1/n1 + var2/n2)`

where `n1` is the size of the first sample `n2` is the size of the second sample; `m1` is the mean of the first sample; `m2` is the mean of the second sample; `var1` is the variance of the first sample; `var2` is the variance of the second sample;

Preconditions:

- The observed array lengths must both be at least 2.

Specified by:
  `t` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
Returns:
  t statistic
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met

#### t

    public double t(StatisticalSummary sampleStats1,
           StatisticalSummary sampleStats2)
             throws java.lang.IllegalArgumentException

Computes a 2-sample t statistic , comparing the means of the datasets described by two `StatisticalSummary` instances, without the assumption of equal subpopulation variances. Use `homoscedasticT(StatisticalSummary, StatisticalSummary)` to compute a t-statistic under the equal variances assumption.

This statistic can be used to perform a two-sample t-test to compare sample means.

The returned t-statisitc is

`t = (m1 - m2) / sqrt(var1/n1 + var2/n2)`

where `n1` is the size of the first sample; `n2` is the size of the second sample; `m1` is the mean of the first sample; `m2` is the mean of the second sample `var1` is the variance of the first sample; `var2` is the variance of the second sample

Preconditions:

- The datasets described by the two Univariates must each contain at least 2 observations.

Specified by:
  `t` in interface `TTest`
Parameters:
  `sampleStats1` - StatisticalSummary describing data from the first sample
  `sampleStats2` - StatisticalSummary describing data from the second sample
Returns:
  t statistic
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met

#### homoscedasticT

    public double homoscedasticT(StatisticalSummary sampleStats1,
                        StatisticalSummary sampleStats2)
                          throws java.lang.IllegalArgumentException

Computes a 2-sample t statistic, comparing the means of the datasets described by two `StatisticalSummary` instances, under the assumption of equal subpopulation variances. To compute a t-statistic without the equal variances assumption, use `t(StatisticalSummary, StatisticalSummary)`.

This statistic can be used to perform a (homoscedastic) two-sample t-test to compare sample means.

The t-statisitc returned is

`t = (m1 - m2) / (sqrt(1/n1 +1/n2) sqrt(var))`

where `n1` is the size of first sample; `n2` is the size of second sample; `m1` is the mean of first sample; `m2` is the mean of second sample and `var` is the pooled variance estimate:

`var = sqrt(((n1 - 1)var1 + (n2 - 1)var2) / ((n1-1) + (n2-1)))`

with `var1``` the variance of the first sample and `var2` the variance of the second sample.

Preconditions:

- The datasets described by the two Univariates must each contain at least 2 observations.

Specified by:
  `homoscedasticT` in interface `TTest`
Parameters:
  `sampleStats1` - StatisticalSummary describing data from the first sample
  `sampleStats2` - StatisticalSummary describing data from the second sample
Returns:
  t statistic
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met

#### tTest

    public double tTest(double mu,
               double[] sample)
                 throws java.lang.IllegalArgumentException,
                        MathException

Returns the observed significance level, or p-value, associated with a one-sample, two-tailed t-test comparing the mean of the input array with the constant `mu`.

The number returned is the smallest significance level at which one can reject the null hypothesis that the mean equals `mu` in favor of the two-sided alternative that the mean is different from `mu`. For a one-sided test, divide the returned value by 2.

Usage Note:
The validity of the test depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The observed array length must be at least 2.

Specified by:
  `tTest` in interface `TTest`
Parameters:
  `mu` - constant value to compare sample mean against
  `sample` - array of sample data values
Returns:
  p-value
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error occurs computing the p-value

#### tTest

    public boolean tTest(double mu,
                double[] sample,
                double alpha)
                  throws java.lang.IllegalArgumentException,
                         MathException

Performs a two-sided t-test evaluating the null hypothesis that the mean of the population from which `sample` is drawn equals `mu`.

Returns `true` iff the null hypothesis can be rejected with confidence `1 - alpha`. To perform a 1-sided test, use `alpha * 2`

Examples:

1. To test the (2-sided) hypothesis `sample mean = mu` at the 95% level, use
   `tTest(mu, sample, 0.05)`
2. To test the (one-sided) hypothesis `sample mean < mu` at the 99% level, first verify that the measured sample mean is less than `mu` and then use
   `tTest(mu, sample, 0.02)`

Usage Note:
The validity of the test depends on the assumptions of the one-sample parametric t-test procedure, as discussed here

Preconditions:

- The observed array length must be at least 2.

Specified by:
  `tTest` in interface `TTest`
Parameters:
  `mu` - constant value to compare sample mean against
  `sample` - array of sample data values
  `alpha` - significance level of the test
Returns:
  p-value
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error computing the p-value

#### tTest

    public double tTest(double mu,
               StatisticalSummary sampleStats)
                 throws java.lang.IllegalArgumentException,
                        MathException

Returns the observed significance level, or p-value, associated with a one-sample, two-tailed t-test comparing the mean of the dataset described by `sampleStats` with the constant `mu`.

The number returned is the smallest significance level at which one can reject the null hypothesis that the mean equals `mu` in favor of the two-sided alternative that the mean is different from `mu`. For a one-sided test, divide the returned value by 2.

Usage Note:
The validity of the test depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The sample must contain at least 2 observations.

Specified by:
  `tTest` in interface `TTest`
Parameters:
  `mu` - constant value to compare sample mean against
  `sampleStats` - StatisticalSummary describing sample data
Returns:
  p-value
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error occurs computing the p-value

#### tTest

    public boolean tTest(double mu,
                StatisticalSummary sampleStats,
                double alpha)
                  throws java.lang.IllegalArgumentException,
                         MathException

Performs a two-sided t-test evaluating the null hypothesis that the mean of the population from which the dataset described by `stats` is drawn equals `mu`.

Returns `true` iff the null hypothesis can be rejected with confidence `1 - alpha`. To perform a 1-sided test, use `alpha * 2.`

Examples:

1. To test the (2-sided) hypothesis `sample mean = mu` at the 95% level, use
   `tTest(mu, sampleStats, 0.05)`
2. To test the (one-sided) hypothesis `sample mean < mu` at the 99% level, first verify that the measured sample mean is less than `mu` and then use
   `tTest(mu, sampleStats, 0.02)`

Usage Note:
The validity of the test depends on the assumptions of the one-sample parametric t-test procedure, as discussed here

Preconditions:

- The sample must include at least 2 observations.

Specified by:
  `tTest` in interface `TTest`
Parameters:
  `mu` - constant value to compare sample mean against
  `sampleStats` - StatisticalSummary describing sample data values
  `alpha` - significance level of the test
Returns:
  p-value
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error occurs computing the p-value

#### tTest

    public double tTest(double[] sample1,
               double[] sample2)
                 throws java.lang.IllegalArgumentException,
                        MathException

Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the input arrays.

The number returned is the smallest significance level at which one can reject the null hypothesis that the two means are equal in favor of the two-sided alternative that they are different. For a one-sided test, divide the returned value by 2.

The test does not assume that the underlying popuation variances are equal and it uses approximated degrees of freedom computed from the sample data to compute the p-value. The t-statistic used is as defined in `t(double[], double[])` and the Welch-Satterthwaite approximation to the degrees of freedom is used, as described here. To perform the test under the assumption of equal subpopulation variances, use `homoscedasticTTest(double[], double[])`.

Usage Note:
The validity of the p-value depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The observed array lengths must both be at least 2.

Specified by:
  `tTest` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
Returns:
  p-value for t-test
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error occurs computing the p-value

#### homoscedasticTTest

    public double homoscedasticTTest(double[] sample1,
                            double[] sample2)
                              throws java.lang.IllegalArgumentException,
                                     MathException

Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the input arrays, under the assumption that the two samples are drawn from subpopulations with equal variances. To perform the test without the equal variances assumption, use `tTest(double[], double[])`.

The number returned is the smallest significance level at which one can reject the null hypothesis that the two means are equal in favor of the two-sided alternative that they are different. For a one-sided test, divide the returned value by 2.

A pooled variance estimate is used to compute the t-statistic. See `homoscedasticT(double[], double[])`. The sum of the sample sizes minus 2 is used as the degrees of freedom.

Usage Note:
The validity of the p-value depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The observed array lengths must both be at least 2.

Specified by:
  `homoscedasticTTest` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
Returns:
  p-value for t-test
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error occurs computing the p-value

#### tTest

    public boolean tTest(double[] sample1,
                double[] sample2,
                double alpha)
                  throws java.lang.IllegalArgumentException,
                         MathException

Performs a two-sided t-test evaluating the null hypothesis that `sample1` and `sample2` are drawn from populations with the same mean, with significance level `alpha`. This test does not assume that the subpopulation variances are equal. To perform the test assuming equal variances, use `homoscedasticTTest(double[], double[], double)`.

Returns `true` iff the null hypothesis that the means are equal can be rejected with confidence `1 - alpha`. To perform a 1-sided test, use `alpha / 2`

See `t(double[], double[])` for the formula used to compute the t-statistic. Degrees of freedom are approximated using the Welch-Satterthwaite approximation.

Examples:

1. To test the (2-sided) hypothesis `mean 1 = mean 2` at the 95% level, use
   `tTest(sample1, sample2, 0.05).`
2. To test the (one-sided) hypothesis `mean 1 < mean 2` at the 99% level, first verify that the measured mean of `sample 1` is less than the mean of `sample 2` and then use
   `tTest(sample1, sample2, 0.02)`

Usage Note:
The validity of the test depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The observed array lengths must both be at least 2.
- `0 < alpha < 0.5`

Specified by:
  `tTest` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
  `alpha` - significance level of the test
Returns:
  true if the null hypothesis can be rejected with confidence 1 - alpha
Throws:
  `java.lang.IllegalArgumentException` - if the preconditions are not met
  `MathException` - if an error occurs performing the test

#### homoscedasticTTest

    public boolean homoscedasticTTest(double[] sample1,
                             double[] sample2,
                             double alpha)
                               throws java.lang.IllegalArgumentException,
                                      MathException

Performs a two-sided t-test evaluating the null hypothesis that `sample1` and `sample2` are drawn from populations with the same mean, with significance level `alpha`, assuming that the subpopulation variances are equal. Use `tTest(double[], double[], double)` to perform the test without the assumption of equal variances.

Returns `true` iff the null hypothesis that the means are equal can be rejected with confidence `1 - alpha`. To perform a 1-sided test, use `alpha * 2.` To perform the test without the assumption of equal subpopulation variances, use `tTest(double[], double[], double)`.

A pooled variance estimate is used to compute the t-statistic. See `t(double[], double[])` for the formula. The sum of the sample sizes minus 2 is used as the degrees of freedom.

Examples:

1. To test the (2-sided) hypothesis `mean 1 = mean 2` at the 95% level, use
   `tTest(sample1, sample2, 0.05).`
2. To test the (one-sided) hypothesis `mean 1 < mean 2,` at the 99% level, first verify that the measured mean of `sample 1` is less than the mean of `sample 2` and then use
   `tTest(sample1, sample2, 0.02)`

Usage Note:
The validity of the test depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The observed array lengths must both be at least 2.
- `0 < alpha < 0.5`

Specified by:
  `homoscedasticTTest` in interface `TTest`
Parameters:
  `sample1` - array of sample data values
  `sample2` - array of sample data values
  `alpha` - significance level of the test
Returns:
  true if the null hypothesis can be rejected with confidence 1 - alpha
Throws:
  `java.lang.IllegalArgumentException` - if the preconditions are not met
  `MathException` - if an error occurs performing the test

#### tTest

    public double tTest(StatisticalSummary sampleStats1,
               StatisticalSummary sampleStats2)
                 throws java.lang.IllegalArgumentException,
                        MathException

Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the datasets described by two StatisticalSummary instances.

The number returned is the smallest significance level at which one can reject the null hypothesis that the two means are equal in favor of the two-sided alternative that they are different. For a one-sided test, divide the returned value by 2.

The test does not assume that the underlying popuation 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 `homoscedasticTTest(StatisticalSummary, StatisticalSummary)`.

Usage Note:
The validity of the p-value depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The datasets described by the two Univariates must each contain at least 2 observations.

Specified by:
  `tTest` in interface `TTest`
Parameters:
  `sampleStats1` - StatisticalSummary describing data from the first sample
  `sampleStats2` - StatisticalSummary describing data from the second sample
Returns:
  p-value for t-test
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error occurs computing the p-value

#### homoscedasticTTest

    public double homoscedasticTTest(StatisticalSummary sampleStats1,
                            StatisticalSummary sampleStats2)
                              throws java.lang.IllegalArgumentException,
                                     MathException

Returns the observed significance level, or p-value, associated with a two-sample, two-tailed t-test comparing the means of the datasets described by two StatisticalSummary instances, under the hypothesis of equal subpopulation variances. To perform a test without the equal variances assumption, use `tTest(StatisticalSummary, StatisticalSummary)`.

The number returned is the smallest significance level at which one can reject the null hypothesis that the two means are equal in favor of the two-sided alternative that they are different. For a one-sided test, divide the returned value by 2.

See `homoscedasticT(double[], double[])` for the formula used to compute the t-statistic. The sum of the sample sizes minus 2 is used as the degrees of freedom.

Usage Note:
The validity of the p-value depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The datasets described by the two Univariates must each contain at least 2 observations.

Specified by:
  `homoscedasticTTest` in interface `TTest`
Parameters:
  `sampleStats1` - StatisticalSummary describing data from the first sample
  `sampleStats2` - StatisticalSummary describing data from the second sample
Returns:
  p-value for t-test
Throws:
  `java.lang.IllegalArgumentException` - if the precondition is not met
  `MathException` - if an error occurs computing the p-value

#### tTest

    public boolean tTest(StatisticalSummary sampleStats1,
                StatisticalSummary sampleStats2,
                double alpha)
                  throws java.lang.IllegalArgumentException,
                         MathException

Performs a two-sided t-test evaluating the null hypothesis that `sampleStats1` and `sampleStats2` describe datasets drawn from populations with the same mean, with significance level `alpha`. This test does not assume that the subpopulation variances are equal. To perform the test under the equal variances assumption, use `homoscedasticTTest(StatisticalSummary, StatisticalSummary)`.

Returns `true` iff the null hypothesis that the means are equal can be rejected with confidence `1 - alpha`. To perform a 1-sided test, use `alpha * 2`

See `t(double[], double[])` for the formula used to compute the t-statistic. Degrees of freedom are approximated using the Welch-Satterthwaite approximation.

Examples:

1. To test the (2-sided) hypothesis `mean 1 = mean 2` at the 95%, use
   `tTest(sampleStats1, sampleStats2, 0.05)`
2. To test the (one-sided) hypothesis `mean 1 < mean 2` at the 99% level, first verify that the measured mean of `sample 1` is less than the mean of `sample 2` and then use
   `tTest(sampleStats1, sampleStats2, 0.02)`

Usage Note:
The validity of the test depends on the assumptions of the parametric t-test procedure, as discussed here

Preconditions:

- The datasets described by the two Univariates must each contain at least 2 observations.
- `0 < alpha < 0.5`

Specified by:
  `tTest` in interface `TTest`
Parameters:
  `sampleStats1` - StatisticalSummary describing sample data values
  `sampleStats2` - StatisticalSummary describing sample data values
  `alpha` - significance level of the test
Returns:
  true if the null hypothesis can be rejected with confidence 1 - alpha
Throws:
  `java.lang.IllegalArgumentException` - if the preconditions are not met
  `MathException` - if an error occurs performing the test

#### df

    protected double df(double v1,
            double v2,
            double n1,
            double n2)

Computes approximate degrees of freedom for 2-sample t-test.

Parameters:
  `v1` - first sample variance
  `v2` - second sample variance
  `n1` - first sample n
  `n2` - second sample n
Returns:
  approximate degrees of freedom

#### t

    protected double t(double m,
           double mu,
           double v,
           double n)

Computes t test statistic for 1-sample t-test.

Parameters:
  `m` - sample mean
  `mu` - constant to test against
  `v` - sample variance
  `n` - sample n
Returns:
  t test statistic

#### t

    protected double t(double m1,
           double m2,
           double v1,
           double v2,
           double n1,
           double n2)

Computes t test statistic for 2-sample t-test.

Does not assume that subpopulation variances are equal.

Parameters:
  `m1` - first sample mean
  `m2` - second sample mean
  `v1` - first sample variance
  `v2` - second sample variance
  `n1` - first sample n
  `n2` - second sample n
Returns:
  t test statistic

#### homoscedasticT

    protected double homoscedasticT(double m1,
                        double m2,
                        double v1,
                        double v2,
                        double n1,
                        double n2)

Computes t test statistic for 2-sample t-test under the hypothesis of equal subpopulation variances.

Parameters:
  `m1` - first sample mean
  `m2` - second sample mean
  `v1` - first sample variance
  `v2` - second sample variance
  `n1` - first sample n
  `n2` - second sample n
Returns:
  t test statistic

#### tTest

    protected double tTest(double m,
               double mu,
               double v,
               double n)
                    throws MathException

Computes p-value for 2-sided, 1-sample t-test.

Parameters:
  `m` - sample mean
  `mu` - constant to test against
  `v` - sample variance
  `n` - sample n
Returns:
  p-value
Throws:
  `MathException` - if an error occurs computing the p-value

#### tTest

    protected double tTest(double m1,
               double m2,
               double v1,
               double v2,
               double n1,
               double n2)
                    throws MathException

Computes p-value for 2-sided, 2-sample t-test.

Does not assume subpopulation variances are equal. Degrees of freedom are estimated from the data.

Parameters:
  `m1` - first sample mean
  `m2` - second sample mean
  `v1` - first sample variance
  `v2` - second sample variance
  `n1` - first sample n
  `n2` - second sample n
Returns:
  p-value
Throws:
  `MathException` - if an error occurs computing the p-value

#### homoscedasticTTest

    protected double homoscedasticTTest(double m1,
                            double m2,
                            double v1,
                            double v2,
                            double n1,
                            double n2)
                                 throws MathException

Computes p-value for 2-sided, 2-sample t-test, under the assumption of equal subpopulation variances.

The sum of the sample sizes minus 2 is used as degrees of freedom.

Parameters:
  `m1` - first sample mean
  `m2` - second sample mean
  `v1` - first sample variance
  `v2` - second sample variance
  `n1` - first sample n
  `n2` - second sample n
Returns:
  p-value
Throws:
  `MathException` - if an error occurs computing the p-value

#### setDistribution

    @Deprecated
    public void setDistribution(TDistribution value)

Deprecated. in 2.2 (to be removed in 3.0).
Modify the distribution used to compute inference statistics.

Parameters:
  `value` - the new distribution
Since:
  1.2

#### checkSignificanceLevel

    private void checkSignificanceLevel(double alpha)
                                 throws java.lang.IllegalArgumentException

Check significance level.

Parameters:
  `alpha` - significance level
Throws:
  `java.lang.IllegalArgumentException` - if significance level is out of bounds

#### checkSampleData

    private void checkSampleData(double[] data)
                          throws java.lang.IllegalArgumentException

Check sample data.

Parameters:
  `data` - sample data
Throws:
  `java.lang.IllegalArgumentException` - if there is not enough sample data

#### checkSampleData

    private void checkSampleData(StatisticalSummary stat)
                          throws java.lang.IllegalArgumentException

Check sample data.

Parameters:
  `stat` - statistical summary
Throws:
  `java.lang.IllegalArgumentException` - if there is not enough sample data