Package org.apache.commons.math3.stat.descriptive

# Class AbstractUnivariateStatistic

java.lang.Object
org.apache.commons.math3.stat.descriptive.AbstractUnivariateStatistic

All Implemented Interfaces:
  `UnivariateStatistic`, `MathArrays.Function`

Direct Known Subclasses:
  `AbstractStorelessUnivariateStatistic`, `Percentile`, `SemiVariance`

public abstract class AbstractUnivariateStatistic extends Object implements UnivariateStatistic
Abstract base class for all implementations of the `UnivariateStatistic` interface.

Provides a default implementation of `evaluate(double[]),` delegating to `evaluate(double[], int, int)` in the natural way.

Also includes a `test` method that performs generic parameter validation for the `evaluate` methods.

## Constructor Summary

Constructors
Constructor
Description
`AbstractUnivariateStatistic()`

## Method Summary

Modifier and Type
Method
Description
`abstract UnivariateStatistic`
`copy()`
Returns a copy of the statistic with the same internal state.
`double`
`evaluate()`
Returns the result of evaluating the statistic over the stored data.
`double`
`evaluate(double[] values)`
Returns the result of evaluating the statistic over the input array.
`abstract double`
`evaluate(double[] values, int begin, int length)`
Returns the result of evaluating the statistic over the specified entries in the input array.
`double[]`
`getData()`
Get a copy of the stored data array.
`protected double[]`
`getDataRef()`
Get a reference to the stored data array.
`void`
`setData(double[] values)`
Set the data array.
`void`
`setData(double[] values, int begin, int length)`
Set the data array.
`protected boolean`
`test(double[] values, double[] weights, int begin, int length)`
This method is used by `evaluate(double[], double[], int, int)` methods to verify that the begin and length parameters designate a subarray of positive length and the weights are all non-negative, non-NaN, finite, and not all zero.
`protected boolean`
`test(double[] values, double[] weights, int begin, int length, boolean allowEmpty)`
This method is used by `evaluate(double[], double[], int, int)` methods to verify that the begin and length parameters designate a subarray of positive length and the weights are all non-negative, non-NaN, finite, and not all zero.
`protected boolean`
`test(double[] values, int begin, int length)`
This method is used by `evaluate(double[], int, int)` methods to verify that the input parameters designate a subarray of positive length.
`protected boolean`
`test(double[] values, int begin, int length, boolean allowEmpty)`
This method is used by `evaluate(double[], int, int)` methods to verify that the input parameters designate a subarray of positive length.

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

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

## Constructor Details

### AbstractUnivariateStatistic

public AbstractUnivariateStatistic()

## Method Details

### setData

public void setData(double[] values)
Set the data array.

The stored value is a copy of the parameter array, not the array itself.

Parameters:
  `values` - data array to store (may be null to remove stored data)
See Also:
  - `evaluate()`

### getData

public double[] getData()
Get a copy of the stored data array.

Returns:
  copy of the stored data array (may be null)

### getDataRef

protected double[] getDataRef()
Get a reference to the stored data array.

Returns:
  reference to the stored data array (may be null)

### setData

public void setData(double[] values, int begin, int length) throws MathIllegalArgumentException
Set the data array. The input array is copied, not referenced.

Parameters:
  `values` - data array to store
  `begin` - the index of the first element to include
  `length` - the number of elements to include
Throws:
  `MathIllegalArgumentException` - if values is null or the indices are not valid
See Also:
  - `evaluate()`

### evaluate

public double evaluate() throws MathIllegalArgumentException
Returns the result of evaluating the statistic over the stored data.

The stored array is the one which was set by previous calls to `setData(double[])`.

Returns:
  the value of the statistic applied to the stored data
Throws:
  `MathIllegalArgumentException` - if the stored data array is null

### evaluate

public double evaluate(double[] values) throws MathIllegalArgumentException
Returns the result of evaluating the statistic over the input array.

Specified by:
  `evaluate` in interface `MathArrays.Function`
Specified by:
  `evaluate` in interface `UnivariateStatistic`
Parameters:
  `values` - input array
Returns:
  the value of the statistic applied to the input array
Throws:
  `MathIllegalArgumentException` - if values is null

### evaluate

public abstract double evaluate(double[] values, int begin, int length) throws MathIllegalArgumentException
Returns the result of evaluating the statistic over the specified entries in the input array.

Specified by:
  `evaluate` in interface `MathArrays.Function`
Specified by:
  `evaluate` in interface `UnivariateStatistic`
Parameters:
  `values` - the input array
  `begin` - the index of the first element to include
  `length` - the number of elements to include
Returns:
  the value of the statistic applied to the included array entries
Throws:
  `MathIllegalArgumentException` - if values is null or the indices are invalid

### copy

public abstract UnivariateStatistic copy()
Returns a copy of the statistic with the same internal state.

Specified by:
  `copy` in interface `UnivariateStatistic`
Returns:
  a copy of the statistic

### test

protected boolean test(double[] values, int begin, int length) throws MathIllegalArgumentException
This method is used by `evaluate(double[], int, int)` methods to verify that the input parameters designate a subarray of positive length.

- returns `true` iff the parameters designate a subarray of positive length
- throws `MathIllegalArgumentException` if the array is null or or the indices are invalid
- returns `false`
if the array is non-null, but `length` is 0.

Parameters:
  `values` - the input array
  `begin` - index of the first array element to include
  `length` - the number of elements to include
Returns:
  true if the parameters are valid and designate a subarray of positive length
Throws:
  `MathIllegalArgumentException` - if the indices are invalid or the array is null

### test

protected boolean test(double[] values, int begin, int length, boolean allowEmpty) throws MathIllegalArgumentException
This method is used by `evaluate(double[], int, int)` methods to verify that the input parameters designate a subarray of positive length.

- returns `true` iff the parameters designate a subarray of non-negative length
- throws `IllegalArgumentException` if the array is null or or the indices are invalid
- returns `false`
if the array is non-null, but `length` is 0 unless `allowEmpty` is `true`

Parameters:
  `values` - the input array
  `begin` - index of the first array element to include
  `length` - the number of elements to include
  `allowEmpty` - if `true` then zero length arrays are allowed
Returns:
  true if the parameters are valid
Throws:
  `MathIllegalArgumentException` - if the indices are invalid or the array is null
Since:
  3.0

### test

protected boolean test(double[] values, double[] weights, int begin, int length) throws MathIllegalArgumentException
This method is used by `evaluate(double[], double[], int, int)` methods to verify that the begin and length parameters designate a subarray of positive length and the weights are all non-negative, non-NaN, finite, and not all zero.

- returns `true` iff the parameters designate a subarray of positive length and the weights array contains legitimate values.
- 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
- returns `false`
if the array is non-null, but `length` is 0.

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:
  true if the parameters are valid and designate a subarray of positive length
Throws:
  `MathIllegalArgumentException` - if the indices are invalid or the array is null
Since:
  2.1

### test

protected boolean test(double[] values, double[] weights, int begin, int length, boolean allowEmpty) throws MathIllegalArgumentException
This method is used by `evaluate(double[], double[], int, int)` methods to verify that the begin and length parameters designate a subarray of positive length and the weights are all non-negative, non-NaN, finite, and not all zero.

- returns `true` iff the parameters designate a subarray of non-negative length and the weights array contains legitimate values.
- 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
  - the start and length arguments do not determine a valid array
- returns `false`
if the array is non-null, but `length` is 0 unless `allowEmpty` is `true`.

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.
  `allowEmpty` - if `true` than allow zero length arrays to pass.
Returns:
  `true` if the parameters are valid.
Throws:
  `NullArgumentException` - if either of the arrays are null
  `MathIllegalArgumentException` - if the array indices are not valid, the weights array contains NaN, infinite or negative elements, or there are no positive weights.
Since:
  3.0