/*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    *
    *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package org.apache.commons.statistics.inference;
  
  import java.util.Arrays;
  import java.util.Objects;
  import java.util.function.DoubleSupplier;
  import java.util.function.DoubleUnaryOperator;
  import java.util.function.IntToDoubleFunction;
  import org.apache.commons.numbers.combinatorics.BinomialCoefficientDouble;
  import org.apache.commons.numbers.combinatorics.Factorial;
  import org.apache.commons.numbers.core.ArithmeticUtils;
  import org.apache.commons.numbers.core.Sum;
  import org.apache.commons.rng.UniformRandomProvider;
  
  /**
   * Implements the Kolmogorov-Smirnov (K-S) test for equality of continuous distributions.
   *
   * <p>The one-sample test uses a D statistic based on the maximum deviation of the empirical
   * distribution of sample data points from the distribution expected under the null hypothesis.
   *
   * <p>The two-sample test uses a D statistic based on the maximum deviation of the two empirical
   * distributions of sample data points. The two-sample tests evaluate the null hypothesis that
   * the two samples {@code x} and {@code y} come from the same underlying distribution.
   *
   * <p>References:
   * <ol>
   * <li>
   * Marsaglia, G., Tsang, W. W., &amp; Wang, J. (2003).
   * <a href="https://doi.org/10.18637/jss.v008.i18">Evaluating Kolmogorov's Distribution.</a>
   * Journal of Statistical Software, 8(18), 1–4.
   * <li>Simard, R., &amp; L’Ecuyer, P. (2011).
   * <a href="https://doi.org/10.18637/jss.v039.i11">Computing the Two-Sided Kolmogorov-Smirnov Distribution.</a>
   * Journal of Statistical Software, 39(11), 1–18.
   * <li>Sekhon, J. S. (2011).
   * <a href="https://doi.org/10.18637/jss.v042.i07">
   * Multivariate and Propensity Score Matching Software with Automated Balance Optimization:
   * The Matching package for R.</a>
   * Journal of Statistical Software, 42(7), 1–52.
   * <li>Viehmann, T (2021).
   * <a href="https://doi.org/10.48550/arXiv.2102.08037">
   * Numerically more stable computation of the p-values for the two-sample Kolmogorov-Smirnov test.</a>
   * arXiv:2102.08037
   * <li>Hodges, J. L. (1958).
   * <a href="https://doi.org/10.1007/BF02589501">
   * The significance probability of the smirnov two-sample test.</a>
   * Arkiv for Matematik, 3(5), 469-486.
   * </ol>
   *
   * <p>Note that [1] contains an error in computing h, refer to <a
   * href="https://issues.apache.org/jira/browse/MATH-437">MATH-437</a> for details.
   *
   * @see <a href="https://en.wikipedia.org/wiki/Kolmogorov-Smirnov_test">
   * Kolmogorov-Smirnov (K-S) test (Wikipedia)</a>
   * @since 1.1
   */
  public final class KolmogorovSmirnovTest {
      /** Name for sample 1. */
      private static final String SAMPLE_1_NAME = "Sample 1";
      /** Name for sample 2. */
      private static final String SAMPLE_2_NAME = "Sample 2";
      /** When the largest sample size exceeds this value, 2-sample test AUTO p-value
       * uses an asymptotic distribution to compute the p-value. */
      private static final int LARGE_SAMPLE = 10000;
      /** Maximum finite factorial. */
      private static final int MAX_FACTORIAL = 170;
      /** Maximum length of an array. This is used to determine if two arrays can be concatenated
       * to create a sampler from the joint distribution. The limit is copied from the limit
       * of java.util.ArrayList. */
      private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
      /** The maximum least common multiple (lcm) to attempt the exact p-value computation.
       * The integral d value is in [0, n*m] in steps of the greatest common denominator (gcd),
       * thus lcm = n*m/gcd is the number of possible different p-values.
       * Some methods have a lower limit due to computation limits. This should be larger
       * than LARGE_SAMPLE^2 so all AUTO p-values attempt an exact computation, i.e.
       * at least 10000^2 ~ 2^26.56. */
      private static final long MAX_LCM_TWO_SAMPLE_EXACT_P = 1L << 31;
      /** Placeholder to use for the two-sample sign array when the value can be ignored. */
      private static final int[] IGNORED_SIGN = new int[1];
      /** Placeholder to use for the two-sample ties D array when the value can be ignored. */
      private static final long[] IGNORED_D = new long[2];
      /** Default instance. */
      private static final KolmogorovSmirnovTest DEFAULT = new KolmogorovSmirnovTest(
          AlternativeHypothesis.TWO_SIDED, PValueMethod.AUTO, false, null, 1000);
 
     /** Alternative hypothesis. */
     private final AlternativeHypothesis alternative;
     /** Method to compute the p-value. */
     private final PValueMethod pValueMethod;
     /** Use a strict inequality for the two-sample exact p-value. */
     private final boolean strictInequality;
     /** Source of randomness. */
     private final UniformRandomProvider rng;
     /** Number of iterations . */
     private final int iterations;
 
     /**
      * Result for the one-sample Kolmogorov-Smirnov test.
      *
      * <p>This class is immutable.
      *
      * @since 1.1
      */
     public static class OneResult extends BaseSignificanceResult {
         /** Sign of the statistic. */
         private final int sign;
 
         /**
          * Create an instance.
          *
          * @param statistic Test statistic.
          * @param sign Sign of the statistic.
          * @param p Result p-value.
          */
         OneResult(double statistic, int sign, double p) {
             super(statistic, p);
             this.sign = sign;
         }
 
         /**
          * Gets the sign of the statistic. This is 1 for \(D^+\) and -1 for \(D^-\).
          * For a two sided-test this is zero if the magnitude of \(D^+\) and \(D^-\) was equal;
          * otherwise the sign indicates the larger of \(D^+\) or \(D^-\).
          *
          * @return the sign
          */
         public int getSign() {
             return sign;
         }
     }
 
     /**
      * Result for the two-sample Kolmogorov-Smirnov test.
      *
      * <p>This class is immutable.
      *
      * @since 1.1
      */
     public static final class TwoResult extends OneResult {
         /** Flag to indicate there were significant ties.
          * Note that in extreme cases there may be significant ties despite {@code upperD == D}
          * due to rounding when converting the integral statistic to a double. For this
          * reason the presence of ties is stored as a flag. */
         private final boolean significantTies;
         /** Upper bound of the D statistic from all possible paths through regions with ties. */
         private final double upperD;
         /** The p-value of the upper D value. */
         private final double upperP;
 
         /**
          * Create an instance.
          *
          * @param statistic Test statistic.
          * @param sign Sign of the statistic.
          * @param p Result p-value.
          * @param significantTies Flag to indicate there were significant ties.
          * @param upperD Upper bound of the D statistic from all possible paths through
          * regions with ties.
          * @param upperP The p-value of the upper D value.
          */
         TwoResult(double statistic, int sign, double p, boolean significantTies, double upperD, double upperP) {
             super(statistic, sign, p);
             this.significantTies = significantTies;
             this.upperD = upperD;
             this.upperP = upperP;
         }
 
         /**
          * {@inheritDoc}
          *
          * <p><strong>Ties</strong>
          *
          * <p>The presence of ties in the data creates a distribution for the D values generated
          * by all possible orderings of the tied regions. This statistic is computed using the
          * path with the <em>minimum</em> effect on the D statistic.
          *
          * <p>For a one-sided statistic \(D^+\) or \(D^-\), this is the lower bound of the D statistic.
          *
          * <p>For a two-sided statistic D, this may be <em>below</em> the lower bound of the
          * distribution of all possible D values. This case occurs when the number of ties
          * is very high and is identified by a {@link #getPValue() p-value} of 1.
          *
          * <p>If the two-sided statistic is zero this only occurs in the presence of ties:
          * either the two arrays are identical, are 'identical' data of a single value
          * (sample sizes may be different), or have a sequence of ties of 'identical' data
          * with a net zero effect on the D statistic, e.g.
          * <pre>
          *  [1,2,3]           vs [1,2,3]
          *  [0,0,0,0]         vs [0,0,0]
          *  [0,0,0,0,1,1,1,1] vs [0,0,0,1,1,1]
          * </pre>
          */
         @Override
         public double getStatistic() {
             // Note: This method is here for documentation
             return super.getStatistic();
         }
 
         /**
          * Returns {@code true} if there were ties between samples that occurred
          * in a region which could change the D statistic if the ties were resolved to
          * a defined order.
          *
          * <p>Ties between the data can be interpreted as if the values were different
          * but within machine epsilon. In this case the order within the tie region is not known.
          * If the most extreme ordering of any tied regions (e.g. all tied values of {@code x}
          * before all tied values of {@code y}) could create a larger D statistic this
          * method will return {@code true}.
          *
          * <p>If there were no ties, or all possible orderings of tied regions create the same
          * D statistic, this method returns {@code false}.
          *
          * <p>Note it is possible that this method returns {@code true} when {@code D == upperD}
          * due to rounding when converting the computed D statistic to a double. This will
          * only occur for large sample sizes {@code n} and {@code m} where the product
          * {@code n*m >= 2^53}.
          *
          * @return true if the D statistic could be changed by resolution of ties
          * @see #getUpperD()
          */
         public boolean hasSignificantTies() {
             return significantTies;
         }
 
         /**
          * Return the upper bound of the D statistic from all possible paths through regions with ties.
          *
          * <p>This will return a value equal to or greater than {@link #getStatistic()}.
          *
          * @return the upper bound of D
          * @see #hasSignificantTies()
          */
         public double getUpperD() {
             return upperD;
         }
 
         /**
          * Return the p-value of the upper bound of the D statistic.
          *
          * <p>If computed, this will return a value equal to or less than
          * {@link #getPValue() getPValue}. It may be orders of magnitude smaller.
          *
          * <p>Note: This p-value corresponds to the most extreme p-value from all possible
          * orderings of tied regions. It is <strong>not</strong> recommended to use this to
          * reject the null hypothesis. The upper bound of D and the corresponding p-value
          * provide information that must be interpreted in the context of the sample data and
          * used to inform a decision on the suitability of the test to the data.
          *
          * <p>This value is set to {@link Double#NaN NaN} if the {@link #getPValue() p-value} was
          * {@linkplain PValueMethod#ESTIMATE estimated}. The estimated p-value will have been created
          * using a distribution of possible D values given the underlying joint distribution of
          * the sample data. Comparison of the p-value to the upper p-value is not applicable.
          *
          * @return the p-value of the upper bound of D (or NaN)
          * @see #getUpperD()
          */
         public double getUpperPValue() {
             return upperP;
         }
     }
 
     /**
      * @param alternative Alternative hypothesis.
      * @param method P-value method.
      * @param strict true to use a strict inequality.
      * @param rng Source of randomness.
      * @param iterations Number of iterations.
      */
     private KolmogorovSmirnovTest(AlternativeHypothesis alternative, PValueMethod method, boolean strict,
         UniformRandomProvider rng, int iterations) {
         this.alternative = alternative;
         this.pValueMethod = method;
         this.strictInequality = strict;
         this.rng = rng;
         this.iterations = iterations;
     }
 
     /**
      * Return an instance using the default options.
      *
      * <ul>
      * <li>{@link AlternativeHypothesis#TWO_SIDED}
      * <li>{@link PValueMethod#AUTO}
      * <li>{@link Inequality#NON_STRICT}
      * <li>{@linkplain #with(UniformRandomProvider) RNG = none}
      * <li>{@linkplain #withIterations(int) Iterations = 1000}
      * </ul>
      *
      * @return default instance
      */
     public static KolmogorovSmirnovTest withDefaults() {
         return DEFAULT;
     }
 
     /**
      * Return an instance with the configured alternative hypothesis.
      *
      * @param v Value.
      * @return an instance
      */
     public KolmogorovSmirnovTest with(AlternativeHypothesis v) {
         return new KolmogorovSmirnovTest(Objects.requireNonNull(v), pValueMethod, strictInequality, rng, iterations);
     }
 
     /**
      * Return an instance with the configured p-value method.
      *
      * <p>For the one-sample two-sided test Kolmogorov's asymptotic approximation can be used;
      * otherwise the p-value uses the distribution of the D statistic.
      *
      * <p>For the two-sample test the exact p-value can be computed for small sample sizes;
      * otherwise the p-value resorts to the asymptotic approximation. Alternatively a p-value
      * can be estimated from the combined distribution of the samples. This requires a source
      * of randomness.
      *
      * @param v Value.
      * @return an instance
      * @see #with(UniformRandomProvider)
      */
     public KolmogorovSmirnovTest with(PValueMethod v) {
         return new KolmogorovSmirnovTest(alternative, Objects.requireNonNull(v), strictInequality, rng, iterations);
     }
 
     /**
      * Return an instance with the configured inequality.
      *
      * <p>Computes the p-value for the two-sample test as \(P(D_{n,m} &gt; d)\) if strict;
      * otherwise \(P(D_{n,m} \ge d)\), where \(D_{n,m}\) is the 2-sample
      * Kolmogorov-Smirnov statistic, either the two-sided \(D_{n,m}\) or one-sided
      * \(D_{n,m}^+\) or \(D_{n,m}^-\).
      *
      * @param v Value.
      * @return an instance
      */
     public KolmogorovSmirnovTest with(Inequality v) {
         return new KolmogorovSmirnovTest(alternative, pValueMethod,
             Objects.requireNonNull(v) == Inequality.STRICT, rng, iterations);
     }
 
     /**
      * Return an instance with the configured source of randomness.
      *
      * <p>Applies to the two-sample test when the p-value method is set to
      * {@link PValueMethod#ESTIMATE ESTIMATE}. The randomness
      * is used for sampling of the combined distribution.
      *
      * <p>There is no default source of randomness. If the randomness is not
      * set then estimation is not possible and an {@link IllegalStateException} will be
      * raised in the two-sample test.
      *
      * @param v Value.
      * @return an instance
      * @see #with(PValueMethod)
      */
     public KolmogorovSmirnovTest with(UniformRandomProvider v) {
         return new KolmogorovSmirnovTest(alternative, pValueMethod, strictInequality,
             Objects.requireNonNull(v), iterations);
     }
 
     /**
      * Return an instance with the configured number of iterations.
      *
      * <p>Applies to the two-sample test when the p-value method is set to
      * {@link PValueMethod#ESTIMATE ESTIMATE}. This is the number of sampling iterations
      * used to estimate the p-value. The p-value is a fraction using the {@code iterations}
      * as the denominator. The number of significant digits in the p-value is
      * upper bounded by log<sub>10</sub>(iterations); small p-values have fewer significant
      * digits. A large number of iterations is recommended when using a small critical
      * value to reject the null hypothesis.
      *
      * @param v Value.
      * @return an instance
      * @throws IllegalArgumentException if the number of iterations is not strictly positive
      */
     public KolmogorovSmirnovTest withIterations(int v) {
         return new KolmogorovSmirnovTest(alternative, pValueMethod, strictInequality, rng,
             Arguments.checkStrictlyPositive(v));
     }
 
     /**
      * Computes the one-sample Kolmogorov-Smirnov test statistic.
      *
      * <ul>
      * <li>two-sided: \(D_n=\sup_x |F_n(x)-F(x)|\)
      * <li>greater: \(D_n^+=\sup_x (F_n(x)-F(x))\)
      * <li>less: \(D_n^-=\sup_x (F(x)-F_n(x))\)
      * </ul>
      *
      * <p>where \(F\) is the distribution cumulative density function ({@code cdf}),
      * \(n\) is the length of {@code x} and \(F_n\) is the empirical distribution that puts
      * mass \(1/n\) at each of the values in {@code x}.
      *
      * <p>The cumulative distribution function should map a real value {@code x} to a probability
      * in [0, 1]. To use a reference distribution the CDF can be passed using a method reference:
      * <pre>
      * UniformContinuousDistribution dist = UniformContinuousDistribution.of(0, 1);
      * UniformRandomProvider rng = RandomSource.KISS.create(123);
      * double[] x = dist.sampler(rng).samples(100);
      * double d = KolmogorovSmirnovTest.withDefaults().statistic(x, dist::cumulativeProbability);
      * </pre>
      *
      * @param cdf Reference cumulative distribution function.
      * @param x Sample being evaluated.
      * @return Kolmogorov-Smirnov statistic
      * @throws IllegalArgumentException if {@code data} does not have length at least 2; or contains NaN values.
      * @see #test(double[], DoubleUnaryOperator)
      */
     public double statistic(double[] x, DoubleUnaryOperator cdf) {
         return computeStatistic(x, cdf, IGNORED_SIGN);
     }
 
     /**
      * Computes the two-sample Kolmogorov-Smirnov test statistic.
      *
      * <ul>
      * <li>two-sided: \(D_{n,m}=\sup_x |F_n(x)-F_m(x)|\)
      * <li>greater: \(D_{n,m}^+=\sup_x (F_n(x)-F_m(x))\)
      * <li>less: \(D_{n,m}^-=\sup_x (F_m(x)-F_n(x))\)
      * </ul>
      *
      * <p>where \(n\) is the length of {@code x}, \(m\) is the length of {@code y}, \(F_n\) is the
      * empirical distribution that puts mass \(1/n\) at each of the values in {@code x} and \(F_m\)
      * is the empirical distribution that puts mass \(1/m\) at each of the values in {@code y}.
      *
      * @param x First sample.
      * @param y Second sample.
      * @return Kolmogorov-Smirnov statistic
      * @throws IllegalArgumentException if either {@code x} or {@code y} does not
      * have length at least 2; or contain NaN values.
      * @see #test(double[], double[])
      */
     public double statistic(double[] x, double[] y) {
         final int n = checkArrayLength(x);
         final int m = checkArrayLength(y);
         // Clone to avoid destructive modification of input
         final long dnm = computeIntegralKolmogorovSmirnovStatistic(x.clone(), y.clone(),
                 IGNORED_SIGN, IGNORED_D);
         // Re-use the method to compute D in [0, 1] for consistency
         return computeD(dnm, n, m, ArithmeticUtils.gcd(n, m));
     }
 
     /**
      * Performs a one-sample Kolmogorov-Smirnov test evaluating the null hypothesis
      * that {@code x} conforms to the distribution cumulative density function ({@code cdf}).
      *
      * <p>The test is defined by the {@link AlternativeHypothesis}:
      * <ul>
      * <li>Two-sided evaluates the null hypothesis that the two distributions are
      * identical, \(F_n(i) = F(i)\) for all \( i \); the alternative is that the are not
      * identical. The statistic is \( max(D_n^+, D_n^-) \) and the sign of \( D \) is provided.
      * <li>Greater evaluates the null hypothesis that the \(F_n(i) &lt;= F(i)\) for all \( i \);
      * the alternative is \(F_n(i) &gt; F(i)\) for at least one \( i \). The statistic is \( D_n^+ \).
      * <li>Less evaluates the null hypothesis that the \(F_n(i) &gt;= F(i)\) for all \( i \);
      * the alternative is \(F_n(i) &lt; F(i)\) for at least one \( i \). The statistic is \( D_n^- \).
      * </ul>
      *
      * <p>The p-value method defaults to exact. The one-sided p-value uses Smirnov's stable formula:
      *
      * <p>\[ P(D_n^+ \ge x) = x \sum_{j=0}^{\lfloor n(1-x) \rfloor} \binom{n}{j} \left(\frac{j}{n} + x\right)^{j-1} \left(1-x-\frac{j}{n} \right)^{n-j} \]
      *
      * <p>The two-sided p-value is computed using methods described in
      * Simard &amp; L’Ecuyer (2011). The two-sided test supports an asymptotic p-value
      * using Kolmogorov's formula:
      *
      * <p>\[ \lim_{n\to\infty} P(\sqrt{n}D_n &gt; z) = 2 \sum_{i=1}^\infty (-1)^{i-1} e^{-2 i^2 z^2} \]
      *
      * @param x Sample being being evaluated.
      * @param cdf Reference cumulative distribution function.
      * @return test result
      * @throws IllegalArgumentException if {@code data} does not have length at least 2; or contains NaN values.
      * @see #statistic(double[], DoubleUnaryOperator)
      */
     public OneResult test(double[] x, DoubleUnaryOperator cdf) {
         final int[] sign = {0};
         final double d = computeStatistic(x, cdf, sign);
         final double p;
         if (alternative == AlternativeHypothesis.TWO_SIDED) {
             PValueMethod method = pValueMethod;
             if (method == PValueMethod.AUTO) {
                 // No switch to the asymptotic for large n
                 method = PValueMethod.EXACT;
             }
             if (method == PValueMethod.ASYMPTOTIC) {
                 // Kolmogorov's asymptotic formula using z = sqrt(n) * d
                 p = KolmogorovSmirnovDistribution.ksSum(Math.sqrt(x.length) * d);
             } else {
                 // exact
                 p = KolmogorovSmirnovDistribution.Two.sf(d, x.length);
             }
         } else {
             // one-sided: always use exact
             p = KolmogorovSmirnovDistribution.One.sf(d, x.length);
         }
         return new OneResult(d, sign[0], p);
     }
 
     /**
      * Performs a two-sample Kolmogorov-Smirnov test on samples {@code x} and {@code y}.
      * Test the empirical distributions \(F_n\) and \(F_m\) where \(n\) is the length
      * of {@code x}, \(m\) is the length of {@code y}, \(F_n\) is the empirical distribution
      * that puts mass \(1/n\) at each of the values in {@code x} and \(F_m\) is the empirical
      * distribution that puts mass \(1/m\) of the {@code y} values.
      *
      * <p>The test is defined by the {@link AlternativeHypothesis}:
      * <ul>
      * <li>Two-sided evaluates the null hypothesis that the two distributions are
      * identical, \(F_n(i) = F_m(i)\) for all \( i \); the alternative is that they are not
      * identical. The statistic is \( max(D_n^+, D_n^-) \) and the sign of \( D \) is provided.
      * <li>Greater evaluates the null hypothesis that the \(F_n(i) &lt;= F_m(i)\) for all \( i \);
      * the alternative is \(F_n(i) &gt; F_m(i)\) for at least one \( i \). The statistic is \( D_n^+ \).
      * <li>Less evaluates the null hypothesis that the \(F_n(i) &gt;= F_m(i)\) for all \( i \);
      * the alternative is \(F_n(i) &lt; F_m(i)\) for at least one \( i \). The statistic is \( D_n^- \).
      * </ul>
      *
      * <p>If the {@linkplain PValueMethod p-value method} is auto, then an exact p computation
      * is attempted if both sample sizes are less than 10000 using the methods presented in
      * Viehmann (2021) and Hodges (1958); otherwise an asymptotic p-value is returned.
      * The two-sided p-value is \(\overline{F}(d, \sqrt{mn / (m + n)})\) where \(\overline{F}\)
      * is the complementary cumulative density function of the two-sided one-sample
      * Kolmogorov-Smirnov distribution. The one-sided p-value uses an approximation from
      * Hodges (1958) Eq 5.3.
      *
      * <p>\(D_{n,m}\) has a discrete distribution. This makes the p-value associated with the
      * null hypothesis \(H_0 : D_{n,m} \gt d \) differ from \(H_0 : D_{n,m} \ge d \)
      * by the mass of the observed value \(d\). These can be distinguished using an
      * {@link Inequality} parameter. This is ignored for large samples.
      *
      * <p>If the data contains ties there is no defined ordering in the tied region to use
      * for the difference between the two empirical distributions. Each ordering of the
      * tied region <em>may</em> create a different D statistic. All possible orderings
      * generate a distribution for the D value. In this case the tied region is traversed
      * entirely and the effect on the D value evaluated at the end of the tied region.
      * This is the path with the least change on the D statistic. The path with the
      * greatest change on the D statistic is also computed as the upper bound on D.
      * If these two values are different then the tied region is known to generate a
      * distribution for the D statistic and the p-value is an over estimate for the cases
      * with a larger D statistic. The presence of any significant tied regions is returned
      * in the result.
      *
      * <p>If the p-value method is {@link PValueMethod#ESTIMATE ESTIMATE} then the p-value is
      * estimated by repeat sampling of the joint distribution of {@code x} and {@code y}.
      * The p-value is the frequency that a sample creates a D statistic
      * greater than or equal to (or greater than for strict inequality) the observed value.
      * In this case a source of randomness must be configured or an {@link IllegalStateException}
      * will be raised. The p-value for the upper bound on D will not be estimated and is set to
      * {@link Double#NaN NaN}. This estimation procedure is not affected by ties in the data
      * and is increasingly robust for larger datasets. The method is modeled after
      * <a href="https://sekhon.berkeley.edu/matching/ks.boot.html">ks.boot</a>
      * in the R {@code Matching} package (Sekhon (2011)).
      *
      * @param x First sample.
      * @param y Second sample.
      * @return test result
      * @throws IllegalArgumentException if either {@code x} or {@code y} does not
      * have length at least 2; or contain NaN values.
      * @throws IllegalStateException if the p-value method is {@link PValueMethod#ESTIMATE ESTIMATE}
      * and there is no source of randomness.
      * @see #statistic(double[], double[])
      */
     public TwoResult test(double[] x, double[] y) {
         final int n = checkArrayLength(x);
         final int m = checkArrayLength(y);
         PValueMethod method = pValueMethod;
         final int[] sign = {0};
         final long[] tiesD = {0, 0};
 
         final double[] sx = x.clone();
         final double[] sy = y.clone();
         final long dnm = computeIntegralKolmogorovSmirnovStatistic(sx, sy, sign, tiesD);
 
         // Compute p-value. Note that the p-value is not invalidated by ties; it is the
         // D statistic that could be invalidated by resolution of the ties. So compute
         // the exact p even if ties are present.
         if (method == PValueMethod.AUTO) {
             // Use exact for small samples
             method = Math.max(n, m) < LARGE_SAMPLE ?
                 PValueMethod.EXACT :
                 PValueMethod.ASYMPTOTIC;
         }
         final int gcd = ArithmeticUtils.gcd(n, m);
         final double d = computeD(dnm, n, m, gcd);
         final boolean significantTies = tiesD[1] > dnm;
         final double d2 = significantTies ? computeD(tiesD[1], n, m, gcd) : d;
 
         final double p;
         double p2;
 
         // Allow bootstrap estimation of the p-value
         if (method == PValueMethod.ESTIMATE) {
             p = estimateP(sx, sy, dnm);
             p2 = Double.NaN;
         } else {
             final boolean exact = method == PValueMethod.EXACT;
             p = p2 = twoSampleP(dnm, n, m, gcd, d, exact);
             if (significantTies) {
                 // Compute the upper bound on D.
                 // The p-value is also computed. The alternative is to save the options
                 // in the result with (upper dnm, n, m) and compute it on-demand.
                 // Note detection of whether the exact P computation is possible is based on
                 // n and m, thus this will use the same computation.
                 p2 = twoSampleP(tiesD[1], n, m, gcd, d2, exact);
             }
         }
         return new TwoResult(d, sign[0], p, significantTies, d2, p2);
     }
 
     /**
      * Estimates the <i>p-value</i> of a two-sample Kolmogorov-Smirnov test evaluating the
      * null hypothesis that {@code x} and {@code y} are samples drawn from the same
      * probability distribution.
      *
      * <p>This method will destructively modify the input arrays (via a sort).
      *
      * <p>This method estimates the p-value by repeatedly sampling sets of size
      * {@code x.length} and {@code y.length} from the empirical distribution
      * of the combined sample. The memory requirement is an array copy of each of
      * the input arguments.
      *
      * <p>When using strict inequality, this is equivalent to the algorithm implemented in
      * the R function {@code ks.boot} as described in Sekhon (2011) Journal of Statistical
      * Software, 42(7), 1–52 [3].
      *
      * @param x First sample.
      * @param y Second sample.
      * @param dnm Integral D statistic.
      * @return p-value
      * @throws IllegalStateException if the source of randomness is null.
      */
     private double estimateP(double[] x, double[] y, long dnm) {
         if (rng == null) {
             throw new IllegalStateException("No source of randomness");
         }
 
         // Test if the random statistic is greater (strict), or greater or equal to d
         final long d = strictInequality ? dnm : dnm - 1;
 
         final long plus;
         final long minus;
         if (alternative == AlternativeHypothesis.GREATER_THAN) {
             plus = d;
             minus = Long.MIN_VALUE;
         } else if (alternative == AlternativeHypothesis.LESS_THAN) {
             plus = Long.MAX_VALUE;
             minus = -d;
         } else {
             // two-sided
             plus = d;
             minus = -d;
         }
 
         // Test dnm=0. This occurs for example when x == y.
         if (0 < minus || 0 > plus) {
             // Edge case where all possible d will be outside the inclusive bounds
             return 1;
         }
 
         // Sample randomly with replacement from the combined distribution.
         final DoubleSupplier gen = createSampler(x, y, rng);
         int count = 0;
         for (int i = iterations; i > 0; i--) {
             for (int j = 0; j < x.length; j++) {
                 x[j] = gen.getAsDouble();
             }
             for (int j = 0; j < y.length; j++) {
                 y[j] = gen.getAsDouble();
             }
             if (testIntegralKolmogorovSmirnovStatistic(x, y, plus, minus)) {
                 count++;
             }
         }
         return count / (double) iterations;
     }
 
     /**
      * Computes the magnitude of the one-sample Kolmogorov-Smirnov test statistic.
      * The sign of the statistic is optionally returned in {@code sign}. For the two-sided case
      * the sign is 0 if the magnitude of D+ and D- was equal; otherwise it indicates which D
      * had the larger magnitude.
      *
      * @param x Sample being evaluated.
      * @param cdf Reference cumulative distribution function.
      * @param sign Sign of the statistic (non-zero length).
      * @return Kolmogorov-Smirnov statistic
      * @throws IllegalArgumentException if {@code data} does not have length at least 2;
      * or contains NaN values.
      */
     private double computeStatistic(double[] x, DoubleUnaryOperator cdf, int[] sign) {
         final int n = checkArrayLength(x);
         final double nd = n;
         final double[] sx = sort(x.clone(), "Sample");
         // Note: ties in the data do not matter as we compare the empirical CDF
         // immediately before the value (i/n) and at the value (i+1)/n. For ties
         // of length m this would be (i-m+1)/n and (i+1)/n and the result is the same.
         double d = 0;
         if (alternative == AlternativeHypothesis.GREATER_THAN) {
             // Compute D+
             for (int i = 0; i < n; i++) {
                 final double yi = cdf.applyAsDouble(sx[i]);
                 final double dp = (i + 1) / nd - yi;
                 d = dp > d ? dp : d;
             }
             sign[0] = 1;
         } else if (alternative == AlternativeHypothesis.LESS_THAN) {
             // Compute D-
             for (int i = 0; i < n; i++) {
                 final double yi = cdf.applyAsDouble(sx[i]);
                 final double dn = yi - i / nd;
                 d = dn > d ? dn : d;
             }
             sign[0] = -1;
         } else {
             // Two sided.
             // Compute both (as unsigned) and return the sign indicating the largest result.
             double plus = 0;
             double minus = 0;
             for (int i = 0; i < n; i++) {
                 final double yi = cdf.applyAsDouble(sx[i]);
                 final double dn = yi - i / nd;
                 final double dp = (i + 1) / nd - yi;
                 minus = dn > minus ? dn : minus;
                 plus = dp > plus ? dp : plus;
             }
             sign[0] = Double.compare(plus, minus);
             d = Math.max(plus, minus);
         }
         return d;
     }
 
     /**
      * Computes the two-sample Kolmogorov-Smirnov test statistic. The statistic is integral
      * and has a value in {@code [0, n*m]}. Not all values are possible; the smallest
      * increment is the greatest common divisor of {@code n} and {@code m}.
      *
      * <p>This method will destructively modify the input arrays (via a sort).
      *
      * <p>The sign of the statistic is returned in {@code sign}. For the two-sided case
      * the sign is 0 if the magnitude of D+ and D- was equal; otherwise it indicates which D
      * had the larger magnitude. If the two-sided statistic is zero the two arrays are
      * identical, or are 'identical' data of a single value (sample sizes may be different),
      * or have a sequence of ties of 'identical' data with a net zero effect on the D statistic
      * e.g.
      * <pre>
      *  [1,2,3]           vs [1,2,3]
      *  [0,0,0,0]         vs [0,0,0]
      *  [0,0,0,0,1,1,1,1] vs [0,0,0,1,1,1]
      * </pre>
      *
      * <p>This method detects ties in the input data. Not all ties will invalidate the returned
      * statistic. Ties between the data can be interpreted as if the values were different
      * but within machine epsilon. In this case the path through the tie region is not known.
      * All paths through the tie region end at the same point. This method will compute the
      * most extreme path through each tie region and the D statistic for these paths. If the
      * ties D statistic is a larger magnitude than the returned D statistic then at least
      * one tie region lies at a point on the full path that could result in a different
      * statistic in the absence of ties. This signals the P-value computed using the returned
      * D statistic is one of many possible p-values given the data and how ties are resolved.
      * Note: The tiesD value may be smaller than the returned D statistic as it is not set
      * to the maximum of D or tiesD. The only result of interest is when {@code tiesD > D}
      * due to a tie region that can change the output D. On output {@code tiesD[0] != 0}
      * if there were ties between samples and {@code tiesD[1] = D} of the most extreme path
      * through the ties.
      *
      * @param x First sample (destructively modified by sort).
      * @param y Second sample  (destructively modified by sort).
      * @param sign Sign of the statistic (non-zero length).
      * @param tiesD Integral statistic for the most extreme path through any ties (length at least 2).
      * @return integral Kolmogorov-Smirnov statistic
      * @throws IllegalArgumentException if either {@code x} or {@code y} contain NaN values.
      */
     private long computeIntegralKolmogorovSmirnovStatistic(double[] x, double[] y, int[] sign, long[] tiesD) {
         // Sort the sample arrays
         sort(x, SAMPLE_1_NAME);
         sort(y, SAMPLE_2_NAME);
         final int n = x.length;
         final int m = y.length;
 
         // CDFs range from 0 to 1 using increments of 1/n and 1/m for x and y respectively.
         // Scale by n*m to use increments of m and n for x and y.
         // Find the max difference between cdf_x and cdf_y.
         int i = 0;
         int j = 0;
         long d = 0;
         long plus = 0;
         long minus = 0;
         // Ties: store the D+,D- for most extreme path though tie region(s)
         long tplus = 0;
         long tminus = 0;
         do {
             // No NaNs so compare using < and >
             if (x[i] < y[j]) {
                 final double z = x[i];
                 do {
                     i++;
                     d += m;
                 } while (i < n && x[i] == z);
                 plus = d > plus ? d : plus;
             } else if (x[i] > y[j]) {
                 final double z = y[j];
                 do {
                     j++;
                     d -= n;
                 } while (j < m && y[j] == z);
                 minus = d < minus ? d : minus;
             } else {
                 // Traverse to the end of the tied section for d.
                 // Also compute the most extreme path through the tied region.
                 final double z = x[i];
                 final long dd = d;
                 int k = i;
                 do {
                     i++;
                 } while (i < n && x[i] == z);
                 k = i - k;
                 d += k * (long) m;
                 // Extreme D+ path
                 tplus = d > tplus ? d : tplus;
                 k = j;
                 do {
                     j++;
                 } while (j < m && y[j] == z);
                 k = j - k;
                 d -= k * (long) n;
                 // Extreme D- path must start at the original d
                 tminus = Math.min(tminus, dd - k * (long) n);
                 // End of tied section
                 if (d > plus) {
                     plus = d;
                 } else if (d < minus) {
                     minus = d;
                 }
             }
         } while (i < n && j < m);
         // The presence of any ties is flagged by a non-zero value for D+ or D-.
         // Note we cannot use the selected tiesD value as in the one-sided case it may be zero
         // and the non-selected D value will be non-zero.
         tiesD[0] = tplus | tminus;
         // For simplicity the correct tiesD is not returned (correct value is commented).
         // The only case that matters is tiesD > D which is evaluated by the caller.
         // Note however that the distance of tiesD < D is a measure of how little the
         // tied region matters.
         if (alternative == AlternativeHypothesis.GREATER_THAN) {
             sign[0] = 1;
             // correct = max(tplus, plus)
             tiesD[1] = tplus;
             return plus;
         } else if (alternative == AlternativeHypothesis.LESS_THAN) {
             sign[0] = -1;
             // correct = -min(tminus, minus)
             tiesD[1] = -tminus;
             return -minus;
         } else {
             // Two sided.
             sign[0] = Double.compare(plus, -minus);
             d = Math.max(plus, -minus);
             // correct = max(d, max(tplus, -tminus))
             tiesD[1] = Math.max(tplus, -tminus);
             return d;
         }
     }
 
     /**
      * Test if the two-sample integral Kolmogorov-Smirnov statistic is strictly greater
      * than the specified values for D+ and D-. Note that D- should have a negative sign
      * to impose an inclusive lower bound.
      *
      * <p>This method will destructively modify the input arrays (via a sort).
      *
      * <p>For a two-sided alternative hypothesis {@code plus} and {@code minus} should have the
      * same magnitude with opposite signs.
      *
      * <p>For a one-sided alternative hypothesis the value of {@code plus} or {@code minus}
      * should have the expected value of the statistic, and the opposite D should have the maximum
      * or minimum long value. The {@code minus} should be negatively signed:
      *
      * <ul>
      * <li>greater: {@code plus} = D, {@code minus} = {@link Long#MIN_VALUE}
      * <li>greater: {@code minus} = -D, {@code plus} = {@link Long#MAX_VALUE}
      * </ul>
      *
      * <p>Note: This method has not been specialized for the one-sided case. Specialization
      * would eliminate a conditional branch for {@code d > Long.MAX_VALUE} or
      * {@code d < Long.MIN_VALUE}. Since these branches are never possible in the one-sided case
      * this should be efficiently chosen by branch prediction in a processor pipeline.
      *
      * @param x First sample (destructively modified by sort; must not contain NaN).
      * @param y Second sample (destructively modified by sort; must not contain NaN).
      * @param plus Limit on D+ (inclusive upper bound).
      * @param minus Limit on D- (inclusive lower bound).
      * @return true if the D value exceeds the provided limits
      */
     private static boolean testIntegralKolmogorovSmirnovStatistic(double[] x, double[] y, long plus, long minus) {
         // Sort the sample arrays
         Arrays.sort(x);
         Arrays.sort(y);
         final int n = x.length;
         final int m = y.length;
 
         // CDFs range from 0 to 1 using increments of 1/n and 1/m for x and y respectively.
         // Scale by n*m to use increments of m and n for x and y.
         // Find the any difference that exceeds the specified bounds.
         int i = 0;
         int j = 0;
         long d = 0;
         do {
             // No NaNs so compare using < and >
             if (x[i] < y[j]) {
                 final double z = x[i];
                 do {
                     i++;
                     d += m;
                 } while (i < n && x[i] == z);
                 if (d > plus) {
                     return true;
                 }
             } else if (x[i] > y[j]) {
                 final double z = y[j];
                 do {
                     j++;
                     d -= n;
                 } while (j < m && y[j] == z);
                 if (d < minus) {
                     return true;
                 }
             } else {
                 // Traverse to the end of the tied section for d.
                 final double z = x[i];
                 do {
                     i++;
                     d += m;
                 } while (i < n && x[i] == z);
                 do {
                     j++;
                     d -= n;
                 } while (j < m && y[j] == z);
                 // End of tied section
                 if (d > plus || d < minus) {
                     return true;
                 }
             }
         } while (i < n && j < m);
         // Note: Here d requires returning to zero. This is applicable to the one-sided
         // cases since d may have always been above zero (favours D+) or always below zero
         // (favours D-). This is ignored as the method is not called when dnm=0 is
         // outside the inclusive bounds.
         return false;
     }
 
     /**
      * Creates a sampler to sample randomly from the combined distribution of the two samples.
      *
      * @param x First sample.
      * @param y Second sample.
      * @param rng Source of randomness.
      * @return the sampler
      */
     private static DoubleSupplier createSampler(double[] x, double[] y,
                                                 UniformRandomProvider rng) {
         return createSampler(x, y, rng, MAX_ARRAY_SIZE);
     }
 
     /**
      * Creates a sampler to sample randomly from the combined distribution of the two
      * samples. This will copy the input data for the sampler.
      *
      * @param x First sample.
      * @param y Second sample.
      * @param rng Source of randomness.
      * @param maxArraySize Maximum size of a single array.
      * @return the sampler
      */
     static DoubleSupplier createSampler(double[] x, double[] y,
                                         UniformRandomProvider rng,
                                         int maxArraySize) {
         final int n = x.length;
         final int m = y.length;
         final int len = n + m;
         // Overflow safe: len > maxArraySize
         if (len - maxArraySize > 0) {
             // Support sampling with maximum length arrays
             // (where a concatenated array is not possible)
             // by choosing one or the other.
             // - generate i in [-n, m)
             // - return i < 0 ? x[n + i] : y[i]
             // The sign condition is a 50-50 branch.
             // Perform branchless by extracting the sign bit to pick the array.
             // Copy the source data.
             final double[] xx = x.clone();
             final double[] yy = y.clone();
             final IntToDoubleFunction nextX = i -> xx[n + i];
             final IntToDoubleFunction nextY = i -> yy[i];
             // Arrange function which accepts the negative index at position [1]
             final IntToDoubleFunction[] next = {nextY, nextX};
             return () -> {
                 final int i = rng.nextInt(-n, m);
                 return next[i >>> 31].applyAsDouble(i);
             };
         }
         // Concatenate arrays
         final double[] z = new double[len];
         System.arraycopy(x, 0, z, 0, n);
         System.arraycopy(y, 0, z, n, m);
         return () -> z[rng.nextInt(len)];
     }
 
     /**
      * Compute the D statistic from the integral D value.
      *
      * @param dnm Integral D-statistic value (in [0, n*m]).
      * @param n First sample size.
      * @param m Second sample size.
      * @param gcd Greatest common divisor of n and m.
      * @return D-statistic value (in [0, 1]).
      */
     private static double computeD(long dnm, int n, int m, int gcd) {
         // Note: Integer division using the gcd is intentional
         final long a = dnm / gcd;
         final int b = m / gcd;
         return a / ((double) n * b);
     }
 
     /**
      * Computes \(P(D_{n,m} &gt; d)\) for the 2-sample Kolmogorov-Smirnov statistic.
      *
      * @param dnm Integral D-statistic value (in [0, n*m]).
      * @param n First sample size.
      * @param m Second sample size.
      * @param gcd Greatest common divisor of n and m.
      * @param d D-statistic value (in [0, 1]).
      * @param exact whether to compute the exact probability; otherwise approximate.
      * @return probability
      * @see #twoSampleExactP(long, int, int, int, boolean, boolean)
      * @see #twoSampleApproximateP(double, int, int, boolean)
      */
     private double twoSampleP(long dnm, int n, int m, int gcd, double d, boolean exact) {
         // Exact computation returns -1 if it cannot compute.
         double p = -1;
         if (exact) {
             p = twoSampleExactP(dnm, n, m, gcd, strictInequality, alternative == AlternativeHypothesis.TWO_SIDED);
         }
         if (p < 0) {
             p = twoSampleApproximateP(d, n, m, alternative == AlternativeHypothesis.TWO_SIDED);
         }
         return p;
     }
 
     /**
      * Computes \(P(D_{n,m} &gt; d)\) if {@code strict} is {@code true}; otherwise \(P(D_{n,m} \ge
      * d)\), where \(D_{n,m}\) is the 2-sample Kolmogorov-Smirnov statistic, either the two-sided
      * \(D_{n,m}\) or one-sided \(D_{n,m}^+\}. See
      * {@link #statistic(double[], double[])} for the definition of \(D_{n,m}\).
      *
      * <p>The returned probability is exact. If the value cannot be computed this returns -1.
      *
      * <p>Note: This requires the greatest common divisor of n and m. The integral D statistic
      * in the range [0, n*m] is separated by increments of the gcd. The method will only
      * compute p-values for valid values of D by calculating for D/gcd.
      * Strict inquality is performed using the next valid value for D.
      *
      * @param dnm Integral D-statistic value (in [0, n*m]).
      * @param n First sample size.
      * @param m Second sample size.
      * @param gcd Greatest common divisor of n and m.
      * @param strict whether or not the probability to compute is expressed as a strict inequality.
      * @param twoSided whether D refers to D or D+.
      * @return probability that a randomly selected m-n partition of m + n generates D
      *         greater than (resp. greater than or equal to) {@code d} (or -1)
      */
     static double twoSampleExactP(long dnm, int n, int m, int gcd, boolean strict, boolean twoSided) {
         // Create the statistic in [0, lcm]
         // For strict inequality D > d the result is the same if we compute for D >= (d+1)
         final long d = dnm / gcd + (strict ? 1 : 0);
 
         // P-value methods compute for d <= lcm (least common multiple)
         final long lcm = (long) n * (m / gcd);
         if (d > lcm) {
             return 0;
         }
 
         // Note: Some methods require m >= n, others n >= m
         final int a = Math.min(n, m);
         final int b = Math.max(n, m);
 
         if (twoSided) {
             // Any two-sided statistic dnm cannot be less than min(n, m) in the absence of ties.
             if (d * gcd <= a) {
                 return 1;
             }
             // Here d in [2, lcm]
             if (n == m) {
                 return twoSampleTwoSidedPOutsideSquare(d, n);
             }
             return twoSampleTwoSidedPStabilizedInner(d, b, a, gcd);
         }
         // Any one-sided statistic cannot be less than 0
         if (d <= 0) {
             return 1;
         }
         // Here d in [1, lcm]
         if (n == m) {
             return twoSampleOneSidedPOutsideSquare(d, n);
         }
         return twoSampleOneSidedPOutside(d, a, b, gcd);
     }
 
     /**
      * Computes \(P(D_{n,m} \ge d)\), where \(D_{n,m}\) is the 2-sample Kolmogorov-Smirnov statistic.
      *
      * <p>The returned probability is exact, implemented using the stabilized inner method
      * presented in Viehmann (2021).
      *
      * <p>This is optimized for {@code m <= n}. If {@code m > n} and index-out-of-bounds
      * exception can occur.
      *
      * @param d Integral D-statistic value (in [2, lcm])
      * @param n Larger sample size.
      * @param m Smaller sample size.
      * @param gcd Greatest common divisor of n and m.
      * @return probability that a randomly selected m-n partition of m + n generates \(D_{n,m}\)
      *         greater than or equal to {@code d}
      */
     private static double twoSampleTwoSidedPStabilizedInner(long d, int n, int m, int gcd) {
         // Check the computation is possible.
         // Note that the possible paths is binom(m+n, n).
         // However the computation is stable above this limit.
         // Possible d values (requiring a unique p-value) = max(dnm) / gcd = lcm(n, m).
         // Possible terms to compute <= n * size(cij)
         // Simple limit based on the number of possible different p-values
         if ((long) n * (m / gcd) > MAX_LCM_TWO_SAMPLE_EXACT_P) {
             return -1;
         }
 
         // This could be updated to use d in [1, lcm].
         // Currently it uses d in [gcd, n*m].
         // Largest intermediate value is (dnm + im + n) which is within 2^63
         // if n and m are 2^31-1, i = n, dnm = n*m: (2^31-1)^2 + (2^31-1)^2 + 2^31-1 < 2^63
         final long dnm = d * gcd;
 
         // Viehmann (2021): Updated for i in [0, n], j in [0, m]
         // C_i,j = 1                                      if |i/n - j/m| >= d
         //       = 0                                      if |i/n - j/m| < d and (i=0 or j=0)
         //       = C_i-1,j * i/(i+j) + C_i,j-1 * j/(i+j)  otherwise
         // P2 = C_n,m
         // Note: The python listing in Viehmann used d in [0, 1]. This uses dnm in [0, nm]
         // so updates the scaling to compute the ranges. Also note that the listing uses
         // dist > d or dist < -d where this uses |dist| >= d to compute P(D >= d) (non-strict inequality).
         // The provided listing is explicit in the values for each j in the range.
         // It can be optimized given the known start and end j for each iteration as only
         // j where |i/n - j/m| < d must be processed:
         // startJ where: im - jn < dnm : jn > im - dnm
         // j = floor((im - dnm) / n) + 1      in [0, m]
         // endJ where: jn - im >= dnm
         // j = ceil((dnm + im) / n)           in [0, m+1]
 
         // First iteration with i = 0
         // j = ceil(dnm / n)
         int endJ = Math.min(m + 1, (int) ((dnm + n - 1) / n));
 
         // Only require 1 array to store C_i-1,j as the startJ only ever increases
         // and we update lower indices using higher ones.
         // The maximum value *written* is j=m or less using j/m <= 2*d : j = ceil(2*d*m)
         // Viehmann uses: size = int(2*m*d + 2) == ceil(2*d*m) + 1
         // The maximum value *read* is j/m <= 2*d. This may be above m. This occurs when
         // j - lastStartJ > m and C_i-1,j = 1. This can be avoided if (startJ - lastStartJ) <= 1
         // which occurs if m <= n, i.e. the window only slides 0 or 1 in j for each increment i
         // and we can maintain Cij as 1 larger than ceil(2*d*m) + 1.
         final double[] cij = new double[Math.min(m + 1, 2 * endJ + 2)];
 
         // Each iteration fills C_i,j with values and the remaining values are
         // kept as 1 for |i/n - j/m| >= d
         //assert (endJ - 1) * (long) n < dnm : "jn >= dnm for j < endJ";
         for (int j = endJ; j < cij.length; j++) {
             //assert j * (long) n >= dnm : "jn < dnm for j >= endJ";
             cij[j] = 1;
         }
 
         int startJ = 0;
         int length = endJ;
         double val = -1;
         long im = 0;
         for (int i = 1; i <= n; i++) {
             im += m;
             final int lastStartJ = startJ;
 
             // Compute C_i,j for startJ <= j < endJ
             // startJ = floor((im - dnm) / n) + 1      in [0, m]
             // endJ   = ceil((dnm + im) / n)           in [0, m+1]
             startJ = im < dnm ? 0 : Math.min(m, (int) ((im - dnm) / n) + 1);
             endJ = Math.min(m + 1, (int) ((dnm + im + n - 1) / n));
 
             if (startJ >= endJ) {
                 // No possible paths inside the boundary
                 return 1;
             }
 
             //assert startJ - lastStartJ <= 1 : "startJ - lastStartJ > 1";
 
             // Initialize previous value C_i,j-1
             val = startJ == 0 ? 0 : 1;
 
             //assert startJ == 0 || Math.abs(im - (startJ - 1) * (long) n) >= dnm : "|im - jn| < dnm for j < startJ";
             //assert endJ > m || Math.abs(im - endJ * (long) n) >= dnm : "|im - jn| < dnm for j >= endJ";
             for (int j = startJ; j < endJ; j++) {
                 //assert j == 0 || Math.abs(im - j * (long) n) < dnm : "|im - jn| >= dnm for startJ <= j < endJ";
                 // C_i,j = C_i-1,j * i/(i+j) + C_i,j-1 * j/(i+j)
                 // Note: if (j - lastStartJ) >= cij.length this creates an IOOB exception.
                 // In this case cij[j - lastStartJ] == 1. Only happens when m >= n.
                 // Fixed using c_i-1,j = (j - lastStartJ >= cij.length ? 1 : cij[j - lastStartJ]
                 val = (cij[j - lastStartJ] * i + val * j) / ((double) i + j);
                 cij[j - startJ] = val;
             }
 
             // Must keep the remaining values in C_i,j as 1 to allow
             // cij[j - lastStartJ] * i == i when (j - lastStartJ) > lastLength
             final int lastLength = length;
             length = endJ - startJ;
             for (int j = lastLength - length - 1; j >= 0; j--) {
                 cij[length + j] = 1;
             }
         }
         // Return the most recently written value: C_n,m
         return val;
     }
 
     /**
      * Computes \(P(D_{n,m}^+ \ge d)\), where \(D_{n,m}^+\) is the 2-sample one-sided
      * Kolmogorov-Smirnov statistic.
      *
      * <p>The returned probability is exact, implemented using the outer method
      * presented in Hodges (1958).
      *
      * <p>This method will fail-fast and return -1 if the computation of the
      * numbers of paths overflows.
      *
      * @param d Integral D-statistic value (in [0, lcm])
      * @param n First sample size.
      * @param m Second sample size.
      * @param gcd Greatest common divisor of n and m.
      * @return probability that a randomly selected m-n partition of m + n generates \(D_{n,m}\)
      *         greater than or equal to {@code d}
      */
     private static double twoSampleOneSidedPOutside(long d, int n, int m, int gcd) {
         // Hodges, Fig.2
         // Lower boundary: (nx - my)/nm >= d : (nx - my) >= dnm
         // B(x, y) is the number of ways from (0, 0) to (x, y) without previously
         // reaching the boundary.
         // B(x, y) = binom(x+y, y) - [number of ways which previously reached the boundary]
         // Total paths:
         // sum_y { B(x, y) binom(m+n-x-y, n-y) }
 
         // Normalized by binom(m+n, n). Check this is possible.
         final long lm = m;
         if (n + lm > Integer.MAX_VALUE) {
             return -1;
         }
         final double binom = binom(m + n, n);
         if (binom == Double.POSITIVE_INFINITY) {
             return -1;
         }
 
         // This could be updated to use d in [1, lcm].
         // Currently it uses d in [gcd, n*m].
         final long dnm = d * gcd;
 
         // Visit all x in [0, m] where (nx - my) >= d for each increasing y in [0, n].
         // x = ceil( (d + my) / n ) = (d + my + n - 1) / n
         // y = ceil( (nx - d) / m ) = (nx - d + m - 1) / m
         // Note: n m integer, d in [0, nm], the intermediate cannot overflow a long.
         // x | y=0 = (d + n - 1) / n
         final int x0 = (int) ((dnm + n - 1) / n);
         if (x0 >= m) {
             return 1 / binom;
         }
         // The y above is the y *on* the boundary. Set the limit as the next y above:
         // y | x=m = 1 + floor( (nx - d) / m ) = 1 + (nm - d) / m
         final int maxy = (int) ((n * lm - dnm + m) / m);
         // Compute x and B(x, y) for visited B(x,y)
         final int[] xy = new int[maxy];
         final double[] bxy = new double[maxy];
         xy[0] = x0;
         bxy[0] = 1;
         for (int y = 1; y < maxy; y++) {
             final int x = (int) ((dnm + lm * y + n - 1) / n);
             // B(x, y) = binom(x+y, y) - [number of ways which previously reached the boundary]
             // Add the terms to subtract as a negative sum.
             final Sum b = Sum.create();
             for (int yy = 0; yy < y; yy++) {
                 // Here: previousX = x - xy[yy] : previousY = y - yy
                 // bxy[yy] is the paths to (previousX, previousY)
                 // binom represent the paths from (previousX, previousY) to (x, y)
                 b.addProduct(bxy[yy], -binom(x - xy[yy] + y - yy, y - yy));
             }
             b.add(binom(x + y, y));
             xy[y] = x;
             bxy[y] = b.getAsDouble();
         }
         // sum_y { B(x, y) binom(m+n-x-y, n-y) }
         final Sum sum = Sum.create();
         for (int y = 0; y < maxy; y++) {
             sum.addProduct(bxy[y], binom(m + n - xy[y] - y, n - y));
         }
         // No individual term should have overflowed since binom is finite.
         // Any sum above 1 is floating-point error.
         return KolmogorovSmirnovDistribution.clipProbability(sum.getAsDouble() / binom);
     }
 
     /**
      * Computes \(P(D_{n,n}^+ \ge d)\), where \(D_{n,n}^+\) is the 2-sample one-sided
      * Kolmogorov-Smirnov statistic.
      *
      * <p>The returned probability is exact, implemented using the outer method
      * presented in Hodges (1958).
      *
      * @param d Integral D-statistic value (in [1, lcm])
      * @param n Sample size.
      * @return probability that a randomly selected m-n partition of m + n generates \(D_{n,m}\)
      *         greater than or equal to {@code d}
      */
     private static double twoSampleOneSidedPOutsideSquare(long d, int n) {
         // Hodges (1958) Eq. 2.3:
         // p = binom(2n, n-a) / binom(2n, n)
         // a in [1, n] == d * n == dnm / n
         final int a = (int) d;
 
         // Rearrange:
         // p = ( 2n! / ((n-a)! (n+a)!) ) / ( 2n! / (n! n!) )
         //   = n! n! / ( (n-a)! (n+a)! )
         // Perform using pre-computed factorials if possible.
         if (n + a <= MAX_FACTORIAL) {
             final double x = Factorial.doubleValue(n);
             final double y = Factorial.doubleValue(n - a);
             final double z = Factorial.doubleValue(n + a);
             return (x / y) * (x / z);
         }
         // p = n! / (n-a)!  *  n! / (n+a)!
         //       n * (n-1) * ... * (n-a+1)
         //   = -----------------------------
         //     (n+a) * (n+a-1) * ... * (n+1)
 
         double p = 1;
         for (int i = 0; i < a && p != 0; i++) {
             p *= (n - i) / (1.0 + n + i);
         }
         return p;
     }
 
     /**
      * Computes \(P(D_{n,n}^+ \ge d)\), where \(D_{n,n}^+\) is the 2-sample two-sided
      * Kolmogorov-Smirnov statistic.
      *
      * <p>The returned probability is exact, implemented using the outer method
      * presented in Hodges (1958).
      *
      * @param d Integral D-statistic value (in [1, n])
      * @param n Sample size.
      * @return probability that a randomly selected m-n partition of n + n generates \(D_{n,n}\)
      *         greater than or equal to {@code d}
      */
     private static double twoSampleTwoSidedPOutsideSquare(long d, int n) {
         // Hodges (1958) Eq. 2.4:
         // p = 2 [ binom(2n, n-a) - binom(2n, n-2a) + binom(2n, n-3a) - ... ] / binom(2n, n)
         // a in [1, n] == d * n == dnm / n
 
         // As per twoSampleOneSidedPOutsideSquare, divide by binom(2n, n) and each term
         // can be expressed as a product:
         //         (             n - i                    n - i                   n - i         )
         // p = 2 * ( prod_i=0^a --------- - prod_i=0^2a --------- + prod_i=0^3a --------- + ... )
         //         (           1 + n + i                1 + n + i               1 + n + i       )
         // for ja in [1, ..., n/a]
         // Avoid repeat computation of terms by extracting common products:
         // p = 2 * ( p0a * (1 - p1a * (1 - p2a * (1 - ... ))) )
         // where each term pja is prod_i={ja}^{ja+a} for all j in [1, n / a]
 
         // The first term is the one-sided p.
         final double p0a = twoSampleOneSidedPOutsideSquare(d, n);
         if (p0a == 0) {
             // Underflow - nothing more to do
             return 0;
         }
         // Compute the inner-terms from small to big.
         // j = n / (d/n) ~ n*n / d
         // j is a measure of how extreme the d value is (small j is extreme d).
         // When j is above 0 a path may traverse from the lower boundary to the upper boundary.
         final int a = (int) d;
         double p = 0;
         for (int j = n / a; j > 0; j--) {
             double pja = 1;
             final int jaa = j * a + a;
             // Since p0a did not underflow we avoid the check for pj != 0
             for (int i = j * a; i < jaa; i++) {
                 pja *= (n - i) / (1.0 + n + i);
             }
             p = pja * (1 - p);
         }
         p = p0a * (1 - p);
         return Math.min(1, 2 * p);
     }
 
     /**
      * Compute the binomial coefficient binom(n, k).
      *
      * @param n N.
      * @param k K.
      * @return binom(n, k)
      */
     private static double binom(int n, int k) {
         return BinomialCoefficientDouble.value(n, k);
     }
 
     /**
      * Uses the Kolmogorov-Smirnov distribution to approximate \(P(D_{n,m} &gt; d)\) where \(D_{n,m}\)
      * is the 2-sample Kolmogorov-Smirnov statistic. See
      * {@link #statistic(double[], double[])} for the definition of \(D_{n,m}\).
      *
      * <p>Specifically, what is returned is \(1 - CDF(d, \sqrt{mn / (m + n)})\) where CDF
      * is the cumulative density function of the two-sided one-sample Kolmogorov-Smirnov
      * distribution.
      *
      * @param d D-statistic value.
      * @param n First sample size.
      * @param m Second sample size.
      * @param twoSided True to compute the two-sided p-value; else one-sided.
      * @return approximate probability that a randomly selected m-n partition of m + n generates
      *         \(D_{n,m}\) greater than {@code d}
      */
     static double twoSampleApproximateP(double d, int n, int m, boolean twoSided) {
         final double nn = Math.min(n, m);
         final double mm = Math.max(n, m);
         if (twoSided) {
             // Smirnov's asymptotic formula:
             // P(sqrt(N) D_n > x)
             // N = m*n/(m+n)
             return KolmogorovSmirnovDistribution.Two.sf(d, (int) Math.round(mm * nn / (mm + nn)));
         }
         // one-sided
         // Use Hodges Eq 5.3. Requires m >= n
         // Correct for m=n, m an integral multiple of n, and 'on the average' for m nearly equal to n
         final double z = d * Math.sqrt(nn * mm / (nn + mm));
         return Math.exp(-2 * z * z - 2 * z * (mm + 2 * nn) / Math.sqrt(mm * nn * (mm + nn)) / 3);
     }
 
     /**
      * Verifies that {@code array} has length at least 2.
      *
      * @param array Array to test.
      * @return the length
      * @throws IllegalArgumentException if array is too short
      */
     private static int checkArrayLength(double[] array) {
         final int n = array.length;
         if (n <= 1) {
             throw new InferenceException(InferenceException.TWO_VALUES_REQUIRED, n);
         }
         return n;
     }
 
     /**
      * Sort the input array. Throws an exception if NaN values are
      * present. It is assumed the array is non-zero length.
      *
      * @param x Input array.
      * @param name Name of the array.
      * @return a reference to the input (sorted) array
      * @throws IllegalArgumentException if {@code x} contains NaN values.
      */
     private static double[] sort(double[] x, String name) {
         Arrays.sort(x);
         // NaN will be at the end
         if (Double.isNaN(x[x.length - 1])) {
             throw new InferenceException(name + " contains NaN");
         }
         return x;
     }
 }