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.math.stat.descriptive;
18
19 import org.apache.commons.math.MathRuntimeException;
20 import org.apache.commons.math.util.MathUtils;
21
22 /**
23 *
24 * Abstract implementation of the {@link StorelessUnivariateStatistic} interface.
25 * <p>
26 * Provides default <code>evaluate()</code> and <code>incrementAll(double[])<code>
27 * implementations.</p>
28 * <p>
29 * <strong>Note that these implementations are not synchronized.</strong></p>
30 *
31 * @version $Revision: 780637 $ $Date: 2009-06-01 08:48:32 -0400 (Mon, 01 Jun 2009) $
32 */
33 public abstract class AbstractStorelessUnivariateStatistic
34 extends AbstractUnivariateStatistic
35 implements StorelessUnivariateStatistic {
36
37 /**
38 * This default implementation calls {@link #clear}, then invokes
39 * {@link #increment} in a loop over the the input array, and then uses
40 * {@link #getResult} to compute the return value.
41 * <p>
42 * Note that this implementation changes the internal state of the
43 * statistic. Its side effects are the same as invoking {@link #clear} and
44 * then {@link #incrementAll(double[])}.</p>
45 * <p>
46 * Implementations may override this method with a more efficient and
47 * possibly more accurate implementation that works directly with the
48 * input array.</p>
49 * <p>
50 * If the array is null, an IllegalArgumentException is thrown.</p>
51 * @param values input array
52 * @return the value of the statistic applied to the input array
53 * @see org.apache.commons.math.stat.descriptive.UnivariateStatistic#evaluate(double[])
54 */
55 @Override
56 public double evaluate(final double[] values) {
57 if (values == null) {
58 throw MathRuntimeException.createIllegalArgumentException("input values array is null");
59 }
60 return evaluate(values, 0, values.length);
61 }
62
63 /**
64 * This default implementation calls {@link #clear}, then invokes
65 * {@link #increment} in a loop over the specified portion of the input
66 * array, and then uses {@link #getResult} to compute the return value.
67 * <p>
68 * Note that this implementation changes the internal state of the
69 * statistic. Its side effects are the same as invoking {@link #clear} and
70 * then {@link #incrementAll(double[], int, int)}.</p>
71 * <p>
72 * Implementations may override this method with a more efficient and
73 * possibly more accurate implementation that works directly with the
74 * input array.</p>
75 * <p>
76 * If the array is null or the index parameters are not valid, an
77 * IllegalArgumentException is thrown.</p>
78 * @param values the input array
79 * @param begin the index of the first element to include
80 * @param length the number of elements to include
81 * @return the value of the statistic applied to the included array entries
82 * @see org.apache.commons.math.stat.descriptive.UnivariateStatistic#evaluate(double[], int, int)
83 */
84 @Override
85 public double evaluate(final double[] values, final int begin, final int length) {
86 if (test(values, begin, length)) {
87 clear();
88 incrementAll(values, begin, length);
89 }
90 return getResult();
91 }
92
93 /**
94 * {@inheritDoc}
95 */
96 @Override
97 public abstract StorelessUnivariateStatistic copy();
98
99 /**
100 * {@inheritDoc}
101 */
102 public abstract void clear();
103
104 /**
105 * {@inheritDoc}
106 */
107 public abstract double getResult();
108
109 /**
110 * {@inheritDoc}
111 */
112 public abstract void increment(final double d);
113
114 /**
115 * This default implementation just calls {@link #increment} in a loop over
116 * the input array.
117 * <p>
118 * Throws IllegalArgumentException if the input values array is null.</p>
119 *
120 * @param values values to add
121 * @throws IllegalArgumentException if values is null
122 * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#incrementAll(double[])
123 */
124 public void incrementAll(double[] values) {
125 if (values == null) {
126 throw MathRuntimeException.createIllegalArgumentException("input values array is null");
127 }
128 incrementAll(values, 0, values.length);
129 }
130
131 /**
132 * This default implementation just calls {@link #increment} in a loop over
133 * the specified portion of the input array.
134 * <p>
135 * Throws IllegalArgumentException if the input values array is null.</p>
136 *
137 * @param values array holding values to add
138 * @param begin index of the first array element to add
139 * @param length number of array elements to add
140 * @throws IllegalArgumentException if values is null
141 * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#incrementAll(double[], int, int)
142 */
143 public void incrementAll(double[] values, int begin, int length) {
144 if (test(values, begin, length)) {
145 int k = begin + length;
146 for (int i = begin; i < k; i++) {
147 increment(values[i]);
148 }
149 }
150 }
151
152 /**
153 * Returns true iff <code>object</code> is an
154 * <code>AbstractStorelessUnivariateStatistic</code> returning the same
155 * values as this for <code>getResult()</code> and <code>getN()</code>
156 * @param object object to test equality against.
157 * @return true if object returns the same value as this
158 */
159 @Override
160 public boolean equals(Object object) {
161 if (object == this ) {
162 return true;
163 }
164 if (object instanceof AbstractStorelessUnivariateStatistic == false) {
165 return false;
166 }
167 AbstractStorelessUnivariateStatistic stat = (AbstractStorelessUnivariateStatistic) object;
168 return (MathUtils.equals(stat.getResult(), this.getResult()) &&
169 MathUtils.equals(stat.getN(), this.getN()));
170 }
171
172 /**
173 * Returns hash code based on getResult() and getN()
174 *
175 * @return hash code
176 */
177 @Override
178 public int hashCode() {
179 return 31* (31 + MathUtils.hash(getResult())) + MathUtils.hash(getN());
180 }
181
182 }