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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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`.

Copyright (c) 2003-2013 Apache Software Foundation