1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.math.stat.ranking;
18
19 import org.apache.commons.math.TestUtils;
20 import org.apache.commons.math.random.JDKRandomGenerator;
21 import org.apache.commons.math.random.RandomGenerator;
22
23 import junit.framework.TestCase;
24
25
26
27
28
29
30
31 public class NaturalRankingTest extends TestCase {
32
33 private final double[] exampleData = { 20, 17, 30, 42.3, 17, 50,
34 Double.NaN, Double.NEGATIVE_INFINITY, 17 };
35 private final double[] tiesFirst = { 0, 0, 2, 1, 4 };
36 private final double[] tiesLast = { 4, 4, 1, 0 };
37 private final double[] multipleNaNs = { 0, 1, Double.NaN, Double.NaN };
38 private final double[] multipleTies = { 3, 2, 5, 5, 6, 6, 1 };
39 private final double[] allSame = { 0, 0, 0, 0 };
40
41 public NaturalRankingTest(String arg0) {
42 super(arg0);
43 }
44
45 @Override
46 protected void setUp() throws Exception {
47 super.setUp();
48 }
49
50 @Override
51 protected void tearDown() throws Exception {
52 super.tearDown();
53 }
54
55 public void testDefault() {
56 NaturalRanking ranking = new NaturalRanking();
57 double[] ranks = ranking.rank(exampleData);
58 double[] correctRanks = { 5, 3, 6, 7, 3, 8, 9, 1, 3 };
59 TestUtils.assertEquals(correctRanks, ranks, 0d);
60 ranks = ranking.rank(tiesFirst);
61 correctRanks = new double[] { 1.5, 1.5, 4, 3, 5 };
62 TestUtils.assertEquals(correctRanks, ranks, 0d);
63 ranks = ranking.rank(tiesLast);
64 correctRanks = new double[] { 3.5, 3.5, 2, 1 };
65 TestUtils.assertEquals(correctRanks, ranks, 0d);
66 ranks = ranking.rank(multipleNaNs);
67 correctRanks = new double[] { 1, 2, 3.5, 3.5 };
68 TestUtils.assertEquals(correctRanks, ranks, 0d);
69 ranks = ranking.rank(multipleTies);
70 correctRanks = new double[] { 3, 2, 4.5, 4.5, 6.5, 6.5, 1 };
71 TestUtils.assertEquals(correctRanks, ranks, 0d);
72 ranks = ranking.rank(allSame);
73 correctRanks = new double[] { 2.5, 2.5, 2.5, 2.5 };
74 TestUtils.assertEquals(correctRanks, ranks, 0d);
75 }
76
77 public void testNaNsMaximalTiesMinimum() {
78 NaturalRanking ranking = new NaturalRanking(TiesStrategy.MINIMUM);
79 double[] ranks = ranking.rank(exampleData);
80 double[] correctRanks = { 5, 2, 6, 7, 2, 8, 9, 1, 2 };
81 TestUtils.assertEquals(correctRanks, ranks, 0d);
82 ranks = ranking.rank(tiesFirst);
83 correctRanks = new double[] { 1, 1, 4, 3, 5 };
84 TestUtils.assertEquals(correctRanks, ranks, 0d);
85 ranks = ranking.rank(tiesLast);
86 correctRanks = new double[] { 3, 3, 2, 1 };
87 TestUtils.assertEquals(correctRanks, ranks, 0d);
88 ranks = ranking.rank(multipleNaNs);
89 correctRanks = new double[] { 1, 2, 3, 3 };
90 TestUtils.assertEquals(correctRanks, ranks, 0d);
91 ranks = ranking.rank(multipleTies);
92 correctRanks = new double[] { 3, 2, 4, 4, 6, 6, 1 };
93 TestUtils.assertEquals(correctRanks, ranks, 0d);
94 ranks = ranking.rank(allSame);
95 correctRanks = new double[] { 1, 1, 1, 1 };
96 TestUtils.assertEquals(correctRanks, ranks, 0d);
97 }
98
99 public void testNaNsRemovedTiesSequential() {
100 NaturalRanking ranking = new NaturalRanking(NaNStrategy.REMOVED,
101 TiesStrategy.SEQUENTIAL);
102 double[] ranks = ranking.rank(exampleData);
103 double[] correctRanks = { 5, 2, 6, 7, 3, 8, 1, 4 };
104 TestUtils.assertEquals(correctRanks, ranks, 0d);
105 ranks = ranking.rank(tiesFirst);
106 correctRanks = new double[] { 1, 2, 4, 3, 5 };
107 TestUtils.assertEquals(correctRanks, ranks, 0d);
108 ranks = ranking.rank(tiesLast);
109 correctRanks = new double[] { 3, 4, 2, 1 };
110 TestUtils.assertEquals(correctRanks, ranks, 0d);
111 ranks = ranking.rank(multipleNaNs);
112 correctRanks = new double[] { 1, 2 };
113 TestUtils.assertEquals(correctRanks, ranks, 0d);
114 ranks = ranking.rank(multipleTies);
115 correctRanks = new double[] { 3, 2, 4, 5, 6, 7, 1 };
116 TestUtils.assertEquals(correctRanks, ranks, 0d);
117 ranks = ranking.rank(allSame);
118 correctRanks = new double[] { 1, 2, 3, 4 };
119 TestUtils.assertEquals(correctRanks, ranks, 0d);
120 }
121
122 public void testNaNsMinimalTiesMaximum() {
123 NaturalRanking ranking = new NaturalRanking(NaNStrategy.MINIMAL,
124 TiesStrategy.MAXIMUM);
125 double[] ranks = ranking.rank(exampleData);
126 double[] correctRanks = { 6, 5, 7, 8, 5, 9, 2, 2, 5 };
127 TestUtils.assertEquals(correctRanks, ranks, 0d);
128 ranks = ranking.rank(tiesFirst);
129 correctRanks = new double[] { 2, 2, 4, 3, 5 };
130 TestUtils.assertEquals(correctRanks, ranks, 0d);
131 ranks = ranking.rank(tiesLast);
132 correctRanks = new double[] { 4, 4, 2, 1 };
133 TestUtils.assertEquals(correctRanks, ranks, 0d);
134 ranks = ranking.rank(multipleNaNs);
135 correctRanks = new double[] { 3, 4, 2, 2 };
136 TestUtils.assertEquals(correctRanks, ranks, 0d);
137 ranks = ranking.rank(multipleTies);
138 correctRanks = new double[] { 3, 2, 5, 5, 7, 7, 1 };
139 TestUtils.assertEquals(correctRanks, ranks, 0d);
140 ranks = ranking.rank(allSame);
141 correctRanks = new double[] { 4, 4, 4, 4 };
142 TestUtils.assertEquals(correctRanks, ranks, 0d);
143 }
144
145 public void testNaNsMinimalTiesAverage() {
146 NaturalRanking ranking = new NaturalRanking(NaNStrategy.MINIMAL);
147 double[] ranks = ranking.rank(exampleData);
148 double[] correctRanks = { 6, 4, 7, 8, 4, 9, 1.5, 1.5, 4 };
149 TestUtils.assertEquals(correctRanks, ranks, 0d);
150 ranks = ranking.rank(tiesFirst);
151 correctRanks = new double[] { 1.5, 1.5, 4, 3, 5 };
152 TestUtils.assertEquals(correctRanks, ranks, 0d);
153 ranks = ranking.rank(tiesLast);
154 correctRanks = new double[] { 3.5, 3.5, 2, 1 };
155 TestUtils.assertEquals(correctRanks, ranks, 0d);
156 ranks = ranking.rank(multipleNaNs);
157 correctRanks = new double[] { 3, 4, 1.5, 1.5 };
158 TestUtils.assertEquals(correctRanks, ranks, 0d);
159 ranks = ranking.rank(multipleTies);
160 correctRanks = new double[] { 3, 2, 4.5, 4.5, 6.5, 6.5, 1 };
161 TestUtils.assertEquals(correctRanks, ranks, 0d);
162 ranks = ranking.rank(allSame);
163 correctRanks = new double[] { 2.5, 2.5, 2.5, 2.5 };
164 TestUtils.assertEquals(correctRanks, ranks, 0d);
165 }
166
167 public void testNaNsFixedTiesRandom() {
168 RandomGenerator randomGenerator = new JDKRandomGenerator();
169 randomGenerator.setSeed(1000);
170 NaturalRanking ranking = new NaturalRanking(NaNStrategy.FIXED,
171 randomGenerator);
172 double[] ranks = ranking.rank(exampleData);
173 double[] correctRanks = { 5, 4, 6, 7, 3, 8, Double.NaN, 1, 4 };
174 TestUtils.assertEquals(correctRanks, ranks, 0d);
175 ranks = ranking.rank(tiesFirst);
176 correctRanks = new double[] { 1, 1, 4, 3, 5 };
177 TestUtils.assertEquals(correctRanks, ranks, 0d);
178 ranks = ranking.rank(tiesLast);
179 correctRanks = new double[] { 3, 4, 2, 1 };
180 TestUtils.assertEquals(correctRanks, ranks, 0d);
181 ranks = ranking.rank(multipleNaNs);
182 correctRanks = new double[] { 1, 2, Double.NaN, Double.NaN };
183 TestUtils.assertEquals(correctRanks, ranks, 0d);
184 ranks = ranking.rank(multipleTies);
185 correctRanks = new double[] { 3, 2, 5, 5, 7, 6, 1 };
186 TestUtils.assertEquals(correctRanks, ranks, 0d);
187 ranks = ranking.rank(allSame);
188 correctRanks = new double[] { 1, 3, 4, 4 };
189 TestUtils.assertEquals(correctRanks, ranks, 0d);
190 }
191
192 public void testNaNsAndInfs() {
193 double[] data = { 0, Double.POSITIVE_INFINITY, Double.NaN,
194 Double.NEGATIVE_INFINITY };
195 NaturalRanking ranking = new NaturalRanking(NaNStrategy.MAXIMAL);
196 double[] ranks = ranking.rank(data);
197 double[] correctRanks = new double[] { 2, 3.5, 3.5, 1 };
198 TestUtils.assertEquals(correctRanks, ranks, 0d);
199 ranking = new NaturalRanking(NaNStrategy.MINIMAL);
200 ranks = ranking.rank(data);
201 correctRanks = new double[] { 3, 4, 1.5, 1.5 };
202 TestUtils.assertEquals(correctRanks, ranks, 0d);
203 }
204 }