1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.math4.legacy.stat;
18
19 import java.io.BufferedReader;
20 import java.io.StringReader;
21 import java.util.ArrayList;
22 import java.util.Iterator;
23 import java.util.List;
24
25 import org.apache.commons.math4.legacy.TestUtils;
26 import org.junit.Assert;
27 import org.junit.Test;
28
29
30
31
32
33 public final class FrequencyTest {
34 private static final long ONE_LONG = 1L;
35 private static final long TWO_LONG = 2L;
36 private static final long THREE_LONG = 3L;
37 private static final int ONE = 1;
38 private static final int TWO = 2;
39 private static final int THREE = 3 ;
40 private static final double TOLERANCE = 10E-15d;
41
42
43 @Test
44 public void testCounts() {
45 Frequency<Long> fLong = new Frequency<>();
46 Assert.assertEquals("total count",0,fLong.getSumFreq());
47 fLong.addValue(ONE_LONG);
48 fLong.addValue(TWO_LONG);
49 fLong.addValue(1L);
50 fLong.addValue(ONE_LONG);
51 Assert.assertEquals("one frequency count",3,fLong.getCount(1L));
52 Assert.assertEquals("two frequency count",1,fLong.getCount(2L));
53 Assert.assertEquals("three frequency count",0,fLong.getCount(3L));
54 Assert.assertEquals("total count",4,fLong.getSumFreq());
55 Assert.assertEquals("zero cumulative frequency", 0, fLong.getCumFreq(0L));
56 Assert.assertEquals("one cumulative frequency", 3, fLong.getCumFreq(1L));
57 Assert.assertEquals("two cumulative frequency", 4, fLong.getCumFreq(2L));
58 Assert.assertEquals("Integer argument cum freq",4, fLong.getCumFreq(Long.valueOf(2)));
59 Assert.assertEquals("five cumulative frequency", 4, fLong.getCumFreq(5L));
60 Assert.assertEquals("foo cumulative frequency", 0, fLong.getCumFreq(-1L));
61
62 fLong.clear();
63 Assert.assertEquals("total count",0,fLong.getSumFreq());
64
65
66 Frequency<String> fString = new Frequency<>();
67 fString.addValue("one");
68 fString.addValue("One");
69 fString.addValue("oNe");
70 fString.addValue("Z");
71 Assert.assertEquals("one cumulative frequency", 1 , fString.getCount("one"));
72 Assert.assertEquals("Z cumulative pct", 0.5, fString.getCumPct("Z"), TOLERANCE);
73 Assert.assertEquals("z cumulative pct", 1.0, fString.getCumPct("z"), TOLERANCE);
74 Assert.assertEquals("Ot cumulative pct", 0.25, fString.getCumPct("Ot"), TOLERANCE);
75
76 Frequency<Integer> fInteger = new Frequency<>();
77 fInteger.addValue(1);
78 fInteger.addValue(Integer.valueOf(1));
79 fInteger.addValue(ONE);
80 fInteger.addValue(2);
81 fInteger.addValue(Integer.valueOf(-1));
82 Assert.assertEquals("1 count", 3, fInteger.getCount(1));
83 Assert.assertEquals("1 count", 3, fInteger.getCount(Integer.valueOf(1)));
84 Assert.assertEquals("0 cum pct", 0.2, fInteger.getCumPct(0), TOLERANCE);
85 Assert.assertEquals("1 pct", 0.6, fInteger.getPct(Integer.valueOf(1)), TOLERANCE);
86 Assert.assertEquals("-2 cum pct", 0, fInteger.getCumPct(-2), TOLERANCE);
87 Assert.assertEquals("10 cum pct", 1, fInteger.getCumPct(10), TOLERANCE);
88
89 fString = new Frequency<>(String.CASE_INSENSITIVE_ORDER);
90 fString.addValue("one");
91 fString.addValue("One");
92 fString.addValue("oNe");
93 fString.addValue("Z");
94 Assert.assertEquals("one count", 3 , fString.getCount("one"));
95 Assert.assertEquals("Z cumulative pct -- case insensitive", 1 , fString.getCumPct("Z"), TOLERANCE);
96 Assert.assertEquals("z cumulative pct -- case insensitive", 1 , fString.getCumPct("z"), TOLERANCE);
97
98 Frequency<Character> fChar = new Frequency<>();
99 Assert.assertEquals(0L, fChar.getCount('a'));
100 Assert.assertEquals(0L, fChar.getCumFreq('b'));
101 TestUtils.assertEquals(Double.NaN, fChar.getPct('a'), 0.0);
102 TestUtils.assertEquals(Double.NaN, fChar.getCumPct('b'), 0.0);
103 fChar.addValue('a');
104 fChar.addValue('b');
105 fChar.addValue('c');
106 fChar.addValue('d');
107 Assert.assertEquals(1L, fChar.getCount('a'));
108 Assert.assertEquals(2L, fChar.getCumFreq('b'));
109 Assert.assertEquals(0.25, fChar.getPct('a'), 0.0);
110 Assert.assertEquals(0.5, fChar.getCumPct('b'), 0.0);
111 Assert.assertEquals(1.0, fChar.getCumPct('e'), 0.0);
112 }
113
114
115 @Test
116 public void testPcts() {
117 Frequency<Long> f = new Frequency<>();
118 f.addValue(ONE_LONG);
119 f.addValue(TWO_LONG);
120 f.addValue(THREE_LONG);
121 f.addValue(THREE_LONG);
122 Assert.assertEquals("two pct",0.25,f.getPct(Long.valueOf(2)),TOLERANCE);
123 Assert.assertEquals("two cum pct",0.50,f.getCumPct(Long.valueOf(2)),TOLERANCE);
124 Assert.assertEquals("three cum pct",1.0,f.getCumPct(THREE_LONG),TOLERANCE);
125 }
126
127
128 @Test
129 public void testAdd() {
130 Frequency<Character> f = new Frequency<>();
131 char aChar = 'a';
132 char bChar = 'b';
133 f.addValue(aChar);
134 f.addValue(bChar);
135 Assert.assertEquals("a pct",0.5,f.getPct(aChar),TOLERANCE);
136 Assert.assertEquals("b cum pct",1.0,f.getCumPct(bChar),TOLERANCE);
137 }
138
139
140 @Test
141 public void testEmptyTable() {
142 Frequency<Integer> f = new Frequency<>();
143 Assert.assertEquals("freq sum, empty table", 0, f.getSumFreq());
144 Assert.assertEquals("count, empty table", 0, f.getCount(0));
145 Assert.assertEquals("count, empty table",0, f.getCount(Integer.valueOf(0)));
146 Assert.assertEquals("cum freq, empty table", 0, f.getCumFreq(0));
147 Assert.assertTrue("pct, empty table", Double.isNaN(f.getPct(0)));
148 Assert.assertTrue("pct, empty table", Double.isNaN(f.getPct(Integer.valueOf(0))));
149 Assert.assertTrue("cum pct, empty table", Double.isNaN(f.getCumPct(0)));
150 Assert.assertTrue("cum pct, empty table", Double.isNaN(f.getCumPct(Integer.valueOf(0))));
151 }
152
153
154
155
156 @Test
157 public void testToString() throws Exception {
158 Frequency<Long> f = new Frequency<>();
159 f.addValue(ONE_LONG);
160 f.addValue(TWO_LONG);
161
162 String s = f.toString();
163
164 Assert.assertNotNull(s);
165 BufferedReader reader = new BufferedReader(new StringReader(s));
166 String line = reader.readLine();
167 Assert.assertNotNull(line);
168
169 line = reader.readLine();
170 Assert.assertNotNull(line);
171 }
172
173 @Test
174 public void testIntegerValues() {
175 Frequency<Integer> f = new Frequency<>();
176 f.addValue(Integer.valueOf(1));
177 f.addValue(1);
178 f.addValue(2);
179 f.addValue(Integer.valueOf(2));
180 Assert.assertEquals("Integer 1 count", 2, f.getCount(1));
181 Assert.assertEquals("Integer 1 count", 2, f.getCount(Integer.valueOf(1)));
182 Assert.assertEquals("Integer 1 cumPct", 0.5, f.getCumPct(1), TOLERANCE);
183 Assert.assertEquals("Integer 1 cumPct", 0.5, f.getCumPct(Integer.valueOf(1)), TOLERANCE);
184
185 f.incrementValue(ONE, -2);
186 f.incrementValue(THREE, 5);
187
188 Assert.assertEquals("Integer 1 count", 0, f.getCount(1));
189 Assert.assertEquals("Integer 3 count", 5, f.getCount(3));
190
191 Iterator<?> it = f.valuesIterator();
192 while (it.hasNext()) {
193 Assert.assertTrue(it.next() instanceof Integer);
194 }
195 }
196
197 @Test
198 public void testGetUniqueCount() {
199 Frequency<Long> f = new Frequency<>();
200 Assert.assertEquals(0, f.getUniqueCount());
201 f.addValue(ONE_LONG);
202 Assert.assertEquals(1, f.getUniqueCount());
203 f.addValue(ONE_LONG);
204 Assert.assertEquals(1, f.getUniqueCount());
205 f.addValue(TWO_LONG);
206 Assert.assertEquals(2, f.getUniqueCount());
207 }
208
209 @Test
210 public void testIncrement() {
211 Frequency<Long> f = new Frequency<>();
212 Assert.assertEquals(0, f.getUniqueCount());
213 f.incrementValue(ONE_LONG, 1);
214 Assert.assertEquals(1, f.getCount(ONE_LONG));
215
216 f.incrementValue(ONE_LONG, 4);
217 Assert.assertEquals(5, f.getCount(ONE_LONG));
218
219 f.incrementValue(ONE_LONG, -5);
220 Assert.assertEquals(0, f.getCount(ONE_LONG));
221 }
222
223 @Test
224 public void testMerge() {
225 Frequency<Long> f = new Frequency<>();
226 Assert.assertEquals(0, f.getUniqueCount());
227 f.addValue(ONE_LONG);
228 f.addValue(TWO_LONG);
229 f.addValue(ONE_LONG);
230 f.addValue(TWO_LONG);
231
232 Assert.assertEquals(2, f.getUniqueCount());
233 Assert.assertEquals(2, f.getCount(ONE_LONG));
234 Assert.assertEquals(2, f.getCount(TWO_LONG));
235
236 Frequency<Long> g = new Frequency<>();
237 g.addValue(ONE_LONG);
238 g.addValue(THREE_LONG);
239 g.addValue(THREE_LONG);
240
241 Assert.assertEquals(2, g.getUniqueCount());
242 Assert.assertEquals(1, g.getCount(ONE_LONG));
243 Assert.assertEquals(2, g.getCount(THREE_LONG));
244
245 f.merge(g);
246
247 Assert.assertEquals(3, f.getUniqueCount());
248 Assert.assertEquals(3, f.getCount(ONE_LONG));
249 Assert.assertEquals(2, f.getCount(TWO_LONG));
250 Assert.assertEquals(2, f.getCount(THREE_LONG));
251 }
252
253 @Test
254 public void testMergeCollection() {
255 Frequency<Long> f = new Frequency<>();
256 Assert.assertEquals(0, f.getUniqueCount());
257 f.addValue(ONE_LONG);
258
259 Assert.assertEquals(1, f.getUniqueCount());
260 Assert.assertEquals(1, f.getCount(ONE_LONG));
261 Assert.assertEquals(0, f.getCount(TWO_LONG));
262
263 Frequency<Long> g = new Frequency<Long>();
264 g.addValue(TWO_LONG);
265
266 Frequency<Long> h = new Frequency<Long>();
267 h.addValue(THREE_LONG);
268
269 List<Frequency<Long>> coll = new ArrayList<>();
270 coll.add(g);
271 coll.add(h);
272 f.merge(coll);
273
274 Assert.assertEquals(3, f.getUniqueCount());
275 Assert.assertEquals(1, f.getCount(ONE_LONG));
276 Assert.assertEquals(1, f.getCount(TWO_LONG));
277 Assert.assertEquals(1, f.getCount(THREE_LONG));
278 }
279
280 @Test
281 public void testMode() {
282 Frequency<String> f = new Frequency<>();
283 List<String> mode;
284 mode = f.getMode();
285 Assert.assertEquals(0, mode.size());
286
287 f.addValue("3");
288 mode = f.getMode();
289 Assert.assertEquals(1, mode.size());
290 Assert.assertEquals("3", mode.get(0));
291
292 f.addValue("2");
293 mode = f.getMode();
294 Assert.assertEquals(2, mode.size());
295 Assert.assertEquals("2", mode.get(0));
296 Assert.assertEquals("3",mode.get(1));
297
298 f.addValue("2");
299 mode = f.getMode();
300 Assert.assertEquals(1, mode.size());
301 Assert.assertEquals("2", mode.get(0));
302 Assert.assertFalse(mode.contains("1"));
303 Assert.assertTrue(mode.contains("2"));
304 }
305
306 @Test
307 public void testModeDoubleNan() {
308 Frequency<Double> f = new Frequency<>();
309 List<Double> mode;
310 f.addValue(Double.valueOf(Double.NaN));
311 f.addValue(Double.valueOf(Double.NaN));
312 f.addValue(Double.valueOf(Double.NaN));
313 f.addValue(Double.valueOf(Double.NEGATIVE_INFINITY));
314 f.addValue(Double.valueOf(Double.POSITIVE_INFINITY));
315 f.addValue(Double.valueOf(Double.NEGATIVE_INFINITY));
316 f.addValue(Double.valueOf(Double.POSITIVE_INFINITY));
317 f.addValue(Double.valueOf(Double.NEGATIVE_INFINITY));
318 f.addValue(Double.valueOf(Double.POSITIVE_INFINITY));
319 mode = f.getMode();
320 Assert.assertEquals(3, mode.size());
321 Assert.assertEquals(Double.valueOf(Double.NEGATIVE_INFINITY), mode.get(0));
322 Assert.assertEquals(Double.valueOf(Double.POSITIVE_INFINITY), mode.get(1));
323 Assert.assertEquals(Double.valueOf(Double.NaN), mode.get(2));
324 }
325
326 @Test
327 public void testModeFloatNan() {
328 Frequency<Float> f = new Frequency<>();
329 List<Float> mode;
330 f.addValue(Float.valueOf(Float.NaN));
331 f.addValue(Float.valueOf(Float.NaN));
332 f.addValue(Float.valueOf(Float.NaN));
333 f.addValue(Float.valueOf(Float.NEGATIVE_INFINITY));
334 f.addValue(Float.valueOf(Float.POSITIVE_INFINITY));
335 f.addValue(Float.valueOf(Float.NEGATIVE_INFINITY));
336 f.addValue(Float.valueOf(Float.POSITIVE_INFINITY));
337 f.addValue(Float.valueOf(Float.NEGATIVE_INFINITY));
338 f.addValue(Float.valueOf(Float.POSITIVE_INFINITY));
339 mode = f.getMode();
340 Assert.assertEquals(3, mode.size());
341 Assert.assertEquals(Float.valueOf(Float.NEGATIVE_INFINITY), mode.get(0));
342 Assert.assertEquals(Float.valueOf(Float.POSITIVE_INFINITY), mode.get(1));
343 Assert.assertEquals(Float.valueOf(Float.NaN), mode.get(2));
344 }
345 }