org.apache.commons.math3.distribution

## Class KolmogorovSmirnovDistribution

- java.lang.Object
- - org.apache.commons.math3.distribution.KolmogorovSmirnovDistribution

All Implemented Interfaces:
  Serializable

    public class KolmogorovSmirnovDistribution
    extends Object
    implements Serializable

Implementation of the Kolmogorov-Smirnov distribution.

Treats the distribution of the two-sided `P(D_n < d)` where `D_n = sup_x |G(x) - G_n (x)|` for the theoretical cdf `G` and the empirical cdf `G_n`.

This implementation is based on [1] with certain quick decisions for extreme values given in [2].

In short, when wanting to evaluate `P(D_n < d)`, the method in [1] is to write `d = (k - h) / n` for positive integer `k` and `0 <= h < 1`. Then `P(D_n < d) = (n! / n^n) * t_kk`, where `t_kk` is the `(k, k)`'th entry in the special matrix `H^n`, i.e. `H` to the `n`'th power.

References:

- [1] Evaluating Kolmogorov's Distribution by George Marsaglia, Wai Wan Tsang, and Jingbo Wang
- [2] Computing the Two-Sided Kolmogorov-Smirnov Distribution by Richard Simard and Pierre L'Ecuyer

Note that [1] contains an error in computing h, refer to MATH-437 for details.

Version:
  $Id: KolmogorovSmirnovDistribution.java 1416643 2012-12-03 19:37:14Z tn $
See Also:
  Kolmogorov-Smirnov test (Wikipedia), Serialized Form

### Field Summary

Fields
`private int` `n` Number of observations.
`private static long` `serialVersionUID` Serializable version identifier.

### Constructor Summary

Constructors
Constructor and Description
`KolmogorovSmirnovDistribution(int n)`

### Method Summary

Methods
`double` `cdf(double d)` Calculates `P(D_n < d)` using method described in [1] with quick decisions for extreme values given in [2] (see above).
`double` `cdf(double d, boolean exact)` Calculates `P(D_n < d)` using method described in [1] with quick decisions for extreme values given in [2] (see above).
`double` `cdfExact(double d)` Calculates `P(D_n < d)` using method described in [1] with quick decisions for extreme values given in [2] (see above).
`private FieldMatrix<BigFraction>` `createH(double d)` Creates `H` of size `m x m` as described in [1] (see above).
`private double` `exactK(double d)` Calculates the exact value of `P(D_n < d)` using method described in [1] and `BigFraction` (see above).
`private double` `roundedK(double d)` Calculates `P(D_n < d)` using method described in [1] and doubles (see above).

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

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

### Field Detail

#### serialVersionUID

    private static final long serialVersionUID

Serializable version identifier.

See Also:
  Constant Field Values

#### n

    private int n

Number of observations.

### Constructor Detail

#### KolmogorovSmirnovDistribution

    public KolmogorovSmirnovDistribution(int n)
                                  throws NotStrictlyPositiveException

Parameters:
  `n` - Number of observations
Throws:
  `NotStrictlyPositiveException` - if `n <= 0`

### Method Detail

#### cdf

    public double cdf(double d)
               throws MathArithmeticException

Calculates `P(D_n < d)` using method described in [1] with quick decisions for extreme values given in [2] (see above). The result is not exact as with `cdfExact(double)` because calculations are based on `double` rather than `BigFraction`.

Parameters:
  `d` - statistic
Returns:
  the two-sided probability of `P(D_n < d)`
Throws:
  `MathArithmeticException` - if algorithm fails to convert `h` to a `BigFraction` in expressing `d` as `(k - h) / m` for integer `k, m` and `0 <= h < 1`.

#### cdfExact

    public double cdfExact(double d)
                    throws MathArithmeticException

Calculates `P(D_n < d)` using method described in [1] with quick decisions for extreme values given in [2] (see above). The result is exact in the sense that BigFraction/BigReal is used everywhere at the expense of very slow execution time. Almost never choose this in real applications unless you are very sure; this is almost solely for verification purposes. Normally, you would choose `cdf(double)`

Parameters:
  `d` - statistic
Returns:
  the two-sided probability of `P(D_n < d)`
Throws:
  `MathArithmeticException` - if algorithm fails to convert `h` to a `BigFraction` in expressing `d` as `(k - h) / m` for integer `k, m` and `0 <= h < 1`.

#### cdf

    public double cdf(double d,
             boolean exact)
               throws MathArithmeticException

Calculates `P(D_n < d)` using method described in [1] with quick decisions for extreme values given in [2] (see above).

Parameters:
  `d` - statistic
  `exact` - whether the probability should be calculated exact using `BigFraction` everywhere at the expense of very slow execution time, or if `double` should be used convenient places to gain speed. Almost never choose `true` in real applications unless you are very sure; `true` is almost solely for verification purposes.
Returns:
  the two-sided probability of `P(D_n < d)`
Throws:
  `MathArithmeticException` - if algorithm fails to convert `h` to a `BigFraction` in expressing `d` as `(k - h) / m` for integer `k, m` and `0 <= h < 1`.

#### exactK

    private double exactK(double d)
                   throws MathArithmeticException

Calculates the exact value of `P(D_n < d)` using method described in [1] and `BigFraction` (see above).

Parameters:
  `d` - statistic
Returns:
  the two-sided probability of `P(D_n < d)`
Throws:
  `MathArithmeticException` - if algorithm fails to convert `h` to a `BigFraction` in expressing `d` as `(k - h) / m` for integer `k, m` and `0 <= h < 1`.

#### roundedK

    private double roundedK(double d)
                     throws MathArithmeticException

Calculates `P(D_n < d)` using method described in [1] and doubles (see above).

Parameters:
  `d` - statistic
Returns:
  the two-sided probability of `P(D_n < d)`
Throws:
  `MathArithmeticException` - if algorithm fails to convert `h` to a `BigFraction` in expressing `d` as `(k - h) / m` for integer `k, m` and `0 <= h < 1`.

#### createH

    private FieldMatrix<BigFraction> createH(double d)
                                      throws NumberIsTooLargeException,
                                             FractionConversionException

Creates `H` of size `m x m` as described in [1] (see above).

Parameters:
  `d` - statistic
Returns:
  H matrix
Throws:
  `NumberIsTooLargeException` - if fractional part is greater than 1
  `FractionConversionException` - if algorithm fails to convert `h` to a `BigFraction` in expressing `d` as `(k - h) / m` for integer `k, m` and `0 <= h < 1`.