/*
    * 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.math4.legacy.distribution;
  
  
  import java.util.ArrayList;
  import java.util.Collections;
  
  import org.apache.commons.statistics.distribution.ContinuousDistribution;
  import org.apache.commons.math4.legacy.TestUtils;
  import org.apache.commons.math4.legacy.analysis.UnivariateFunction;
  import org.apache.commons.math4.legacy.analysis.integration.BaseAbstractUnivariateIntegrator;
  import org.apache.commons.math4.legacy.analysis.integration.IterativeLegendreGaussIntegrator;
  import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
  import org.apache.commons.math4.legacy.exception.NumberIsTooLargeException;
  import org.apache.commons.rng.simple.RandomSource;
  import org.apache.commons.math4.core.jdkmath.JdkMath;
  import org.junit.After;
  import org.junit.Assert;
  import org.junit.Before;
  import org.junit.Test;
  
  /**
   * Abstract base class for {@link ContinuousDistribution} tests.
   * <p>
   * To create a concrete test class for a continuous distribution
   * implementation, first implement makeDistribution() to return a distribution
   * instance to use in tests. Then implement each of the test data generation
   * methods below.  In each case, the test points and test values arrays
   * returned represent parallel arrays of inputs and expected values for the
   * distribution returned by makeDistribution().  Default implementations
   * are provided for the makeInverseXxx methods that just invert the mapping
   * defined by the arrays returned by the makeCumulativeXxx methods.
   * <p>
   * makeCumulativeTestPoints() -- arguments used to test cumulative probabilities
   * makeCumulativeTestValues() -- expected cumulative probabilities
   * makeDensityTestValues() -- expected density values at cumulativeTestPoints
   * makeInverseCumulativeTestPoints() -- arguments used to test inverse cdf
   * makeInverseCumulativeTestValues() -- expected inverse cdf values
   * <p>
   * To implement additional test cases with different distribution instances and
   * test data, use the setXxx methods for the instance data in test cases and
   * call the verifyXxx methods to verify results.
   * <p>
   * Error tolerance can be overridden by implementing getTolerance().
   * <p>
   * Test data should be validated against reference tables or other packages
   * where possible, and the source of the reference data and/or validation
   * should be documented in the test cases.  A framework for validating
   * distribution data against R is included in the /src/test/R source tree.
   *
   */
  public abstract class RealDistributionAbstractTest {
  
  //-------------------- Private test instance data -------------------------
      /**  Distribution instance used to perform tests */
      private ContinuousDistribution distribution;
  
      /** Tolerance used in comparing expected and returned values */
      private double tolerance = 1E-4;
  
      /** Arguments used to test cumulative probability density calculations */
      private double[] cumulativeTestPoints;
  
      /** Values used to test cumulative probability density calculations */
      private double[] cumulativeTestValues;
  
      /** Arguments used to test inverse cumulative probability density calculations */
      private double[] inverseCumulativeTestPoints;
  
      /** Values used to test inverse cumulative probability density calculations */
      private double[] inverseCumulativeTestValues;
  
      /** Values used to test density calculations */
      private double[] densityTestValues;
  
      /** Values used to test logarithmic density calculations */
      private double[] logDensityTestValues;
  
      //-------------------- Abstract methods -----------------------------------
  
      /** Creates the default continuous distribution instance to use in tests. */
      public abstract ContinuousDistribution makeDistribution();
  
      /** Creates the default cumulative probability test input values */
     public abstract double[] makeCumulativeTestPoints();
 
     /** Creates the default cumulative probability test expected values */
     public abstract double[] makeCumulativeTestValues();
 
     /** Creates the default density test expected values */
     public abstract double[] makeDensityTestValues();
 
     /** Creates the default logarithmic density test expected values.
      * The default implementation simply computes the logarithm
      * of each value returned by {@link #makeDensityTestValues()}.*/
     public double[] makeLogDensityTestValues() {
         final double[] densityTestValues = makeDensityTestValues();
         final double[] logDensityTestValues = new double[densityTestValues.length];
         for (int i = 0; i < densityTestValues.length; i++) {
             logDensityTestValues[i] = JdkMath.log(densityTestValues[i]);
         }
         return logDensityTestValues;
     }
 
     //---- Default implementations of inverse test data generation methods ----
 
     /** Creates the default inverse cumulative probability test input values */
     public double[] makeInverseCumulativeTestPoints() {
         return makeCumulativeTestValues();
     }
 
     /** Creates the default inverse cumulative probability density test expected values */
     public double[] makeInverseCumulativeTestValues() {
         return makeCumulativeTestPoints();
     }
 
     //-------------------- Setup / tear down ----------------------------------
 
     /**
      * Setup sets all test instance data to default values
      */
     @Before
     public void setUp() {
         distribution = makeDistribution();
         cumulativeTestPoints = makeCumulativeTestPoints();
         cumulativeTestValues = makeCumulativeTestValues();
         inverseCumulativeTestPoints = makeInverseCumulativeTestPoints();
         inverseCumulativeTestValues = makeInverseCumulativeTestValues();
         densityTestValues = makeDensityTestValues();
         logDensityTestValues = makeLogDensityTestValues();
     }
 
     /**
      * Cleans up test instance data
      */
     @After
     public void tearDown() {
         distribution = null;
         cumulativeTestPoints = null;
         cumulativeTestValues = null;
         inverseCumulativeTestPoints = null;
         inverseCumulativeTestValues = null;
         densityTestValues = null;
         logDensityTestValues = null;
     }
 
     //-------------------- Verification methods -------------------------------
 
     /**
      * Verifies that cumulative probability density calculations match expected values
      * using current test instance data
      */
     protected void verifyCumulativeProbabilities() {
         // verify cumulativeProbability(double)
         for (int i = 0; i < cumulativeTestPoints.length; i++) {
             TestUtils.assertEquals("Incorrect cumulative probability value returned for "
                 + cumulativeTestPoints[i], cumulativeTestValues[i],
                 distribution.cumulativeProbability(cumulativeTestPoints[i]),
                 getTolerance());
         }
         // verify probability(double, double)
         for (int i = 0; i < cumulativeTestPoints.length; i++) {
             for (int j = 0; j < cumulativeTestPoints.length; j++) {
                 if (cumulativeTestPoints[i] <= cumulativeTestPoints[j]) {
                     TestUtils.assertEquals(cumulativeTestValues[j] - cumulativeTestValues[i],
                         distribution.probability(cumulativeTestPoints[i], cumulativeTestPoints[j]),
                         getTolerance());
                 } else {
                     try {
                         distribution.probability(cumulativeTestPoints[i], cumulativeTestPoints[j]);
                     } catch (NumberIsTooLargeException e) {
                         continue;
                     }
                     Assert.fail("distribution.probability(double, double) should have thrown an exception that second argument is too large");
                 }
             }
         }
     }
 
     /**
      * Verifies that inverse cumulative probability density calculations match expected values
      * using current test instance data
      */
     protected void verifyInverseCumulativeProbabilities() {
         for (int i = 0; i < inverseCumulativeTestPoints.length; i++) {
             TestUtils.assertEquals("Incorrect inverse cumulative probability value returned for "
                 + inverseCumulativeTestPoints[i], inverseCumulativeTestValues[i],
                  distribution.inverseCumulativeProbability(inverseCumulativeTestPoints[i]),
                  getTolerance());
         }
     }
 
     /**
      * Verifies that density calculations match expected values
      */
     protected void verifyDensities() {
         for (int i = 0; i < cumulativeTestPoints.length; i++) {
             TestUtils.assertEquals("Incorrect probability density value returned for "
                 + cumulativeTestPoints[i], densityTestValues[i],
                  distribution.density(cumulativeTestPoints[i]),
                  getTolerance());
         }
     }
 
     /**
      * Verifies that logarithmic density calculations match expected values
      */
     protected void verifyLogDensities() {
         for (int i = 0; i < cumulativeTestPoints.length; i++) {
             TestUtils.assertEquals("Incorrect probability density value returned for "
                     + cumulativeTestPoints[i], logDensityTestValues[i],
                     distribution.logDensity(cumulativeTestPoints[i]),
                     getTolerance());
         }
     }
 
     //------------------------ Default test cases -----------------------------
 
     /**
      * Verifies that cumulative probability density calculations match expected values
      * using default test instance data
      */
     @Test
     public void testCumulativeProbabilities() {
         verifyCumulativeProbabilities();
     }
 
     /**
      * Verifies that inverse cumulative probability density calculations match expected values
      * using default test instance data
      */
     @Test
     public void testInverseCumulativeProbabilities() {
         verifyInverseCumulativeProbabilities();
     }
 
     /**
      * Verifies that density calculations return expected values
      * for default test instance data
      */
     @Test
     public void testDensities() {
         verifyDensities();
     }
 
     /**
      * Verifies that logarithmic density calculations return expected values
      * for default test instance data
      */
     @Test
     public void testLogDensities() {
         verifyLogDensities();
     }
 
     /**
      * Verifies that probability computations are consistent
      */
     @Test
     public void testConsistency() {
         for (int i=1; i < cumulativeTestPoints.length; i++) {
 
             // check that cdf(x, x) = 0
             TestUtils.assertEquals(0d,
                distribution.probability
                  (cumulativeTestPoints[i], cumulativeTestPoints[i]), tolerance);
 
             // check that P(a < X <= b) = P(X <= b) - P(X <= a)
             double upper = JdkMath.max(cumulativeTestPoints[i], cumulativeTestPoints[i -1]);
             double lower = JdkMath.min(cumulativeTestPoints[i], cumulativeTestPoints[i -1]);
             double diff = distribution.cumulativeProbability(upper) -
                 distribution.cumulativeProbability(lower);
             double direct = distribution.probability(lower, upper);
             TestUtils.assertEquals("Inconsistent probability for ("
                     + lower + "," + upper + ")", diff, direct, tolerance);
         }
     }
 
     /**
      * Verifies that illegal arguments are correctly handled
      */
     @Test
     public void testIllegalArguments() {
         try {
             distribution.probability(1, 0);
             Assert.fail("Expecting MathIllegalArgumentException for bad cumulativeProbability interval");
         } catch (MathIllegalArgumentException ex) {
             // expected
         }
         try {
             distribution.inverseCumulativeProbability(-1);
             Assert.fail("Expecting MathIllegalArgumentException for p = -1");
         } catch (MathIllegalArgumentException ex) {
             // expected
         }
         try {
             distribution.inverseCumulativeProbability(2);
             Assert.fail("Expecting MathIllegalArgumentException for p = 2");
         } catch (MathIllegalArgumentException ex) {
             // expected
         }
     }
 
     /**
      * Test sampling
      */
     @Test
     public void testSampler() {
         final int sampleSize = 1000;
         final ContinuousDistribution.Sampler sampler =
             distribution.createSampler(RandomSource.WELL_19937_C.create(123456789L));
         final double[] sample = AbstractRealDistribution.sample(sampleSize, sampler);
         final double[] quartiles = TestUtils.getDistributionQuartiles(distribution);
         final double[] expected = {250, 250, 250, 250};
         final long[] counts = new long[4];
 
         for (int i = 0; i < sampleSize; i++) {
             TestUtils.updateCounts(sample[i], counts, quartiles);
         }
         TestUtils.assertChiSquareAccept(expected, counts, 0.001);
     }
 
     /**
      * Verify that density integrals match the distribution.
      * The (filtered, sorted) cumulativeTestPoints array is used to source
      * integration limits. The integral of the density (estimated using a
      * Legendre-Gauss integrator) is compared with the cdf over the same
      * interval. Test points outside of the domain of the density function
      * are discarded.
      */
     @Test
     public void testDensityIntegrals() {
         final double tol = 1.0e-9;
         final BaseAbstractUnivariateIntegrator integrator =
             new IterativeLegendreGaussIntegrator(5, 1.0e-12, 1.0e-10);
         final UnivariateFunction d = new UnivariateFunction() {
             @Override
             public double value(double x) {
                 return distribution.density(x);
             }
         };
         final ArrayList<Double> integrationTestPoints = new ArrayList<>();
         for (int i = 0; i < cumulativeTestPoints.length; i++) {
             if (Double.isNaN(cumulativeTestValues[i]) ||
                     cumulativeTestValues[i] < 1.0e-5 ||
                     cumulativeTestValues[i] > 1 - 1.0e-5) {
                 continue; // exclude integrals outside domain.
             }
             integrationTestPoints.add(cumulativeTestPoints[i]);
         }
         Collections.sort(integrationTestPoints);
         for (int i = 1; i < integrationTestPoints.size(); i++) {
             Assert.assertEquals(
                     distribution.probability(
                             integrationTestPoints.get(0), integrationTestPoints.get(i)),
                             integrator.integrate(
                                     1000000, // Triangle integrals are very slow to converge
                                     d, integrationTestPoints.get(0),
                                     integrationTestPoints.get(i)), tol);
         }
     }
 
     //------------------ Getters / Setters for test instance data -----------
     /**
      * @return Returns the cumulativeTestPoints.
      */
     protected double[] getCumulativeTestPoints() {
         return cumulativeTestPoints;
     }
 
     /**
      * @param cumulativeTestPoints The cumulativeTestPoints to set.
      */
     protected void setCumulativeTestPoints(double[] cumulativeTestPoints) {
         this.cumulativeTestPoints = cumulativeTestPoints;
     }
 
     /**
      * @return Returns the cumulativeTestValues.
      */
     protected double[] getCumulativeTestValues() {
         return cumulativeTestValues;
     }
 
     /**
      * @param cumulativeTestValues The cumulativeTestValues to set.
      */
     protected void setCumulativeTestValues(double[] cumulativeTestValues) {
         this.cumulativeTestValues = cumulativeTestValues;
     }
 
     protected double[] getDensityTestValues() {
         return densityTestValues;
     }
 
     protected void setDensityTestValues(double[] densityTestValues) {
         this.densityTestValues = densityTestValues;
     }
 
     /**
      * @return Returns the distribution.
      */
     protected ContinuousDistribution getDistribution() {
         return distribution;
     }
 
     /**
      * @param distribution The distribution to set.
      */
     protected void setDistribution(ContinuousDistribution distribution) {
         this.distribution = distribution;
     }
 
     /**
      * @return Returns the inverseCumulativeTestPoints.
      */
     protected double[] getInverseCumulativeTestPoints() {
         return inverseCumulativeTestPoints;
     }
 
     /**
      * @param inverseCumulativeTestPoints The inverseCumulativeTestPoints to set.
      */
     protected void setInverseCumulativeTestPoints(double[] inverseCumulativeTestPoints) {
         this.inverseCumulativeTestPoints = inverseCumulativeTestPoints;
     }
 
     /**
      * @return Returns the inverseCumulativeTestValues.
      */
     protected double[] getInverseCumulativeTestValues() {
         return inverseCumulativeTestValues;
     }
 
     /**
      * @param inverseCumulativeTestValues The inverseCumulativeTestValues to set.
      */
     protected void setInverseCumulativeTestValues(double[] inverseCumulativeTestValues) {
         this.inverseCumulativeTestValues = inverseCumulativeTestValues;
     }
 
     /**
      * @return Returns the tolerance.
      */
     protected double getTolerance() {
         return tolerance;
     }
 
     /**
      * @param tolerance The tolerance to set.
      */
     protected void setTolerance(double tolerance) {
         this.tolerance = tolerance;
     }
 }