org.apache.commons.math3.stat.descriptive.moment

## Class Mean

- java.lang.Object
- - org.apache.commons.math3.stat.descriptive.AbstractUnivariateStatistic
  - - org.apache.commons.math3.stat.descriptive.AbstractStorelessUnivariateStatistic
    - - org.apache.commons.math3.stat.descriptive.moment.Mean

- All Implemented Interfaces:
    Serializable, StorelessUnivariateStatistic, UnivariateStatistic, WeightedEvaluation, MathArrays.Function

      public class Mean
      extends AbstractStorelessUnivariateStatistic
      implements Serializable, WeightedEvaluation

  Computes the arithmetic mean of a set of values. Uses the definitional formula:

  mean = sum(x_i) / n

  where `n` is the number of observations.

  When `increment(double)` is used to add data incrementally from a stream of (unstored) values, the value of the statistic that `getResult()` returns is computed using the following recursive updating algorithm:

  1. Initialize `m =` the first value
  2. For each additional value, update using
     `m = m + (new value - m) / (number of observations)`

  If `AbstractStorelessUnivariateStatistic.evaluate(double[])` is used to compute the mean of an array of stored values, a two-pass, corrected algorithm is used, starting with the definitional formula computed using the array of stored values and then correcting this by adding the mean deviation of the data values from the arithmetic mean. See, e.g. "Comparison of Several Algorithms for Computing Sample Means and Variances," Robert F. Ling, Journal of the American Statistical Association, Vol. 69, No. 348 (Dec., 1974), pp. 859-866.

  Returns `Double.NaN` if the dataset is empty. Note that Double.NaN may also be returned if the input includes NaN and / or infinite values.

  Note that this implementation is not synchronized. If multiple threads access an instance of this class concurrently, and at least one of the threads invokes the `increment()` or `clear()` method, it must be synchronized externally.
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected boolean` | `incMoment` Determines whether or not this statistic can be incremented or cleared.
    `protected org.apache.commons.math3.stat.descriptive.moment.FirstMoment` | `moment` First moment on which this statistic is based.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Mean()` Constructs a Mean.
    `Mean(org.apache.commons.math3.stat.descriptive.moment.FirstMoment m1)` Constructs a Mean with an External Moment.
    `Mean(Mean original)` Copy constructor, creates a new `Mean` identical to the `original`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clear()` Clears the internal state of the Statistic
    `Mean` | `copy()` Returns a copy of the statistic with the same internal state.
    `static void` | `copy(Mean source, Mean dest)` Copies source to dest.
    `double` | `evaluate(double[] values, double[] weights)` Returns the weighted arithmetic mean of the entries in the input array.
    `double` | `evaluate(double[] values, double[] weights, int begin, int length)` Returns the weighted arithmetic mean of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
    `double` | `evaluate(double[] values, int begin, int length)` Returns the arithmetic mean of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.
    `long` | `getN()` Returns the number of values that have been added.
    `double` | `getResult()` Returns the current value of the Statistic.
    `void` | `increment(double d)` Updates the internal state of the statistic to reflect the addition of the new value.

    - ### Methods inherited from class org.apache.commons.math3.stat.descriptive.AbstractStorelessUnivariateStatistic

      `equals, evaluate, hashCode, incrementAll, incrementAll`

    - ### Methods inherited from class org.apache.commons.math3.stat.descriptive.AbstractUnivariateStatistic

      `evaluate, getData, getDataRef, setData, setData, test, test, test, test`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### moment

          protected org.apache.commons.math3.stat.descriptive.moment.FirstMoment moment

      First moment on which this statistic is based.

    - #### incMoment

          protected boolean incMoment

      Determines whether or not this statistic can be incremented or cleared.

      Statistics based on (constructed from) external moments cannot be incremented or cleared.

  - ### Constructor Detail

    - #### Mean

          public Mean()

      Constructs a Mean.

    - #### Mean

          public Mean(org.apache.commons.math3.stat.descriptive.moment.FirstMoment m1)

      Constructs a Mean with an External Moment.
      Parameters:
        `m1` - the moment

    - #### Mean

          public Mean(Mean original)
               throws NullArgumentException

      Copy constructor, creates a new `Mean` identical to the `original`
      Parameters:
        `original` - the `Mean` instance to copy
      Throws:
        `NullArgumentException` - if original is null

  - ### Method Detail

    - #### increment

          public void increment(double d)

      Updates the internal state of the statistic to reflect the addition of the new value.

      Note that when `Mean(FirstMoment)` is used to create a Mean, this method does nothing. In that case, the FirstMoment should be incremented directly.

      Specified by:
        `increment` in interface `StorelessUnivariateStatistic`
      Specified by:
        `increment` in class `AbstractStorelessUnivariateStatistic`
      Parameters:
        `d` - the new value.

    - #### clear

          public void clear()

      Clears the internal state of the Statistic
      Specified by:
        `clear` in interface `StorelessUnivariateStatistic`
      Specified by:
        `clear` in class `AbstractStorelessUnivariateStatistic`

    - #### getResult

          public double getResult()

      Returns the current value of the Statistic.
      Specified by:
        `getResult` in interface `StorelessUnivariateStatistic`
      Specified by:
        `getResult` in class `AbstractStorelessUnivariateStatistic`
      Returns:
        value of the statistic, `Double.NaN` if it has been cleared or just instantiated.

    - #### getN

          public long getN()

      Returns the number of values that have been added.
      Specified by:
        `getN` in interface `StorelessUnivariateStatistic`
      Returns:
        the number of values.

    - #### evaluate

          public double evaluate(double[] values,
                        int begin,
                        int length)
                          throws MathIllegalArgumentException

      Returns the arithmetic mean of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.

      Throws `IllegalArgumentException` if the array is null.

      See `Mean` for details on the computing algorithm.

      Specified by:
        `evaluate` in interface `UnivariateStatistic`
      Specified by:
        `evaluate` in interface `MathArrays.Function`
      Overrides:
        `evaluate` in class `AbstractStorelessUnivariateStatistic`
      Parameters:
        `values` - the input array
        `begin` - index of the first array element to include
        `length` - the number of elements to include
      Returns:
        the mean of the values or Double.NaN if length = 0
      Throws:
        `MathIllegalArgumentException` - if the array is null or the array index parameters are not valid
      See Also:
        `UnivariateStatistic.evaluate(double[], int, int)`

    - #### evaluate

          public double evaluate(double[] values,
                        double[] weights,
                        int begin,
                        int length)
                          throws MathIllegalArgumentException

      Returns the weighted arithmetic mean of the entries in the specified portion of the input array, or `Double.NaN` if the designated subarray is empty.

      Throws `IllegalArgumentException` if either array is null.

      See `Mean` for details on the computing algorithm. The two-pass algorithm described above is used here, with weights applied in computing both the original estimate and the correction factor.

      Throws `IllegalArgumentException` if any of the following are true:

      - the values array is null
      - the weights array is null
      - the weights array does not have the same length as the values array
      - the weights array contains one or more infinite values
      - the weights array contains one or more NaN values
      - the weights array contains negative values
      - the start and length arguments do not determine a valid array
      Specified by:
        `evaluate` in interface `WeightedEvaluation`
      Parameters:
        `values` - the input array
        `weights` - the weights array
        `begin` - index of the first array element to include
        `length` - the number of elements to include
      Returns:
        the mean of the values or Double.NaN if length = 0
      Throws:
        `MathIllegalArgumentException` - if the parameters are not valid
      Since:
        2.1

    - #### evaluate

          public double evaluate(double[] values,
                        double[] weights)
                          throws MathIllegalArgumentException

      Returns the weighted arithmetic mean of the entries in the input array.

      Throws `MathIllegalArgumentException` if either array is null.

      See `Mean` for details on the computing algorithm. The two-pass algorithm described above is used here, with weights applied in computing both the original estimate and the correction factor.

      Throws `MathIllegalArgumentException` if any of the following are true:

      - the values array is null
      - the weights array is null
      - the weights array does not have the same length as the values array
      - the weights array contains one or more infinite values
      - the weights array contains one or more NaN values
      - the weights array contains negative values
      Specified by:
        `evaluate` in interface `WeightedEvaluation`
      Parameters:
        `values` - the input array
        `weights` - the weights array
      Returns:
        the mean of the values or Double.NaN if length = 0
      Throws:
        `MathIllegalArgumentException` - if the parameters are not valid
      Since:
        2.1

    - #### copy

          public Mean copy()

      Returns a copy of the statistic with the same internal state.
      Specified by:
        `copy` in interface `StorelessUnivariateStatistic`
      Specified by:
        `copy` in interface `UnivariateStatistic`
      Specified by:
        `copy` in class `AbstractStorelessUnivariateStatistic`
      Returns:
        a copy of the statistic

    - #### copy

          public static void copy(Mean source,
                  Mean dest)
                           throws NullArgumentException

      Copies source to dest.

      Neither source nor dest can be null.

      Parameters:
        `source` - Mean to copy
        `dest` - Mean to copy to
      Throws:
        `NullArgumentException` - if either source or dest is null

Copyright © 2003–2016 The Apache Software Foundation. All rights reserved.