| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.commons.math3.stat; |
| |
| import java.io.BufferedReader; |
| import java.io.StringReader; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| |
| import org.apache.commons.math3.TestUtils; |
| import org.apache.commons.math3.exception.MathIllegalArgumentException; |
| import org.junit.Assert; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| /** |
| * Test cases for the {@link Frequency} class. |
| * |
| */ |
| public final class FrequencyTest { |
| private static final long ONE_LONG = 1L; |
| private static final long TWO_LONG = 2L; |
| private static final long THREE_LONG = 3L; |
| private static final int ONE = 1; |
| private static final int TWO = 2; |
| private static final int THREE = 3 ; |
| private static final double TOLERANCE = 10E-15d; |
| private static final char CHAR_A = 'a'; |
| |
| private Frequency f = null; |
| |
| @Before |
| public void setUp() { |
| f = new Frequency(); |
| } |
| |
| /** test freq counts */ |
| @Test |
| public void testCounts() { |
| Assert.assertEquals("total count",0,f.getSumFreq()); |
| f.addValue(ONE_LONG); |
| f.addValue(TWO_LONG); |
| f.addValue(1); |
| f.addValue(ONE); |
| Assert.assertEquals("one frequency count",3,f.getCount(1)); |
| Assert.assertEquals("two frequency count",1,f.getCount(2)); |
| Assert.assertEquals("three frequency count",0,f.getCount(3)); |
| Assert.assertEquals("total count",4,f.getSumFreq()); |
| Assert.assertEquals("zero cumulative frequency", 0, f.getCumFreq(0)); |
| Assert.assertEquals("one cumulative frequency", 3, f.getCumFreq(1)); |
| Assert.assertEquals("two cumulative frequency", 4, f.getCumFreq(2)); |
| Assert.assertEquals("Integer argument cum freq",4, f.getCumFreq(Integer.valueOf(2))); |
| Assert.assertEquals("five cumulative frequency", 4, f.getCumFreq(5)); |
| Assert.assertEquals("foo cumulative frequency", 0, f.getCumFreq("foo")); |
| |
| f.clear(); |
| Assert.assertEquals("total count",0,f.getSumFreq()); |
| |
| // userguide examples ------------------------------------------------------------------- |
| f.addValue("one"); |
| f.addValue("One"); |
| f.addValue("oNe"); |
| f.addValue("Z"); |
| Assert.assertEquals("one cumulative frequency", 1 , f.getCount("one")); |
| Assert.assertEquals("Z cumulative pct", 0.5, f.getCumPct("Z"), TOLERANCE); |
| Assert.assertEquals("z cumulative pct", 1.0, f.getCumPct("z"), TOLERANCE); |
| Assert.assertEquals("Ot cumulative pct", 0.25, f.getCumPct("Ot"), TOLERANCE); |
| f.clear(); |
| |
| f = null; |
| Frequency f = new Frequency(); |
| f.addValue(1); |
| f.addValue(Integer.valueOf(1)); |
| f.addValue(Long.valueOf(1)); |
| f.addValue(2); |
| f.addValue(Integer.valueOf(-1)); |
| Assert.assertEquals("1 count", 3, f.getCount(1)); |
| Assert.assertEquals("1 count", 3, f.getCount(Integer.valueOf(1))); |
| Assert.assertEquals("0 cum pct", 0.2, f.getCumPct(0), TOLERANCE); |
| Assert.assertEquals("1 pct", 0.6, f.getPct(Integer.valueOf(1)), TOLERANCE); |
| Assert.assertEquals("-2 cum pct", 0, f.getCumPct(-2), TOLERANCE); |
| Assert.assertEquals("10 cum pct", 1, f.getCumPct(10), TOLERANCE); |
| |
| f = null; |
| f = new Frequency(String.CASE_INSENSITIVE_ORDER); |
| f.addValue("one"); |
| f.addValue("One"); |
| f.addValue("oNe"); |
| f.addValue("Z"); |
| Assert.assertEquals("one count", 3 , f.getCount("one")); |
| Assert.assertEquals("Z cumulative pct -- case insensitive", 1 , f.getCumPct("Z"), TOLERANCE); |
| Assert.assertEquals("z cumulative pct -- case insensitive", 1 , f.getCumPct("z"), TOLERANCE); |
| |
| f = null; |
| f = new Frequency(); |
| Assert.assertEquals(0L, f.getCount('a')); |
| Assert.assertEquals(0L, f.getCumFreq('b')); |
| TestUtils.assertEquals(Double.NaN, f.getPct('a'), 0.0); |
| TestUtils.assertEquals(Double.NaN, f.getCumPct('b'), 0.0); |
| f.addValue('a'); |
| f.addValue('b'); |
| f.addValue('c'); |
| f.addValue('d'); |
| Assert.assertEquals(1L, f.getCount('a')); |
| Assert.assertEquals(2L, f.getCumFreq('b')); |
| Assert.assertEquals(0.25, f.getPct('a'), 0.0); |
| Assert.assertEquals(0.5, f.getCumPct('b'), 0.0); |
| Assert.assertEquals(1.0, f.getCumPct('e'), 0.0); |
| } |
| |
| /** test pcts */ |
| @Test |
| public void testPcts() { |
| f.addValue(ONE_LONG); |
| f.addValue(TWO_LONG); |
| f.addValue(ONE); |
| f.addValue(TWO); |
| f.addValue(THREE_LONG); |
| f.addValue(THREE_LONG); |
| f.addValue(3); |
| f.addValue(THREE); |
| Assert.assertEquals("one pct",0.25,f.getPct(1),TOLERANCE); |
| Assert.assertEquals("two pct",0.25,f.getPct(Long.valueOf(2)),TOLERANCE); |
| Assert.assertEquals("three pct",0.5,f.getPct(THREE_LONG),TOLERANCE); |
| Assert.assertEquals("five pct",0,f.getPct(5),TOLERANCE); |
| Assert.assertEquals("foo pct",0,f.getPct("foo"),TOLERANCE); |
| Assert.assertEquals("one cum pct",0.25,f.getCumPct(1),TOLERANCE); |
| Assert.assertEquals("two cum pct",0.50,f.getCumPct(Long.valueOf(2)),TOLERANCE); |
| Assert.assertEquals("Integer argument",0.50,f.getCumPct(Integer.valueOf(2)),TOLERANCE); |
| Assert.assertEquals("three cum pct",1.0,f.getCumPct(THREE_LONG),TOLERANCE); |
| Assert.assertEquals("five cum pct",1.0,f.getCumPct(5),TOLERANCE); |
| Assert.assertEquals("zero cum pct",0.0,f.getCumPct(0),TOLERANCE); |
| Assert.assertEquals("foo cum pct",0,f.getCumPct("foo"),TOLERANCE); |
| } |
| |
| /** test adding incomparable values */ |
| @Test |
| public void testAdd() { |
| char aChar = 'a'; |
| char bChar = 'b'; |
| String aString = "a"; |
| f.addValue(aChar); |
| f.addValue(bChar); |
| try { |
| f.addValue(aString); |
| Assert.fail("Expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // expected |
| } |
| try { |
| f.addValue(2); |
| Assert.fail("Expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // expected |
| } |
| Assert.assertEquals("a pct",0.5,f.getPct(aChar),TOLERANCE); |
| Assert.assertEquals("b cum pct",1.0,f.getCumPct(bChar),TOLERANCE); |
| Assert.assertEquals("a string pct",0.0,f.getPct(aString),TOLERANCE); |
| Assert.assertEquals("a string cum pct",0.0,f.getCumPct(aString),TOLERANCE); |
| |
| f = new Frequency(); |
| f.addValue("One"); |
| try { |
| f.addValue(new Integer("One")); |
| Assert.fail("Expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // expected |
| } |
| } |
| |
| /** test empty table */ |
| @Test |
| public void testEmptyTable() { |
| Assert.assertEquals("freq sum, empty table", 0, f.getSumFreq()); |
| Assert.assertEquals("count, empty table", 0, f.getCount(0)); |
| Assert.assertEquals("count, empty table",0, f.getCount(Integer.valueOf(0))); |
| Assert.assertEquals("cum freq, empty table", 0, f.getCumFreq(0)); |
| Assert.assertEquals("cum freq, empty table", 0, f.getCumFreq("x")); |
| Assert.assertTrue("pct, empty table", Double.isNaN(f.getPct(0))); |
| Assert.assertTrue("pct, empty table", Double.isNaN(f.getPct(Integer.valueOf(0)))); |
| Assert.assertTrue("cum pct, empty table", Double.isNaN(f.getCumPct(0))); |
| Assert.assertTrue("cum pct, empty table", Double.isNaN(f.getCumPct(Integer.valueOf(0)))); |
| } |
| |
| @Test |
| public void testNonComparableCumPct() { |
| f.addValue("a"); |
| Assert.assertEquals("cum freq, single entry", 1.0d, f.getCumPct("a"),TOLERANCE); |
| Assert.assertEquals("cum freq, single entry non comparable", 0.0d, f.getCumPct(100),TOLERANCE); |
| } |
| |
| @Test |
| public void testNonComparablePct() { |
| f.addValue("a"); |
| Assert.assertEquals("cum freq, single entry", 1.0d, f.getPct("a"),TOLERANCE); |
| Assert.assertEquals("cum freq, single entry non comparable", 0.0d, f.getPct(100),TOLERANCE); |
| } |
| |
| /** |
| * Tests toString() |
| */ |
| @Test |
| public void testToString() throws Exception { |
| f.addValue(ONE_LONG); |
| f.addValue(TWO_LONG); |
| f.addValue(ONE); |
| f.addValue(TWO); |
| |
| String s = f.toString(); |
| //System.out.println(s); |
| Assert.assertNotNull(s); |
| BufferedReader reader = new BufferedReader(new StringReader(s)); |
| String line = reader.readLine(); // header line |
| Assert.assertNotNull(line); |
| |
| line = reader.readLine(); // one's or two's line |
| Assert.assertNotNull(line); |
| |
| line = reader.readLine(); // one's or two's line |
| Assert.assertNotNull(line); |
| |
| line = reader.readLine(); // no more elements |
| Assert.assertNull(line); |
| } |
| |
| @Test |
| public void testIntegerValues() { |
| Comparable<?> obj1 = null; |
| obj1 = Integer.valueOf(1); |
| Integer int1 = Integer.valueOf(1); |
| f.addValue(obj1); |
| f.addValue(int1); |
| f.addValue(2); |
| f.addValue(Long.valueOf(2)); |
| Assert.assertEquals("Integer 1 count", 2, f.getCount(1)); |
| Assert.assertEquals("Integer 1 count", 2, f.getCount(Integer.valueOf(1))); |
| Assert.assertEquals("Integer 1 count", 2, f.getCount(Long.valueOf(1))); |
| Assert.assertEquals("Integer 1 cumPct", 0.5, f.getCumPct(1), TOLERANCE); |
| Assert.assertEquals("Integer 1 cumPct", 0.5, f.getCumPct(Long.valueOf(1)), TOLERANCE); |
| Assert.assertEquals("Integer 1 cumPct", 0.5, f.getCumPct(Integer.valueOf(1)), TOLERANCE); |
| |
| f.incrementValue(ONE, -2); |
| f.incrementValue(THREE, 5); |
| |
| Assert.assertEquals("Integer 1 count", 0, f.getCount(1)); |
| Assert.assertEquals("Integer 3 count", 5, f.getCount(3)); |
| |
| Iterator<?> it = f.valuesIterator(); |
| while (it.hasNext()) { |
| Assert.assertTrue(it.next() instanceof Long); |
| } |
| } |
| |
| @Test |
| public void testSerial() { |
| f.addValue(ONE_LONG); |
| f.addValue(TWO_LONG); |
| f.addValue(ONE); |
| f.addValue(TWO); |
| Assert.assertEquals(f, TestUtils.serializeAndRecover(f)); |
| } |
| |
| @Test |
| public void testGetUniqueCount() { |
| Assert.assertEquals(0, f.getUniqueCount()); |
| f.addValue(ONE_LONG); |
| Assert.assertEquals(1, f.getUniqueCount()); |
| f.addValue(ONE_LONG); |
| Assert.assertEquals(1, f.getUniqueCount()); |
| f.addValue(TWO); |
| Assert.assertEquals(2, f.getUniqueCount()); |
| } |
| |
| @Test |
| public void testIncrement() { |
| Assert.assertEquals(0, f.getUniqueCount()); |
| f.incrementValue(ONE_LONG, 1); |
| Assert.assertEquals(1, f.getCount(ONE_LONG)); |
| |
| f.incrementValue(ONE_LONG, 4); |
| Assert.assertEquals(5, f.getCount(ONE_LONG)); |
| |
| f.incrementValue(ONE_LONG, -5); |
| Assert.assertEquals(0, f.getCount(ONE_LONG)); |
| |
| try { |
| f.incrementValue(CHAR_A, 1); |
| Assert.fail("Expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // expected |
| } |
| |
| f = new Frequency(); |
| f.incrementValue(CHAR_A, 2); |
| |
| Assert.assertEquals(2, f.getCount(CHAR_A)); |
| |
| try { |
| f.incrementValue(ONE, 1); |
| Assert.fail("Expecting IllegalArgumentException"); |
| } catch (IllegalArgumentException ex) { |
| // expected |
| } |
| |
| f.incrementValue(CHAR_A, 3); |
| Assert.assertEquals(5, f.getCount(CHAR_A)); |
| |
| } |
| |
| @Test |
| public void testMerge() { |
| Assert.assertEquals(0, f.getUniqueCount()); |
| f.addValue(ONE_LONG); |
| f.addValue(TWO_LONG); |
| f.addValue(ONE); |
| f.addValue(TWO); |
| |
| Assert.assertEquals(2, f.getUniqueCount()); |
| Assert.assertEquals(2, f.getCount(ONE)); |
| Assert.assertEquals(2, f.getCount(TWO)); |
| |
| Frequency g = new Frequency(); |
| g.addValue(ONE_LONG); |
| g.addValue(THREE_LONG); |
| g.addValue(THREE); |
| |
| Assert.assertEquals(2, g.getUniqueCount()); |
| Assert.assertEquals(1, g.getCount(ONE)); |
| Assert.assertEquals(2, g.getCount(THREE)); |
| |
| f.merge(g); |
| |
| Assert.assertEquals(3, f.getUniqueCount()); |
| Assert.assertEquals(3, f.getCount(ONE)); |
| Assert.assertEquals(2, f.getCount(TWO)); |
| Assert.assertEquals(2, f.getCount(THREE)); |
| } |
| |
| @Test |
| public void testMergeCollection() { |
| Assert.assertEquals(0, f.getUniqueCount()); |
| f.addValue(ONE_LONG); |
| |
| Assert.assertEquals(1, f.getUniqueCount()); |
| Assert.assertEquals(1, f.getCount(ONE)); |
| Assert.assertEquals(0, f.getCount(TWO)); |
| |
| Frequency g = new Frequency(); |
| g.addValue(TWO_LONG); |
| |
| Frequency h = new Frequency(); |
| h.addValue(THREE_LONG); |
| |
| List<Frequency> coll = new ArrayList<Frequency>(); |
| coll.add(g); |
| coll.add(h); |
| f.merge(coll); |
| |
| Assert.assertEquals(3, f.getUniqueCount()); |
| Assert.assertEquals(1, f.getCount(ONE)); |
| Assert.assertEquals(1, f.getCount(TWO)); |
| Assert.assertEquals(1, f.getCount(THREE)); |
| } |
| |
| @Test |
| public void testMode() { |
| List<Comparable<?>> mode; |
| mode = f.getMode(); |
| Assert.assertEquals(0, mode.size()); |
| |
| f.addValue("3"); |
| mode = f.getMode(); |
| Assert.assertEquals(1, mode.size()); |
| Assert.assertEquals("3", mode.get(0)); |
| |
| f.addValue("2"); |
| mode = f.getMode(); |
| Assert.assertEquals(2, mode.size()); |
| Assert.assertEquals("2", mode.get(0)); |
| Assert.assertEquals("3",mode.get(1)); |
| |
| f.addValue("2"); |
| mode = f.getMode(); |
| Assert.assertEquals(1, mode.size()); |
| Assert.assertEquals("2", mode.get(0)); |
| Assert.assertFalse(mode.contains("1")); |
| Assert.assertTrue(mode.contains("2")); |
| |
| try { |
| f.addValue(Double.valueOf(Double.NaN)); |
| Assert.fail("Expected MathIllegalArgumentException"); |
| } catch (MathIllegalArgumentException e) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testModeDoubleNan() { |
| List<Comparable<?>> mode; |
| f.addValue(Double.valueOf(Double.NaN)); |
| f.addValue(Double.valueOf(Double.NaN)); |
| f.addValue(Double.valueOf(Double.NaN)); |
| f.addValue(Double.valueOf(Double.NEGATIVE_INFINITY)); |
| f.addValue(Double.valueOf(Double.POSITIVE_INFINITY)); |
| f.addValue(Double.valueOf(Double.NEGATIVE_INFINITY)); |
| f.addValue(Double.valueOf(Double.POSITIVE_INFINITY)); |
| f.addValue(Double.valueOf(Double.NEGATIVE_INFINITY)); |
| f.addValue(Double.valueOf(Double.POSITIVE_INFINITY)); |
| mode = f.getMode(); |
| Assert.assertEquals(3, mode.size()); |
| Assert.assertEquals(Double.valueOf(Double.NEGATIVE_INFINITY), mode.get(0)); |
| Assert.assertEquals(Double.valueOf(Double.POSITIVE_INFINITY), mode.get(1)); |
| Assert.assertEquals(Double.valueOf(Double.NaN), mode.get(2)); |
| try { |
| f.addValue(Float.valueOf(Float.NaN)); |
| Assert.fail("Expected MathIllegalArgumentException"); |
| } catch (MathIllegalArgumentException e) { |
| // expected |
| } |
| } |
| |
| @Test |
| public void testModeFloatNan() { |
| List<Comparable<?>> mode; |
| f.addValue(Float.valueOf(Float.NaN)); |
| f.addValue(Float.valueOf(Float.NaN)); |
| f.addValue(Float.valueOf(Float.NaN)); |
| f.addValue(Float.valueOf(Float.NEGATIVE_INFINITY)); |
| f.addValue(Float.valueOf(Float.POSITIVE_INFINITY)); |
| f.addValue(Float.valueOf(Float.NEGATIVE_INFINITY)); |
| f.addValue(Float.valueOf(Float.POSITIVE_INFINITY)); |
| f.addValue(Float.valueOf(Float.NEGATIVE_INFINITY)); |
| f.addValue(Float.valueOf(Float.POSITIVE_INFINITY)); |
| mode = f.getMode(); |
| Assert.assertEquals(3, mode.size()); |
| Assert.assertEquals(Float.valueOf(Float.NEGATIVE_INFINITY), mode.get(0)); |
| Assert.assertEquals(Float.valueOf(Float.POSITIVE_INFINITY), mode.get(1)); |
| Assert.assertEquals(Float.valueOf(Float.NaN), mode.get(2)); |
| try { |
| f.addValue(Double.valueOf(Double.NaN)); |
| Assert.fail("Expected MathIllegalArgumentException"); |
| } catch (MathIllegalArgumentException e) { |
| // expected |
| } |
| } |
| |
| } |