← Back to branch summary

~ubuntu-branches/ubuntu/maverick/commons-math/maverick

« back to all changes in this revision

Viewing changes to src/java/org/apache/commons/math/stat/descriptive/AbstractStorelessUnivariateStatistic.java

  • Committer: Bazaar Package Importer
  • Author(s): Damien Raude-Morvan
  • Date: 2009-08-22 01:13:25 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20090822011325-hi4peq1ua5weguwn
Tags: 2.0-1
* New upstream release.
* Set Maintainer field to Debian Java Team
* Add myself as Uploaders
* Switch to Quilt patch system:
  - Refresh all patchs
  - Remove B-D on dpatch, Add B-D on quilt
  - Include patchsys-quilt.mk in debian/rules
* Bump Standards-Version to 3.8.3:
  - Add a README.source to describe patch system
* Maven POMs:
  - Add a Build-Depends-Indep dependency on maven-repo-helper
  - Use mh_installpom and mh_installjar to install the POM and the jar to the
    Maven repository
* Use default-jdk/jre:
  - Depends on java5-runtime-headless
  - Build-Depends on default-jdk
  - Use /usr/lib/jvm/default-java as JAVA_HOME
* Move api documentation to /usr/share/doc/libcommons-math-java/api
* Build-Depends on junit4 instead of junit

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/java/org/apache/commons/math/stat/descriptive/AbstractStorelessUnivariateStatistic.java
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.util.MathUtils;
20
 
import java.io.Serializable;
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: 617953 $ $Date: 2008-02-02 22:54:00 -0700 (Sat, 02 Feb 2008) $
32
 
 */
33
 
public abstract class AbstractStorelessUnivariateStatistic
34
 
    extends AbstractUnivariateStatistic
35
 
    implements StorelessUnivariateStatistic, Serializable {
36
 
 
37
 
    /** Serialization UID */
38
 
    private static final long serialVersionUID = -44915725420072521L;
39
 
    
40
 
    /**
41
 
     * This default implementation calls {@link #clear}, then invokes 
42
 
     * {@link #increment} in a loop over the the input array, and then uses 
43
 
     * {@link #getResult} to compute the return value.  
44
 
     * <p>
45
 
     * Note that this implementation changes the internal state of the
46
 
     * statistic.  Its side effects are the same as invoking {@link #clear} and
47
 
     * then {@link #incrementAll(double[])}.</p>
48
 
     * <p>
49
 
     * Implementations may override this method with a more efficient and
50
 
     * possibly more accurate implementation that works directly with the
51
 
     * input array.</p>
52
 
     * <p>
53
 
     * If the array is null, an IllegalArgumentException is thrown.</p>
54
 
     * 
55
 
     * @see org.apache.commons.math.stat.descriptive.UnivariateStatistic#evaluate(double[])
56
 
     */
57
 
    public double evaluate(final double[] values) {
58
 
        if (values == null) {
59
 
            throw new IllegalArgumentException("input value array is null");
60
 
        }
61
 
        return evaluate(values, 0, values.length);
62
 
    }
63
 
    
64
 
    /**
65
 
     * This default implementation calls {@link #clear}, then invokes 
66
 
     * {@link #increment} in a loop over the specified portion of the input 
67
 
     * array, and then uses {@link #getResult} to compute the return value.  
68
 
     * <p>
69
 
     * Note that this implementation changes the internal state of the
70
 
     * statistic.  Its side effects are the same as invoking {@link #clear} and
71
 
     * then {@link #incrementAll(double[], int, int)}.</p>
72
 
     * <p>
73
 
     * Implementations may override this method with a more efficient and
74
 
     * possibly more accurate implementation that works directly with the
75
 
     * input array.</p>
76
 
     * <p>
77
 
     * If the array is null or the index parameters are not valid, an 
78
 
     * IllegalArgumentException is thrown.</p>
79
 
     * 
80
 
     * @see org.apache.commons.math.stat.descriptive.UnivariateStatistic#evaluate(double[], int, int)
81
 
     */
82
 
    public double evaluate(final double[] values, final int begin, final int length) {
83
 
        if (test(values, begin, length)) {
84
 
            clear();
85
 
            incrementAll(values, begin, length);
86
 
        }
87
 
        return getResult();
88
 
    }
89
 
 
90
 
    /**
91
 
     * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#clear()
92
 
     */
93
 
    public abstract void clear();
94
 
 
95
 
    /**
96
 
     * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#getResult()
97
 
     */
98
 
    public abstract double getResult();
99
 
 
100
 
    /**
101
 
     * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#increment(double)
102
 
     */
103
 
    public abstract void increment(final double d);
104
 
    
105
 
    /**
106
 
     * This default implementation just calls {@link #increment} in a loop over
107
 
     * the input array.   
108
 
     * <p>
109
 
     * Throws IllegalArgumentException if the input values array is null.</p>
110
 
     * 
111
 
     * @param values values to add
112
 
     * @throws IllegalArgumentException if values is null
113
 
     * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#incrementAll(double[])
114
 
     */
115
 
    public void incrementAll(double[] values) {
116
 
        if (values == null) {
117
 
            throw new IllegalArgumentException("input values array is null");
118
 
        }
119
 
        incrementAll(values, 0, values.length);
120
 
    } 
121
 
   
122
 
    /**
123
 
     * This default implementation just calls {@link #increment} in a loop over
124
 
     * the specified portion of the input array.
125
 
     * <p>
126
 
     * Throws IllegalArgumentException if the input values array is null.</p>
127
 
     * 
128
 
     * @param values  array holding values to add
129
 
     * @param begin   index of the first array element to add
130
 
     * @param length  number of array elements to add
131
 
     * @throws IllegalArgumentException if values is null
132
 
     * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#incrementAll(double[], int, int)
133
 
     */
134
 
    public void incrementAll(double[] values, int begin, int length) {
135
 
        if (test(values, begin, length)) {
136
 
            int k = begin + length;
137
 
            for (int i = begin; i < k; i++) {
138
 
                increment(values[i]);
139
 
            }   
140
 
        }
141
 
    }
142
 
    
143
 
    /**
144
 
     * Returns true iff <code>object</code> is an 
145
 
     * <code>AbstractStorelessUnivariateStatistic</code> returning the same
146
 
     * values as this for <code>getResult()</code> and <code>getN()</code>
147
 
     * @param object object to test equality against.
148
 
     * @return true if object returns the same value as this
149
 
     */
150
 
    public boolean equals(Object object) {
151
 
        if (object == this ) {
152
 
            return true;
153
 
        }
154
 
       if (object instanceof AbstractStorelessUnivariateStatistic == false) {
155
 
            return false;
156
 
        }
157
 
        AbstractStorelessUnivariateStatistic stat = (AbstractStorelessUnivariateStatistic) object;
158
 
        return (MathUtils.equals(stat.getResult(), this.getResult()) && 
159
 
                MathUtils.equals(stat.getN(), this.getN()));
160
 
    }
161
 
    
162
 
    /**
163
 
     * Returns hash code based on getResult() and getN()
164
 
     * 
165
 
     * @return hash code
166
 
     */
167
 
    public int hashCode() {
168
 
        return 31* (31 + MathUtils.hash(getResult())) + MathUtils.hash(getN());
169
 
    }
170
 
 
171
 
}
 
 
b'\\ No newline at end of file'