Coverage Report - org.apache.commons.math.stat.descriptive.AbstractStorelessUnivariateStatistic

Classes in this File Line Coverage Branch Coverage Complexity
AbstractStorelessUnivariateStatistic
96% 
100% 
2.222

 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$ $Date: 2005-02-26 05:11:52 -0800 (Sat, 26 Feb 2005) $
 31   
  */
 32  129540 
 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  416 
         if (values == null) {
 57  8 
             throw new IllegalArgumentException("input value array is null");
 58   
         }
 59  408 
         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  60 
         if (test(values, begin, length)) {
 81  52 
             clear();
 82  52 
             incrementAll(values, begin, length);
 83   
         }
 84  60 
         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  40 
         if (values == null) {
 114  0 
             throw new IllegalArgumentException("input values array is null");
 115   
         }
 116  40 
         incrementAll(values, 0, values.length);
 117  40 
     }
 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  110 
         if (test(values, begin, length)) {
 133  110 
             int k = begin + length;
 134  1702 
             for (int i = begin; i < k; i++) {
 135  1592 
                 increment(values[i]);
 136   
             }
 137   
         }
 138  110 
     }
 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  384 
         if (object == this ) {
 149  64 
             return true;
 150   
         }
 151  320 
        if (object instanceof AbstractStorelessUnivariateStatistic == false) {
 152  32 
             return false;
 153   
         }
 154  288 
         AbstractStorelessUnivariateStatistic stat = (AbstractStorelessUnivariateStatistic) object;
 155  288 
         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  480 
         return 31* (31 + MathUtils.hash(getResult())) + MathUtils.hash(getN());
 166   
     }
 167   
 
 168   
 }

Reports generated by Cobertura.