org.apache.commons.math3.util

## Class ResizableDoubleArray

- java.lang.Object
- - org.apache.commons.math3.util.ResizableDoubleArray

All Implemented Interfaces:
  java.io.Serializable, DoubleArray

    public class ResizableDoubleArray
    extends java.lang.Object
    implements DoubleArray, java.io.Serializable

A variable length `DoubleArray` implementation that automatically handles expanding and contracting its internal storage array as elements are added and removed.

### Important note: Usage should not assume that this class is thread-safe even though some of the methods are `synchronized`. This qualifier will be dropped in the next major release (4.0).

The internal storage array starts with capacity determined by the `initialCapacity` property, which can be set by the constructor. The default initial capacity is 16. Adding elements using `addElement(double)` appends elements to the end of the array. When there are no open entries at the end of the internal storage array, the array is expanded. The size of the expanded array depends on the `expansionMode` and `expansionFactor` properties. The `expansionMode` determines whether the size of the array is multiplied by the `expansionFactor` (`ResizableDoubleArray.ExpansionMode.MULTIPLICATIVE`) or if the expansion is additive (`ResizableDoubleArray.ExpansionMode.ADDITIVE` -- `expansionFactor` storage locations added). The default `expansionMode` is `MULTIPLICATIVE` and the default `expansionFactor` is 2.

The `addElementRolling(double)` method adds a new element to the end of the internal storage array and adjusts the "usable window" of the internal array forward by one position (effectively making what was the second element the first, and so on). Repeated activations of this method (or activation of `discardFrontElements(int)`) will effectively orphan the storage locations at the beginning of the internal storage array. To reclaim this storage, each time one of these methods is activated, the size of the internal storage array is compared to the number of addressable elements (the `numElements` property) and if the difference is too large, the internal array is contracted to size `numElements + 1`. The determination of when the internal storage array is "too large" depends on the `expansionMode` and `contractionFactor` properties. If the `expansionMode` is `MULTIPLICATIVE`, contraction is triggered when the ratio between storage array length and `numElements` exceeds `contractionFactor.` If the `expansionMode` is `ADDITIVE`, the number of excess storage locations is compared to `contractionFactor`.

To avoid cycles of expansions and contractions, the `expansionFactor` must not exceed the `contractionFactor`. Constructors and mutators for both of these properties enforce this requirement, throwing a `MathIllegalArgumentException` if it is violated.

Version:
  $Id: ResizableDoubleArray.java 1422433 2012-12-16 00:45:18Z erans $
See Also:
  Serialized Form

### Nested Class Summary

Nested Classes
`static class` `ResizableDoubleArray.ExpansionMode` Specification of expansion algorithm.

### Field Summary

Fields
`static int` `ADDITIVE_MODE` Deprecated. As of 3.1. Please use `ResizableDoubleArray.ExpansionMode.ADDITIVE` instead.
`private double` `contractionCriterion` The contraction criteria determines when the internal array will be contracted to fit the number of elements contained in the element array + 1.
`private static double` `DEFAULT_CONTRACTION_DELTA` Default value for the difference between `contractionCriterion` and `expansionFactor`.
`private static double` `DEFAULT_EXPANSION_FACTOR` Default value for array size modifier.
`private static int` `DEFAULT_INITIAL_CAPACITY` Default value for initial capacity.
`private double` `expansionFactor` The expansion factor of the array.
`private ResizableDoubleArray.ExpansionMode` `expansionMode` Determines whether array expansion by `expansionFactor` is additive or multiplicative.
`private double[]` `internalArray` The internal storage array.
`static int` `MULTIPLICATIVE_MODE` Deprecated. As of 3.1. Please use `ResizableDoubleArray.ExpansionMode.MULTIPLICATIVE` instead.
`private int` `numElements` The number of addressable elements in the array.
`private static long` `serialVersionUID` Serializable version identifier.
`private int` `startIndex` The position of the first addressable element in the internal storage array.

### Constructor Summary

Constructors
Constructor and Description
`ResizableDoubleArray()` Creates an instance with default properties.
`ResizableDoubleArray(double[] initialArray)` Creates an instance from an existing `double[]` with the initial capacity and numElements corresponding to the size of the supplied `double[]` array.
`ResizableDoubleArray(int initialCapacity)` Creates an instance with the specified initial capacity.
`ResizableDoubleArray(int initialCapacity, double expansionFactor)` Creates an instance with the specified initial capacity and expansion factor.
`ResizableDoubleArray(int initialCapacity, double expansionFactor, double contractionCriterion)` Creates an instance with the specified initial capacity, expansion factor, and contraction criteria.
`ResizableDoubleArray(int initialCapacity, double expansionFactor, double contractionCriterion, ResizableDoubleArray.ExpansionMode expansionMode, double... data)` Creates an instance with the specified properties.
`ResizableDoubleArray(int initialCapacity, float expansionFactor)` Deprecated. As of 3.1. Please use `ResizableDoubleArray(int,double)` instead.
`ResizableDoubleArray(int initialCapacity, float expansionFactor, float contractionCriteria)` Deprecated. As of 3.1. Please use `ResizableDoubleArray(int,double,double)` instead.
`ResizableDoubleArray(int initialCapacity, float expansionFactor, float contractionCriteria, int expansionMode)` Deprecated. As of 3.1. Please use `ResizableDoubleArray(int,double,double,ExpansionMode,double[])` instead.
`ResizableDoubleArray(ResizableDoubleArray original)` Copy constructor.

### Method Summary

Methods
`void` `addElement(double value)` Adds an element to the end of this expandable array.
`double` `addElementRolling(double value)` Adds an element to the end of the array and removes the first element in the array.
`void` `addElements(double[] values)` Adds several element to the end of this expandable array.
`protected void` `checkContractExpand(double contraction, double expansion)` Checks the expansion factor and the contraction criterion and raises an exception if the contraction criterion is smaller than the expansion criterion.
`protected void` `checkContractExpand(float contraction, float expansion)` Deprecated. As of 3.1. Please use `checkContractExpand(double,double)` instead.
`void` `clear()` Clear the array contents, resetting the number of elements to zero.
`double` `compute(MathArrays.Function f)` Performs an operation on the addressable elements of the array.
`void` `contract()` Contracts the storage array to the (size of the element set) + 1 - to avoid a zero length array.
`ResizableDoubleArray` `copy()` Returns a copy of the ResizableDoubleArray.
`static void` `copy(ResizableDoubleArray source, ResizableDoubleArray dest)` Copies source to dest, copying the underlying data, so dest is a new, independent copy of source.
`private void` `discardExtremeElements(int i, boolean front)` Discards the `i` first or last elements of the array, depending on the value of `front`.
`void` `discardFrontElements(int i)` Discards the `i` initial elements of the array.
`void` `discardMostRecentElements(int i)` Discards the `i` last elements of the array.
`boolean` `equals(java.lang.Object object)` Returns true iff object is a ResizableDoubleArray with the same properties as this and an identical internal storage array.
`protected void` `expand()` Expands the internal storage array using the expansion factor.
`private void` `expandTo(int size)` Expands the internal storage array to the specified size.
`protected double[]` `getArrayRef()` Provides direct access to the internal storage array.
`int` `getCapacity()` Gets the currently allocated size of the internal data structure used for storing elements.
`float` `getContractionCriteria()` Deprecated. As of 3.1. Please use `getContractionCriterion()` instead.
`double` `getContractionCriterion()` The contraction criterion defines when the internal array will contract to store only the number of elements in the element array.
`double` `getElement(int index)` Returns the element at the specified index
`double[]` `getElements()` Returns a double array containing the elements of this `ResizableArray`.
`float` `getExpansionFactor()` Deprecated. As of 3.1. Return type will be changed to "double" in 4.0.
`int` `getExpansionMode()` Deprecated. As of 3.1. Return value to be changed to `ResizableDoubleArray.ExpansionMode` in 4.0.
`(package private) int` `getInternalLength()` Deprecated. As of 3.1. Please use `getCapacity()` instead.
`double[]` `getInternalValues()` Deprecated. As of 3.1.
`int` `getNumElements()` Returns the number of elements currently in the array.
`protected int` `getStartIndex()` Returns the "start index" of the internal array.
`int` `hashCode()` Returns a hash code consistent with equals.
`void` `setContractionCriteria(float contractionCriteria)` Deprecated. As of 3.1 (to be removed in 4.0 as field will become "final").
`void` `setElement(int index, double value)` Sets the element at the specified index.
`void` `setExpansionFactor(float expansionFactor)` Deprecated. As of 3.1 (to be removed in 4.0 as field will become "final").
`void` `setExpansionMode(int expansionMode)` Deprecated. As of 3.1. Please use `setExpansionMode(ExpansionMode)` instead.
`void` `setExpansionMode(ResizableDoubleArray.ExpansionMode expansionMode)` Deprecated. As of 3.1 (to be removed in 4.0 as field will become "final").
`protected void` `setInitialCapacity(int initialCapacity)` Deprecated. As of 3.1, this is a no-op.
`void` `setNumElements(int i)` This function allows you to control the number of elements contained in this array, and can be used to "throw out" the last n values in an array.
`private boolean` `shouldContract()` Returns true if the internal storage array has too many unused storage positions.
`int` `start()` Deprecated. As of 3.1.
`double` `substituteMostRecentElement(double value)` Substitutes `value` for the most recently added value.

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

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

### Field Detail

#### ADDITIVE_MODE

    @Deprecated
    public static final int ADDITIVE_MODE

Deprecated. As of 3.1. Please use `ResizableDoubleArray.ExpansionMode.ADDITIVE` instead.
Additive expansion mode.

See Also:
  Constant Field Values

#### MULTIPLICATIVE_MODE

    @Deprecated
    public static final int MULTIPLICATIVE_MODE

Deprecated. As of 3.1. Please use `ResizableDoubleArray.ExpansionMode.MULTIPLICATIVE` instead.
Multiplicative expansion mode.

See Also:
  Constant Field Values

#### serialVersionUID

    private static final long serialVersionUID

Serializable version identifier.

See Also:
  Constant Field Values

#### DEFAULT_INITIAL_CAPACITY

    private static final int DEFAULT_INITIAL_CAPACITY

Default value for initial capacity.

See Also:
  Constant Field Values

#### DEFAULT_EXPANSION_FACTOR

    private static final double DEFAULT_EXPANSION_FACTOR

Default value for array size modifier.

See Also:
  Constant Field Values

#### DEFAULT_CONTRACTION_DELTA

    private static final double DEFAULT_CONTRACTION_DELTA

Default value for the difference between `contractionCriterion` and `expansionFactor`.

See Also:
  Constant Field Values

#### contractionCriterion

    private double contractionCriterion

The contraction criteria determines when the internal array will be contracted to fit the number of elements contained in the element array + 1.

#### expansionFactor

    private double expansionFactor

The expansion factor of the array. When the array needs to be expanded, the new array size will be `internalArray.length * expansionFactor` if `expansionMode` is set to MULTIPLICATIVE_MODE, or `internalArray.length + expansionFactor` if `expansionMode` is set to ADDITIVE_MODE.

#### expansionMode

    private ResizableDoubleArray.ExpansionMode expansionMode

Determines whether array expansion by `expansionFactor` is additive or multiplicative.

#### internalArray

    private double[] internalArray

The internal storage array.

#### numElements

    private int numElements

The number of addressable elements in the array. Note that this has nothing to do with the length of the internal storage array.

#### startIndex

    private int startIndex

The position of the first addressable element in the internal storage array. The addressable elements in the array are `internalArray[startIndex],...,internalArray[startIndex + numElements - 1]`.

### Constructor Detail

#### ResizableDoubleArray

    public ResizableDoubleArray()

Creates an instance with default properties.

- `initialCapacity = 16`
- `expansionMode = MULTIPLICATIVE`
- `expansionFactor = 2.0`
- `contractionCriterion = 2.5`

#### ResizableDoubleArray

    public ResizableDoubleArray(int initialCapacity)
                         throws MathIllegalArgumentException

Creates an instance with the specified initial capacity. Other properties take default values:

- `expansionMode = MULTIPLICATIVE`
- `expansionFactor = 2.0`
- `contractionCriterion = 2.5`

Parameters:
  `initialCapacity` - Initial size of the internal storage array.
Throws:
  `MathIllegalArgumentException` - if `initialCapacity <= 0`.

#### ResizableDoubleArray

    public ResizableDoubleArray(double[] initialArray)

Creates an instance from an existing `double[]` with the initial capacity and numElements corresponding to the size of the supplied `double[]` array. If the supplied array is null, a new empty array with the default initial capacity will be created. The input array is copied, not referenced. Other properties take default values:

- `initialCapacity = 16`
- `expansionMode = MULTIPLICATIVE`
- `expansionFactor = 2.0`
- `contractionCriterion = 2.5`

Parameters:
  `initialArray` - initial array
Since:
  2.2

#### ResizableDoubleArray

    @Deprecated
    public ResizableDoubleArray(int initialCapacity,
                                   float expansionFactor)
                         throws MathIllegalArgumentException

Deprecated. As of 3.1. Please use `ResizableDoubleArray(int,double)` instead.
Creates an instance with the specified initial capacity and expansion factor. The remaining properties take default values:

- `expansionMode = MULTIPLICATIVE`
- `contractionCriterion = 0.5 + expansionFactor`

Throws IllegalArgumentException if the following conditions are not met:

- `initialCapacity > 0`
- `expansionFactor > 1`

Parameters:
  `initialCapacity` - Initial size of the internal storage array.
  `expansionFactor` - The array will be expanded based on this parameter.
Throws:
  `MathIllegalArgumentException` - if parameters are not valid.

#### ResizableDoubleArray

    public ResizableDoubleArray(int initialCapacity,
                        double expansionFactor)
                         throws MathIllegalArgumentException

Creates an instance with the specified initial capacity and expansion factor. The remaining properties take default values:

- `expansionMode = MULTIPLICATIVE`
- `contractionCriterion = 0.5 + expansionFactor`

Throws IllegalArgumentException if the following conditions are not met:

- `initialCapacity > 0`
- `expansionFactor > 1`

Parameters:
  `initialCapacity` - Initial size of the internal storage array.
  `expansionFactor` - The array will be expanded based on this parameter.
Throws:
  `MathIllegalArgumentException` - if parameters are not valid.
Since:
  3.1

#### ResizableDoubleArray

    @Deprecated
    public ResizableDoubleArray(int initialCapacity,
                                   float expansionFactor,
                                   float contractionCriteria)
                         throws MathIllegalArgumentException

Deprecated. As of 3.1. Please use `ResizableDoubleArray(int,double,double)` instead.
Creates an instance with the specified initialCapacity, expansionFactor, and contractionCriterion. The expansion mode will default to `MULTIPLICATIVE`.
Throws IllegalArgumentException if the following conditions are not met:

- `initialCapacity > 0`
- `expansionFactor > 1`
- `contractionCriterion >= expansionFactor`

Parameters:
  `initialCapacity` - Initial size of the internal storage array..
  `expansionFactor` - The array will be expanded based on this parameter.
  `contractionCriteria` - Contraction criteria.
Throws:
  `MathIllegalArgumentException` - if parameters are not valid.

#### ResizableDoubleArray

    public ResizableDoubleArray(int initialCapacity,
                        double expansionFactor,
                        double contractionCriterion)
                         throws MathIllegalArgumentException

Creates an instance with the specified initial capacity, expansion factor, and contraction criteria. The expansion mode will default to `MULTIPLICATIVE`.
Throws IllegalArgumentException if the following conditions are not met:

- `initialCapacity > 0`
- `expansionFactor > 1`
- `contractionCriterion >= expansionFactor`

Parameters:
  `initialCapacity` - Initial size of the internal storage array..
  `expansionFactor` - The array will be expanded based on this parameter.
  `contractionCriterion` - Contraction criterion.
Throws:
  `MathIllegalArgumentException` - if the parameters are not valid.
Since:
  3.1

#### ResizableDoubleArray

    public ResizableDoubleArray(int initialCapacity,
                        float expansionFactor,
                        float contractionCriteria,
                        int expansionMode)
                         throws MathIllegalArgumentException

Deprecated. As of 3.1. Please use `ResizableDoubleArray(int,double,double,ExpansionMode,double[])` instead.

Create a ResizableArray with the specified properties.

Throws IllegalArgumentException if the following conditions are not met:

- `initialCapacity > 0`
- `expansionFactor > 1`
- `contractionFactor >= expansionFactor`
- `expansionMode in {MULTIPLICATIVE_MODE, ADDITIVE_MODE}`

Parameters:
  `initialCapacity` - the initial size of the internal storage array
  `expansionFactor` - the array will be expanded based on this parameter
  `contractionCriteria` - the contraction Criteria
  `expansionMode` - the expansion mode
Throws:
  `MathIllegalArgumentException` - if parameters are not valid

#### ResizableDoubleArray

    public ResizableDoubleArray(int initialCapacity,
                        double expansionFactor,
                        double contractionCriterion,
                        ResizableDoubleArray.ExpansionMode expansionMode,
                        double... data)
                         throws MathIllegalArgumentException

Creates an instance with the specified properties.
Throws MathIllegalArgumentException if the following conditions are not met:

- `initialCapacity > 0`
- `expansionFactor > 1`
- `contractionCriterion >= expansionFactor`

Parameters:
  `initialCapacity` - Initial size of the internal storage array.
  `expansionFactor` - The array will be expanded based on this parameter.
  `contractionCriterion` - Contraction criteria.
  `expansionMode` - Expansion mode.
  `data` - Initial contents of the array.
Throws:
  `MathIllegalArgumentException` - if the parameters are not valid.

#### ResizableDoubleArray

    public ResizableDoubleArray(ResizableDoubleArray original)
                         throws NullArgumentException

Copy constructor. Creates a new ResizableDoubleArray that is a deep, fresh copy of the original. Needs to acquire synchronization lock on original. Original may not be null; otherwise a `NullArgumentException` is thrown.

Parameters:
  `original` - array to copy
Throws:
  `NullArgumentException` - if original is null
Since:
  2.0

### Method Detail

#### addElement

    public void addElement(double value)

Adds an element to the end of this expandable array.

Specified by:
  `addElement` in interface `DoubleArray`
Parameters:
  `value` - Value to be added to end of array.

#### addElements

    public void addElements(double[] values)

Adds several element to the end of this expandable array.

Specified by:
  `addElements` in interface `DoubleArray`
Parameters:
  `values` - Values to be added to end of array.
Since:
  2.2

#### addElementRolling

    public double addElementRolling(double value)

Adds an element to the end of the array and removes the first element in the array. Returns the discarded first element. The effect is similar to a push operation in a FIFO queue.

Example: If the array contains the elements 1, 2, 3, 4 (in that order) and addElementRolling(5) is invoked, the result is an array containing the entries 2, 3, 4, 5 and the value returned is 1.

Specified by:
  `addElementRolling` in interface `DoubleArray`
Parameters:
  `value` - Value to be added to the array.
Returns:
  the value which has been discarded or "pushed" out of the array by this rolling insert.

#### substituteMostRecentElement

    public double substituteMostRecentElement(double value)
                                       throws MathIllegalStateException

Substitutes `value` for the most recently added value. Returns the value that has been replaced. If the array is empty (i.e. if `numElements` is zero), an IllegalStateException is thrown.

Parameters:
  `value` - New value to substitute for the most recently added value
Returns:
  the value that has been replaced in the array.
Throws:
  `MathIllegalStateException` - if the array is empty
Since:
  2.0

#### checkContractExpand

    protected void checkContractExpand(float contraction,
                           float expansion)
                                throws MathIllegalArgumentException

Deprecated. As of 3.1. Please use `checkContractExpand(double,double)` instead.
Checks the expansion factor and the contraction criterion and throws an IllegalArgumentException if the contractionCriteria is less than the expansionCriteria

Parameters:
  `expansion` - factor to be checked
  `contraction` - criteria to be checked
Throws:
  `MathIllegalArgumentException` - if the contractionCriteria is less than the expansionCriteria.

#### checkContractExpand

    protected void checkContractExpand(double contraction,
                           double expansion)
                                throws NumberIsTooSmallException

Checks the expansion factor and the contraction criterion and raises an exception if the contraction criterion is smaller than the expansion criterion.

Parameters:
  `contraction` - Criterion to be checked.
  `expansion` - Factor to be checked.
Throws:
  `NumberIsTooSmallException` - if `contraction < expansion`.
  `NumberIsTooSmallException` - if `contraction <= 1`.
  `NumberIsTooSmallException` - if `expansion <= 1` .
Since:
  3.1

#### clear

    public void clear()

Clear the array contents, resetting the number of elements to zero.

Specified by:
  `clear` in interface `DoubleArray`

#### contract

    public void contract()

Contracts the storage array to the (size of the element set) + 1 - to avoid a zero length array. This function also resets the startIndex to zero.

#### discardFrontElements

    public void discardFrontElements(int i)
                              throws MathIllegalArgumentException

Discards the `i` initial elements of the array. For example, if the array contains the elements 1,2,3,4, invoking `discardFrontElements(2)` will cause the first two elements to be discarded, leaving 3,4 in the array. Throws illegalArgumentException if i exceeds numElements.

Parameters:
  `i` - the number of elements to discard from the front of the array
Throws:
  `MathIllegalArgumentException` - if i is greater than numElements.
Since:
  2.0

#### discardMostRecentElements

    public void discardMostRecentElements(int i)
                                   throws MathIllegalArgumentException

Discards the `i` last elements of the array. For example, if the array contains the elements 1,2,3,4, invoking `discardMostRecentElements(2)` will cause the last two elements to be discarded, leaving 1,2 in the array. Throws illegalArgumentException if i exceeds numElements.

Parameters:
  `i` - the number of elements to discard from the end of the array
Throws:
  `MathIllegalArgumentException` - if i is greater than numElements.
Since:
  2.0

#### discardExtremeElements

    private void discardExtremeElements(int i,
                              boolean front)
                                 throws MathIllegalArgumentException

Discards the `i` first or last elements of the array, depending on the value of `front`. For example, if the array contains the elements 1,2,3,4, invoking `discardExtremeElements(2,false)` will cause the last two elements to be discarded, leaving 1,2 in the array. For example, if the array contains the elements 1,2,3,4, invoking `discardExtremeElements(2,true)` will cause the first two elements to be discarded, leaving 3,4 in the array. Throws illegalArgumentException if i exceeds numElements.

Parameters:
  `i` - the number of elements to discard from the front/end of the array
  `front` - true if elements are to be discarded from the front of the array, false if elements are to be discarded from the end of the array
Throws:
  `MathIllegalArgumentException` - if i is greater than numElements.
Since:
  2.0

#### expand

    protected void expand()

Expands the internal storage array using the expansion factor.

if `expansionMode` is set to MULTIPLICATIVE_MODE, the new array size will be `internalArray.length * expansionFactor.` If `expansionMode` is set to ADDITIVE_MODE, the length after expansion will be `internalArray.length + expansionFactor`

#### expandTo

    private void expandTo(int size)

Expands the internal storage array to the specified size.

Parameters:
  `size` - Size of the new internal storage array.

#### getContractionCriteria

    @Deprecated
    public float getContractionCriteria()

Deprecated. As of 3.1. Please use `getContractionCriterion()` instead.
The contraction criteria defines when the internal array will contract to store only the number of elements in the element array. If the `expansionMode` is `MULTIPLICATIVE_MODE`, contraction is triggered when the ratio between storage array length and `numElements` exceeds `contractionFactor`. If the `expansionMode` is `ADDITIVE_MODE`, the number of excess storage locations is compared to `contractionFactor.`

Returns:
  the contraction criteria used to reclaim memory.

#### getContractionCriterion

    public double getContractionCriterion()

The contraction criterion defines when the internal array will contract to store only the number of elements in the element array. If the `expansionMode` is `MULTIPLICATIVE_MODE`, contraction is triggered when the ratio between storage array length and `numElements` exceeds `contractionFactor`. If the `expansionMode` is `ADDITIVE_MODE`, the number of excess storage locations is compared to `contractionFactor.`

Returns:
  the contraction criterion used to reclaim memory.
Since:
  3.1

#### getElement

    public double getElement(int index)

Returns the element at the specified index

Specified by:
  `getElement` in interface `DoubleArray`
Parameters:
  `index` - index to fetch a value from
Returns:
  value stored at the specified index
Throws:
  `java.lang.ArrayIndexOutOfBoundsException` - if `index` is less than zero or is greater than `getNumElements() - 1`.

#### getElements

    public double[] getElements()

Returns a double array containing the elements of this `ResizableArray`. This method returns a copy, not a reference to the underlying array, so that changes made to the returned array have no effect on this `ResizableArray.`

Specified by:
  `getElements` in interface `DoubleArray`
Returns:
  the double array.

#### getExpansionFactor

    @Deprecated
    public float getExpansionFactor()

Deprecated. As of 3.1. Return type will be changed to "double" in 4.0.
The expansion factor controls the size of a new array when an array needs to be expanded. The `expansionMode` determines whether the size of the array is multiplied by the `expansionFactor` (MULTIPLICATIVE_MODE) or if the expansion is additive (ADDITIVE_MODE -- `expansionFactor` storage locations added). The default `expansionMode` is MULTIPLICATIVE_MODE and the default `expansionFactor` is 2.0.

Returns:
  the expansion factor of this expandable double array

#### getExpansionMode

    public int getExpansionMode()

Deprecated. As of 3.1. Return value to be changed to `ResizableDoubleArray.ExpansionMode` in 4.0.
The expansion mode determines whether the internal storage array grows additively or multiplicatively when it is expanded.

Returns:
  the expansion mode.

#### getInternalLength

    @Deprecated
    int getInternalLength()

Deprecated. As of 3.1. Please use `getCapacity()` instead.
Notice the package scope on this method. This method is simply here for the JUnit test, it allows us check if the expansion is working properly after a number of expansions. This is not meant to be a part of the public interface of this class.

Returns:
  the length of the internal storage array.

#### getCapacity

    public int getCapacity()

Gets the currently allocated size of the internal data structure used for storing elements. This is not to be confused with `the number of elements actually stored`.

Returns:
  the length of the internal array.
Since:
  3.1

#### getNumElements

    public int getNumElements()

Returns the number of elements currently in the array. Please note that this is different from the length of the internal storage array.

Specified by:
  `getNumElements` in interface `DoubleArray`
Returns:
  the number of elements.

#### getInternalValues

    @Deprecated
    public double[] getInternalValues()

Deprecated. As of 3.1.
Returns the internal storage array. Note that this method returns a reference to the internal storage array, not a copy, and to correctly address elements of the array, the `startIndex` is required (available via the `start()` method). This method should only be used in cases where copying the internal array is not practical. The `getElements()` method should be used in all other cases.

Returns:
  the internal storage array used by this object
Since:
  2.0

#### getArrayRef

    protected double[] getArrayRef()

Provides direct access to the internal storage array. Please note that this method returns a reference to this object's storage array, not a copy.
To correctly address elements of the array, the "start index" is required (available via the `getStartIndex` method.
This method should only be used to avoid copying the internal array. The returned value must be used for reading only; other uses could lead to this object becoming inconsistent.
The `getElements()` method has no such limitation since it returns a copy of this array's addressable elements.

Returns:
  the internal storage array used by this object.
Since:
  3.1

#### getStartIndex

    protected int getStartIndex()

Returns the "start index" of the internal array. This index is the position of the first addressable element in the internal storage array. The addressable elements in the array are at indices contained in the interval [`getStartIndex()`, `getStartIndex()` + `getNumElements()` - 1].

Returns:
  the start index.
Since:
  3.1

#### setContractionCriteria

    @Deprecated
    public void setContractionCriteria(float contractionCriteria)
                                throws MathIllegalArgumentException

Deprecated. As of 3.1 (to be removed in 4.0 as field will become "final").
Sets the contraction criteria.

Parameters:
  `contractionCriteria` - contraction criteria
Throws:
  `MathIllegalArgumentException` - if the contractionCriteria is less than the expansionCriteria.

#### compute

    public double compute(MathArrays.Function f)

Performs an operation on the addressable elements of the array.

Parameters:
  `f` - Function to be applied on this array.
Returns:
  the result.
Since:
  3.1

#### setElement

    public void setElement(int index,
                  double value)

Sets the element at the specified index. If the specified index is greater than `getNumElements() - 1`, the `numElements` property is increased to `index +1` and additional storage is allocated (if necessary) for the new element and all (uninitialized) elements between the new element and the previous end of the array).

Specified by:
  `setElement` in interface `DoubleArray`
Parameters:
  `index` - index to store a value in
  `value` - value to store at the specified index
Throws:
  `java.lang.ArrayIndexOutOfBoundsException` - if `index < 0`.

#### setExpansionFactor

    @Deprecated
    public void setExpansionFactor(float expansionFactor)
                            throws MathIllegalArgumentException

Deprecated. As of 3.1 (to be removed in 4.0 as field will become "final").
Sets the expansionFactor. Throws IllegalArgumentException if the the following conditions are not met:

- `expansionFactor > 1`
- `contractionFactor >= expansionFactor`

Parameters:
  `expansionFactor` - the new expansion factor value.
Throws:
  `MathIllegalArgumentException` - if expansionFactor is <= 1 or greater than contractionFactor

#### setExpansionMode

    @Deprecated
    public void setExpansionMode(int expansionMode)
                          throws MathIllegalArgumentException

Deprecated. As of 3.1. Please use `setExpansionMode(ExpansionMode)` instead.
Sets the `expansionMode`. The specified value must be one of ADDITIVE_MODE, MULTIPLICATIVE_MODE.

Parameters:
  `expansionMode` - The expansionMode to set.
Throws:
  `MathIllegalArgumentException` - if the specified mode value is not valid.

#### setExpansionMode

    @Deprecated
    public void setExpansionMode(ResizableDoubleArray.ExpansionMode expansionMode)

Deprecated. As of 3.1 (to be removed in 4.0 as field will become "final").
Sets the `expansion mode`.

Parameters:
  `expansionMode` - Expansion mode to use for resizing the array.

#### setInitialCapacity

    @Deprecated
    protected void setInitialCapacity(int initialCapacity)
                               throws MathIllegalArgumentException

Deprecated. As of 3.1, this is a no-op.
Sets the initial capacity. Should only be invoked by constructors.

Parameters:
  `initialCapacity` - of the array
Throws:
  `MathIllegalArgumentException` - if `initialCapacity` is not positive.

#### setNumElements

    public void setNumElements(int i)
                        throws MathIllegalArgumentException

This function allows you to control the number of elements contained in this array, and can be used to "throw out" the last n values in an array. This function will also expand the internal array as needed.

Parameters:
  `i` - a new number of elements
Throws:
  `MathIllegalArgumentException` - if `i` is negative.

#### shouldContract

    private boolean shouldContract()

Returns true if the internal storage array has too many unused storage positions.

Returns:
  true if array satisfies the contraction criteria

#### start

    @Deprecated
    public int start()

Deprecated. As of 3.1.
Returns the starting index of the internal array. The starting index is the position of the first addressable element in the internal storage array. The addressable elements in the array are `internalArray[startIndex],...,internalArray[startIndex + numElements -1]`

Returns:
  the starting index.

#### copy

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

Copies source to dest, copying the underlying data, so dest is a new, independent copy of source. Does not contract before the copy.

Obtains synchronization locks on both source and dest (in that order) before performing the copy.

Neither source nor dest may be null; otherwise a `NullArgumentException` is thrown

Parameters:
  `source` - ResizableDoubleArray to copy
  `dest` - ResizableArray to replace with a copy of the source array
Throws:
  `NullArgumentException` - if either source or dest is null
Since:
  2.0

#### copy

    public ResizableDoubleArray copy()

Returns a copy of the ResizableDoubleArray. Does not contract before the copy, so the returned object is an exact copy of this.

Returns:
  a new ResizableDoubleArray with the same data and configuration properties as this
Since:
  2.0

#### equals

    public boolean equals(java.lang.Object object)

Returns true iff object is a ResizableDoubleArray with the same properties as this and an identical internal storage array.

Overrides:
  `equals` in class `java.lang.Object`
Parameters:
  `object` - object to be compared for equality with this
Returns:
  true iff object is a ResizableDoubleArray with the same data and properties as this
Since:
  2.0

#### hashCode

    public int hashCode()

Returns a hash code consistent with equals.

Overrides:
  `hashCode` in class `java.lang.Object`
Returns:
  the hash code representing this `ResizableDoubleArray`.
Since:
  2.0