001 /* 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.commons.math.stat.descriptive.rank; 018 019 import junit.framework.Test; 020 import junit.framework.TestSuite; 021 022 import org.apache.commons.math.stat.descriptive.UnivariateStatistic; 023 import org.apache.commons.math.stat.descriptive.UnivariateStatisticAbstractTest; 024 025 /** 026 * Test cases for the {@link UnivariateStatistic} class. 027 * @version $Revision: 762087 $ $Date: 2009-04-05 10:20:18 -0400 (Sun, 05 Apr 2009) $ 028 */ 029 public class PercentileTest extends UnivariateStatisticAbstractTest{ 030 031 protected Percentile stat; 032 033 /** 034 * @param name 035 */ 036 public PercentileTest(String name) { 037 super(name); 038 } 039 040 public static Test suite() { 041 TestSuite suite = new TestSuite(PercentileTest.class); 042 suite.setName("Percentile Tests"); 043 return suite; 044 } 045 046 /** 047 * {@inheritDoc} 048 */ 049 @Override 050 public UnivariateStatistic getUnivariateStatistic() { 051 return new Percentile(95.0); 052 } 053 054 /** 055 * {@inheritDoc} 056 */ 057 @Override 058 public double expectedValue() { 059 return this.percentile95; 060 } 061 062 public void testHighPercentile(){ 063 double[] d = new double[]{1, 2, 3}; 064 Percentile p = new Percentile(75); 065 assertEquals(3.0, p.evaluate(d), 1.0e-5); 066 } 067 068 public void testPercentile() { 069 double[] d = new double[] {1, 3, 2, 4}; 070 Percentile p = new Percentile(30); 071 assertEquals(1.5, p.evaluate(d), 1.0e-5); 072 p.setQuantile(25); 073 assertEquals(1.25, p.evaluate(d), 1.0e-5); 074 p.setQuantile(75); 075 assertEquals(3.75, p.evaluate(d), 1.0e-5); 076 p.setQuantile(50); 077 assertEquals(2.5, p.evaluate(d), 1.0e-5); 078 079 // invalid percentiles 080 try { 081 p.evaluate(d, 0, d.length, -1.0); 082 fail(); 083 } catch (IllegalArgumentException ex) { 084 // success 085 } 086 try { 087 p.evaluate(d, 0, d.length, 101.0); 088 fail(); 089 } catch (IllegalArgumentException ex) { 090 // success 091 } 092 } 093 094 public void testNISTExample() { 095 double[] d = new double[] {95.1772, 95.1567, 95.1937, 95.1959, 096 95.1442, 95.0610, 95.1591, 95.1195, 95.1772, 95.0925, 95.1990, 95.1682 097 }; 098 Percentile p = new Percentile(90); 099 assertEquals(95.1981, p.evaluate(d), 1.0e-4); 100 assertEquals(95.1990, p.evaluate(d,0,d.length, 100d), 0); 101 } 102 103 public void test5() { 104 Percentile percentile = new Percentile(5); 105 assertEquals(this.percentile5, percentile.evaluate(testArray), getTolerance()); 106 } 107 108 public void testNullEmpty() { 109 Percentile percentile = new Percentile(50); 110 double[] nullArray = null; 111 double[] emptyArray = new double[] {}; 112 try { 113 percentile.evaluate(nullArray); 114 fail("Expecting IllegalArgumentException for null array"); 115 } catch (IllegalArgumentException ex) { 116 // expected 117 } 118 assertTrue(Double.isNaN(percentile.evaluate(emptyArray))); 119 } 120 121 public void testSingleton() { 122 Percentile percentile = new Percentile(50); 123 double[] singletonArray = new double[] {1d}; 124 assertEquals(1d, percentile.evaluate(singletonArray), 0); 125 assertEquals(1d, percentile.evaluate(singletonArray, 0, 1), 0); 126 assertEquals(1d, percentile.evaluate(singletonArray, 0, 1, 5), 0); 127 assertEquals(1d, percentile.evaluate(singletonArray, 0, 1, 100), 0); 128 assertTrue(Double.isNaN(percentile.evaluate(singletonArray, 0, 0))); 129 } 130 131 public void testSpecialValues() { 132 Percentile percentile = new Percentile(50); 133 double[] specialValues = new double[] {0d, 1d, 2d, 3d, 4d, Double.NaN}; 134 assertEquals(2.5d, percentile.evaluate(specialValues), 0); 135 specialValues = new double[] {Double.NEGATIVE_INFINITY, 1d, 2d, 3d, 136 Double.NaN, Double.POSITIVE_INFINITY}; 137 assertEquals(2.5d, percentile.evaluate(specialValues), 0); 138 specialValues = new double[] {1d, 1d, Double.POSITIVE_INFINITY, 139 Double.POSITIVE_INFINITY}; 140 assertTrue(Double.isInfinite(percentile.evaluate(specialValues))); 141 specialValues = new double[] {1d, 1d, Double.NaN, 142 Double.NaN}; 143 assertTrue(Double.isNaN(percentile.evaluate(specialValues))); 144 specialValues = new double[] {1d, 1d, Double.NEGATIVE_INFINITY, 145 Double.NEGATIVE_INFINITY}; 146 // Interpolation results in NEGATIVE_INFINITY + POSITIVE_INFINITY 147 assertTrue(Double.isNaN(percentile.evaluate(specialValues))); 148 } 149 150 public void testSetQuantile() { 151 Percentile percentile = new Percentile(10); 152 percentile.setQuantile(100); // OK 153 assertEquals(100, percentile.getQuantile(), 0); 154 try { 155 percentile.setQuantile(0); 156 fail("Expecting IllegalArgumentException"); 157 } catch (IllegalArgumentException ex) { 158 // expected 159 } 160 try { 161 new Percentile(0); 162 fail("Expecting IllegalArgumentException"); 163 } catch (IllegalArgumentException ex) { 164 // expected 165 } 166 } 167 168 }