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