/*
    * 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
    *
    *      https://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.
   */
  
  /*
   * This is not the original file distributed by the Apache Software Foundation
   * It has been modified by the Hipparchus project
   */
  package org.hipparchus.distribution.discrete;
  
  import org.hipparchus.distribution.IntegerDistribution;
  import org.junit.jupiter.api.BeforeEach;
  import org.junit.jupiter.api.Test;
  
  import static org.junit.jupiter.api.Assertions.assertEquals;
  
  /**
   * Test cases for PascalDistribution.
   */
  public class PascalDistributionTest extends IntegerDistributionAbstractTest {
  
      // --------------------- Override tolerance  --------------
      protected double defaultTolerance = 1e-9;
  
      @BeforeEach
      @Override
      public void setUp() {
          super.setUp();
          setTolerance(defaultTolerance);
      }
  
      //-------------- Implementations for abstract methods -----------------------
  
      /** Creates the default discrete distribution instance to use in tests. */
      @Override
      public IntegerDistribution makeDistribution() {
          return new PascalDistribution(10,0.70);
      }
  
      /** Creates the default probability density test input values */
      @Override
      public int[] makeDensityTestPoints() {
        return new int[] {-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
      }
  
      /** Creates the default probability density test expected values */
      @Override
      public double[] makeDensityTestValues() {
        return new double[] {0, 0.0282475249, 0.0847425747, 0.139825248255, 0.167790297906, 0.163595540458,
                0.137420253985, 0.103065190489, 0.070673273478, 0.0450542118422, 0.0270325271053,
                0.0154085404500, 0.0084046584273};
      }
  
      /** Creates the default cumulative probability density test input values */
      @Override
      public int[] makeCumulativeTestPoints() {
        return makeDensityTestPoints();
      }
  
      /** Creates the default cumulative probability density test expected values */
      @Override
      public double[] makeCumulativeTestValues() {
        return new double[] {0, 0.0282475249, 0.1129900996, 0.252815347855, 0.420605645761, 0.584201186219,
                0.721621440204, 0.824686630693, 0.895359904171, 0.940414116013, 0.967446643119,
                0.982855183569, 0.991259841996};
          }
  
      /** Creates the default inverse cumulative probability test input values */
      @Override
      public double[] makeInverseCumulativeTestPoints() {
        return new double[] {0.0, 0.001, 0.010, 0.025, 0.050, 0.100, 0.999,
            0.990, 0.975, 0.950, 0.900, 1.0};
          }
  
      /** Creates the default inverse cumulative probability density test expected values */
      @Override
      public int[] makeInverseCumulativeTestValues() {
        return new int[] {0, 0, 0, 0, 1, 1, 14, 11, 10, 9, 8, Integer.MAX_VALUE};
      }
  
      //----------------- Additional test cases ---------------------------------
  
      /** Test degenerate case p = 0   */
      @Test
      void testDegenerate0() {
          setDistribution(new PascalDistribution(5, 0.0d));
         setCumulativeTestPoints(new int[] {-1, 0, 1, 5, 10 });
         setCumulativeTestValues(new double[] {0d, 0d, 0d, 0d, 0d});
         setDensityTestPoints(new int[] {-1, 0, 1, 10, 11});
         setDensityTestValues(new double[] {0d, 0d, 0d, 0d, 0d});
         setInverseCumulativeTestPoints(new double[] {0.1d, 0.5d});
         setInverseCumulativeTestValues(new int[] {Integer.MAX_VALUE, Integer.MAX_VALUE});
         verifyDensities();
         verifyCumulativeProbabilities();
         verifyInverseCumulativeProbabilities();
     }
 
     /** Test degenerate case p = 1   */
     @Test
     void testDegenerate1() {
         setDistribution(new PascalDistribution(5, 1.0d));
         setCumulativeTestPoints(new int[] {-1, 0, 1, 2, 5, 10 });
         setCumulativeTestValues(new double[] {0d, 1d, 1d, 1d, 1d, 1d});
         setDensityTestPoints(new int[] {-1, 0, 1, 2, 5, 10});
         setDensityTestValues(new double[] {0d, 1d, 0d, 0d, 0d, 0d});
         setInverseCumulativeTestPoints(new double[] {0.1d, 0.5d});
         setInverseCumulativeTestValues(new int[] {0, 0});
         verifyDensities();
         verifyCumulativeProbabilities();
         verifyInverseCumulativeProbabilities();
     }
 
     @Test
     void testMoments() {
         final double tol = 1e-9;
         PascalDistribution dist;
 
         dist = new PascalDistribution(10, 0.5);
         assertEquals(dist.getNumericalMean(), ( 10d * 0.5d ) / 0.5d, tol);
         assertEquals(dist.getNumericalVariance(), ( 10d * 0.5d ) / (0.5d * 0.5d), tol);
 
         dist = new PascalDistribution(25, 0.7);
         assertEquals(dist.getNumericalMean(), ( 25d * 0.3d ) / 0.7d, tol);
         assertEquals(dist.getNumericalVariance(), ( 25d * 0.3d ) / (0.7d * 0.7d), tol);
     }
 }