gnu.trove

## Class TDoubleArrayList

- java.lang.Object
- - gnu.trove.TDoubleArrayList

All Implemented Interfaces:
  java.io.Externalizable, java.io.Serializable, java.lang.Cloneable

    public class TDoubleArrayList
    extends java.lang.Object
    implements java.io.Externalizable, java.lang.Cloneable

A resizable, array-backed list of double primitives. Created: Sat Dec 29 14:21:12 2001

Author:
  Eric D. Friedman, Rob Eden
See Also:
  Serialized Form

### Field Summary

Fields
`protected double[]` `_data` the data of the list
`protected int` `_pos` the index after the last entry in the list
`protected static int` `DEFAULT_CAPACITY` the default capacity for new lists

### Constructor Summary

Constructors
Constructor and Description
`TDoubleArrayList()` Creates a new `TDoubleArrayList` instance with the default capacity.
`TDoubleArrayList(double[] values)` Creates a new `TDoubleArrayList` instance whose capacity is the greater of the length of `values` and DEFAULT_CAPACITY and whose initial contents are the specified values.
`TDoubleArrayList(int capacity)` Creates a new `TDoubleArrayList` instance with the specified capacity.

### Method Summary

Methods
`void` `add(double val)` Adds `val` to the end of the list, growing as needed.
`void` `add(double[] vals)` Adds the values in the array `vals` to the end of the list, in order.
`void` `add(double[] vals, int offset, int length)` Adds a subset of the values in the array `vals` to the end of the list, in order.
`int` `binarySearch(double value)` Performs a binary search for `value` in the entire list.
`int` `binarySearch(double value, int fromIndex, int toIndex)` Performs a binary search for `value` in the specified range.
`void` `clear()` Flushes the internal state of the list, resetting the capacity to the default.
`void` `clear(int capacity)` Flushes the internal state of the list, setting the capacity of the empty list to `capacity`.
`java.lang.Object` `clone()` Returns a clone of this list.
`boolean` `contains(double value)` Searches the list for `value`
`void` `ensureCapacity(int capacity)` Grow the internal array as needed to accommodate the specified number of elements.
`boolean` `equals(java.lang.Object other)` Compares this list to another list, value by value.
`void` `fill(double val)` Fills every slot in the list with the specified value.
`void` `fill(int fromIndex, int toIndex, double val)` Fills a range in the list with the specified value.
`boolean` `forEach(TDoubleProcedure procedure)` Applies the procedure to each value in the list in ascending (front to back) order.
`boolean` `forEachDescending(TDoubleProcedure procedure)` Applies the procedure to each value in the list in descending (back to front) order.
`double` `get(int offset)` Returns the value at the specified offset.
`double` `getQuick(int offset)` Returns the value at the specified offset without doing any bounds checking.
`double` `getSet(int offset, double val)` Sets the value at the specified offset and returns the previously stored value.
`TDoubleArrayList` `grep(TDoubleProcedure condition)` Searches the list for values satisfying `condition` in the manner of the *nix `grep` utility.
`int` `hashCode()`
`int` `indexOf(double value)` Searches the list front to back for the index of `value`.
`int` `indexOf(int offset, double value)` Searches the list front to back for the index of `value`, starting at `offset`.
`void` `insert(int offset, double value)` Inserts `value` into the list at `offset`.
`void` `insert(int offset, double[] values)` Inserts the array of `values` into the list at `offset`.
`void` `insert(int offset, double[] values, int valOffset, int len)` Inserts a slice of the array of `values` into the list at `offset`.
`TDoubleArrayList` `inverseGrep(TDoubleProcedure condition)` Searches the list for values which do not satisfy `condition`.
`boolean` `isEmpty()` Tests whether this list contains any values.
`int` `lastIndexOf(double value)` Searches the list back to front for the last index of `value`.
`int` `lastIndexOf(int offset, double value)` Searches the list back to front for the last index of `value`, starting at `offset`.
`double` `max()` Finds the maximum value in the list.
`double` `min()` Finds the minimum value in the list.
`void` `readExternal(java.io.ObjectInput in)`
`double` `remove(int offset)` Removes the value at `offset` from the list.
`void` `remove(int offset, int length)` Removes `length` values from the list, starting at `offset`
`void` `reset()` Sets the size of the list to 0, but does not change its capacity.
`void` `resetQuick()` Sets the size of the list to 0, but does not change its capacity.
`void` `reverse()` Reverse the order of the elements in the list.
`void` `reverse(int from, int to)` Reverse the order of the elements in the range of the list.
`void` `set(int offset, double val)` Sets the value at the specified offset.
`void` `set(int offset, double[] values)` Replace the values in the list starting at `offset` with the contents of the `values` array.
`void` `set(int offset, double[] values, int valOffset, int length)` Replace the values in the list starting at `offset` with `length` values from the `values` array, starting at valOffset.
`void` `setQuick(int offset, double val)` Sets the value at the specified offset without doing any bounds checking.
`void` `shuffle(java.util.Random rand)` Shuffle the elements of the list using the specified random number generator.
`int` `size()` Returns the number of values in the list.
`void` `sort()` Sort the values in the list (ascending) using the Sun quicksort implementation.
`void` `sort(int fromIndex, int toIndex)` Sort a slice of the list (ascending) using the Sun quicksort implementation.
`TDoubleArrayList` `subList(int begin, int end)` Returns a sublist of this list.
`double[]` `toNativeArray()` Copies the contents of the list into a native array.
`void` `toNativeArray(double[] dest, int offset, int len)` Copies a slice of the list into a native array.
`double[]` `toNativeArray(int offset, int len)` Copies a slice of the list into a native array.
`java.lang.String` `toString()` Returns a String representation of the list, front to back.
`void` `transformValues(TDoubleFunction function)` Transform each value in the list using the specified function.
`void` `trimToSize()` Sheds any excess capacity above and beyond the current size of the list.
`void` `writeExternal(java.io.ObjectOutput out)`

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

`finalize, getClass, notify, notifyAll, wait, wait, wait`

### Field Detail

#### _data

    protected double[] _data

the data of the list

#### _pos

    protected int _pos

the index after the last entry in the list

#### DEFAULT_CAPACITY

    protected static final int DEFAULT_CAPACITY

the default capacity for new lists

See Also:
  Constant Field Values

### Constructor Detail

#### TDoubleArrayList

    public TDoubleArrayList()

Creates a new `TDoubleArrayList` instance with the default capacity.

#### TDoubleArrayList

    public TDoubleArrayList(int capacity)

Creates a new `TDoubleArrayList` instance with the specified capacity.

Parameters:
  `capacity` - an `int` value

#### TDoubleArrayList

    public TDoubleArrayList(double[] values)

Creates a new `TDoubleArrayList` instance whose capacity is the greater of the length of `values` and DEFAULT_CAPACITY and whose initial contents are the specified values.

Parameters:
  `values` - an `double[]` value

### Method Detail

#### ensureCapacity

    public void ensureCapacity(int capacity)

Grow the internal array as needed to accommodate the specified number of elements. The size of the array doubles on each resize unless `capacity` requires more than twice the current capacity.

Parameters:
  `capacity` - an `int` value

#### size

    public int size()

Returns the number of values in the list.

Returns:
  the number of values in the list.

#### isEmpty

    public boolean isEmpty()

Tests whether this list contains any values.

Returns:
  true if the list is empty.

#### trimToSize

    public void trimToSize()

Sheds any excess capacity above and beyond the current size of the list.

#### add

    public void add(double val)

Adds `val` to the end of the list, growing as needed.

Parameters:
  `val` - an `double` value

#### add

    public void add(double[] vals)

Adds the values in the array `vals` to the end of the list, in order.

Parameters:
  `vals` - an `double[]` value

#### add

    public void add(double[] vals,
           int offset,
           int length)

Adds a subset of the values in the array `vals` to the end of the list, in order.

Parameters:
  `vals` - an `double[]` value
  `offset` - the offset at which to start copying
  `length` - the number of values to copy.

#### insert

    public void insert(int offset,
              double value)

Inserts `value` into the list at `offset`. All values including and to the right of `offset` are shifted to the right.

Parameters:
  `offset` - an `int` value
  `value` - an `double` value

#### insert

    public void insert(int offset,
              double[] values)

Inserts the array of `values` into the list at `offset`. All values including and to the right of `offset` are shifted to the right.

Parameters:
  `offset` - an `int` value
  `values` - an `double[]` value

#### insert

    public void insert(int offset,
              double[] values,
              int valOffset,
              int len)

Inserts a slice of the array of `values` into the list at `offset`. All values including and to the right of `offset` are shifted to the right.

Parameters:
  `offset` - an `int` value
  `values` - an `double[]` value
  `valOffset` - the offset in the values array at which to start copying.
  `len` - the number of values to copy from the values array

#### get

    public double get(int offset)

Returns the value at the specified offset.

Parameters:
  `offset` - an `int` value
Returns:
  an `double` value

#### getQuick

    public double getQuick(int offset)

Returns the value at the specified offset without doing any bounds checking.

Parameters:
  `offset` - an `int` value
Returns:
  an `double` value

#### set

    public void set(int offset,
           double val)

Sets the value at the specified offset.

Parameters:
  `offset` - an `int` value
  `val` - an `double` value

#### getSet

    public double getSet(int offset,
                double val)

Sets the value at the specified offset and returns the previously stored value.

Parameters:
  `offset` - an `int` value
  `val` - an `double` value
Returns:
  the value previously stored at offset.

#### set

    public void set(int offset,
           double[] values)

Replace the values in the list starting at `offset` with the contents of the `values` array.

Parameters:
  `offset` - the first offset to replace
  `values` - the source of the new values

#### set

    public void set(int offset,
           double[] values,
           int valOffset,
           int length)

Replace the values in the list starting at `offset` with `length` values from the `values` array, starting at valOffset.

Parameters:
  `offset` - the first offset to replace
  `values` - the source of the new values
  `valOffset` - the first value to copy from the values array
  `length` - the number of values to copy

#### setQuick

    public void setQuick(int offset,
                double val)

Sets the value at the specified offset without doing any bounds checking.

Parameters:
  `offset` - an `int` value
  `val` - an `double` value

#### clear

    public void clear()

Flushes the internal state of the list, resetting the capacity to the default.

#### clear

    public void clear(int capacity)

Flushes the internal state of the list, setting the capacity of the empty list to `capacity`.

Parameters:
  `capacity` - an `int` value

#### reset

    public void reset()

Sets the size of the list to 0, but does not change its capacity. This method can be used as an alternative to the `clear` method if you want to recyle a list without allocating new backing arrays.

See Also:
  `clear()`

#### resetQuick

    public void resetQuick()

Sets the size of the list to 0, but does not change its capacity. This method can be used as an alternative to the `clear` method if you want to recyle a list without allocating new backing arrays. This method differs from `reset` in that it does not clear the old values in the backing array. Thus, it is possible for `getQuick` to return stale data if this method is used and the caller is careless about bounds checking.

See Also:
  `reset()`, `clear()`, `getQuick(int)`

#### remove

    public double remove(int offset)

Removes the value at `offset` from the list.

Parameters:
  `offset` - an `int` value
Returns:
  the value previously stored at offset.

#### remove

    public void remove(int offset,
              int length)

Removes `length` values from the list, starting at `offset`

Parameters:
  `offset` - an `int` value
  `length` - an `int` value

#### transformValues

    public void transformValues(TDoubleFunction function)

Transform each value in the list using the specified function.

Parameters:
  `function` - a `TDoubleFunction` value

#### reverse

    public void reverse()

Reverse the order of the elements in the list.

#### reverse

    public void reverse(int from,
               int to)

Reverse the order of the elements in the range of the list.

Parameters:
  `from` - the inclusive index at which to start reversing
  `to` - the exclusive index at which to stop reversing

#### shuffle

    public void shuffle(java.util.Random rand)

Shuffle the elements of the list using the specified random number generator.

Parameters:
  `rand` - a `Random` value

#### clone

    public java.lang.Object clone()

Returns a clone of this list. Since this is a primitive collection, this will be a deep clone.

Overrides:
  `clone` in class `java.lang.Object`
Returns:
  a deep clone of the list.

#### subList

    public TDoubleArrayList subList(int begin,
                           int end)

Returns a sublist of this list.

Parameters:
  `begin` - low endpoint (inclusive) of the subList.
  `end` - high endpoint (exclusive) of the subList.
Returns:
  sublist of this list from begin, inclusive to end, exclusive.
Throws:
  `java.lang.IndexOutOfBoundsException` - - endpoint out of range
  `java.lang.IllegalArgumentException` - - endpoints out of order (end > begin)

#### toNativeArray

    public double[] toNativeArray()

Copies the contents of the list into a native array.

Returns:
  an `double[]` value

#### toNativeArray

    public double[] toNativeArray(int offset,
                         int len)

Copies a slice of the list into a native array.

Parameters:
  `offset` - the offset at which to start copying
  `len` - the number of values to copy.
Returns:
  an `double[]` value

#### toNativeArray

    public void toNativeArray(double[] dest,
                     int offset,
                     int len)

Copies a slice of the list into a native array.

Parameters:
  `dest` - the array to copy into.
  `offset` - the offset of the first value to copy
  `len` - the number of values to copy.

#### equals

    public boolean equals(java.lang.Object other)

Compares this list to another list, value by value.

Overrides:
  `equals` in class `java.lang.Object`
Parameters:
  `other` - the object to compare against
Returns:
  true if other is a TDoubleArrayList and has exactly the same values.

#### hashCode

    public int hashCode()

Overrides:
  `hashCode` in class `java.lang.Object`

#### forEach

    public boolean forEach(TDoubleProcedure procedure)

Applies the procedure to each value in the list in ascending (front to back) order.

Parameters:
  `procedure` - a `TDoubleProcedure` value
Returns:
  true if the procedure did not terminate prematurely.

#### forEachDescending

    public boolean forEachDescending(TDoubleProcedure procedure)

Applies the procedure to each value in the list in descending (back to front) order.

Parameters:
  `procedure` - a `TDoubleProcedure` value
Returns:
  true if the procedure did not terminate prematurely.

#### sort

    public void sort()

Sort the values in the list (ascending) using the Sun quicksort implementation.

See Also:
  `Arrays.sort(int[])`

#### sort

    public void sort(int fromIndex,
            int toIndex)

Sort a slice of the list (ascending) using the Sun quicksort implementation.

Parameters:
  `fromIndex` - the index at which to start sorting (inclusive)
  `toIndex` - the index at which to stop sorting (exclusive)
See Also:
  `Arrays.sort(int[])`

#### fill

    public void fill(double val)

Fills every slot in the list with the specified value.

Parameters:
  `val` - the value to use when filling

#### fill

    public void fill(int fromIndex,
            int toIndex,
            double val)

Fills a range in the list with the specified value.

Parameters:
  `fromIndex` - the offset at which to start filling (inclusive)
  `toIndex` - the offset at which to stop filling (exclusive)
  `val` - the value to use when filling

#### binarySearch

    public int binarySearch(double value)

Performs a binary search for `value` in the entire list. Note that you must @{link #sort sort} the list before doing a search.

Parameters:
  `value` - the value to search for
Returns:
  the absolute offset in the list of the value, or its negative insertion point into the sorted list.

#### binarySearch

    public int binarySearch(double value,
                   int fromIndex,
                   int toIndex)

Performs a binary search for `value` in the specified range. Note that you must @{link #sort sort} the list or the range before doing a search.

Parameters:
  `value` - the value to search for
  `fromIndex` - the lower boundary of the range (inclusive)
  `toIndex` - the upper boundary of the range (exclusive)
Returns:
  the absolute offset in the list of the value, or its negative insertion point into the sorted list.

#### indexOf

    public int indexOf(double value)

Searches the list front to back for the index of `value`.

Parameters:
  `value` - an `double` value
Returns:
  the first offset of the value, or -1 if it is not in the list.
See Also:
  `for faster searches on sorted lists`

#### indexOf

    public int indexOf(int offset,
              double value)

Searches the list front to back for the index of `value`, starting at `offset`.

Parameters:
  `offset` - the offset at which to start the linear search (inclusive)
  `value` - an `double` value
Returns:
  the first offset of the value, or -1 if it is not in the list.
See Also:
  `for faster searches on sorted lists`

#### lastIndexOf

    public int lastIndexOf(double value)

Searches the list back to front for the last index of `value`.

Parameters:
  `value` - an `double` value
Returns:
  the last offset of the value, or -1 if it is not in the list.
See Also:
  `for faster searches on sorted lists`

#### lastIndexOf

    public int lastIndexOf(int offset,
                  double value)

Searches the list back to front for the last index of `value`, starting at `offset`.

Parameters:
  `offset` - the offset at which to start the linear search (exclusive)
  `value` - an `double` value
Returns:
  the last offset of the value, or -1 if it is not in the list.
See Also:
  `for faster searches on sorted lists`

#### contains

    public boolean contains(double value)

Searches the list for `value`

Parameters:
  `value` - an `double` value
Returns:
  true if value is in the list.

#### grep

    public TDoubleArrayList grep(TDoubleProcedure condition)

Searches the list for values satisfying `condition` in the manner of the *nix `grep` utility.

Parameters:
  `condition` - a condition to apply to each element in the list
Returns:
  a list of values which match the condition.

#### inverseGrep

    public TDoubleArrayList inverseGrep(TDoubleProcedure condition)

Searches the list for values which do not satisfy `condition`. This is akin to *nix `grep -v`.

Parameters:
  `condition` - a condition to apply to each element in the list
Returns:
  a list of values which do not match the condition.

#### max

    public double max()

Finds the maximum value in the list.

Returns:
  the largest value in the list.
Throws:
  `java.lang.IllegalStateException` - if the list is empty

#### min

    public double min()

Finds the minimum value in the list.

Returns:
  the smallest value in the list.
Throws:
  `java.lang.IllegalStateException` - if the list is empty

#### toString

    public java.lang.String toString()

Returns a String representation of the list, front to back.

Overrides:
  `toString` in class `java.lang.Object`
Returns:
  a `String` value

#### writeExternal

    public void writeExternal(java.io.ObjectOutput out)
                       throws java.io.IOException

Specified by:
  `writeExternal` in interface `java.io.Externalizable`
Throws:
  `java.io.IOException`

#### readExternal

    public void readExternal(java.io.ObjectInput in)
                      throws java.io.IOException,
                             java.lang.ClassNotFoundException

Specified by:
  `readExternal` in interface `java.io.Externalizable`
Throws:
  `java.io.IOException`
  `java.lang.ClassNotFoundException`