de.caff.generics

Interface MutableDoubleIndexable

All Superinterfaces:

Copyable<MutableDoubleIndexable>, DoubleIndexable, java.lang.Iterable<java.lang.Double>, PrimitiveDoubleIterable, Sizeable

All Known Implementing Classes:

MutableDoubleIndexable.Base

public interface MutableDoubleIndexable
extends DoubleIndexable, Copyable<MutableDoubleIndexable>

Primitive double indexable with fixed length but mutable content. This may be used as a substitute for double[] as it eg allows read-only views or transparent views of subsets of the array.

Since:

November 01, 2019

Author:

Rammi

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	MutableDoubleIndexable.Base Abstract base class which provides useful implementations for Object.equals(Object), Object.hashCode(), Object.toString().

Nested classes/interfaces inherited from interface de.caff.generics.DoubleIndexable

DoubleIndexable.DoubleIndexableSpliterator

Field Summary

Fields

Modifier and Type	Field and Description
static MutableDoubleIndexable.Base	EMPTY Empty mutable indexable.

Fields inherited from interface de.caff.generics.DoubleIndexable

SINGLE_0

Fields inherited from interface de.caff.generics.PrimitiveDoubleIterable

EMPTY_DOUBLE_ITERATOR

Fields inherited from interface de.caff.generics.Sizeable

NULL

Method Summary

Modifier and Type	Method and Description
default java.util.List<java.lang.Double>	asList() View this indexable as a standard list.
static MutableDoubleIndexable.Base	based(MutableDoubleIndexable indexable) View any mutable double indexable as a base double indexable.
static <IN> MutableDoubleIndexable.Base	copy(java.util.Collection<IN> collection, java.util.function.Function<IN,java.lang.Number> copier) Create a mutable indexable which is initialized from copied elements of a given collection.
static MutableDoubleIndexable.Base	copyOf(java.util.Collection<? extends java.lang.Number> collection) Create a mutable indexable which is initialized from a given collection.
static MutableDoubleIndexable.Base	empty()
static MutableDoubleIndexable.Base	fromArray(double... elements) Create a mutable indexable which is initialized from eleemnts of the given array.
static MutableDoubleIndexable.Base	fromArray(double[] elements, int startIndex, int length) Create a mutable indexable which is initialized from elements of the given array.
static MutableDoubleIndexable.Base	fromByteIndexable(ByteIndexable indexable) Return a mutable double indexable initialized with the content of a standard byte indexable.
static MutableDoubleIndexable.Base	fromDoubleIndexable(DoubleIndexable indexable) Return a mutable double indexable initialized with the content of a standard double indexable.
static MutableDoubleIndexable.Base	fromFloatIndexable(FloatIndexable indexable) Return a mutable double indexable initialized with the content of a standard float indexable.
static MutableDoubleIndexable.Base	fromIndexable(Indexable<? extends java.lang.Number> indexable) Create a mutable indexable which is the copy of a standard indexable.
static <B> MutableDoubleIndexable.Base	fromIndexable(Indexable<B> indexable, java.util.function.Function<? super B,? extends java.lang.Number> converter) Create a mutable indexable which is the copy of a standard indexable.
static MutableDoubleIndexable.Base	fromIntIndexable(IntIndexable indexable) Return a mutable double indexable initialized with the content of a standard int indexable.
static MutableDoubleIndexable.Base	fromIterable(int size, java.lang.Iterable<? extends java.lang.Number> iter) Create a mutable indexable from an iterable or a part of it.
static MutableDoubleIndexable.Base	fromLongIndexable(LongIndexable indexable) Return a mutable double indexable initialized with the content of a standard long indexable.
static MutableDoubleIndexable.Base	fromShortIndexable(ShortIndexable indexable) Return a mutable double indexable initialized with the content of a standard short indexable.
default MutableDoubleIndexable	getCopy() Get a copy of this object.
default MutableDoubleIndexable.Base	headSet(int toIndex) Create an indexable subset from the last elements of this indexable set.
static MutableDoubleIndexable.Base	init(int size, double value) Create a mutable
static MutableDoubleIndexable.Base	init(int size, java.util.function.DoubleSupplier creator) Initialize a mutable indexable to a given size.
static MutableDoubleIndexable.Base	initByIndex(int size, java.util.function.IntToDoubleFunction producer) Get a mutable double indexable of a given size which contains elements created by index.
default void	initByIndex(java.util.function.IntToDoubleFunction setter) Set all values of this double indexable by index.
default MutableDoubleIndexable.Base	reverse() Get this indexable but with inverted order.
void	set(int index, double value) Set the element at the given index.
default int	setFrom(java.lang.Iterable<? extends java.lang.Number> iterable) Set the values of this mutable double indexable one after the other from the given Number iterable until either the iterable is emptied or Sizeable.size() elements are set.
default int	setFrom(java.lang.Iterable<? extends java.lang.Number> iterable, int startIndex, int numElements) Set the values of this mutable double indexable one after the other from the given iterable until either the iterable is emptied or numElements elements are set.
default MutableDoubleIndexable.Base	subSet(int fromIndex, int toIndex) Get an indexable subset.
default MutableDoubleIndexable.Base	sybSet(int fromIndex, int toIndex) Get an indexable subset.
default void	syt(int index, double value) Pythonesque set.
default MutableDoubleIndexable.Base	tailSet(int fromIndex) Create an indexable subset from the last elements of this indexable set.
static MutableDoubleIndexable.Base	viewArray(double... array) Mutable indexable view which operates on the given array.
static <T> MutableDoubleIndexable.Base	viewIndexable(Indexable<T> indexable, java.util.function.ToDoubleFunction<? super T> getter, DoubleSetter<? super T> setter) View a generic indexable as a mutable double indexable by accessing a double property of the elements of the underlying generic indexable.
static MutableDoubleIndexable.Base	viewList(java.util.List<java.lang.Double> list) Mutable indexable view which operates on the given array.
static MutableDoubleIndexable.Base	zeroed(int size) Create a mutable double indexable with size 0.0 elements.

Methods inherited from interface de.caff.generics.DoubleIndexable

addAllTo, addToArray, addToArray, asBase, asCollection, asIndexable, compare, deltas, doubleIterator, doubleIterator, doubleSpliterator, emptyIndexable, equal, equal, equal, equalStandard, firstMatch, foldLeft, frozen, frozenDoubleSpliterator, get, gyt, hash, indexes, intIndexes, isEmpty, iterator, lastMatch, listIterator, nextMatch, previousMatch, rotated, singleton, toArray, toList, toString, transformed, view, viewArray, viewArray, viewAsBoolean, viewAsByte, viewAsFloat, viewAsInt, viewAsInt, viewAsLong, viewAsLong, viewAsShort, viewByIndex, viewIndexable, viewIndexable, viewIndexable, viewList, viewList, viewList, viewNumberArray, withAppendedValue, withCachedHash, withExchangedValueAt, withInsertedValueAt, withRemovedValueAt, withSwappedValuesAt

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

Methods inherited from interface de.caff.generics.Copyable

copy

Field Detail

EMPTY

static final MutableDoubleIndexable.Base EMPTY

Empty mutable indexable. Use empty() instead.

Method Detail

set

void set(int index,
         double value)

Set the element at the given index.

Parameters:

index - index between 0 and size() - 1

value - value to put to the given index

syt

default void syt(int index,
                 double value)

Pythonesque set. 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

value - value to put to the given index

setFrom

default int setFrom(@NotNull
                    java.lang.Iterable<? extends java.lang.Number> iterable)

Set the values of this mutable double indexable one after the other from the given Number iterable until either the iterable is emptied or Sizeable.size() elements are set.

Parameters:

iterable - iterable from which this indexable is filled

Returns:

number of elements set

setFrom

default int setFrom(@NotNull
                    java.lang.Iterable<? extends java.lang.Number> iterable,
                    int startIndex,
                    int numElements)

Set the values of this mutable double indexable one after the other from the given iterable until either the iterable is emptied or numElements elements are set.

Parameters:

iterable - iterable from which this indexable is filled

startIndex - start index where the setting begins

numElements - number of elements to set

Returns:

number of elements set

subSet

@NotNull
default MutableDoubleIndexable.Base subSet(int fromIndex,
                                                    int toIndex)

Description copied from interface: DoubleIndexable

Get an indexable subset. The subset includes indices fromIndex to toIndex - 1.

Specified by:

subSet in interface DoubleIndexable

Parameters:

fromIndex - start index of sub set

toIndex - index after last index

Returns:

indxable subset view of this indexable

sybSet

@NotNull
default MutableDoubleIndexable.Base sybSet(int fromIndex,
                                                    int toIndex)

Description copied from interface: DoubleIndexable

Get an indexable subset. This is the Pythonesque version which allows negative indexes.

Specified by:

sybSet in interface DoubleIndexable

Parameters:

fromIndex - start index of sub set

toIndex - end index of sub set

Returns:

indexable subset view of this indexable set

tailSet

@NotNull
default MutableDoubleIndexable.Base tailSet(int fromIndex)

Description copied from interface: DoubleIndexable

Create an indexable subset from the last elements of this indexable set. This already allows Pythonesquew indexing.

Specified by:

tailSet in interface DoubleIndexable

Parameters:

fromIndex - index to start with, negative counts from the back

Returns:

indexable subset view of this indexable set

headSet

@NotNull
default MutableDoubleIndexable.Base headSet(int toIndex)

Description copied from interface: DoubleIndexable

Create an indexable subset from the last elements of this indexable set. This already allows Pythonesquew indexing.

Specified by:

headSet in interface DoubleIndexable

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

reverse

@NotNull
default MutableDoubleIndexable.Base reverse()

Description copied from interface: DoubleIndexable

Get this indexable but with inverted order.

Specified by:

reverse in interface DoubleIndexable

Returns:

a view to this indexable which accesses the elements in reverse order

initByIndex

default void initByIndex(@NotNull
                         java.util.function.IntToDoubleFunction setter)

Set all values of this double indexable by index.

Parameters:

setter - setter which provides the value to be set for a given index

asList

@NotNull
default java.util.List<java.lang.Double> asList()

View this indexable as a standard list. Overwritten to allow for modifications. The returned list will allow usage of the List.set(int, Object) method, but neither any adding nor deleting methods. Standard sorting algorithms will work on the returned list as a sorting algorithm is expected to neither move nor add elements.

Specified by:

asList in interface DoubleIndexable

Returns:

list allowing setting elements

See Also:

DoubleIndexable.toList()

getCopy

@NotNull
default MutableDoubleIndexable getCopy()

Description copied from interface: Copyable

Get a copy of this object. Immutable objects are allowed to return themselves. The copy needs not to be of the same class, it just has to fulfill the type restriction.

Specified by:

getCopy in interface Copyable<MutableDoubleIndexable>

Returns:

independent copy of this object

based

@NotNull
static MutableDoubleIndexable.Base based(@NotNull
                                                  MutableDoubleIndexable indexable)

View any mutable double indexable as a base double indexable. The latter provides various standard methods for comparison, output and hanshing.

Parameters:

indexable - mutqable double indexable to view as a MutableDoubleIndexable.Base mutable double indexable

Returns:

base view of given indexable, or the indexable itself if it is already a Base

init

@NotNull
static MutableDoubleIndexable.Base init(int size,
                                                 @NotNull
                                                 java.util.function.DoubleSupplier creator)

Initialize a mutable indexable to a given size.

Parameters:

size - size of indexable

creator - creator for the initial elements

Returns:

mutable indexable with the given size

See Also:

zeroed(int), init(int, double)

copyOf

@NotNull
static MutableDoubleIndexable.Base copyOf(@NotNull
                                                   java.util.Collection<? extends java.lang.Number> collection)

Create a mutable indexable which is initialized from a given collection.

Parameters:

collection - collection

Returns:

mutable indexable

copy

@NotNull
static <IN> MutableDoubleIndexable.Base copy(@NotNull
                                                      java.util.Collection<IN> collection,
                                                      @NotNull
                                                      java.util.function.Function<IN,java.lang.Number> copier)

Create a mutable indexable which is initialized from copied elements of a given collection.

Type Parameters:

IN - incoming element type

Parameters:

collection - collection

copier - element copier

Returns:

mutable indexable

empty

@NotNull
static MutableDoubleIndexable.Base empty()

fromArray

@NotNull
static MutableDoubleIndexable.Base fromArray(@NotNull
                                                      double... elements)

Create a mutable indexable which is initialized from eleemnts of the given array.

Parameters:

elements - elements

Returns:

mutable indexable independent of elements

fromArray

@NotNull
static MutableDoubleIndexable.Base fromArray(@NotNull
                                                      double[] elements,
                                                      int startIndex,
                                                      int length)

Create a mutable indexable which is initialized from elements of the given array.

Parameters:

elements - array of elements

startIndex - index of first element used in the returned indxable

length - length number of elements used in the returned indexable

Returns:

mutable indexable independnet of eleements

viewArray

@NotNull
static MutableDoubleIndexable.Base viewArray(@NotNull
                                                      double... array)

Mutable indexable view which operates on the given array. Any changes done by the returned indexable will be forwarded to the array.

Specified by:

viewArray in interface DoubleIndexable

Parameters:

array - array

Returns:

mutable indexable view of the given array

viewList

@NotNull
static MutableDoubleIndexable.Base viewList(@NotNull
                                                     java.util.List<java.lang.Double> list)

Mutable indexable view which operates on the given array. Any changes done by the returned indexable will be forwarded to the list.

Parameters:

list - list

Returns:

mutable indexable view of the given list

viewIndexable

@NotNull
static <T> MutableDoubleIndexable.Base viewIndexable(@NotNull
                                                              Indexable<T> indexable,
                                                              @NotNull
                                                              java.util.function.ToDoubleFunction<? super T> getter,
                                                              @NotNull
                                                              DoubleSetter<? super T> setter)

View a generic indexable as a mutable double indexable by accessing a double property of the elements of the underlying generic indexable.

This is useful if you have complex items, but are interested into only one (double) property of each item.

Type Parameters:

T - element type of the underlying indexable

Parameters:

indexable - underlying generic indexable

getter - function used to extract the property of interest

setter - procedure used to set the property of interest

Returns:

mutable double indexable view of the underlying indexable

fromIndexable

@NotNull
static MutableDoubleIndexable.Base fromIndexable(@NotNull
                                                          Indexable<? extends java.lang.Number> indexable)

Create a mutable indexable which is the copy of a standard indexable.

Parameters:

indexable - standard indexable

Returns:

mutable indexable initialize from the standard indexable

fromIndexable

@NotNull
static <B> MutableDoubleIndexable.Base fromIndexable(@NotNull
                                                              Indexable<B> indexable,
                                                              @NotNull
                                                              java.util.function.Function<? super B,? extends java.lang.Number> converter)

Create a mutable indexable which is the copy of a standard indexable. This especieally allows to copy each element during the initialization.

Type Parameters:

B - element type of incoming idexable

Parameters:

indexable - base indexable

converter - converter from base indexable type to result element type,

Returns:

mutable indexable

fromDoubleIndexable

@NotNull
static MutableDoubleIndexable.Base fromDoubleIndexable(@NotNull
                                                                DoubleIndexable indexable)

Return a mutable double indexable initialized with the content of a standard double indexable.

Parameters:

indexable - double indexable

Returns:

mutable indexable initialized with the values of the given double indexable

fromFloatIndexable

@NotNull
static MutableDoubleIndexable.Base fromFloatIndexable(@NotNull
                                                               FloatIndexable indexable)

Return a mutable double indexable initialized with the content of a standard float indexable.

Parameters:

indexable - float indexable

Returns:

mutable indexable initialized with the values of the given float indexable

fromLongIndexable

@NotNull
static MutableDoubleIndexable.Base fromLongIndexable(@NotNull
                                                              LongIndexable indexable)

Return a mutable double indexable initialized with the content of a standard long indexable. Please note that various long values cannot be converted to double without loss of accuracy.

Parameters:

indexable - long indexable

Returns:

mutable indexable initialized with the values of the given long indexable

fromIntIndexable

@NotNull
static MutableDoubleIndexable.Base fromIntIndexable(@NotNull
                                                             IntIndexable indexable)

Return a mutable double indexable initialized with the content of a standard int indexable.

Parameters:

indexable - int indexable

Returns:

mutable indexable initialized with the values of the given int indexable

fromShortIndexable

@NotNull
static MutableDoubleIndexable.Base fromShortIndexable(@NotNull
                                                               ShortIndexable indexable)

Return a mutable double indexable initialized with the content of a standard short indexable.

Parameters:

indexable - long indexable

Returns:

mutable indexable initialized with the values of the given short indexable

fromByteIndexable

@NotNull
static MutableDoubleIndexable.Base fromByteIndexable(@NotNull
                                                              ByteIndexable indexable)

Return a mutable double indexable initialized with the content of a standard byte indexable.

Parameters:

indexable - long indexable

Returns:

mutable indexable initialized with the values of the given byte indexable

fromIterable

@NotNull
static MutableDoubleIndexable.Base fromIterable(int size,
                                                         @NotNull
                                                         java.lang.Iterable<? extends java.lang.Number> iter)

Create a mutable indexable from an iterable or a part of it.

Parameters:

size - maximum size of returned indexable

iter - iterable used for initializing the indexable

Returns:

mutable indexable

zeroed

@NotNull
static MutableDoubleIndexable.Base zeroed(int size)

Create a mutable double indexable with size 0.0 elements.

Parameters:

size - required size of returned mutable double indexable

Returns:

mutable double indexable of the given size initialized with 0.0

See Also:

init(int, double), init(int, DoubleSupplier)

init

@NotNull
static MutableDoubleIndexable.Base init(int size,
                                                 double value)

Create a mutable

Specified by:

init in interface DoubleIndexable

Parameters:

size - required size of returned mutable double indexable

value - initial value of all elements

Returns:

mutable double indexable of the given size initialized with value

See Also:

init(int, DoubleSupplier), zeroed(int)

initByIndex

@NotNull
static MutableDoubleIndexable.Base initByIndex(int size,
                                                        @NotNull
                                                        java.util.function.IntToDoubleFunction producer)

Get a mutable double indexable of a given size which contains elements created by index.

Specified by:

initByIndex in interface DoubleIndexable

Parameters:

size - size of the returned indexable

producer - producer which is called with an index and expected to return the associated value

Returns:

a mutable double indexable with the given size with elements initialized by calling the producer

See Also:

DoubleIndexable.viewByIndex(int, IntToDoubleFunction)