DoubleArrayList (math-base 1.0.0 API)

java.lang.Object
- math.list.DoubleArrayList

All Implemented Interfaces:

Externalizable, Serializable, Cloneable, DoubleList
```
public class DoubleArrayList
extends Object
implements DoubleList, Cloneable, Externalizable
```
Resizable primitive double[] array implementation. This is essentially a shameless stripped-down copy of ArrayList specialized for primitive doubles and augmented with mathematical vector operations.

See Also:

Serialized Form

Constructor Summary

Constructors
Constructor and Description
`DoubleArrayList()` Constructs an empty list with an initial capacity of ten.
`DoubleArrayList(double[] c)` Constructs a list containing the elements of the specified array, in the order they appear in the array.
`DoubleArrayList(DoubleList c)` Constructs a list containing the elements of the specified list, in the order they are returned by the list's `DoubleList.toArray()` method.
`DoubleArrayList(int initialCapacity)` Constructs an empty list with the specified initial capacity.
`DoubleArrayList(int initialLength, double initialValue)` Constructs a list with length `initialLength` where all elements have `initialValue` as initial value.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`add(double e)` Appends the specified element to the end of this list.
`void`	`add(int index, double element)` Inserts the specified element at the specified position in this list.
`boolean`	`addAll(DoubleList c)` Appends all of the elements in the specified list to the end of this list, in the order that they are returned by the specified list's DIterator.
`boolean`	`addAll(int index, DoubleList c)` Inserts all of the elements in the specified list into this list, starting at the specified position.
`DoubleList`	`assignConst(double val)` Assign the constant `val` to each element in this list.
`double`	`avg()` Returns the average value of the elements in this list if this list has at least one element, otherwise throws `NoSuchElementException`.
`void`	`clear()` Removes all of the elements from this list.
`Object`	`clone()` Returns a deep copy of this `DoubleArrayList` instance.
`boolean`	`contains(double o)` Returns `true` if this list contains the specified element.
`boolean`	`containsAll(DoubleList c)` Returns `true` if this DoubleList contains all of the elements in the specified DoubleList.
`DoubleList`	`cross(double[] array)` Computes the cross product of this DoubleList and the given `array` provided that both, this DoubleList and the given `array`, have a dimension of 3.
`DoubleList`	`cross(DoubleList list)` Computes the cross product of this DoubleList and the given `list` provided that both, this DoubleList and the given `list`, have a dimension of 3.
`double`	`dot(double[] array)` Computes the dot product of this list and the given `array`.
`double`	`dot(DoubleList list)` Computes the dot product of this list and the given `list`.
`void`	`ensureCapacity(int minCapacity)` Increases the capacity of this `DoubleArrayList` instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
`boolean`	`equals(Object o)` Compares the specified object with this DoubleList for equality.
`void`	`forEach(DoubleConsumer action)` Performs the given action for each element of this list in the order of iteration until all elements have been processed or the action throws an exception.
`double`	`get(int index)` Returns the element at the specified position in this list.
`double[]`	`getArrayUnsafe()` Returns the underlying array as an escape hatch.
`int`	`hashCode()` Returns the hash code value for this DoubleList.
`int`	`indexOf(double o)` Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
`boolean`	`isEmpty()` Returns `true` if this list contains no elements.
`DForEachIterator`	`iterator()` Returns an iterator over the elements in this list in proper sequence.
`int`	`lastIndexOf(double o)` Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
`DListIterator`	`listIterator()` Returns a list iterator over the elements in this list (in proper sequence).
`DListIterator`	`listIterator(int index)` Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.
`double`	`logSumExp()` Returns the logarithm of the sum of the exponentials of this list (see LogSumExp) if it has at least one element, otherwise `NoSuchElementException` is thrown.
`double`	`max()` Returns the maximum of the elements in this list if this list has at least one element, otherwise throws `NoSuchElementException`.
`double`	`median()` Returns the median value of the elements in this list if this list has at least one element, otherwise throws `NoSuchElementException`.
`double`	`min()` Returns the minimum of the elements in this list if this list has at least one element, otherwise throws `NoSuchElementException`.
`DoubleList`	`mul(double val)` Multiply each element in this list by the scalar `val`.
`double`	`muli(int index, double val)` Multiply the element at `index` by the scalar `val`.
`DoubleList`	`muln(double[] array)` Multiplies the scalars from this list by the scalars from the given `array`.
`DoubleList`	`muln(DoubleList list)` Multiplies the scalars from this list by the scalars from the given `list`.
`double`	`norm2()` Computes the euclidean norm (magnitude) of this list.
`DoubleList`	`normalizedSoftmax(double normalizedSum)` Returns a new list that contains the contents of this list normalized to a distribution according to the softmax function which sums up to `normalizedSum`.
`static DoubleArrayList`	`of(double... values)` Constructs a list containing the passed values in the order of their appearance.
`int`	`offset()` Returns the offset of this list.
`DoubleList`	`plus(double val)` Add the scalar `val` to each element in this list.
`double`	`plusi(int index, double val)` Add the scalar `val` to the element at `index`.
`DoubleList`	`plusn(double[] array)` Add the scalars from the given `array` to the elements in this list.
`DoubleList`	`plusn(DoubleList list)` Add the scalars from the given `list` to the elements in this list.
`static DoubleArrayList`	`randomNormal(double mu, double sigma, int size)` Constructs a random list of length `size` with random values normally distributed with mean `mu` and standard deviation `sigma`.
`static DoubleArrayList`	`randomUniform(double min, double max, int size)` Constructs a random list of length `size` with random values uniformly distributed between `min` and `max`.
`void`	`readExternal(ObjectInput in)`
`boolean`	`remove(double o)` Removes the first occurrence of the specified element from this list, if it is present.
`double`	`remove(int index)` Removes the element at the specified position in this list.
`boolean`	`removeAll(DoubleList c)` Removes from this list all of its elements that are contained in the specified list.
`protected void`	`removeRange(int fromIndex, int toIndex)` Removes from this list all of the elements whose index is between `fromIndex`, inclusive, and `toIndex`, exclusive.
`boolean`	`retainAll(DoubleList c)` Retains only the elements in this list that are contained in the specified list.
`DoubleList`	`round(int scale)` Round the scalars in this list to `scale`.
`DoubleList`	`sanitizeNonFinite(double nanSurrogate, double posInfSurrogate, double negInfSurrogate)` Set all scalars that are either NaN, positive or negative infinity to the respective ersatz value provided by the `nanSurrogate`, `posInfSurrogate` and `negInfSurrogate` arguments.
`double`	`set(int index, double element)` Replaces the element at the specified position in this list with the specified element.
`int`	`size()` Returns the number of elements in this list.
`DoubleList`	`softmax()` Returns a new list that contains the contents of this list normalized to a probability distribution according to the softmax function which sums up to `1.0`.
`void`	`sort()` Sorts this list in ascending order.
`Spliterator.OfDouble`	`spliterator()` Creates a late-binding and fail-fast `Spliterator` over the elements in this list.
`double`	`stddev()` Returns the standard deviation of the elements in this list if this list has at least two elements, otherwise throws `IllegalArgumentException`.
`DoubleList`	`subList(int fromIndex, int toIndex)` Returns a view of the portion of this list between the specified `fromIndex`, inclusive, and `toIndex`, exclusive.
`double`	`sum()` Returns the sum of the elements in this list.
`double[]`	`toArray()` Returns an array containing all of the elements in this list in proper sequence (from first to last element).
`String`	`toString()`
`void`	`trimToSize()` Trims the capacity of this `DoubleArrayList` instance to be the list's current size.
`void`	`writeExternal(ObjectOutput out)`

Methods inherited from class java.lang.Object
finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface math.list.DoubleList
approxEqual, approxEqual, parallelStream, stream

- Constructor Detail
  - DoubleArrayList
```
public DoubleArrayList(int initialCapacity)
```
    Constructs an empty list with the specified initial capacity.
    
    Parameters:
    
    initialCapacity - the initial capacity of the list
    
    Throws:
    
    IllegalArgumentException - if the specified initial capacity is negative
  - DoubleArrayList
```
public DoubleArrayList(int initialLength,
                       double initialValue)
```
    Constructs a list with length initialLength where all elements have initialValue as initial value.
    
    Parameters:
    
    initialLength - the initial length of the list
    
    initialValue - the initial value of all elements in the list
    
    Throws:
    
    IllegalArgumentException - if the specified initial length is negative
  - DoubleArrayList
```
public DoubleArrayList()
```
    Constructs an empty list with an initial capacity of ten.
  - DoubleArrayList
```
public DoubleArrayList(double[] c)
```
    Constructs a list containing the elements of the specified array, in the order they appear in the array.
    
    Parameters:
    
    c - the array whose elements are to be placed into this list
    
    Throws:
    
    NullPointerException - if the specified array is null
  - DoubleArrayList
```
public DoubleArrayList(DoubleList c)
```
    Constructs a list containing the elements of the specified list, in the order they are returned by the list's DoubleList.toArray() method.
    
    Parameters:
    
    c - the list whose elements are to be placed into this list
    
    Throws:
    
    NullPointerException - if the specified list is null
- Method Detail
  - of
```
public static DoubleArrayList of(double... values)
```
    Constructs a list containing the passed values in the order of their appearance.
    
    Specified by:
    
    of in interface DoubleList
    
    Parameters:
    
    values - the values which are to be placed into the list
    
    Returns:
    
    a new DoubleArrayList constructed from the passed values
  - randomUniform
```
public static DoubleArrayList randomUniform(double min,
                                            double max,
                                            int size)
```
    Constructs a random list of length size with random values uniformly distributed between min and max.
    
    Specified by:
    
    randomUniform in interface DoubleList
    
    Parameters:
    
    min - lower bound of the uniform distribution
    
    max - upper bound of the uniform distribution
    
    size - length of the list
    
    Returns:
    
    a random list of length size
  - randomNormal
```
public static DoubleArrayList randomNormal(double mu,
                                           double sigma,
                                           int size)
```
    Constructs a random list of length size with random values normally distributed with mean mu and standard deviation sigma.
    
    Specified by:
    
    randomNormal in interface DoubleList
    
    Parameters:
    
    mu - mean (expectation) of the normal distribution
    
    sigma - standard deviation of the normal distribution, must be > 0.0
    
    size - length of the list
    
    Returns:
    
    a random list of length size
  - trimToSize
```
public void trimToSize()
```
    Trims the capacity of this DoubleArrayList instance to be the list's current size. An application can use this operation to minimize the storage of an DoubleArrayList instance.
  - ensureCapacity
```
public void ensureCapacity(int minCapacity)
```
    Increases the capacity of this DoubleArrayList instance, if necessary, to ensure that it can hold at least the number of elements specified by the minimum capacity argument.
    
    Parameters:
    
    minCapacity - the desired minimum capacity
  - size
```
public int size()
```
    Returns the number of elements in this list.
    
    Specified by:
    
    size in interface DoubleList
    
    Returns:
    
    the number of elements in this list
  - isEmpty
```
public boolean isEmpty()
```
    Returns true if this list contains no elements.
    
    Specified by:
    
    isEmpty in interface DoubleList
    
    Returns:
    
    true if this list contains no elements
  - contains
```
public boolean contains(double o)
```
    Returns true if this list contains the specified element. More formally, returns true if and only if this list contains at least one element e such that o == e.
    
    Specified by:
    
    contains in interface DoubleList
    
    Parameters:
    
    o - element whose presence in this list is to be tested
    
    Returns:
    
    true if this list contains the specified element
  - containsAll
```
public boolean containsAll(DoubleList c)
```
    Returns true if this DoubleList contains all of the elements in the specified DoubleList.
    
    Specified by:
    
    containsAll in interface DoubleList
    
    Parameters:
    
    c - DoubleList to be checked for containment in this DoubleList
    
    Returns:
    
    true if this DoubleList contains all of the elements in the specified DoubleList
  - indexOf
```
public int indexOf(double o)
```
    Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element. More formally, returns the lowest index i such that o == get(i), or -1 if there is no such index.
    
    Specified by:
    
    indexOf in interface DoubleList
    
    Parameters:
    
    o - element to search for
    
    Returns:
    
    index of the first occurrence, or -1 if not found
  - lastIndexOf
```
public int lastIndexOf(double o)
```
    Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element. More formally, returns the highest index i such that o == get(i), or -1 if there is no such index.
    
    Specified by:
    
    lastIndexOf in interface DoubleList
    
    Parameters:
    
    o - element to search for
    
    Returns:
    
    index of the last occurrence, or -1 if not found
  - clone
```
public Object clone()
```
    Returns a deep copy of this DoubleArrayList instance.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    
    a clone of this DoubleArrayList instance
  - toArray
```
public double[] toArray()
```
    Returns an array containing all of the elements in this list in proper sequence (from first to last element).
    The returned array will be "safe" in that no references to it are maintained by this list. (In other words, this method must allocate a new array). The caller is thus free to modify the returned array.
    
    Specified by:
    
    toArray in interface DoubleList
    
    Returns:
    
    an array containing all of the elements in this list in proper sequence
  - get
```
public double get(int index)
```
    Returns the element at the specified position in this list.
    
    Specified by:
    
    get in interface DoubleList
    
    Parameters:
    
    index - index of the element to return
    
    Returns:
    
    the element at the specified position in this list
  - set
```
public double set(int index,
                  double element)
```
    Replaces the element at the specified position in this list with the specified element.
    
    Specified by:
    
    set in interface DoubleList
    
    Parameters:
    
    index - index of the element to replace
    
    element - element to be stored at the specified position
    
    Returns:
    
    the element previously at the specified position
  - add
```
public boolean add(double e)
```
    Appends the specified element to the end of this list.
    
    Specified by:
    
    add in interface DoubleList
    
    Parameters:
    
    e - element to be appended to this list
    
    Returns:
    
    true
  - add
```
public void add(int index,
                double element)
```
    Inserts the specified element at the specified position in this list. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    
    Specified by:
    
    add in interface DoubleList
    
    Parameters:
    
    index - index at which the specified element is to be inserted
    
    element - element to be inserted
  - remove
```
public double remove(int index)
```
    Removes the element at the specified position in this list. Shifts any subsequent elements to the left (subtracts one from their indices).
    
    Specified by:
    
    remove in interface DoubleList
    
    Parameters:
    
    index - the index of the element to be removed
    
    Returns:
    
    the element that was removed from the list
  - equals
```
public boolean equals(Object o)
```
    Compares the specified object with this DoubleList for equality. Returns true if and only if the specified object is also a DoubleList, both lists have the same size, and all corresponding pairs of elements in the two lists are equal. In other words, two DoubleList are defined to be equal if they contain the same elements in the same order.
    
    Specified by:
    
    equals in interface DoubleList
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    o - the object to be compared for equality with this DoubleList
    
    Returns:
    
    true if the specified object is equal to this DoubleList
  - hashCode
```
public int hashCode()
```
    Returns the hash code value for this DoubleList. The hash code of a DoubleList is defined to be the result of the following calculation:
```
  int hashCode = 1;
  for (int i = 0; i < list.size(); i++) {
      hashCode = 31 * hashCode + Double.hashCode(list.get(i));
  }
 
 
```
    This ensures that list1.equals(list2) implies that list1.hashCode()==list2.hashCode() for any two DoubleLists, list1 and list2, as required by the general contract of Object.hashCode().
    Specified by:
    
    hashCode in interface DoubleList
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    the hash code value for this DoubleList
  - remove
```
public boolean remove(double o)
```
    Removes the first occurrence of the specified element from this list, if it is present. If the list does not contain the element, it is unchanged. More formally, removes the element with the lowest index i such that o == get(i) (if such an element exists). Returns true if this list contained the specified element (or equivalently, if this list changed as a result of the call).
    
    Specified by:
    
    remove in interface DoubleList
    
    Parameters:
    
    o - element to be removed from this list, if present
    
    Returns:
    
    true if this list contained the specified element
  - clear
```
public void clear()
```
    Removes all of the elements from this list. The list will be empty after this call returns.
    
    Specified by:
    
    clear in interface DoubleList
  - addAll
```
public boolean addAll(DoubleList c)
```
    Appends all of the elements in the specified list to the end of this list, in the order that they are returned by the specified list's DIterator. The behavior of this operation is undefined if the specified list is modified while the operation is in progress. (This implies that the behavior of this call is undefined if the specified list is this list, and this list is nonempty.)
    
    Specified by:
    
    addAll in interface DoubleList
    
    Parameters:
    
    c - list containing elements to be added to this list
    
    Returns:
    
    true if this list changed as a result of the call
  - addAll
```
public boolean addAll(int index,
                      DoubleList c)
```
    Inserts all of the elements in the specified list into this list, starting at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in the list in the order that they are returned by the specified list's iterator.
    
    Specified by:
    
    addAll in interface DoubleList
    
    Parameters:
    
    index - index at which to insert the first element from the specified list
    
    c - list containing elements to be added to this list
    
    Returns:
    
    true if this list changed as a result of the call
  - removeRange
```
protected void removeRange(int fromIndex,
                           int toIndex)
```
    Removes from this list all of the elements whose index is between fromIndex, inclusive, and toIndex, exclusive. Shifts any succeeding elements to the left (reduces their index). This call shortens the list by (toIndex - fromIndex) elements. (If toIndex==fromIndex, this operation has no effect.)
    
    Parameters:
    
    fromIndex - start index, inclusive
    
    toIndex - end index, exclusive
    
    Throws:
    
    IndexOutOfBoundsException - if fromIndex or toIndex is out of range (fromIndex < 0 || toIndex > size() || toIndex < fromIndex)
  - removeAll
```
public boolean removeAll(DoubleList c)
```
    Removes from this list all of its elements that are contained in the specified list.
    
    Specified by:
    
    removeAll in interface DoubleList
    
    Parameters:
    
    c - list containing elements to be removed from this list
    
    Returns:
    
    true if this list changed as a result of the call
  - retainAll
```
public boolean retainAll(DoubleList c)
```
    Retains only the elements in this list that are contained in the specified list. In other words, removes from this list all of its elements that are not contained in the specified list.
    
    Specified by:
    
    retainAll in interface DoubleList
    
    Parameters:
    
    c - list containing elements to be retained in this list
    
    Returns:
    
    true if this list changed as a result of the call
  - listIterator
```
public DListIterator listIterator(int index)
```
    Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list. The specified index indicates the first element that would be returned by an initial call to next. An initial call to previous would return the element with the specified index minus one.
    The returned list iterator is fail-fast.
    
    Specified by:
    
    listIterator in interface DoubleList
    
    Parameters:
    
    index - starting position
    
    Returns:
    
    a list iterator
  - listIterator
```
public DListIterator listIterator()
```
    Returns a list iterator over the elements in this list (in proper sequence).
    The returned list iterator is fail-fast.
    
    Specified by:
    
    listIterator in interface DoubleList
    
    Returns:
    
    a list iterator
  - iterator
```
public DForEachIterator iterator()
```
    Returns an iterator over the elements in this list in proper sequence.
    The returned iterator is fail-fast.
    
    Specified by:
    
    iterator in interface DoubleList
    
    Returns:
    
    an iterator over the elements in this list in proper sequence
  - subList
```
public DoubleList subList(int fromIndex,
                          int toIndex)
```
    Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the returned list is empty.) The returned list is backed by this list, so non-structural changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations.
    This method eliminates the need for explicit range operations (of the sort that commonly exist for arrays). Any operation that expects a list can be used as a range operation by passing a subList view instead of a whole list. For example, the following idiom removes a range of elements from a list:
```
 list.subList(from, to).clear();
 
```
    Similar idioms may be constructed for DoubleList.indexOf(double) and DoubleList.lastIndexOf(double), and all of the algorithms in a DoubleList can be applied to a subList.
    The semantics of the list returned by this method become undefined if the backing list (i.e., this list) is structurally modified in any way other than via the returned list. (Structural modifications are those that change the size of this list, or otherwise perturb it in such a fashion that iterations in progress may yield incorrect results.)
    Specified by:
    
    subList in interface DoubleList
    
    Parameters:
    
    fromIndex - start index, inclusive
    
    toIndex - end index, exclusive
    
    Returns:
    
    a view of a portion of this list
  - forEach
```
public void forEach(DoubleConsumer action)
```
    Performs the given action for each element of this list in the order of iteration until all elements have been processed or the action throws an exception. Exceptions thrown by the action are relayed to the caller.
    
    Specified by:
    
    forEach in interface DoubleList
    
    Parameters:
    
    action - The action to be performed for each element
  - spliterator
```
public Spliterator.OfDouble spliterator()
```
    Creates a late-binding and fail-fast Spliterator over the elements in this list.
    The Spliterator.OfDouble reports Spliterator.SIZED, Spliterator.SUBSIZED, and Spliterator.ORDERED. Overriding implementations should document the reporting of additional characteristic values.
    
    Specified by:
    
    spliterator in interface DoubleList
    
    Returns:
    
    a Spliterator.OfDouble over the elements in this list
  - sort
```
public void sort()
```
    Sorts this list in ascending order.
    
    Specified by:
    
    sort in interface DoubleList
  - offset
```
public int offset()
```
    Returns the offset of this list.
    
    Specified by:
    
    offset in interface DoubleList
    
    Returns:
    
    the offset of this list
  - getArrayUnsafe
```
public double[] getArrayUnsafe()
```
    Returns the underlying array as an escape hatch. Note that the underlying array may be the root array in the case of SubLists.
    
    Specified by:
    
    getArrayUnsafe in interface DoubleList
    
    Returns:
    
    the underlying array
  - assignConst
```
public DoubleList assignConst(double val)
```
    Assign the constant val to each element in this list.
    
    Specified by:
    
    assignConst in interface DoubleList
    
    Parameters:
    
    val - the constant to assign
    
    Returns:
    
    this DoubleList
  - round
```
public DoubleList round(int scale)
```
    Round the scalars in this list to scale.
    
    Specified by:
    
    round in interface DoubleList
    
    Parameters:
    
    scale - if zero or positive, the scale is the number of digits to the right of the decimal point. If negative, the unscaled value of the number is multiplied by ten to the power of the negation of the scale.
    
    Returns:
    
    this DoubleList
  - plus
```
public DoubleList plus(double val)
```
    Add the scalar val to each element in this list.
    
    Specified by:
    
    plus in interface DoubleList
    
    Parameters:
    
    val - the scalar to add
    
    Returns:
    
    this DoubleList
  - mul
```
public DoubleList mul(double val)
```
    Multiply each element in this list by the scalar val.
    
    Specified by:
    
    mul in interface DoubleList
    
    Parameters:
    
    val - the scalar to multiply by
    
    Returns:
    
    this DoubleList
  - sum
```
public double sum()
```
    Returns the sum of the elements in this list.
    
    Specified by:
    
    sum in interface DoubleList
    
    Returns:
    
    the sum of the elements in this list
  - plusi
```
public double plusi(int index,
                    double val)
```
    Add the scalar val to the element at index.
    
    Specified by:
    
    plusi in interface DoubleList
    
    Parameters:
    
    index - index of the element to increment by val
    
    val - the scalar to add to the element
    
    Returns:
    
    the new value of the element after addition
  - muli
```
public double muli(int index,
                   double val)
```
    Multiply the element at index by the scalar val.
    
    Specified by:
    
    muli in interface DoubleList
    
    Parameters:
    
    index - index of the element to multiply by val
    
    val - the scalar to multiply by
    
    Returns:
    
    the new value of the element after multiplication
  - dot
```
public double dot(DoubleList list)
```
    Computes the dot product of this list and the given list.
    
    Specified by:
    
    dot in interface DoubleList
    
    Parameters:
    
    list - a DoubleList which must have the same DoubleList.size() as this list
    
    Returns:
    
    the dot product of this list and and the given list
  - dot
```
public double dot(double[] array)
```
    Computes the dot product of this list and the given array.
    
    Specified by:
    
    dot in interface DoubleList
    
    Parameters:
    
    array - an array which must have the same length as this list's DoubleList.size()
    
    Returns:
    
    the dot product of this list and and the given array.
  - cross
```
public DoubleList cross(DoubleList list)
```
    Computes the cross product of this DoubleList and the given list provided that both, this DoubleList and the given list, have a dimension of 3. If this DoubleList is not of DoubleList.size() == 3 an UnsupportedOperationException is thrown. Also, if the given list doesn't satisfy list.size() == 3 an IllegalArgumentException is thrown.
    
    Specified by:
    
    cross in interface DoubleList
    
    Parameters:
    
    list - a DoubleList which must have the size() == 3
    
    Returns:
    
    the the cross product of this DoubleList and the given list
  - cross
```
public DoubleList cross(double[] array)
```
    Computes the cross product of this DoubleList and the given array provided that both, this DoubleList and the given array, have a dimension of 3. If this DoubleList is not of DoubleList.size() == 3 an UnsupportedOperationException is thrown. Also, if the given array doesn't satisfy array.length == 3 an IllegalArgumentException is thrown.
    
    Specified by:
    
    cross in interface DoubleList
    
    Parameters:
    
    array - an array which must have length == 3
    
    Returns:
    
    the cross product of this DoubleList and the given array
  - norm2
```
public double norm2()
```
    Computes the euclidean norm (magnitude) of this list.
    
    Specified by:
    
    norm2 in interface DoubleList
    
    Returns:
    
    the euclidean norm of this list
  - softmax
```
public DoubleList softmax()
```
    Returns a new list that contains the contents of this list normalized to a probability distribution according to the softmax function which sums up to 1.0.
    
    Specified by:
    
    softmax in interface DoubleList
    
    Returns:
    
    a new list that contains the contents of this list normalized according to the softmax function
  - normalizedSoftmax
```
public DoubleList normalizedSoftmax(double normalizedSum)
```
    Returns a new list that contains the contents of this list normalized to a distribution according to the softmax function which sums up to normalizedSum.
    
    Specified by:
    
    normalizedSoftmax in interface DoubleList
    
    Parameters:
    
    normalizedSum - the overall sum of the desired distribution
    
    Returns:
    
    a new list that contains the contents of this list normalized according to the softmax function which sums up to normalizedSum
  - logSumExp
```
public double logSumExp()
```
    Returns the logarithm of the sum of the exponentials of this list (see LogSumExp) if it has at least one element, otherwise NoSuchElementException is thrown.
    
    Specified by:
    
    logSumExp in interface DoubleList
    
    Returns:
    
    the logarithm of the sum of the exponentials of this list
  - min
```
public double min()
```
    Returns the minimum of the elements in this list if this list has at least one element, otherwise throws NoSuchElementException.
    
    Specified by:
    
    min in interface DoubleList
    
    Returns:
    
    the minimum of the elements in this list
  - max
```
public double max()
```
    Returns the maximum of the elements in this list if this list has at least one element, otherwise throws NoSuchElementException.
    
    Specified by:
    
    max in interface DoubleList
    
    Returns:
    
    the maximum of the elements in this list
  - avg
```
public double avg()
```
    Returns the average value of the elements in this list if this list has at least one element, otherwise throws NoSuchElementException.
    
    Specified by:
    
    avg in interface DoubleList
    
    Returns:
    
    the average value of the elements in this list
  - stddev
```
public double stddev()
```
    Returns the standard deviation of the elements in this list if this list has at least two elements, otherwise throws IllegalArgumentException. The value is computed without Bessel's correction, i.e., we divide by n, not by n - 1.
    
    Specified by:
    
    stddev in interface DoubleList
    
    Returns:
    
    the standard deviation of the elements in this list
  - median
```
public double median()
```
    Returns the median value of the elements in this list if this list has at least one element, otherwise throws NoSuchElementException.
    
    Specified by:
    
    median in interface DoubleList
    
    Returns:
    
    the median value of the elements in this list
  - plusn
```
public DoubleList plusn(DoubleList list)
```
    Add the scalars from the given list to the elements in this list. Note that list doesn't have to have the same DoubleList.size() as this list as the minimum of both list sizes is used to determine the number of scalars to add.
    
    Specified by:
    
    plusn in interface DoubleList
    
    Parameters:
    
    list - a DoubleList of scalars to add to this list
    
    Returns:
    
    this DoubleList
  - plusn
```
public DoubleList plusn(double[] array)
```
    Add the scalars from the given array to the elements in this list. Note that array doesn't have to have the same length as this list as the minimum of both lengths is used to determine the number of scalars to add.
    
    Specified by:
    
    plusn in interface DoubleList
    
    Parameters:
    
    array - an array of scalars to add to this list
    
    Returns:
    
    this DoubleList
  - muln
```
public DoubleList muln(DoubleList list)
```
    Multiplies the scalars from this list by the scalars from the given list. Note that list doesn't have to have the same DoubleList.size() as this list as the minimum of both list sizes is used to determine the number of scalars to multiply.
    
    Specified by:
    
    muln in interface DoubleList
    
    Parameters:
    
    list - a DoubleList of scalars to multiply by the elements in this list
    
    Returns:
    
    this DoubleList
  - muln
```
public DoubleList muln(double[] array)
```
    Multiplies the scalars from this list by the scalars from the given array. Note that array doesn't have to have the same length as this list as the minimum of both lengths is used to determine the number of scalars to multiply.
    
    Specified by:
    
    muln in interface DoubleList
    
    Parameters:
    
    array - an array of scalars to multiply by the elements in this list
    
    Returns:
    
    this DoubleList
  - sanitizeNonFinite
```
public DoubleList sanitizeNonFinite(double nanSurrogate,
                                    double posInfSurrogate,
                                    double negInfSurrogate)
```
    Set all scalars that are either NaN, positive or negative infinity to the respective ersatz value provided by the nanSurrogate, posInfSurrogate and negInfSurrogate arguments.
    
    Specified by:
    
    sanitizeNonFinite in interface DoubleList
    
    Parameters:
    
    nanSurrogate - the substitution value to use for NaN values, NaNs won't get substituted if you pass Double.NaN
    
    posInfSurrogate - the substitution value to use for positive infinity values, no substitution happens if you pass Double.POSITIVE_INFINITY
    
    negInfSurrogate - the substitution value to use for negative infinity values, no substitution happens if you pass Double.NEGATIVE_INFINITY
    
    Returns:
    
    this DoubleList
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException

Class DoubleArrayList

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface math.list.DoubleList

Constructor Detail

DoubleArrayList

DoubleArrayList

DoubleArrayList

DoubleArrayList

DoubleArrayList

Method Detail

of

randomUniform

randomNormal

trimToSize

ensureCapacity

size

isEmpty

contains

containsAll

indexOf

lastIndexOf

clone

toArray

get

set

add

add

remove

equals

hashCode

remove

clear

addAll

addAll

removeRange

removeAll

retainAll

listIterator

listIterator

iterator

subList

forEach

spliterator

sort

offset

getArrayUnsafe

assignConst

round

plus

mul

sum

plusi

muli

dot

dot

cross

cross

norm2

softmax

normalizedSoftmax

logSumExp

min

max

avg

stddev

median

plusn

plusn

muln

muln

sanitizeNonFinite

toString

writeExternal

readExternal