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.ranking;
018
019 import org.apache.commons.math.TestUtils;
020 import org.apache.commons.math.random.JDKRandomGenerator;
021 import org.apache.commons.math.random.RandomGenerator;
022
023 import junit.framework.TestCase;
024
025 /**
026 * Test cases for NaturalRanking class
027 *
028 * @since 2.0
029 * @version $Revision: 799857 $ $Date: 2009-08-01 09:07:12 -0400 (Sat, 01 Aug 2009) $
030 */
031 public class NaturalRankingTest extends TestCase {
032
033 private final double[] exampleData = { 20, 17, 30, 42.3, 17, 50,
034 Double.NaN, Double.NEGATIVE_INFINITY, 17 };
035 private final double[] tiesFirst = { 0, 0, 2, 1, 4 };
036 private final double[] tiesLast = { 4, 4, 1, 0 };
037 private final double[] multipleNaNs = { 0, 1, Double.NaN, Double.NaN };
038 private final double[] multipleTies = { 3, 2, 5, 5, 6, 6, 1 };
039 private final double[] allSame = { 0, 0, 0, 0 };
040
041 public NaturalRankingTest(String arg0) {
042 super(arg0);
043 }
044
045 @Override
046 protected void setUp() throws Exception {
047 super.setUp();
048 }
049
050 @Override
051 protected void tearDown() throws Exception {
052 super.tearDown();
053 }
054
055 public void testDefault() { // Ties averaged, NaNs maximal
056 NaturalRanking ranking = new NaturalRanking();
057 double[] ranks = ranking.rank(exampleData);
058 double[] correctRanks = { 5, 3, 6, 7, 3, 8, 9, 1, 3 };
059 TestUtils.assertEquals(correctRanks, ranks, 0d);
060 ranks = ranking.rank(tiesFirst);
061 correctRanks = new double[] { 1.5, 1.5, 4, 3, 5 };
062 TestUtils.assertEquals(correctRanks, ranks, 0d);
063 ranks = ranking.rank(tiesLast);
064 correctRanks = new double[] { 3.5, 3.5, 2, 1 };
065 TestUtils.assertEquals(correctRanks, ranks, 0d);
066 ranks = ranking.rank(multipleNaNs);
067 correctRanks = new double[] { 1, 2, 3.5, 3.5 };
068 TestUtils.assertEquals(correctRanks, ranks, 0d);
069 ranks = ranking.rank(multipleTies);
070 correctRanks = new double[] { 3, 2, 4.5, 4.5, 6.5, 6.5, 1 };
071 TestUtils.assertEquals(correctRanks, ranks, 0d);
072 ranks = ranking.rank(allSame);
073 correctRanks = new double[] { 2.5, 2.5, 2.5, 2.5 };
074 TestUtils.assertEquals(correctRanks, ranks, 0d);
075 }
076
077 public void testNaNsMaximalTiesMinimum() {
078 NaturalRanking ranking = new NaturalRanking(TiesStrategy.MINIMUM);
079 double[] ranks = ranking.rank(exampleData);
080 double[] correctRanks = { 5, 2, 6, 7, 2, 8, 9, 1, 2 };
081 TestUtils.assertEquals(correctRanks, ranks, 0d);
082 ranks = ranking.rank(tiesFirst);
083 correctRanks = new double[] { 1, 1, 4, 3, 5 };
084 TestUtils.assertEquals(correctRanks, ranks, 0d);
085 ranks = ranking.rank(tiesLast);
086 correctRanks = new double[] { 3, 3, 2, 1 };
087 TestUtils.assertEquals(correctRanks, ranks, 0d);
088 ranks = ranking.rank(multipleNaNs);
089 correctRanks = new double[] { 1, 2, 3, 3 };
090 TestUtils.assertEquals(correctRanks, ranks, 0d);
091 ranks = ranking.rank(multipleTies);
092 correctRanks = new double[] { 3, 2, 4, 4, 6, 6, 1 };
093 TestUtils.assertEquals(correctRanks, ranks, 0d);
094 ranks = ranking.rank(allSame);
095 correctRanks = new double[] { 1, 1, 1, 1 };
096 TestUtils.assertEquals(correctRanks, ranks, 0d);
097 }
098
099 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 }