View Javadoc

    1   /*
    2    * Copyright 2003-2004 The Apache Software Foundation.
    3    *
    4    * Licensed under the Apache License, Version 2.0 (the "License");
    5    * you may not use this file except in compliance with the License.
    6    * You may obtain a copy of the License at
    7    *
    8    *      http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  package org.apache.commons.math.stat.descriptive;
    17
    18  import org.apache.commons.math.util.MathUtils;
    19  import java.io.Serializable;
    20
    21  /***
    22   *
    23   * Abstract Implementation for the {@link StorelessUnivariateStatistic} interface.
    24   * <p>
    25   * Provides default <code>evaluate()</code> and <code>incrementAll(double[])<code>
    26   * implementations.
    27   * <p>
    28   * <strong>Note that these implementations are not synchronized.</strong>
    29   *
    30   * @version $Revision: 1.1 $ $Date: 2004/10/08 05:08:17 $
    31   */
    32  public abstract class AbstractStorelessUnivariateStatistic
    33      extends AbstractUnivariateStatistic
    34      implements StorelessUnivariateStatistic, Serializable {
    35
    36      /*** Serialization UID */
    37      static final long serialVersionUID = -44915725420072521L;
    38
    39      /***
    40       * This default implementation calls {@link #clear}, then invokes
    41       * {@link #increment} in a loop over the the input array, and then uses
    42       * {@link #getResult} to compute the return value.
    43       * <p>
    44       * Note that this implementation changes the internal state of the
    45       * statistic.  Its side effects are the same as invoking {@link #clear} and
    46       * then {@link #incrementAll(double[])}.
    47       * <p>
    48       * Implementations may override this method with a more efficient
    49       * implementation that works directly with the input array.
    50       * <p>
    51       * If the array is null, an IllegalArgumentException is thrown.
    52       *
    53       * @see org.apache.commons.math.stat.descriptive.UnivariateStatistic#evaluate(double[])
    54       */
    55      public double evaluate(final double[] values) {
    56          if (values == null) {
    57              throw new IllegalArgumentException("input value array is null");
    58          }
    59          return evaluate(values, 0, values.length);
    60      }
    61
    62      /***
    63       * This default implementation calls {@link #clear}, then invokes
    64       * {@link #increment} in a loop over the specified portion of the input
    65       * array, and then uses {@link #getResult} to compute the return value.
    66       * <p>
    67       * Note that this implementation changes the internal state of the
    68       * statistic.  Its side effects are the same as invoking {@link #clear} and
    69       * then {@link #incrementAll(double[], int, int)}.
    70       * <p>
    71       * Implementations may override this method with a more efficient
    72       * implementation that works directly with the input array.
    73       * <p>
    74       * If the array is null or the index parameters are not valid, an
    75       * IllegalArgumentException is thrown.
    76       *
    77       * @see org.apache.commons.math.stat.descriptive.UnivariateStatistic#evaluate(double[], int, int)
    78       */
    79      public double evaluate(final double[] values, final int begin, final int length) {
    80          if (test(values, begin, length)) {
    81              clear();
    82              incrementAll(values, begin, length);
    83          }
    84          return getResult();
    85      }
    86
    87      /***
    88       * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#clear()
    89       */
    90      public abstract void clear();
    91
    92      /***
    93       * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#getResult()
    94       */
    95      public abstract double getResult();
    96
    97      /***
    98       * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#increment(double)
    99       */
    100     public abstract void increment(final double d);
    101
    102     /***
    103      * This default implementation just calls {@link #increment} in a loop over
    104      * the input array.
    105      * <p>
    106      * Throws IllegalArgumentException if the input values array is null.
    107      *
    108      * @param values values to add
    109      * @throws IllegalArgumentException if values is null
    110      * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#incrementAll(double[])
    111      */
    112     public void incrementAll(double[] values) {
    113         if (values == null) {
    114             throw new IllegalArgumentException("input values array is null");
    115         }
    116         incrementAll(values, 0, values.length);
    117     }
    118
    119     /***
    120      * This default implementation just calls {@link #increment} in a loop over
    121      * the specified portion of the input array.
    122      * <p>
    123      * Throws IllegalArgumentException if the input values array is null.
    124      *
    125      * @param values  array holding values to add
    126      * @param begin   index of the first array element to add
    127      * @param length  number of array elements to add
    128      * @throws IllegalArgumentException if values is null
    129      * @see org.apache.commons.math.stat.descriptive.StorelessUnivariateStatistic#incrementAll(double[], int, int)
    130      */
    131     public void incrementAll(double[] values, int begin, int length) {
    132         if (test(values, begin, length)) {
    133             int k = begin + length;
    134             for (int i = begin; i < k; i++) {
    135                 increment(values[i]);
    136             }
    137         }
    138     }
    139
    140     /***
    141      * Returns true iff <code>object</code> is an
    142      * <code>AbstractStorelessUnivariateStatistic</code> returning the same
    143      * values as this for <code>getResult()</code> and <code>getN()</code>
    144      * @param object object to test equality against.
    145      * @return true if object returns the same value as this
    146      */
    147     public boolean equals(Object object) {
    148         if (object == this ) {
    149             return true;
    150         }
    151        if (object instanceof AbstractStorelessUnivariateStatistic == false) {
    152             return false;
    153         }
    154         AbstractStorelessUnivariateStatistic stat = (AbstractStorelessUnivariateStatistic) object;
    155         return (MathUtils.equals(stat.getResult(), this.getResult()) &&
    156                 MathUtils.equals(stat.getN(), this.getN()));
    157     }
    158
    159     /***
    160      * Returns hash code based on getResult() and getN()
    161      *
    162      * @return hash code
    163      */
    164     public int hashCode() {
    165         return 31* (31 + MathUtils.hash(getResult())) + MathUtils.hash(getN());
    166     }
    167
    168 }