DoubleList (math-base 1.0.0 API)

All Known Implementing Classes:

DoubleArrayList
```
public interface DoubleList
```
A resizable primitive double[] array with vector operations that behaves similarly to a java.util.List.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default 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.
`static boolean`	`approxEqual(DoubleList a, DoubleList b)` Tests for approximate equality (or "closeness") of the two DoubleLists `a` and `b` where `a` and `b` must have the same length and each element `xa` of `a` is tested for approximate equality against the corresponding element `xb` of `b` as defined in `approxEqual(DoubleList, DoubleList, double, double)`.
`static boolean`	`approxEqual(DoubleList a, DoubleList b, double relTol, double absTol)` Tests for approximate equality (or "closeness") of the two DoubleLists `a` and `b` where `a` and `b` must have the same length and each element `xa` of `a` is tested for approximate equality against the corresponding element `xb` of `b`.
`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.
`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`.
`boolean`	`equals(Object o)` Compares the specified object with this DoubleList for equality.
`default 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 DoubleList`	`of(double... values)` Constructs a list containing the passed values in the order of their appearance.
`int`	`offset()` Returns the offset of this list.
`default DoubleStream`	`parallelStream()` Returns a parallel `Stream` with this list as its source.
`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 DoubleList`	`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 DoubleList`	`randomUniform(double min, double max, int size)` Constructs a random list of length `size` with random values uniformly distributed between `min` and `max`.
`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.
`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`.
`default 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`.
`default DoubleStream`	`stream()` Returns a sequential `Stream` with this list as its source.
`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).

- Method Detail
  - stream
```
default DoubleStream stream()
```
    Returns a sequential Stream with this list as its source.
    
    Returns:
    
    a sequential Stream over the elements in this list
  - parallelStream
```
default DoubleStream parallelStream()
```
    Returns a parallel Stream with this list as its source.
    
    Returns:
    
    a parallel Stream over the elements in this list
  - forEach
```
default 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.
    
    Parameters:
    
    action - The action to be performed for each element
    
    Throws:
    
    NullPointerException - if the specified action is null
  - sort
```
default void sort()
```
    Sorts this list in ascending order.
  - of
```
static DoubleList of(double... values)
```
    Constructs a list containing the passed values in the order of their appearance.
    
    Parameters:
    
    values - the values which are to be placed into the list
    
    Returns:
    
    a new DoubleList constructed from the passed values
  - approxEqual
```
static boolean approxEqual(DoubleList a,
                           DoubleList b)
```
    Tests for approximate equality (or "closeness") of the two DoubleLists a and b where a and b must have the same length and each element xa of a is tested for approximate equality against the corresponding element xb of b as defined in approxEqual(DoubleList, DoubleList, double, double). This method is equivalent to a call of approxEqual(DoubleList, DoubleList, double, double) with an relTol argument of value 1.0e-8 and an absTol argument equal to 0.0:
```
  approxEqual(a, b, 1.0e-8, 0.0)
 
```
    Parameters:
    
    a - one of the two DoubleLists to test for approximate equality (it doesn't matter which one since the test is symmetric)
    
    b - the other one of the two DoubleLists to test for approximate equality (it doesn't matter which one since the test is symmetric)
    
    Returns:
    
    true if a and b are approximately equal according to the criterion defined in approxEqual(DoubleList, DoubleList, double, double)
  - approxEqual
```
static boolean approxEqual(DoubleList a,
                           DoubleList b,
                           double relTol,
                           double absTol)
```
    Tests for approximate equality (or "closeness") of the two DoubleLists a and b where a and b must have the same length and each element xa of a is tested for approximate equality against the corresponding element xb of b.
    If, for all pairs (xa, xb),
```
  abs(xa - xb) <= max( relTol * max(abs(xa), abs(xb)), absTol )
 
```
    the lists a and b are considered approximately equal, otherwise they are not. This test is symmetric, so interchanging a and b doesn't change the result.
    Implementation Note:
    The definition of approximate equality used here is the one employed in Python's math.isclose() function defined in PEP 485 - A Function for testing approximate equality. This document gives a nice discussion of the rationale for this approach, how to use it, and the alternatives they had considered.
    Parameters:
    
    a - one of the two DoubleLists to test for approximate equality (it doesn't matter which one since the test is symmetric)
    
    b - the other one of the two DoubleLists to test for approximate equality (it doesn't matter which one since the test is symmetric)
    
    relTol - relative tolerance, must be >= 0.0
    
    absTol - absolute tolerance, must be >= 0.0
    
    Returns:
    
    true if a and b are approximately equal according to the criterion defined above, otherwise false
    
    Throws:
    
    IllegalArgumentException - if relTol < 0.0 or absTol < 0.0
  - randomUniform
```
static DoubleList randomUniform(double min,
                                double max,
                                int size)
```
    Constructs a random list of length size with random values uniformly distributed between min and max.
    
    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
```
static DoubleList 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.
    
    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
  - size
```
int size()
```
    Returns the number of elements in this list.
    
    Returns:
    
    the number of elements in this list
  - isEmpty
```
boolean isEmpty()
```
    Returns true if this list contains no elements.
    
    Returns:
    
    true if this list contains no elements
  - contains
```
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.
    
    Parameters:
    
    o - element whose presence in this list is to be tested
    
    Returns:
    
    true if this list contains the specified element
  - containsAll
```
boolean containsAll(DoubleList c)
```
    Returns true if this DoubleList contains all of the elements in the specified 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
```
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.
    
    Parameters:
    
    o - element to search for
    
    Returns:
    
    index of the first occurrence, or -1 if not found
  - lastIndexOf
```
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.
    
    Parameters:
    
    o - element to search for
    
    Returns:
    
    index of the last occurrence, or -1 if not found
  - toArray
```
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.
    
    Returns:
    
    an array containing all of the elements in this list in proper sequence
  - get
```
double get(int index)
```
    Returns the element at the specified position in this list.
    
    Parameters:
    
    index - index of the element to return
    
    Returns:
    
    the element at the specified position in this list
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= size())
  - set
```
double set(int index,
           double element)
```
    Replaces the element at the specified position in this list with the specified element.
    
    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
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= size())
  - add
```
boolean add(double e)
```
    Appends the specified element to the end of this list.
    
    Parameters:
    
    e - element to be appended to this list
    
    Returns:
    
    true
  - add
```
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).
    
    Parameters:
    
    index - index at which the specified element is to be inserted
    
    element - element to be inserted
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= size())
  - remove
```
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).
    
    Parameters:
    
    index - the index of the element to be removed
    
    Returns:
    
    the element that was removed from the list
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= size())
  - equals
```
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.
    
    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
```
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().
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    the hash code value for this DoubleList
  - remove
```
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).
    
    Parameters:
    
    o - element to be removed from this list, if present
    
    Returns:
    
    true if this list contained the specified element
  - clear
```
void clear()
```
    Removes all of the elements from this list. The list will be empty after this call returns.
  - addAll
```
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.)
    
    Parameters:
    
    c - list containing elements to be added to this list
    
    Returns:
    
    true if this list changed as a result of the call
    
    Throws:
    
    NullPointerException - if the specified list is null
  - addAll
```
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.
    
    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
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= size())
    
    NullPointerException - if the specified list is null
  - removeAll
```
boolean removeAll(DoubleList c)
```
    Removes from this list all of its elements that are contained in the specified list.
    
    Parameters:
    
    c - list containing elements to be removed from this list
    
    Returns:
    
    true if this list changed as a result of the call
  - retainAll
```
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.
    
    Parameters:
    
    c - list containing elements to be retained in this list
    
    Returns:
    
    true if this list changed as a result of the call
  - listIterator
```
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.
    
    Parameters:
    
    index - starting position
    
    Returns:
    
    a list iterator
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= size())
  - listIterator
```
DListIterator listIterator()
```
    Returns a list iterator over the elements in this list (in proper sequence).
    The returned list iterator is fail-fast.
    
    Returns:
    
    a list iterator
  - iterator
```
DForEachIterator iterator()
```
    Returns an iterator over the elements in this list in proper sequence.
    The returned iterator is fail-fast.
    
    Returns:
    
    an iterator over the elements in this list in proper sequence
  - subList
```
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 indexOf(double) and 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.)
    Parameters:
    
    fromIndex - start index, inclusive
    
    toIndex - end index, exclusive
    
    Returns:
    
    a view of a portion of this list
    
    Throws:
    
    IndexOutOfBoundsException - if an endpoint index value is out of range (fromIndex < 0 || toIndex > size)
    
    IllegalArgumentException - if the endpoint indices are out of order (fromIndex > toIndex)
  - spliterator
```
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.
    
    Returns:
    
    a Spliterator.OfDouble over the elements in this list
  - offset
```
int offset()
```
    Returns the offset of this list.
    
    Returns:
    
    the offset of this list
  - getArrayUnsafe
```
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.
    
    Returns:
    
    the underlying array
  - assignConst
```
DoubleList assignConst(double val)
```
    Assign the constant val to each element in this list.
    
    Parameters:
    
    val - the constant to assign
    
    Returns:
    
    this DoubleList
  - plus
```
DoubleList plus(double val)
```
    Add the scalar val to each element in this list.
    
    Parameters:
    
    val - the scalar to add
    
    Returns:
    
    this DoubleList
  - mul
```
DoubleList mul(double val)
```
    Multiply each element in this list by the scalar val.
    
    Parameters:
    
    val - the scalar to multiply by
    
    Returns:
    
    this DoubleList
  - min
```
double min()
```
    Returns the minimum of the elements in this list if this list has at least one element, otherwise throws NoSuchElementException.
    
    Returns:
    
    the minimum of the elements in this list
    
    Throws:
    
    NoSuchElementException - if this list is empty
  - max
```
double max()
```
    Returns the maximum of the elements in this list if this list has at least one element, otherwise throws NoSuchElementException.
    
    Returns:
    
    the maximum of the elements in this list
    
    Throws:
    
    NoSuchElementException - if this list is empty
  - avg
```
double avg()
```
    Returns the average value of the elements in this list if this list has at least one element, otherwise throws NoSuchElementException.
    
    Returns:
    
    the average value of the elements in this list
    
    Throws:
    
    NoSuchElementException - if this list is empty
  - stddev
```
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.
    
    Returns:
    
    the standard deviation of the elements in this list
    
    Throws:
    
    IllegalArgumentException - if this list has less than two elements
  - median
```
double median()
```
    Returns the median value of the elements in this list if this list has at least one element, otherwise throws NoSuchElementException.
    
    Returns:
    
    the median value of the elements in this list
    
    Throws:
    
    NoSuchElementException - if this list is empty
  - sum
```
double sum()
```
    Returns the sum of the elements in this list.
    
    Returns:
    
    the sum of the elements in this list
  - plusi
```
double plusi(int index,
             double val)
```
    Add the scalar val to the element at index.
    
    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
```
double muli(int index,
            double val)
```
    Multiply the element at index by the scalar val.
    
    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
```
double dot(DoubleList list)
```
    Computes the dot product of this list and the given list.
    
    Parameters:
    
    list - a DoubleList which must have the same size() as this list
    
    Returns:
    
    the dot product of this list and and the given list
  - dot
```
double dot(double[] array)
```
    Computes the dot product of this list and the given array.
    
    Parameters:
    
    array - an array which must have the same length as this list's size()
    
    Returns:
    
    the dot product of this list and and the given array.
  - cross
```
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 size() == 3 an UnsupportedOperationException is thrown. Also, if the given list doesn't satisfy list.size() == 3 an IllegalArgumentException is thrown.
    
    Parameters:
    
    list - a DoubleList which must have the size() == 3
    
    Returns:
    
    the the cross product of this DoubleList and the given list
    
    Throws:
    
    UnsupportedOperationException - if this DoubleList is not of size() == 3
    
    IllegalArgumentException - if the given list doesn't satisfy list.size() == 3
  - cross
```
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 size() == 3 an UnsupportedOperationException is thrown. Also, if the given array doesn't satisfy array.length == 3 an IllegalArgumentException is thrown.
    
    Parameters:
    
    array - an array which must have length == 3
    
    Returns:
    
    the cross product of this DoubleList and the given array
    
    Throws:
    
    UnsupportedOperationException - if this DoubleList is not of size() == 3
    
    IllegalArgumentException - if the given array doesn't satisfy array.length == 3
  - softmax
```
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.
    
    Returns:
    
    a new list that contains the contents of this list normalized according to the softmax function
  - normalizedSoftmax
```
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.
    
    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
  - norm2
```
double norm2()
```
    Computes the euclidean norm (magnitude) of this list.
    
    Returns:
    
    the euclidean norm of this list
  - logSumExp
```
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.
    
    Returns:
    
    the logarithm of the sum of the exponentials of this list
    
    Throws:
    
    NoSuchElementException - if this list is empty
  - plusn
```
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 size() as this list as the minimum of both list sizes is used to determine the number of scalars to add.
    
    Parameters:
    
    list - a DoubleList of scalars to add to this list
    
    Returns:
    
    this DoubleList
  - plusn
```
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.
    
    Parameters:
    
    array - an array of scalars to add to this list
    
    Returns:
    
    this DoubleList
  - muln
```
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 size() as this list as the minimum of both list sizes is used to determine the number of scalars to multiply.
    
    Parameters:
    
    list - a DoubleList of scalars to multiply by the elements in this list
    
    Returns:
    
    this DoubleList
  - muln
```
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.
    
    Parameters:
    
    array - an array of scalars to multiply by the elements in this list
    
    Returns:
    
    this DoubleList
  - round
```
DoubleList round(int scale)
```
    Round the scalars in this list to scale.
    
    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
  - sanitizeNonFinite
```
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.
    
    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

Interface DoubleList

Method Summary

Method Detail

stream

parallelStream

forEach

sort

of

approxEqual

approxEqual

randomUniform

randomNormal

size

isEmpty

contains

containsAll

indexOf

lastIndexOf

toArray

get

set

add

add

remove

equals

hashCode

remove

clear

addAll

addAll

removeAll

retainAll

listIterator

listIterator

iterator

subList

spliterator

offset

getArrayUnsafe

assignConst

plus

mul

min

max

avg

stddev

median

sum

plusi

muli

dot

dot

cross

cross

softmax

normalizedSoftmax

norm2

logSumExp

plusn

plusn

muln

muln

round

sanitizeNonFinite