/*
    * 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.stat.descriptive.rank;
  
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.LinkedHashSet;
  import java.util.Set;
  import org.apache.commons.statistics.distribution.LogNormalDistribution;
  import org.apache.commons.statistics.distribution.NormalDistribution;
  import org.apache.commons.statistics.distribution.ContinuousDistribution;
  import org.apache.commons.math4.legacy.distribution.AbstractRealDistribution;
  import org.apache.commons.math4.legacy.exception.MathIllegalArgumentException;
  import org.apache.commons.math4.legacy.exception.NullArgumentException;
  import org.apache.commons.math4.legacy.exception.OutOfRangeException;
  import org.apache.commons.rng.UniformRandomProvider;
  import org.apache.commons.rng.simple.RandomSource;
  import org.apache.commons.math4.legacy.stat.descriptive.StorelessUnivariateStatistic;
  import org.apache.commons.math4.legacy.stat.descriptive.StorelessUnivariateStatisticAbstractTest;
  import org.apache.commons.math4.legacy.stat.descriptive.UnivariateStatistic;
  import org.apache.commons.math4.legacy.stat.descriptive.rank.PSquarePercentile.PSquareMarkers;
  import org.apache.commons.math4.core.jdkmath.JdkMath;
  import org.junit.Assert;
  import org.junit.Test;
  
  /**
   * Test cases for the {@link PSquarePercentile} class which naturally extends
   * {@link StorelessUnivariateStatisticAbstractTest}.
   */
  public class PSquarePercentileTest extends
          StorelessUnivariateStatisticAbstractTest {
  
      protected double percentile5 = 8.2299d;
      protected double percentile95 = 16.72195;// 20.82d; this is approximation
      protected double tolerance = 10E-12;
  
      private final UniformRandomProvider randomGenerator = RandomSource.WELL_19937_C.create(1000);
  
      @Override
      public double getTolerance() {
          return 1.0e-2;// tolerance limit changed as this is an approximation
          // algorithm and also gets accurate after few tens of
          // samples
      }
  
      /**
       * Verifies that copied statistics remain equal to originals when
       * incremented the same way by making the copy after a majority of elements
       * are incremented
       */
      @Test
      public void testCopyConsistencyWithInitialMostElements() {
  
          StorelessUnivariateStatistic master =
                  (StorelessUnivariateStatistic) getUnivariateStatistic();
  
          StorelessUnivariateStatistic replica = null;
  
          // select a portion of testArray till 75 % of the length to load first
          long index = JdkMath.round(0.75 * testArray.length);
  
          // Put first half in master and copy master to replica
          master.incrementAll(testArray, 0, (int) index);
          replica = master.copy();
  
          // Check same
          Assert.assertEquals(replica, master);
          Assert.assertEquals(master, replica);
  
          // Now add second part to both and check again
          master.incrementAll(testArray, (int) index,
                  (int) (testArray.length - index));
          replica.incrementAll(testArray, (int) index,
                  (int) (testArray.length - index));
          Assert.assertEquals(replica, master);
          Assert.assertEquals(master, replica);
      }
  
      /**
       * Verifies that copied statistics remain equal to originals when
       * incremented the same way by way of copying original after just a few
       * elements are incremented
      */
     @Test
     public void testCopyConsistencyWithInitialFirstFewElements() {
 
         StorelessUnivariateStatistic master =
                 (StorelessUnivariateStatistic) getUnivariateStatistic();
 
         StorelessUnivariateStatistic replica = null;
 
         // select a portion of testArray which is 10% of the length to load
         // first
         long index = JdkMath.round(0.1 * testArray.length);
 
         // Put first half in master and copy master to replica
         master.incrementAll(testArray, 0, (int) index);
         replica = master.copy();
 
         // Check same
         Assert.assertEquals(replica, master);
         Assert.assertEquals(master, replica);
         // Now add second part to both and check again
         master.incrementAll(testArray, (int) index,
                 (int) (testArray.length - index));
         replica.incrementAll(testArray, (int) index,
                 (int) (testArray.length - index));
         // Check same
         // Explicit test of the equals method
         Assert.assertTrue(master.equals(master));
         Assert.assertTrue(replica.equals(replica));
         Assert.assertEquals(replica, master);
         Assert.assertEquals(master, replica);
     }
 
     @Test(expected = MathIllegalArgumentException.class)
     public void testNullListInMarkers() {
         // In case of null list Markers cannot be instantiated..is getting
         // verified
         // new Markers(null, 0, PSquarePercentile.newEstimator());
         PSquarePercentile.newMarkers(null, 0);
     }
 
     @Test
     public void testEqualsInMarkers() {
         double p = 0.5;
         PSquareMarkers markers =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 0.02, 1.18, 9.15, 21.91,
                                 38.62 }), p);
         // Markers equality
         Assert.assertEquals(markers, markers);
         Assert.assertNotEquals(markers, null);
         Assert.assertNotEquals(markers, "");
         // Check for null markers test during equality testing
         // Until 5 elements markers are not initialized
         PSquarePercentile p1 = new PSquarePercentile();
         PSquarePercentile p2 = new PSquarePercentile();
         Assert.assertEquals(p1, p2);
         p1.evaluate(new double[] { 1.0, 2.0, 3.0 });
         p2.evaluate(new double[] { 1.0, 2.0, 3.0 });
         Assert.assertEquals(p1, p2);
         // Move p2 alone with more values just to make sure markers are not null
         // for p2
         p2.incrementAll(new double[] { 5.0, 7.0, 11.0 });
         Assert.assertNotEquals(p1, p2);
         Assert.assertNotEquals(p2, p1);
         // Next add different data to p1 to make number of elements match and
         // markers are not null however actual results will vary
         p1.incrementAll(new double[] { 20, 21, 22, 23 });
         Assert.assertNotEquals(p1, p2);// though markers are non null, N
         // matches, results wont
     }
 
     @Test(expected = OutOfRangeException.class)
     public void testMarkersOORLow() {
         PSquarePercentile.newMarkers(
                 Arrays.asList(new Double[] { 0.02, 1.18, 9.15, 21.91, 38.62 }),
                 0.5).estimate(0);
     }
 
     @Test(expected = OutOfRangeException.class)
     public void testMarkersOORHigh() {
         PSquarePercentile.newMarkers(
                 Arrays.asList(new Double[] { 0.02, 1.18, 9.15, 21.91, 38.62 }),
                 0.5).estimate(5);
     }
 
     @Test
     public void testMarkers2() {
         double p = 0.5;
         PSquareMarkers markers =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 0.02, 1.18, 9.15, 21.91,
                                 38.62 }), p);
 
         PSquareMarkers markersNew =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 0.02, 1.18, 9.15, 21.91,
                                 38.62 }), p);
 
         Assert.assertEquals(markers, markersNew);
         // If just one element of markers got changed then its still false.
         markersNew.processDataPoint(39);
         Assert.assertNotEquals(markers, markersNew);
     }
 
     @Test
     public void testHashCodeInMarkers() {
         PSquarePercentile p = new PSquarePercentile(95);
         PSquarePercentile p2 = new PSquarePercentile(95);
         Set<PSquarePercentile> s = new HashSet<>();
         s.add(p);
         s.add(p2);
         Assert.assertEquals(1, s.size());
         Assert.assertEquals(p, s.iterator().next());
         double[] d =
                 new double[] { 95.1772, 95.1567, 95.1937, 95.1959, 95.1442,
                         95.0610, 95.1591, 95.1195, 95.1772, 95.0925, 95.1990,
                         95.1682 };
         Assert.assertEquals(95.1981, p.evaluate(d), 1.0e-2); // change
         Assert.assertEquals(95.1981, p2.evaluate(d), 1.0e-2); // change
         s.clear();
         s.add(p);
         s.add(p2);
         Assert.assertEquals(1, s.size());
         Assert.assertEquals(p, s.iterator().next());
 
         PSquareMarkers m1 =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 95.1772, 95.1567, 95.1937,
                                 95.1959, 95.1442, 95.0610, 95.1591, 95.1195,
                                 95.1772, 95.0925, 95.1990, 95.1682 }), 0.0);
         PSquareMarkers m2 =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 95.1772, 95.1567, 95.1937,
                                 95.1959, 95.1442, 95.0610, 95.1591, 95.1195,
                                 95.1772, 95.0925, 95.1990, 95.1682 }), 0.0);
         Assert.assertEquals(m1, m2);
         Set<PSquareMarkers> setMarkers = new LinkedHashSet<>();
         Assert.assertTrue(setMarkers.add(m1));
         Assert.assertFalse(setMarkers.add(m2));
         Assert.assertEquals(1, setMarkers.size());
 
         PSquareMarkers mThis =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 195.1772, 195.1567,
                                 195.1937, 195.1959, 95.1442, 195.0610,
                                 195.1591, 195.1195, 195.1772, 95.0925, 95.1990,
                                 195.1682 }), 0.50);
         PSquareMarkers mThat =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 95.1772, 95.1567, 95.1937,
                                 95.1959, 95.1442, 95.0610, 95.1591, 95.1195,
                                 95.1772, 95.0925, 95.1990, 95.1682 }), 0.50);
         Assert.assertEquals(mThis, mThis);
         Assert.assertNotEquals(mThis, mThat);
         String s1="";
         Assert.assertNotEquals(mThis, s1);
         for (int i = 0; i < testArray.length; i++) {
             mThat.processDataPoint(testArray[i]);
         }
         setMarkers.add(mThat);
         setMarkers.add(mThis);
         Assert.assertEquals(mThat, mThat);
         Assert.assertTrue(setMarkers.contains(mThat));
         Assert.assertTrue(setMarkers.contains(mThis));
         Assert.assertEquals(3, setMarkers.size());
         Iterator<PSquareMarkers> iterator=setMarkers.iterator();
         Assert.assertEquals(m1, iterator.next());
         Assert.assertEquals(mThat, iterator.next());
         Assert.assertEquals(mThis, iterator.next());
     }
 
     @Test(expected = OutOfRangeException.class)
     public void testMarkersWithLowerIndex() {
         PSquareMarkers mThat =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 95.1772, 95.1567, 95.1937,
                                 95.1959, 95.1442, 95.0610, 95.1591, 95.1195,
                                 95.1772, 95.0925, 95.1990, 95.1682 }), 0.50);
         for (int i = 0; i < testArray.length; i++) {
             mThat.processDataPoint(testArray[i]);
         }
         mThat.estimate(0);
     }
 
     @Test(expected = OutOfRangeException.class)
     public void testMarkersWithHigherIndex() {
         PSquareMarkers mThat =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 95.1772, 95.1567, 95.1937,
                                 95.1959, 95.1442, 95.0610, 95.1591, 95.1195,
                                 95.1772, 95.0925, 95.1990, 95.1682 }), 0.50);
         for (int i = 0; i < testArray.length; i++) {
             mThat.processDataPoint(testArray[i]);
         }
         mThat.estimate(6);
     }
 
     @Test(expected = OutOfRangeException.class)
     public void testMarkerHeightWithLowerIndex() {
         PSquareMarkers mThat =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 95.1772, 95.1567, 95.1937,
                                 95.1959, 95.1442, 95.0610, 95.1591, 95.1195,
                                 95.1772, 95.0925, 95.1990, 95.1682 }), 0.50);
         mThat.height(0);
     }
 
     @Test(expected = OutOfRangeException.class)
     public void testMarkerHeightWithHigherIndex() {
         PSquareMarkers mThat =
                 PSquarePercentile.newMarkers(
                         Arrays.asList(new Double[] { 95.1772, 95.1567, 95.1937,
                                 95.1959, 95.1442, 95.0610, 95.1591, 95.1195,
                                 95.1772, 95.0925, 95.1990, 95.1682 }), 0.50);
         mThat.height(6);
     }
 
     @Test
     public void testPSquaredEqualsAndMin() {
         PSquarePercentile ptile = new PSquarePercentile(0);
         Assert.assertEquals(ptile, ptile);
         Assert.assertNotEquals(ptile, null);
         Assert.assertNotEquals(ptile, "");
         // Just to check if there is no data get result for zeroth and 100th
         // ptile returns NAN
         Assert.assertTrue(Double.isNaN(ptile.getResult()));
         Assert.assertTrue(Double.isNaN(new PSquarePercentile(100).getResult()));
 
         double[] d = new double[] { 1, 3, 2, 4, 9, 10, 11 };
         ptile.incrementAll(d);
         Assert.assertEquals(ptile, ptile);
         Assert.assertEquals(1d, ptile.getResult(), 1e-02);// this calls min
     }
 
     @Test
     public void testString() {
         PSquarePercentile ptile = new PSquarePercentile(95);
         Assert.assertNotNull(ptile.toString());
         ptile.increment(1);
         ptile.increment(2);
         ptile.increment(3);
         Assert.assertNotNull(ptile.toString());
         Assert.assertEquals(expectedValue(), ptile.evaluate(testArray), getTolerance());
         Assert.assertNotNull(ptile.toString());
     }
 
     @Override
     public UnivariateStatistic getUnivariateStatistic() {
         PSquarePercentile ptile = new PSquarePercentile(95);
         // Assert.assertNull(ptile.markers());
         return ptile;
     }
 
     @Override
     public double expectedValue() {
         return this.percentile95;
     }
 
     @Test
     public void testHighPercentile() {
         double[] d = new double[] { 1, 2, 3 };
         PSquarePercentile p = new PSquarePercentile(75.0);
         Assert.assertEquals(2, p.evaluate(d), 1.0e-5);
         PSquarePercentile p95 = new PSquarePercentile();
         Assert.assertEquals(2, p95.evaluate(d), 1.0e-5);
     }
 
     @Test
     public void testLowPercentile() {
         double[] d = new double[] { 0, 1 };
         PSquarePercentile p = new PSquarePercentile(25.0);
         Assert.assertEquals(0d, p.evaluate(d), Double.MIN_VALUE);
     }
 
     @Test
     public void testPercentile() {
         double[] d = new double[] { 1, 3, 2, 4 };
         PSquarePercentile p = new PSquarePercentile(30d);
         Assert.assertEquals(1.0, p.evaluate(d), 1.0e-5);
         p = new PSquarePercentile(25);
         Assert.assertEquals(1.0, p.evaluate(d), 1.0e-5);
         p = new PSquarePercentile(75);
         Assert.assertEquals(3.0, p.evaluate(d), 1.0e-5);
         p = new PSquarePercentile(50);
         Assert.assertEquals(2d, p.evaluate(d), 1.0e-5);
     }
 
     @Test(expected = MathIllegalArgumentException.class)
     public void testInitial() {
         PSquarePercentile.newMarkers(new ArrayList<>(), 0.5);
         Assert.fail();
     }
 
     @Test(expected = MathIllegalArgumentException.class)
     public void testNegativeInvalidValues() {
         double[] d =
                 new double[] { 95.1772, 95.1567, 95.1937, 95.1959, 95.1442,
                         95.0610, 95.1591, 95.1195, 95.1772, 95.0925, 95.1990,
                         95.1682 };
         PSquarePercentile p = new PSquarePercentile(-1.0);
         p.evaluate(d, 0, d.length);
         Assert.fail("This method has had to throw exception..but it is not..");
     }
 
     @Test(expected = MathIllegalArgumentException.class)
     public void testPositiveInvalidValues() {
         double[] d =
                 new double[] { 95.1772, 95.1567, 95.1937, 95.1959, 95.1442,
                         95.0610, 95.1591, 95.1195, 95.1772, 95.0925, 95.1990,
                         95.1682 };
         PSquarePercentile p = new PSquarePercentile(101.0);
         p.evaluate(d, 0, d.length);
         Assert.fail("This method has had to throw exception..but it is not..");
     }
 
     @Test
     public void testNISTExample() {
         double[] d =
                 new double[] { 95.1772, 95.1567, 95.1937, 95.1959, 95.1442,
                         95.0610, 95.1591, 95.1195, 95.1772, 95.0925, 95.1990,
                         95.1682 };
         Assert.assertEquals(95.1981, new PSquarePercentile(90d).evaluate(d),
                 1.0e-2); // changed the accuracy to 1.0e-2
         Assert.assertEquals(95.061, new PSquarePercentile(0d).evaluate(d), 0);
         Assert.assertEquals(95.1990,
                 new PSquarePercentile(100d).evaluate(d, 0, d.length), 0);
     }
 
     @Test
     public void test5() {
         PSquarePercentile percentile = new PSquarePercentile(5d);
         Assert.assertEquals(this.percentile5, percentile.evaluate(testArray),
                 1.0);// changed the accuracy to 1 instead of tolerance
     }
 
     @Test(expected = NullArgumentException.class)
     public void testNull() {
         PSquarePercentile percentile = new PSquarePercentile(50d);
         double[] nullArray = null;
         percentile.evaluate(nullArray);
     }
 
     @Test
     public void testEmpty() {
         PSquarePercentile percentile = new PSquarePercentile(50d);
         double[] emptyArray = new double[] {};
         Assert.assertTrue(Double.isNaN(percentile.evaluate(emptyArray)));
     }
 
     @Test
     public void testSingleton() {
         PSquarePercentile percentile = new PSquarePercentile(50d);
         double[] singletonArray = new double[] { 1d };
         Assert.assertEquals(1d, percentile.evaluate(singletonArray), 0);
         Assert.assertEquals(1d, percentile.evaluate(singletonArray, 0, 1), 0);
         percentile = new PSquarePercentile(5);
         Assert.assertEquals(1d, percentile.evaluate(singletonArray, 0, 1), 0);
         percentile = new PSquarePercentile(100);
         Assert.assertEquals(1d, percentile.evaluate(singletonArray, 0, 1), 0);
         percentile = new PSquarePercentile(100);
         Assert.assertTrue(Double.isNaN(percentile
                 .evaluate(singletonArray, 0, 0)));
     }
 
     @Test
     public void testSpecialValues() {
         PSquarePercentile percentile = new PSquarePercentile(50d);
         double[] specialValues =
                 new double[] { 0d, 1d, 2d, 3d, 4d, Double.NaN };
         Assert.assertEquals(2d, percentile.evaluate(specialValues), 0);
         specialValues =
                 new double[] { Double.NEGATIVE_INFINITY, 1d, 2d, 3d,
                         Double.NaN, Double.POSITIVE_INFINITY };
         Assert.assertEquals(2d, percentile.evaluate(specialValues), 0);
         specialValues =
                 new double[] { 1d, 1d, Double.POSITIVE_INFINITY,
                         Double.POSITIVE_INFINITY };
         Assert.assertFalse(Double.isInfinite(percentile.evaluate(specialValues)));
         specialValues = new double[] { 1d, 1d, Double.NaN, Double.NaN };
         Assert.assertFalse(Double.isNaN(percentile.evaluate(specialValues)));
         specialValues =
                 new double[] { 1d, 1d, Double.NEGATIVE_INFINITY,
                         Double.NEGATIVE_INFINITY };
         percentile = new PSquarePercentile(50d);
         // Interpolation results in NEGATIVE_INFINITY + POSITIVE_INFINITY
         // changed the result check to infinity instead of NaN
         Assert.assertTrue(Double.isInfinite(percentile.evaluate(specialValues)));
     }
 
     @Test
     public void testArrayExample() {
         Assert.assertEquals(expectedValue(),
                 new PSquarePercentile(95d).evaluate(testArray), getTolerance());
     }
 
     @Test
     public void testSetQuantile() {
         PSquarePercentile percentile = new PSquarePercentile(10d);
 
         percentile = new PSquarePercentile(100); // OK
         Assert.assertEquals(1.0, percentile.quantile(), 0);
         try {
             percentile = new PSquarePercentile(0);
             // Assert.fail("Expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // expected
         }
         try {
             new PSquarePercentile(0d);
             // Assert.fail("Expecting MathIllegalArgumentException");
         } catch (MathIllegalArgumentException ex) {
             // expected
         }
     }
 
     private Double[] randomTestData(int factor, int values) {
         Double[] test = new Double[values];
         for (int i = 0; i < test.length; i++) {
             test[i] = Math.abs(randomGenerator.nextDouble() * factor);
         }
         return test;
     }
 
     @Test
     public void testAccept() {
         PSquarePercentile psquared = new PSquarePercentile(0.99);
         Assert.assertTrue(Double.isNaN(psquared.getResult()));
         Double[] test = randomTestData(100, 10000);
 
         for (Double value : test) {
             psquared.increment(value);
             Assert.assertTrue(psquared.getResult() >= 0);
         }
     }
 
     private void assertValues(Double a, Double b, double delta) {
         if (Double.isNaN(a)) {
             Assert.assertTrue("" + b + " is not NaN.", Double.isNaN(a));
         } else {
             double max = JdkMath.max(a, b);
             double percentage = JdkMath.abs(a - b) / max;
             double deviation = delta;
             Assert.assertTrue(String.format(
                     "Deviated = %f and is beyond %f as a=%f,  b=%f",
                     percentage, deviation, a, b), percentage < deviation);
         }
     }
 
     private void doCalculatePercentile(Double percentile, Number[] test) {
         doCalculatePercentile(percentile, test, Double.MAX_VALUE);
     }
 
     private void doCalculatePercentile(Double percentile, Number[] test,
             double delta) {
         PSquarePercentile psquared = new PSquarePercentile(percentile);
         for (Number value : test) {
             psquared.increment(value.doubleValue());
         }
 
         Percentile p2 = new Percentile(percentile * 100);
 
         double[] dall = new double[test.length];
         for (int i = 0; i < test.length; i++) {
             dall[i] = test[i].doubleValue();
         }
 
         Double referenceValue = p2.evaluate(dall);
         assertValues(psquared.getResult(), referenceValue, delta);
     }
 
     private void doCalculatePercentile(double percentile, double[] test,
             double delta) {
         PSquarePercentile psquared = new PSquarePercentile(percentile);
         for (double value : test) {
             psquared.increment(value);
         }
 
         Percentile p2 =
                 new Percentile(percentile < 1 ? percentile * 100 : percentile);
         /*
          * double[] dall = new double[test.length]; for (int i = 0; i <
          * test.length; i++) dall[i] = test[i];
          */
         Double referenceValue = p2.evaluate(test);
         assertValues(psquared.getResult(), referenceValue, delta);
     }
 
     @Test
     public void testCannedDataSet() {
         // test.unoverride("dump");
         Integer[] seedInput =
                 new Integer[] { 283, 285, 298, 304, 310, 31, 319, 32, 33, 339,
                         342, 348, 350, 354, 354, 357, 36, 36, 369, 37, 37, 375,
                         378, 383, 390, 396, 405, 408, 41, 414, 419, 416, 42,
                         420, 430, 430, 432, 444, 447, 447, 449, 45, 451, 456,
                         468, 470, 471, 474, 600, 695, 70, 83, 97, 109, 113, 128 };
         Integer[] input = new Integer[seedInput.length * 100];
         for (int i = 0; i < input.length; i++) {
             input[i] = seedInput[i % seedInput.length] + i;
         }
         // Arrays.sort(input);
         doCalculatePercentile(0.50d, input);
         doCalculatePercentile(0.95d, input);
     }
 
     @Test
     public void test99Percentile() {
         Double[] test = randomTestData(100, 10000);
         doCalculatePercentile(0.99d, test);
     }
 
     @Test
     public void test90Percentile() {
         Double[] test = randomTestData(100, 10000);
         doCalculatePercentile(0.90d, test);
     }
 
     @Test
     public void test20Percentile() {
         Double[] test = randomTestData(100, 100000);
         doCalculatePercentile(0.20d, test);
     }
 
     @Test
     public void test5Percentile() {
         Double[] test = randomTestData(50, 990000);
         doCalculatePercentile(0.50d, test);
     }
 
     @Test
     public void test99PercentileHighValues() {
         Double[] test = randomTestData(100000, 10000);
         doCalculatePercentile(0.99d, test);
     }
 
     @Test
     public void test90PercentileHighValues() {
         Double[] test = randomTestData(100000, 100000);
         doCalculatePercentile(0.90d, test);
     }
 
     @Test
     public void test20PercentileHighValues() {
         Double[] test = randomTestData(100000, 100000);
         doCalculatePercentile(0.20d, test);
     }
 
     @Test
     public void test5PercentileHighValues() {
         Double[] test = randomTestData(100000, 100000);
         doCalculatePercentile(0.05d, test);
     }
 
     @Test
     public void test0PercentileValuesWithFewerThan5Values() {
         double[] test = { 1d, 2d, 3d, 4d };
         PSquarePercentile p = new PSquarePercentile(0d);
         Assert.assertEquals(1d, p.evaluate(test), 0);
         Assert.assertNotNull(p.toString());
     }
 
     @Test
     public void testPSQuaredEvalFuncWithPapersExampleData() throws IOException {
 
         // This data as input is considered from
         // http://www.cs.wustl.edu/~jain/papers/ftp/psqr.pdf
         double[] data =
                 { 0.02, 0.5, 0.74, 3.39, 0.83, 22.37, 10.15, 15.43, 38.62,
                         15.92, 34.6, 10.28, 1.47, 0.4, 0.05, 11.39, 0.27, 0.42,
                         0.09, 11.37,
 
                         11.39, 15.43, 15.92, 22.37, 34.6, 38.62, 18.9, 19.2,
                         27.6, 12.8, 13.7, 21.9
                 };
 
         PSquarePercentile psquared = new PSquarePercentile(50);
 
         Double p2value = 0d;
         for (int i = 0; i < 20; i++) {
             psquared.increment(data[i]);
             p2value = psquared.getResult();
             // System.out.println(psquared.toString());//uncomment here to see
             // the papers example output
         }
         // System.out.println("p2value=" + p2value);
         Double expected = 4.44d;// 13d; // From The Paper
         // http://www.cs.wustl.edu/~jain/papers/ftp/psqr.pdf.
         // Pl refer Pg 1061 Look at the mid marker
         // height
         // expected = new Percentile(50).evaluate(data,0,20);
         // Well the values deviate in our calculation by 0.25 so its 4.25 vs
         // 4.44
         Assert.assertEquals(
                 String.format("Expected=%f, Actual=%f", expected, p2value),
                 expected, p2value, 0.25);
     }
 
     private final int TINY = 10;
     private final int SMALL = 50;
     private final int NOMINAL = 100;
     private final int MEDIUM = 500;
     private final int STANDARD = 1000;
     private final int BIG = 10000;
     private final int VERY_BIG = 50000;
     private final int LARGE = 1000000;
     private final int VERY_LARGE = 10000000;
 
     private void doDistributionTest(ContinuousDistribution distribution) {
         final ContinuousDistribution.Sampler sampler =
             distribution.createSampler(RandomSource.WELL_19937_C.create(1000));
         double data[];
 
         data = AbstractRealDistribution.sample(VERY_LARGE, sampler);
         doCalculatePercentile(50, data, 0.0001);
         doCalculatePercentile(95, data, 0.0001);
 
         data = AbstractRealDistribution.sample(LARGE, sampler);
         doCalculatePercentile(50, data, 0.001);
         doCalculatePercentile(95, data, 0.001);
 
         data = AbstractRealDistribution.sample(VERY_BIG, sampler);
         doCalculatePercentile(50, data, 0.001);
         doCalculatePercentile(95, data, 0.001);
 
         data = AbstractRealDistribution.sample(BIG, sampler);
         doCalculatePercentile(50, data, 0.001);
         doCalculatePercentile(95, data, 0.001);
 
         data = AbstractRealDistribution.sample(STANDARD, sampler);
         doCalculatePercentile(50, data, 0.005);
         doCalculatePercentile(95, data, 0.005);
 
         data = AbstractRealDistribution.sample(MEDIUM, sampler);
         doCalculatePercentile(50, data, 0.005);
         doCalculatePercentile(95, data, 0.005);
 
         data = AbstractRealDistribution.sample(NOMINAL, sampler);
         doCalculatePercentile(50, data, 0.01);
         doCalculatePercentile(95, data, 0.01);
 
         data = AbstractRealDistribution.sample(SMALL, sampler);
         doCalculatePercentile(50, data, 0.01);
         doCalculatePercentile(95, data, 0.01);
 
         data = AbstractRealDistribution.sample(TINY, sampler);
         doCalculatePercentile(50, data, 0.05);
         doCalculatePercentile(95, data, 0.05);
     }
 
     /**
      * Test Various Dist
      */
     @Test
     public void testDistribution() {
         doDistributionTest(NormalDistribution.of(4000, 50));
         doDistributionTest(LogNormalDistribution.of(4000, 50));
         // doDistributionTest((ExponentialDistribution.of(4000));
         // doDistributionTest(GammaDistribution.of(5d,1d),0.1);
     }
 }