View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    *
9    *      https://www.apache.org/licenses/LICENSE-2.0
10   *
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  /*
19   * This is not the original file distributed by the Apache Software Foundation
20   * It has been modified by the Hipparchus project
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   * Test cases for NaturalRanking class
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() { // Ties averaged, NaNs failed
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              // expected
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              // expected
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 }