DoubleIndexable (CAFF Viewer Class Documentation)

All Superinterfaces:

java.lang.Iterable<java.lang.Double>, PrimitiveDoubleIterable, Sizeable

All Known Subinterfaces:

ExpandableDoubleIndexable, MutableDoubleIndexable

All Known Implementing Classes:

DoubleIndexable.Base, DoublePair, MutableDoubleIndexable.Base
```
public interface DoubleIndexable
extends PrimitiveDoubleIterable, Sizeable
```
Class which allows readonly access of raw doubles by index.
The EMPTY constant or emptyIndexable() method provide the same useful return value to indicate emptiness.
Simple implementations should extend DoubleIndexable.Base because that provides useful implementations for standard Object methods and implements Comparable.

Since:

July 7, 2020

Author:

Rammi

See Also:

FastDoubleSequenceSearch

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static class`	`DoubleIndexable.Base` Abstract base class which provides useful implementations for `Object.equals(Object)`, `Object.hashCode()`, `Object.toString()`.
`static class`	`DoubleIndexable.DoubleIndexableSpliterator` Spliterator for double indexables.

Field Summary

Fields
Modifier and Type	Field and Description
`static DoubleIndexable.Base`	`EMPTY` An empty indexable.
`static DoubleIndexable`	`SINGLE_0` Double indexable which only contains the single value `0.0`.

Fields inherited from interface de.caff.generics.PrimitiveDoubleIterable
EMPTY_DOUBLE_ITERATOR

Fields inherited from interface de.caff.generics.Sizeable
NULL

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default void`	`addAllTo(java.util.Collection<? super java.lang.Double> collection)` Add all elements of this indexable to the given collection.
`default int`	`addToArray(double[] array, int pos)` Add the content of this indexable to the given array.
`default int`	`addToArray(double[] array, int arrayPos, int index, int length)` Add a part of the content of this indexable to the given array.
`default DoubleIndexable.Base`	`asBase()` Make this double indexable usable as a base class with defined standard Object methods.
`default java.util.Collection<java.lang.Double>`	`asCollection()` Get a view on this indexable as an unmodifiable collection.
`default Indexable<java.lang.Double>`	`asIndexable()` Get a view of this indexable as a standard object-based indexable.
`default java.util.List<java.lang.Double>`	`asList()` Get a view on this indexable as an unmodifiable list.
`default int`	`binarySearch(double value)` Do a binary search in an indexable ordered in natural ascending order.
`default int`	`binarySearch(double value, DoubleOrdering order)` Do a binary search in an ordered indexable.
`static int`	`compare(DoubleIndexable indexable1, DoubleIndexable indexable2)` Compare two double indexables.
`default DoubleIndexable`	`deltas()` View the differences between consecutive elements as a new double indexable.
`default java.util.PrimitiveIterator.OfDouble`	`doubleIterator()` Get an primitive double iterator.
`default java.util.PrimitiveIterator.OfDouble`	`doubleIterator(int from, int to)` Get a double iterator from the given sub set.
`default java.util.Spliterator.OfDouble`	`doubleSpliterator()` Get a spliterator on this indexable.
`static DoubleIndexable.Base`	`emptyIndexable()` Get an empty indexable set.
`static boolean`	`equal(DoubleIndexable indexable1, DoubleIndexable indexable2)` Are two double indexables equal?
`static boolean`	`equal(DoubleIndexable indexable1, DoubleIndexable indexable2, DoublePredicate2 checker)` Are two double indexables equal?
`static boolean`	`equal(DoubleIndexable indexable1, java.lang.Object indexable2)` Are two double indexables equal?
`static boolean`	`equalStandard(DoubleIndexable indexable1, DoubleIndexable indexable2)` Are two double indexables equal?
`default int`	`firstMatch(java.util.function.DoublePredicate check)` Get the first index for which the given check is fulfilled.
`default double`	`firstValue()` Get the first value in this double indexable.
`default double`	`foldLeft(double initialValue, java.util.function.DoubleBinaryOperator foldOperation)` Go over all values and do a cumulative calculation.
`default DoubleIndexable`	`frozen()` Get a frozen version of this indexable.
`default java.util.Spliterator.OfDouble`	`frozenDoubleSpliterator()` Get an immutable spliterator on a frozen copy of this indexable.
`double`	`get(int index)` Get the element at the given index.
`default double`	`gyt(int index)` Pythonesque get.
`static int`	`hash(DoubleIndexable indexable)` Calculate a hashcode for a double indexable.
`default DoubleIndexable.Base`	`headSet(int toIndex)` Create an indexable subset from the last elements of this indexable set.
`default java.lang.Iterable<java.lang.Integer>`	`indexes()` Get the indexes of this indexable as an iterable range.
`static DoubleIndexable.Base`	`init(int size, double value)` Get a double indexable of a given size which always returns the same value.
`static DoubleIndexable`	`initByIndex(int size, java.util.function.IntToDoubleFunction producer)` Get a double indexable of a given size which returns elements created by index.
`default IntIndexable`	`intIndexes()` Get the indexes of this indexable as an integer indexable.
`default boolean`	`isEmpty()` Is this indexable empty?
`default boolean`	`isOrdered(DoubleOrdering order)` Is this indexable sorted according to the given ordering?
`default boolean`	`isStrictlyOrdered(DoubleOrdering order)` Is this indexable strictly sorted according to the given ordering?
`default java.util.Iterator<java.lang.Double>`	`iterator()` Returns an iterator over elements of type `T`.
`default int`	`lastMatch(java.util.function.DoublePredicate check)` Get the last index for which the given check is fulfilled.
`default double`	`lastValue()` Get the last value in this double indexable.
`default java.util.ListIterator<java.lang.Double>`	`listIterator()` Returns a list iterator over elements of type `T`.
`default int`	`nextMatch(int startIndex, java.util.function.DoublePredicate check)` Get the next index for which the given check is fulfilled.
`default MutableDoubleIndexable`	`ordered()` Create a (mutable) double indexable from the values of this indexable which is ordered in natural order.
`default MutableDoubleIndexable`	`ordered(DoubleOrdering order)` Create a (mutable) double indexable from the values of this indexable which is ordered as defined by the given ordering.
`default int`	`previousMatch(int startIndex, java.util.function.DoublePredicate check)` Get the previous index for which the given check is fulfilled.
`default DoubleIndexable.Base`	`reverse()` Get this indexable but with inverted order.
`default DoubleIndexable`	`rotated(int steps)` Get a rotated view of this double indexable.
`static DoubleIndexable.Base`	`singleton(double value)` View a single double value as a double indexable of size 1.
`default DoubleIndexable.Base`	`subSet(int fromIndex, int toIndex)` Get an indexable subset.
`default DoubleIndexable.Base`	`sybSet(int fromIndex, int toIndex)` Get an indexable subset.
`default DoubleIndexable.Base`	`tailSet(int fromIndex)` Create an indexable subset from the last elements of this indexable set.
`default double[]`	`toArray()` Convert this indexable into a Java array.
`default java.util.ArrayList<java.lang.Double>`	`toList()` Create a list from this double indexable.
`static java.lang.String`	`toString(DoubleIndexable indexable)` Create a string representation of the given indexable.
`default DoubleIndexable.Base`	`transformed(DoubleOperator1 operator)` View the elements of this double indexable transformed.
`default <T> Indexable<T>`	`view(java.util.function.DoubleFunction<? extends T> convert)` View this as an indexable of another type.
`static DoubleIndexable.Base`	`viewArray(double... array)` View a double array as an Indexable.
`static DoubleIndexable.Base`	`viewArray(double[] array, int start, int length)` View part of a double array as an Indexable.
`static <T> DoubleIndexable.Base`	`viewArray(T[] array, java.util.function.ToDoubleFunction<? super T> valueExtract)` View an object array as a double indexable.
`static <T> DoubleIndexable.Base`	`viewArray(java.util.function.ToDoubleFunction<? super T> extractor, T... array)` View an array of a different type.
`default BooleanIndexable`	`viewAsBoolean(java.util.function.DoublePredicate convert)` View this indexable as a boolean indexable while using a conversion for each value.
`default ByteIndexable`	`viewAsByte()` View this double indexable as a byte integer indexable.
`default FloatIndexable`	`viewAsFloat()` View this double indexable as a float indexable.
`default IntIndexable`	`viewAsInt()` View this double indexable as a short integer indexable.
`default IntIndexable`	`viewAsInt(java.util.function.DoubleToIntFunction convert)` View this indexable as an integer indexable while using a conversion for each value.
`default LongIndexable`	`viewAsLong()` View this double indexable as a long integer indexable.
`default LongIndexable`	`viewAsLong(java.util.function.DoubleToLongFunction convert)` View this indexable as a long integer indexable while using a conversion for each value.
`default ShortIndexable`	`viewAsShort()` View this double indexable as a short integer indexable.
`static DoubleIndexable.Base`	`viewByIndex(int size, java.util.function.IntToDoubleFunction producer)` Get a double indexable of a given size which returns elements created by index.
`static DoubleIndexable.Base`	`viewIndexable(Indexable<? extends java.lang.Number> indexable)` View a generic Number indexable as double indexable.
`static DoubleIndexable.Base`	`viewIndexable(Indexable<? extends java.lang.Number> indexable, double nullFallback)` View a generic Number indexable as double indexable.
`static <T> DoubleIndexable.Base`	`viewIndexable(Indexable<T> indexable, java.util.function.ToDoubleFunction<? super T> extractor)` View a generic indexable as a double indexable.
`static DoubleIndexable.Base`	`viewList(java.util.List<? extends java.lang.Number> list)` View a list of numbers as a double indexable.
`static DoubleIndexable.Base`	`viewList(java.util.List<? extends java.lang.Number> list, double nullValue)` View a list as an Indexable.
`static <T> DoubleIndexable.Base`	`viewList(java.util.List<T> list, java.util.function.ToDoubleFunction<? super T> extractor)` View a generic list as a double indexable.
`static DoubleIndexable.Base`	`viewNumberArray(java.lang.Number... array)` View a Number array as an Indexable.
`default DoubleIndexable`	`viewOp(java.util.function.DoubleUnaryOperator op)` View this double indexable transformed by an operator.
`default DoubleIndexable`	`withAppendedValue(double value)` Create a view with of this indexable with another value added at the end.
`static DoubleIndexable.Base`	`withCachedHash(DoubleIndexable indexable)` Wrap an indexable with one which caches the hash value.
`default DoubleIndexable`	`withExchangedValueAt(int index, double value)` Create a view of this double indexable with an exchanged value.
`default DoubleIndexable`	`withInsertedValueAt(int index, double value)` Create a view of this double indexable with an inserted value.
`default DoubleIndexable`	`withRemovedValueAt(int index)` Create a view of this indexable with one value removed.
`default DoubleIndexable`	`withSwappedValuesAt(int index1, int index2)` Create a view of this double indexable with two values swapped.

Methods inherited from interface de.caff.generics.PrimitiveDoubleIterable
average, containsDouble, containsDouble, forEachDouble, forEachDoubleFragile, spliterator, stream, sum

Methods inherited from interface java.lang.Iterable
forEach

Methods inherited from interface de.caff.generics.Sizeable
size

- Field Detail
  - SINGLE_0
```
static final DoubleIndexable SINGLE_0
```
    Double indexable which only contains the single value 0.0.
  - EMPTY
```
@NotNull
static final DoubleIndexable.Base EMPTY
```
    An empty indexable.
- Method Detail
  - get
```
double get(int index)
```
    Get the element at the given index.
    
    Parameters:
    
    index - index between 0 and size() - 1
    
    Returns:
    
    element at the given index
  - gyt
```
default double gyt(int index)
```
    Pythonesque get. This allows to access elements from the back by using negative indexes, e.g. -1 references the last element, -2 its predecessor, and so on.
    
    Parameters:
    
    index - index between -size() and size() - 1
    
    Returns:
    
    element at the given index
  - reverse
```
@NotNull
default DoubleIndexable.Base reverse()
```
    Get this indexable but with inverted order.
    
    Returns:
    
    a view to this indexable which accesses the elements in reverse order
  - isEmpty
```
default boolean isEmpty()
```
    Is this indexable empty?
    
    Returns:
    
    true: there are no elements in this indexable
    false: this indexable has elements
  - doubleIterator
```
@NotNull
default java.util.PrimitiveIterator.OfDouble doubleIterator()
```
    Get an primitive double iterator.
    
    Specified by:
    
    doubleIterator in interface PrimitiveDoubleIterable
    
    Returns:
    
    double iterator which iterates over this indexable
  - doubleIterator
```
@NotNull
default java.util.PrimitiveIterator.OfDouble doubleIterator(int from,
                                                                     int to)
```
    Get a double iterator from the given sub set.
    
    Parameters:
    
    from - first index of iterator
    
    to - one past last index of iterator
    
    Returns:
    
    int iterator which iterates over the given part of this indexable
  - iterator
```
@NotNull
default java.util.Iterator<java.lang.Double> iterator()
```
    Returns an iterator over elements of type T.
    
    Specified by:
    
    iterator in interface java.lang.Iterable<java.lang.Double>
    
    Specified by:
    
    iterator in interface PrimitiveDoubleIterable
    
    Returns:
    
    an Iterator.
  - firstValue
```
default double firstValue()
```
    Get the first value in this double indexable.
    
    Returns:
    
    first value
  - lastValue
```
default double lastValue()
```
    Get the last value in this double indexable.
    
    Returns:
    
    last value
  - listIterator
```
@NotNull
default java.util.ListIterator<java.lang.Double> listIterator()
```
    Returns a list iterator over elements of type T.
    
    Returns:
    
    a list iterator.
  - subSet
```
@NotNull
default DoubleIndexable.Base subSet(int fromIndex,
                                             int toIndex)
```
    Get an indexable subset. The subset includes indices fromIndex to toIndex - 1.
    
    Parameters:
    
    fromIndex - start index of sub set
    
    toIndex - index after last index
    
    Returns:
    
    indxable subset view of this indexable
  - sybSet
```
@NotNull
default DoubleIndexable.Base sybSet(int fromIndex,
                                             int toIndex)
```
    Get an indexable subset. This is the Pythonesque version which allows negative indexes.
    
    Parameters:
    
    fromIndex - start index of sub set
    
    toIndex - end index of sub set
    
    Returns:
    
    indexable subset view of this indexable set
  - tailSet
```
@NotNull
default DoubleIndexable.Base tailSet(int fromIndex)
```
    Create an indexable subset from the last elements of this indexable set. This already allows Pythonesquew indexing.
    
    Parameters:
    
    fromIndex - index to start with, negative counts from the back
    
    Returns:
    
    indexable subset view of this indexable set
  - headSet
```
@NotNull
default DoubleIndexable.Base headSet(int toIndex)
```
    Create an indexable subset from the last elements of this indexable set. This already allows Pythonesquew indexing.
    
    Parameters:
    
    toIndex - index one after the end (equal to the length of the returned set), negative counts from the back
    
    Returns:
    
    indexable subset view of this indexable set
  - asCollection
```
@NotNull
default java.util.Collection<java.lang.Double> asCollection()
```
    Get a view on this indexable as an unmodifiable collection. This is especially useful for conversion to standard collection classes, eg for adding all elements via Collection.addAll(Collection).
    
    Returns:
    
    collection view
  - asList
```
@NotNull
default java.util.List<java.lang.Double> asList()
```
    Get a view on this indexable as an unmodifiable list. This is especially useful for conversion to standard collection classes, eg for adding all elements via Collection.addAll(Collection).
    
    Returns:
    
    collection view
    
    See Also:
    
    toList()
  - toList
```
@NotNull
default java.util.ArrayList<java.lang.Double> toList()
```
    Create a list from this double indexable. This creates an independent list to which the elements of this indexable are copied.
    
    Returns:
    
    list copy of this indexable
    
    See Also:
    
    asList()
  - addAllTo
```
default void addAllTo(@NotNull
                      java.util.Collection<? super java.lang.Double> collection)
```
    Add all elements of this indexable to the given collection.
    
    Parameters:
    
    collection - collection to add to
  - asIndexable
```
@NotNull
default Indexable<java.lang.Double> asIndexable()
```
    Get a view of this indexable as a standard object-based indexable.
    
    Returns:
    
    indexable with non-null Double values
  - toArray
```
@NotNull
default double[] toArray()
```
    Convert this indexable into a Java array.
    
    Returns:
    
    array copy containing all values of this indexable
  - addToArray
```
default int addToArray(@NotNull
                       double[] array,
                       int pos)
```
    Add the content of this indexable to the given array.
    
    Parameters:
    
    array - array where the content is added
    
    pos - position in the array where the content of this indexable is added
    
    Returns:
    
    array position after this indexable
  - addToArray
```
default int addToArray(@NotNull
                       double[] array,
                       int arrayPos,
                       int index,
                       int length)
```
    Add a part of the content of this indexable to the given array.
    
    Parameters:
    
    array - array where the content is added
    
    arrayPos - position in hte array where the content is added
    
    index - start index of this indexable which is added first
    
    length - number of entries of this indexable added to the array
    
    Returns:
    
    array position after the added content
  - indexes
```
@NotNull
default java.lang.Iterable<java.lang.Integer> indexes()
```
    Get the indexes of this indexable as an iterable range.
    
    Returns:
    
    iterable indexes
    
    See Also:
    
    intIndexes(), Range.indexes(int)
  - intIndexes
```
@NotNull
default IntIndexable intIndexes()
```
    Get the indexes of this indexable as an integer indexable.
    
    Returns:
    
    indexes as integer indexable
    
    See Also:
    
    indexes(), IntIndexable.rangeFromSize(int)
  - foldLeft
```
default double foldLeft(double initialValue,
                        @NotNull
                        java.util.function.DoubleBinaryOperator foldOperation)
```
    Go over all values and do a cumulative calculation.
    Eg calculate the maximum of this indexable use
```
   double max = indexable.foldLeft(Double.NEGATIVE_INFINITY, Math::max);
 
```
    Parameters:
    
    initialValue - start value for the operation, will be returned if this iterable is empty
    
    foldOperation - operation applied to each value, will get the accumulated value as its first and the current element value as its second argument
    
    Returns:
    
    accumulated value, result of applying fold operation to all values of this indexable iteratively
  - transformed
```
@NotNull
default DoubleIndexable.Base transformed(@NotNull
                                                  DoubleOperator1 operator)
```
    View the elements of this double indexable transformed.
    
    Parameters:
    
    operator - transformer applied before doubles are returned
    
    Returns:
    
    double indexable view with transformed elements
  - nextMatch
```
default int nextMatch(int startIndex,
                      @NotNull
                      java.util.function.DoublePredicate check)
```
    Get the next index for which the given check is fulfilled.
    
    Parameters:
    
    startIndex - start index for checking, Pythonesque indexing supported
    
    check - check to perform on elements of this indexable until true
    
    Returns:
    
    next index starting with startIndex for which the check returns true, Pythonesque.UNMAPPABLE if none
  - firstMatch
```
default int firstMatch(@NotNull
                       java.util.function.DoublePredicate check)
```
    Get the first index for which the given check is fulfilled.
    
    Parameters:
    
    check - check to perform on elements of this indexable until true
    
    Returns:
    
    first index for which the check returns true, -1 if none
  - previousMatch
```
default int previousMatch(int startIndex,
                          @NotNull
                          java.util.function.DoublePredicate check)
```
    Get the previous index for which the given check is fulfilled.
    
    Parameters:
    
    startIndex - start index for checking, Pythonesque indexing supported
    
    check - check to perform on elements of this indexable until true
    
    Returns:
    
    next index starting with startIndex for which the check returns true, Pythonesque.UNMAPPABLE if none
  - lastMatch
```
default int lastMatch(@NotNull
                      java.util.function.DoublePredicate check)
```
    Get the last index for which the given check is fulfilled.
    
    Parameters:
    
    check - check to perform on elements of this indexable until true
    
    Returns:
    
    last index for which the check returns true, -1 if none
  - frozen
```
@NotNull
default DoubleIndexable frozen()
```
    Get a frozen version of this indexable.
    Often Indexables are used as a view to underlying collections. Although this interface is immutable, the underlying colelction might nevertheless change. This copies the current state of this indexable into an unmodifiable state, and returns an Indexable which is stable in size and will return always the same element for a given index. Beware: it is still possible that any element itself changes when the elements are mutable.
    Calling frozen() again on the returned object will just return the object itself, so you can safely call this method more than once.
    
    Returns:
    
    frozen version of this Indexable
  - doubleSpliterator
```
@NotNull
default java.util.Spliterator.OfDouble doubleSpliterator()
```
    Get a spliterator on this indexable. The returned spliterator will not have its Spliterator.IMMUTABLE flag set, see frozenDoubleSpliterator() for an alternative.
    
    Returns:
    
    a spliterator on this indexable
  - frozenDoubleSpliterator
```
@NotNull
default java.util.Spliterator.OfDouble frozenDoubleSpliterator()
```
    Get an immutable spliterator on a frozen copy of this indexable. If this indexable is already immutable (i.e. if frozen() returns this) then this is the same as PrimitiveDoubleIterable.spliterator() with the difference that the spliterator returned here will have its Spliterator.IMMUTABLE flag set. If this is not immutable a frozen copy will be created, and the spliterator will be operating on that. Please refer to frozen() to understand what level of immutabiliy it will provide.
    
    Returns:
    
    an "immutable" spliterator with the possible cost of copying this indexable
  - view
```
@NotNull
default <T> Indexable<T> view(@NotNull
                                       java.util.function.DoubleFunction<? extends T> convert)
```
    View this as an indexable of another type. This returns a view of this double indexable where each access invokes the convert function, but you can use Countable.frozen() on it to get a fix independent indexable object.
    
    Type Parameters:
    
    T - required type
    
    Parameters:
    
    convert - converter between double and the required type
    
    Returns:
    
    view of this double indexable
  - withInsertedValueAt
```
@NotNull
default DoubleIndexable withInsertedValueAt(int index,
                                                     double value)
```
    Create a view of this double indexable with an inserted value. Note that this is not efficient, but handy in certain situations where only 1 or a few values are inserted. Use ExpandableDoubleIndexable if you want to carry out more stuff like this.
    As this creates a view of this indexable, changes to this indexable might result in a disaster when using the returned indexable!
    
    Parameters:
    
    index - index where the value is inserted before the current index (not Pythonesque, because it is possible to add an value at index == size(), and it is expected that most insertion will happen at 0 or at the end)
    
    value - inserted value at that index
    
    Returns:
    
    a view of this indexable with 1 more value at the given index, all values beyond are moved one index forward
    
    See Also:
    
    withAppendedValue(double)
  - withAppendedValue
```
@NotNull
default DoubleIndexable withAppendedValue(double value)
```
    Create a view with of this indexable with another value added at the end. Note that this is not efficient, but handy in certain situations where only 1 or a few items are added.
    
    Parameters:
    
    value - value to add
    
    Returns:
    
    indexable view of this indexable, with the given value added at the end, so size is larger by 1
    
    See Also:
    
    withInsertedValueAt(int, double)
  - withExchangedValueAt
```
@NotNull
default DoubleIndexable withExchangedValueAt(int index,
                                                      double value)
```
    Create a view of this double indexable with an exchanged value. Note that this is not efficient, but handy in certain situations where only 1 or a few values are exchanged. Use ExpandableDoubleIndexable if you want to carry out more stuff like this.
    As this creates a view of this indexable, changes to this indexable could lead to unexpected results when using the returned indexable!
    
    Parameters:
    
    index - index where the element is exchanged, hiding the current element. (Pythonesque)
    
    value - exchanged value at that index
    
    Returns:
    
    a view of this indexable with 1 more element at the given index, all elements beyond are moved one index forward
  - withRemovedValueAt
```
@NotNull
default DoubleIndexable withRemovedValueAt(int index)
```
    Create a view of this indexable with one value removed. Note that this is not efficient, but handy in certain situations where only one or a few values are removed.
    
    Parameters:
    
    index - index of the removed value (Pythonesque)
    
    Returns:
    
    a view of this indexable where the value at the given index is removed
  - withSwappedValuesAt
```
@NotNull
default DoubleIndexable withSwappedValuesAt(int index1,
                                                     int index2)
```
    Create a view of this double indexable with two values swapped. Note that this is not efficient, but handy in certain situations where only a few items are swapped.
    
    Parameters:
    
    index1 - index of the first value (Pythonesque)
    
    index2 - index of the second value (Pythonesque)
    
    Returns:
    
    a view of this indexable where the first and second value have exchanged places
  - rotated
```
@NotNull
default DoubleIndexable rotated(int steps)
```
    Get a rotated view of this double indexable. The returned indexable will show this indexable with rotated indexes. A positive steps will rotate left, i.e. any index will be accessed as if the number of steps is added before extraction (modulo length). E.g. a rotation of -1 will return the last element when index 0 is requested, and the first element for index 1.
    
    Parameters:
    
    steps - steps to rotate
    
    Returns:
    
    rotated view of this indexable, use frozen() to create an indexable which no longer depends on this one
  - viewOp
```
@NotNull
default DoubleIndexable viewOp(@NotNull
                                        java.util.function.DoubleUnaryOperator op)
```
    View this double indexable transformed by an operator.
    
    Parameters:
    
    op - transforming operator
    
    Returns:
    
    view of this indexable with transformed values
  - viewAsFloat
```
@NotNull
default FloatIndexable viewAsFloat()
```
    View this double indexable as a float indexable. Note that this will result in a loss of precision and reduction of the numeric range of the values. This will downcast the values of this indexable on each request, use frozen() on the result to create an independent copy if this seems like a problem to you.
    
    Returns:
    
    a float indexable view of this indexable
  - viewAsLong
```
@NotNull
default LongIndexable viewAsLong()
```
    View this double indexable as a long integer indexable. Note that this will usually result in a loss of precision and reduction of the numeric range of the values. This will cast the double values of this indexable on each request, use frozen() on the result to create an independent copy if this seems like a problem to you.
    
    Returns:
    
    a long indexable view of this indexable
  - viewAsLong
```
@NotNull
default LongIndexable viewAsLong(@NotNull
                                          java.util.function.DoubleToLongFunction convert)
```
    View this indexable as a long integer indexable while using a conversion for each value.
    Use frozen() on the result to decouple it from this indexable.
    
    Parameters:
    
    convert - converter applied to each value of this indexable before it is returned from the resulting indexable
    
    Returns:
    
    long indexable view of this indexable
  - viewAsInt
```
@NotNull
default IntIndexable viewAsInt()
```
    View this double indexable as a short integer indexable. Note that this will usually result in a loss of precision and reduction of the numeric range of the values. This will cast the float values of this indexable on each request, use frozen() on the result to create an independent copy if this seems like a problem to you.
    
    Returns:
    
    an integer indexable view of this indexable
  - viewAsInt
```
@NotNull
default IntIndexable viewAsInt(@NotNull
                                        java.util.function.DoubleToIntFunction convert)
```
    View this indexable as an integer indexable while using a conversion for each value.
    Use frozen() on the result to decouple it from this indexable.
    
    Parameters:
    
    convert - converter applied to each value of this indexable before it is returned from the resulting indexable
    
    Returns:
    
    integer indexable view of this indexable
  - viewAsShort
```
@NotNull
default ShortIndexable viewAsShort()
```
    View this double indexable as a short integer indexable. Note that this will usually result in a loss of precision and severe reduction of the numeric range of the values. This will cast the float values of this indexable on each request, use frozen() on the result to create an independent copy if this seems like a problem to you.
    
    Returns:
    
    a short integer indexable view of this indexable
  - viewAsByte
```
@NotNull
default ByteIndexable viewAsByte()
```
    View this double indexable as a byte integer indexable. Note that this will usually result in a loss of precision and severe reduction of the numeric range. This will cast the float values of this indexable on each request, use frozen() on the result to create an independent copy if this seems like a problem to you.
    
    Returns:
    
    a byte integer indexable view of this indexable
  - viewAsBoolean
```
@NotNull
default BooleanIndexable viewAsBoolean(@NotNull
                                                java.util.function.DoublePredicate convert)
```
    View this indexable as a boolean indexable while using a conversion for each value.
    Use frozen() on the result to decouple it from this indexable.
    
    Parameters:
    
    convert - converter applied to each value of this indexable before it is returned from the resulting indexable
    
    Returns:
    
    boolean indexable view of this indexable
  - deltas
```
@NotNull
default DoubleIndexable deltas()
```
    View the differences between consecutive elements as a new double indexable. This will return an indexable which contains the differences between values of this indexable. E.g. for index 0 the returned indexable will return the difference between the element with index 1 and index 0 of this indexable.
    
    Returns:
    
    differences indexable as described, empty if the size of this indexable is 1 or less. As the returned result is a view, use frozen() if you plan to use it more than once.
  - viewList
```
@NotNull
static DoubleIndexable.Base viewList(@NotNull
                                              java.util.List<? extends java.lang.Number> list)
```
    View a list of numbers as a double indexable. This requires a list of non-null numbers as a base.
    
    Parameters:
    
    list - list used as a base, required to have only non-null elements
    
    Returns:
    
    indexable view of the given list, so any changes of the list will be reflected by the returned Indexable
  - viewList
```
@NotNull
static DoubleIndexable.Base viewList(@NotNull
                                              java.util.List<? extends java.lang.Number> list,
                                              double nullValue)
```
    View a list as an Indexable. This allows to provide a fallback for null elements in the list.
    
    Parameters:
    
    list - list used as a base, required to have only non-null elements
    
    nullValue - value returned for null elements in the list
    
    Returns:
    
    indexable view of the given list, so any changes of the list will be reflected by the returned Indexable
  - viewList
```
@NotNull
static <T> DoubleIndexable.Base viewList(@NotNull
                                                  java.util.List<T> list,
                                                  @NotNull
                                                  java.util.function.ToDoubleFunction<? super T> extractor)
```
    View a generic list as a double indexable.
    
    Type Parameters:
    
    T - element type of list
    
    Parameters:
    
    list - generic list
    
    extractor - extractor function which extracts a double from the elements of list
    
    Returns:
    
    a double indexable view of list
  - viewIndexable
```
@NotNull
static DoubleIndexable.Base viewIndexable(@NotNull
                                                   Indexable<? extends java.lang.Number> indexable)
```
    View a generic Number indexable as double indexable.
    
    Parameters:
    
    indexable - generic indexable with Number elements, required to have only non-null elements
    
    Returns:
    
    double indexable view
  - viewIndexable
```
@NotNull
static DoubleIndexable.Base viewIndexable(@NotNull
                                                   Indexable<? extends java.lang.Number> indexable,
                                                   double nullFallback)
```
    View a generic Number indexable as double indexable.
    
    Parameters:
    
    indexable - generic indexable with Number elements
    
    nullFallback - fallback for null elements
    
    Returns:
    
    double indexable view
  - viewIndexable
```
@NotNull
static <T> DoubleIndexable.Base viewIndexable(@NotNull
                                                       Indexable<T> indexable,
                                                       @NotNull
                                                       java.util.function.ToDoubleFunction<? super T> extractor)
```
    View a generic indexable as a double indexable.
    
    Type Parameters:
    
    T - element type of indexable
    
    Parameters:
    
    indexable - generic indexable
    
    extractor - extractor function which extracts a double from the elements of indexable
    
    Returns:
    
    a double indexable view of indexable
  - viewNumberArray
```
@NotNull
static DoubleIndexable.Base viewNumberArray(@NotNull
                                                     java.lang.Number... array)
```
    View a Number array as an Indexable. To view only part of the array use subSet(int, int).
    
    Parameters:
    
    array - array used as base, required to hold only non-null values
    
    Returns:
    
    indexable view of the given array, any changes to the underlying array will be reflected by the returned Indexable
  - viewArray
```
@NotNull
static DoubleIndexable.Base viewArray(@NotNull
                                               double... array)
```
    View a double array as an Indexable. To view only part of the array use viewArray(double[], int, int).
    
    Parameters:
    
    array - array used as base
    
    Returns:
    
    indexable view of the given array, any changes to the underlying array will be reflected by the returned Indexable
  - viewArray
```
@NotNull
static DoubleIndexable.Base viewArray(@NotNull
                                               double[] array,
                                               int start,
                                               int length)
```
    View part of a double array as an Indexable.
    
    Parameters:
    
    array - array used as base
    
    start - index of first byte to use from the array
    
    length - number of elements to use from the array
    
    Returns:
    
    indexable view of the given array, any changes to the underlying array will be reflected by the returned Indexable
  - viewArray
```
@NotNull
static <T> DoubleIndexable.Base viewArray(@NotNull
                                                   T[] array,
                                                   @NotNull
                                                   java.util.function.ToDoubleFunction<? super T> valueExtract)
```
    View an object array as a double indexable.
    
    Type Parameters:
    
    T - array element type
    
    Parameters:
    
    array - viewed array
    
    valueExtract - converter from array elements to the double values of this indexable
    
    Returns:
    
    indexable view of the given array, any changes to the underlying array will be reflected by the returned Indexable
  - viewArray
```
@NotNull
 @SafeVarargs
static <T> DoubleIndexable.Base viewArray(@NotNull
                                                                 java.util.function.ToDoubleFunction<? super T> extractor,
                                                                 T... array)
```
    View an array of a different type.
    
    Type Parameters:
    
    T - array type
    
    Parameters:
    
    extractor - function used to extract the double value from the different type
    
    array - array of a different type
    
    Returns:
    
    indexable view of the given array
  - init
```
@NotNull
static DoubleIndexable.Base init(int size,
                                          double value)
```
    Get a double indexable of a given size which always returns the same value.
    
    Parameters:
    
    size - size of the returned indexable
    
    value - value returned for each element
    
    Returns:
    
    indexable of size size with always the same element
  - viewByIndex
```
@NotNull
static DoubleIndexable.Base viewByIndex(int size,
                                                 @NotNull
                                                 java.util.function.IntToDoubleFunction producer)
```
    Get a double indexable of a given size which returns elements created by index. This will always call the producer when an element is requested. Use frozen() on the result to create an indexable which avoids this.
    
    Parameters:
    
    size - size of the returned indexable
    
    producer - producer which is called with an index and expected to return the associated value
    
    Returns:
    
    indexable view which calls the producer with the given index when an element is requested
    
    See Also:
    
    initByIndex(int, IntToDoubleFunction)
  - initByIndex
```
@NotNull
static DoubleIndexable initByIndex(int size,
                                            @NotNull
                                            java.util.function.IntToDoubleFunction producer)
```
    Get a double indexable of a given size which returns elements created by index. This will call the producer only once for each element during the call of this method, and return the results on later requests.
    
    Parameters:
    
    size - size of the returned indexable
    
    producer - producer which is called with an index and expected to return the associated value
    
    Returns:
    
    indexable with elements initialized by the producer
    
    See Also:
    
    viewByIndex(int, IntToDoubleFunction)
  - singleton
```
@NotNull
static DoubleIndexable.Base singleton(double value)
```
    View a single double value as a double indexable of size 1.
    
    Parameters:
    
    value - single value
    
    Returns:
    
    indexable with one value
  - emptyIndexable
```
@NotNull
static DoubleIndexable.Base emptyIndexable()
```
    Get an empty indexable set.
    
    Returns:
    
    empty indexable
  - toString
```
@NotNull
static java.lang.String toString(@NotNull
                                          DoubleIndexable indexable)
```
    Create a string representation of the given indexable.
    
    Parameters:
    
    indexable - indexable
    
    Returns:
    
    string representation
  - equal
```
static boolean equal(@NotNull
                     DoubleIndexable indexable1,
                     @NotNull
                     DoubleIndexable indexable2)
```
    Are two double indexables equal?
    This handles NaN values specially so that two of them are considered equal, compare DoublePredicate2.EQUAL_EVEN_NAN.
    
    Parameters:
    
    indexable1 - first indexable
    
    indexable2 - second indexable
    
    Returns:
    
    true if both indexables contain the same values in the same sequence
    false if sizes or values differ
  - equalStandard
```
static boolean equalStandard(@NotNull
                             DoubleIndexable indexable1,
                             @NotNull
                             DoubleIndexable indexable2)
```
    Are two double indexables equal?
    This handles NaN values according to the standard so that two of them are considered non-equal, compare DoublePredicate2.EQUAL_STANDARD.
    
    Parameters:
    
    indexable1 - first indexable
    
    indexable2 - second indexable
    
    Returns:
    
    true if both indexables contain the same values in the same sequence
    false if sizes or values differ
  - equal
```
static boolean equal(@NotNull
                     DoubleIndexable indexable1,
                     @NotNull
                     DoubleIndexable indexable2,
                     @NotNull
                     DoublePredicate2 checker)
```
    Are two double indexables equal?
    
    Parameters:
    
    indexable1 - first indexable
    
    indexable2 - second indexable
    
    checker - equality checker, this can be DoublePredicate2.EQUAL_STANDARD pr DoublePredicate2.EQUAL_EVEN_NAN which handle NaN differently, or allow for a small epsilon difference
    
    Returns:
    
    true if both indexables contain the same values as defined by the checker in the same sequence
    false if sizes or values differ
  - equal
```
static boolean equal(@NotNull
                     DoubleIndexable indexable1,
                     @Nullable
                     java.lang.Object indexable2)
```
    Are two double indexables equal? This is a convenience method which may be called from implementations for their Object.equals(Object) method.
    
    Parameters:
    
    indexable1 - first indexable
    
    indexable2 - object expected to be an indexable itself
    
    Returns:
    
    true if both indexables contain the same values in the same sequence
    false if the second object is not an indexable, of if sizes or values differ
  - compare
```
static int compare(@NotNull
                   DoubleIndexable indexable1,
                   @NotNull
                   DoubleIndexable indexable2)
```
    Compare two double indexables. This compares the two indexables lexically element by element using Double.compareTo(Double) until either the first difference is found (smaller of the two values define the lower indexable) or the end of one is met (shorter indexable is less).
    
    Parameters:
    
    indexable1 - first indexable
    
    indexable2 - second indexable
    
    Returns:
    
    < 0> if indexable1 < indxable2, 0 if indexable1 == indexable2, or > 0 if indexable1 > indexable2
  - hash
```
static int hash(@NotNull
                DoubleIndexable indexable)
```
    Calculate a hashcode for a double indexable.
    
    Parameters:
    
    indexable - indexable for which the hash code is required
    
    Returns:
    
    hash code for the given indexable
  - withCachedHash
```
@NotNull
static DoubleIndexable.Base withCachedHash(@NotNull
                                                    DoubleIndexable indexable)
```
    Wrap an indexable with one which caches the hash value. This is useful if indexables are used as hash keys because hash value calculation is expensive.
    The wrapped indexable must not change after it is wrapped, otherwise strange things are expected to happen.
    
    Parameters:
    
    indexable - wrapped indexable, must not change
    
    Returns:
    
    indexable which forwards most methods to indexable, but also provides useful implementations for Object.hashCode(), Object.equals(Object), and Object.toString()
  - isOrdered
```
default boolean isOrdered(@NotNull
                          DoubleOrdering order)
```
    Is this indexable sorted according to the given ordering? This method tests that consecutive elements in this indexable or either ascending or the same, but never descending. See isStrictlyOrdered(DoubleOrdering) for a stricter alternative.
    
    Parameters:
    
    order - expected ordering
    
    Returns:
    
    true if this indexable is sorted as defined by order
    false if not
  - isStrictlyOrdered
```
default boolean isStrictlyOrdered(@NotNull
                                  DoubleOrdering order)
```
    Is this indexable strictly sorted according to the given ordering? This method tests that consecutive elements in this indexable or strictly ascending or the same, but never descending. See isOrdered(DoubleOrdering) for a more relaxed alternative.
    
    Parameters:
    
    order - expected ordering
    
    Returns:
    
    true if this indexable is sorted as defined by order
    false if not
  - binarySearch
```
default int binarySearch(double value)
```
    Do a binary search in an indexable ordered in natural ascending order. This requires this indexable to be ordered in standard Java ascending order, i.e. isOrdered(DoubleOrdering) has to return true for this ordering. For efficiency this prerequisite is not checked, but not fulfilling it will make this method return bogus results. If this indexable is only ordered, but not strictly ordered it is not defined which index is returned when the looked up value appears in a sequence of equal values.
    
    Parameters:
    
    value - value to look up
    
    Returns:
    
    a positive integer defining the index where the given value was found, and a negative integer if the value is not contained. The latter defines the insertion point where the looked up value would match into this sorted indexable in the form -(insertIndex + 1).
  - binarySearch
```
default int binarySearch(double value,
                         @NotNull
                         DoubleOrdering order)
```
    Do a binary search in an ordered indexable. This requires this indexable to be ordered in non-descending order as defined by the given order, i.e. isOrdered(DoubleOrdering) has to return true for this order. For efficiency this prerequisite is not checked, but not fulfilling it will make this method return bogus results. If this indexable is only ordered, but not strictly ordered it is not defined which index is returned when the looked up value appears in a sequence of equal values.
    
    Parameters:
    
    value - value to look up
    
    order - sort order
    
    Returns:
    
    a positive integer defining the index where the given value was found, and a negative integer if the value is not contained. The latter defines the insertion point where the looked up value would match into this sorted indexable in the form -(insertIndex + 1).
  - ordered
```
@NotNull
default MutableDoubleIndexable ordered(@NotNull
                                                DoubleOrdering order)
```
    Create a (mutable) double indexable from the values of this indexable which is ordered as defined by the given ordering.
    If natural ordering is required prefer calling ordered() because that typically runs 1.5 times faster.
    
    Parameters:
    
    order - sort order
    
    Returns:
    
    independent indexable with sorted values
  - ordered
```
@NotNull
default MutableDoubleIndexable ordered()
```
    Create a (mutable) double indexable from the values of this indexable which is ordered in natural order.
    This can be some 1.5x faster than using ordered(DoubleOrdering) with standard Java order.
    
    Returns:
    
    independent indexable with sorted values
  - asBase
```
@NotNull
default DoubleIndexable.Base asBase()
```
    Make this double indexable usable as a base class with defined standard Object methods.
    
    Returns:
    
    based version of this indexable

Interface DoubleIndexable

Nested Class Summary

Field Summary

Fields inherited from interface de.caff.generics.PrimitiveDoubleIterable

Fields inherited from interface de.caff.generics.Sizeable

Method Summary

Methods inherited from interface de.caff.generics.PrimitiveDoubleIterable

Methods inherited from interface java.lang.Iterable

Methods inherited from interface de.caff.generics.Sizeable

Field Detail

SINGLE_0

EMPTY

Method Detail

get

gyt

reverse

isEmpty

doubleIterator

doubleIterator

iterator

firstValue

lastValue

listIterator

subSet

sybSet

tailSet

headSet

asCollection

asList

toList

addAllTo

asIndexable

toArray

addToArray

addToArray

indexes

intIndexes

foldLeft

transformed

nextMatch

firstMatch

previousMatch

lastMatch

frozen

doubleSpliterator

frozenDoubleSpliterator

view

withInsertedValueAt

withAppendedValue

withExchangedValueAt

withRemovedValueAt

withSwappedValuesAt

rotated

viewOp

viewAsFloat

viewAsLong

viewAsLong

viewAsInt

viewAsInt

viewAsShort

viewAsByte

viewAsBoolean

deltas

viewList

viewList

viewList

viewIndexable

viewIndexable

viewIndexable

viewNumberArray

viewArray

viewArray

viewArray

viewArray

init

viewByIndex

initByIndex

singleton

emptyIndexable

toString