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.descriptive;
018
019 import org.apache.commons.math.TestUtils;
020 import org.apache.commons.math.stat.descriptive.moment.SecondMoment;
021
022 /**
023 * Test cases for {@link StorelessUnivariateStatistic} classes.
024 * @version $Revision: 780541 $ $Date: 2009-05-31 20:47:02 -0400 (Sun, 31 May 2009) $
025 */
026 public abstract class StorelessUnivariateStatisticAbstractTest
027 extends UnivariateStatisticAbstractTest {
028
029 public StorelessUnivariateStatisticAbstractTest(String name) {
030 super(name);
031 }
032
033 /** Small sample arrays */
034 protected double[][] smallSamples = {{}, {1}, {1,2}, {1,2,3}, {1,2,3,4}};
035
036 /** Return a new instance of the statistic */
037 @Override
038 public abstract UnivariateStatistic getUnivariateStatistic();
039
040 /**Expected value for the testArray defined in UnivariateStatisticAbstractTest */
041 @Override
042 public abstract double expectedValue();
043
044 /**
045 * Verifies that increment() and incrementAll work properly.
046 */
047 public void testIncrementation() throws Exception {
048
049 StorelessUnivariateStatistic statistic =
050 (StorelessUnivariateStatistic) getUnivariateStatistic();
051
052 // Add testArray one value at a time and check result
053 for (int i = 0; i < testArray.length; i++) {
054 statistic.increment(testArray[i]);
055 }
056
057 assertEquals(expectedValue(), statistic.getResult(), getTolerance());
058 assertEquals(testArray.length, statistic.getN());
059
060 statistic.clear();
061
062 // Add testArray all at once and check again
063 statistic.incrementAll(testArray);
064 assertEquals(expectedValue(), statistic.getResult(), getTolerance());
065 assertEquals(testArray.length, statistic.getN());
066
067 statistic.clear();
068
069 // Cleared
070 assertTrue(Double.isNaN(statistic.getResult()));
071 assertEquals(0, statistic.getN());
072
073 }
074
075 public void testSerialization() throws Exception {
076
077 StorelessUnivariateStatistic statistic =
078 (StorelessUnivariateStatistic) getUnivariateStatistic();
079
080 TestUtils.checkSerializedEquality(statistic);
081
082 statistic.clear();
083
084 for (int i = 0; i < testArray.length; i++) {
085 statistic.increment(testArray[i]);
086 if(i % 5 == 0)
087 statistic = (StorelessUnivariateStatistic)TestUtils.serializeAndRecover(statistic);
088 }
089
090 TestUtils.checkSerializedEquality(statistic);
091
092 assertEquals(expectedValue(), statistic.getResult(), getTolerance());
093
094 statistic.clear();
095
096 assertTrue(Double.isNaN(statistic.getResult()));
097
098 }
099
100 public void testEqualsAndHashCode() {
101 StorelessUnivariateStatistic statistic =
102 (StorelessUnivariateStatistic) getUnivariateStatistic();
103 StorelessUnivariateStatistic statistic2 = null;
104
105 assertTrue("non-null, compared to null", !statistic.equals(statistic2));
106 assertTrue("reflexive, non-null", statistic.equals(statistic));
107
108 int emptyHash = statistic.hashCode();
109 statistic2 = (StorelessUnivariateStatistic) getUnivariateStatistic();
110 assertTrue("empty stats should be equal", statistic.equals(statistic2));
111 assertEquals("empty stats should have the same hashcode",
112 emptyHash, statistic2.hashCode());
113
114 statistic.increment(1d);
115 assertTrue("reflexive, non-empty", statistic.equals(statistic));
116 assertTrue("non-empty, compared to empty", !statistic.equals(statistic2));
117 assertTrue("non-empty, compared to empty", !statistic2.equals(statistic));
118 assertTrue("non-empty stat should have different hashcode from empty stat",
119 statistic.hashCode() != emptyHash);
120
121 statistic2.increment(1d);
122 assertTrue("stats with same data should be equal", statistic.equals(statistic2));
123 assertEquals("stats with same data should have the same hashcode",
124 statistic.hashCode(), statistic2.hashCode());
125
126 statistic.increment(Double.POSITIVE_INFINITY);
127 assertTrue("stats with different n's should not be equal", !statistic2.equals(statistic));
128 assertTrue("stats with different n's should have different hashcodes",
129 statistic.hashCode() != statistic2.hashCode());
130
131 statistic2.increment(Double.POSITIVE_INFINITY);
132 assertTrue("stats with same data should be equal", statistic.equals(statistic2));
133 assertEquals("stats with same data should have the same hashcode",
134 statistic.hashCode(), statistic2.hashCode());
135
136 statistic.clear();
137 statistic2.clear();
138 assertTrue("cleared stats should be equal", statistic.equals(statistic2));
139 assertEquals("cleared stats should have thashcode of empty stat",
140 emptyHash, statistic2.hashCode());
141 assertEquals("cleared stats should have thashcode of empty stat",
142 emptyHash, statistic.hashCode());
143
144 }
145
146 public void testMomentSmallSamples() {
147 UnivariateStatistic stat = getUnivariateStatistic();
148 if (stat instanceof SecondMoment) {
149 SecondMoment moment = (SecondMoment) getUnivariateStatistic();
150 assertTrue(Double.isNaN(moment.getResult()));
151 moment.increment(1d);
152 assertEquals(0d, moment.getResult(), 0);
153 }
154 }
155
156 /**
157 * Make sure that evaluate(double[]) and inrementAll(double[]),
158 * getResult() give same results.
159 */
160 public void testConsistency() {
161 StorelessUnivariateStatistic stat = (StorelessUnivariateStatistic) getUnivariateStatistic();
162 stat.incrementAll(testArray);
163 assertEquals(stat.getResult(), stat.evaluate(testArray), getTolerance());
164 for (int i = 0; i < smallSamples.length; i++) {
165 stat.clear();
166 for (int j =0; j < smallSamples[i].length; j++) {
167 stat.increment(smallSamples[i][j]);
168 }
169 TestUtils.assertEquals(stat.getResult(), stat.evaluate(smallSamples[i]), getTolerance());
170 }
171 }
172
173 /**
174 * Verifies that copied statistics remain equal to originals when
175 * incremented the same way.
176 *
177 */
178 public void testCopyConsistency() {
179
180 StorelessUnivariateStatistic master =
181 (StorelessUnivariateStatistic) getUnivariateStatistic();
182
183 StorelessUnivariateStatistic replica = null;
184
185 // Randomly select a portion of testArray to load first
186 long index = Math.round((Math.random()) * testArray.length);
187
188 // Put first half in master and copy master to replica
189 master.incrementAll(testArray, 0, (int) index);
190 replica = master.copy();
191
192 // Check same
193 assertTrue(replica.equals(master));
194 assertTrue(master.equals(replica));
195
196 // Now add second part to both and check again
197 master.incrementAll(testArray,
198 (int) index, (int) (testArray.length - index));
199 replica.incrementAll(testArray,
200 (int) index, (int) (testArray.length - index));
201 assertTrue(replica.equals(master));
202 assertTrue(master.equals(replica));
203 }
204
205 public void testSerial() {
206 StorelessUnivariateStatistic s =
207 (StorelessUnivariateStatistic) getUnivariateStatistic();
208 assertEquals(s, TestUtils.serializeAndRecover(s));
209 }
210 }