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