de.caff.generics

## Interface MutableIntIndexable

- All Superinterfaces:
    Copyable<MutableIntIndexable>, IntCountable, IntIndexable, java.lang.Iterable<java.lang.Integer>, PrimitiveIntIterable, Sizeable
  All Known Implementing Classes:
    MutableIntIndexable.Base

      public interface MutableIntIndexable
      extends IntIndexable, Copyable<MutableIntIndexable>

  Primitive int indexable with fixed length but mutable content. This may be used as a substitute for `int[]` 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` | `MutableIntIndexable.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.IntIndexable

      `IntIndexable.EntryConsumer, IntIndexable.IntIndexableSpliterator`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static MutableIntIndexable.Base` | `EMPTY` Empty mutable indexable.

    - ### Fields inherited from interface de.caff.generics.IntIndexable

      `SINGLE_0`

    - ### Fields inherited from interface de.caff.generics.PrimitiveIntIterable

      `EMPTY_INT_ITERATOR`

    - ### Fields inherited from interface de.caff.generics.Sizeable

      `NULL`

  - ### Method Summary

    All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `default java.util.List<java.lang.Integer>` | `asList()` View this indexable as a standard list.
    `static MutableIntIndexable.Base` | `based(MutableIntIndexable indexable)` View any mutable int indexable as a base int indexable.
    `static <IN> MutableIntIndexable.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.
    `default void` | `copyInternally(int fromIndex, int toIndex, int numElements)` Copy elements inside this indexable.
    `static MutableIntIndexable.Base` | `copyOf(java.util.Collection<? extends java.lang.Number> collection)` Create a mutable indexable which is initialized from a given collection.
    `static MutableIntIndexable.Base` | `empty()` Get an empty countable.
    `default void` | `fillFrom(java.util.function.IntUnaryOperator provider)` Fill this indexable from a provider.
    `static MutableIntIndexable.Base` | `fromArray(int... elements)` Create a mutable indexable which is initialized from elements of the given array.
    `static MutableIntIndexable.Base` | `fromArray(int[] elements, int startIndex, int length)` Create a mutable indexable which is initialized from elements of the given array.
    `static MutableIntIndexable.Base` | `fromByteIndexable(ByteIndexable indexable)` Return a mutable int indexable initialized with the content of a standard byte indexable.
    `static MutableIntIndexable.Base` | `fromCharIndexable(CharIndexable indexable)` Return a mutable int indexable initialized with the content of a standard char indexable.
    `static MutableIntIndexable.Base` | `fromDoubleIndexable(DoubleIndexable indexable)` Return a mutable int indexable initialized with the content of a standard double indexable.
    `static MutableIntIndexable.Base` | `fromFloatIndexable(FloatIndexable indexable)` Return a mutable int indexable initialized with the content of a standard float indexable.
    `static MutableIntIndexable.Base` | `fromIndexable(Indexable<? extends java.lang.Number> indexable)` Create a mutable indexable which is the copy of a standard indexable.
    `static <B> MutableIntIndexable.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 MutableIntIndexable.Base` | `fromIntIndexable(IntIndexable indexable)` Return a mutable int indexable initialized with the content of a standard int indexable.
    `static MutableIntIndexable.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 MutableIntIndexable.Base` | `fromLongIndexable(LongIndexable indexable)` Return a mutable int indexable initialized with the content of a standard long indexable.
    `static MutableIntIndexable.Base` | `fromShortIndexable(ShortIndexable indexable)` Return a mutable int indexable initialized with the content of a standard short indexable.
    `default MutableIntIndexable` | `getCopy()` Get a copy of this object.
    `default MutableIntIndexable.Base` | `headSet(int toIndex)` Create an indexable subset from the last elements of this indexable set.
    `static MutableIntIndexable.Base` | `init(int size, int value)` Create a mutable
    `static MutableIntIndexable.Base` | `init(int size, java.util.function.IntSupplier creator)` Initialize a mutable indexable to a given size.
    `static MutableIntIndexable.Base` | `initByIndex(int size, java.util.function.IntUnaryOperator producer)` Get a mutable integer indexable of a given size which contains elements created by index.
    `default void` | `initByIndex(java.util.function.IntUnaryOperator setter)` Deprecated. use `fillFrom(IntUnaryOperator)` instead
    `default void` | `order()` Order the elements in this indexable in their natural order.
    `default void` | `order(IntOrdering ordering)` Order the elements in this indexable by the given ordering.
    `default MutableIntIndexable.Base` | `reverse()` Get this indexable but with inverted order.
    `default void` | `revert()` Revert the elements in this indexable.
    `default void` | `revert(int from, int to)` Revert the order of all elements in the given range.
    `void` | `set(int index, int 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 int 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 int indexable one after the other from the given iterable until either the iterable is emptied or `numElements` elements are set.
    `default void` | `setFromArray(int[] array, int arrayIndex, int startIndex, int numElements)` Set consecutive entries from an array.
    `default void` | `setMulti(int from, int len, int value)` Set multiple elements to the same value.
    `default void` | `shuffle(java.util.Random random)` Randomize the content of this mutable indexable.
    `default MutableIntIndexable.Base` | `subSet(int fromIndex, int toIndex)` Get an indexable subset.
    `default void` | `swap(int idx1, int idx2)` Swap the values at two indices.
    `default void` | `swyp(int idx1, int idx2)` Swap the values at two indices using Pythonesque indices.
    `default MutableIntIndexable.Base` | `sybSet(int fromIndex, int toIndex)` Get an indexable subset.
    `default void` | `syt(int index, int value)` Pythonesque set.
    `default MutableIntIndexable.Base` | `tailSet(int fromIndex)` Create an indexable subset from the last elements of this indexable set.
    `static MutableIntIndexable.Base` | `viewArray(int[] array)` Mutable indexable view which operates on the given array.
    `static MutableIntIndexable.Base` | `viewArray(int[] array, int start, int length)` Mutable indexable view which operates on a part of the given array.
    `static <T> MutableIntIndexable.Base` | `viewIndexable(Indexable<T> indexable, java.util.function.ToIntFunction<? super T> getter, IntSetter<? super T> setter)` View a generic indexable as a mutable int indexable by accessing a int property of the elements of the underlying generic indexable.
    `static MutableIntIndexable.Base` | `viewList(java.util.List<java.lang.Integer> list)` Mutable indexable view which operates on the given array.
    `static MutableIntIndexable.Base` | `zeroed(int size)` Create a mutable int indexable with `size` `0.0` elements.

    - ### Methods inherited from interface de.caff.generics.IntIndexable

      `addAllTo, addToArray, addToArray, asBase, asCollection, asIndexable, asLongIndexable, asUnsignedIndexable, binarySearch, binarySearch, compare, compareUnsigned, emptyIndexable, equal, equal, firstMatch, foldLeft, forEachIntEntry, frozen, frozenIntSpliterator, get, getMod, gyt, hash, indexes, intIndexes, intIterator, intIterator, intSpliterator, isEmpty, isOrdered, isStrictlyOrdered, iterator, lastMatch, listIterator, nextMatch, ordered, ordered, previousMatch, range, range, rangeFromSize, rotated, singleton, toArray, toList, toString, view, viewArray, viewAsBoolean, viewAsByte, viewAsChar, viewAsDouble, viewAsDouble, viewAsFloat, viewAsLong, viewAsLong, viewAsShort, viewAsUnsignedLong, viewByIndex, viewIndexable, viewIndexable, viewIndexable, viewList, viewList, viewList, viewNumberArray, viewOp, with, withAppendedValue, withCachedHash, withExchangedValueAt, withInsertedValueAt, withRemovedValueAt, withSwappedValuesAt, wyth`

    - ### Methods inherited from interface de.caff.generics.IntCountable

      `filtered, first, isEqual, isSorted, isStrictlySorted, last, sorted, toString, uniform, viewCollection, viewCollection, viewCollectionN, viewCollectionN`

    - ### Methods inherited from interface de.caff.generics.PrimitiveIntIterable

      `average, containsInt, forEachInt, forEachIntFragile, longSum, longSumX, spliterator, stream, sum, sumX`

    - ### 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 MutableIntIndexable.Base EMPTY

      Empty mutable indexable. Use `empty()` instead.

  - ### Method Detail

    - #### set

          void set(int index,
                   int 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,
                           int 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 int 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 int 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

    - #### setFromArray

          default void setFromArray(@NotNull
                                    int[] array,
                                    int arrayIndex,
                                    int startIndex,
                                    int numElements)

      Set consecutive entries from an array. This will set less elements
      Parameters:
        `array` - array with elements to set from
        `arrayIndex` - start index in the array
        `startIndex` - start index in this mutable indexable
        `numElements` - number of elements to copy
      Throws:
        `java.lang.IndexOutOfBoundsException` - if this mutable indexable would overflow by this operation
        `java.lang.ArrayIndexOutOfBoundsException` - if array overflows by this operation

    - #### setMulti

          default void setMulti(int from,
                                int len,
                                int value)

      Set multiple elements to the same value.
      Parameters:
        `from` - first index to be set (Pythonesque)
        `len` - number of elements to be set (non-negative)
        `value` - value to be set

    - #### copyInternally

          default void copyInternally(int fromIndex,
                                      int toIndex,
                                      int numElements)

      Copy elements inside this indexable.
      Parameters:
        `fromIndex` - start index from where elements are copied (Pythonesque)
        `toIndex` - start index to where elements are copied (Pythonesque)
        `numElements` - number of elements to copy

    - #### fillFrom

          default void fillFrom(@NotNull
                                java.util.function.IntUnaryOperator provider)

      Fill this indexable from a provider.
      Parameters:
        `provider` - provider which is called for each index and provides the element for that index

    - #### swap

          default void swap(int idx1,
                            int idx2)

      Swap the values at two indices.
      Parameters:
        `idx1` - first index
        `idx2` - second index

    - #### swyp

          default void swyp(int idx1,
                            int idx2)

      Swap the values at two indices using Pythonesque indices.
      Parameters:
        `idx1` - first index (`Pythonesque`)
        `idx2` - second index (`Pythonesque`)

    - #### subSet

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

      Description copied from interface: `IntIndexable`
      Get an indexable subset. The subset includes indices `fromIndex` to `toIndex - 1`.
      Specified by:
        `subSet` in interface `IntIndexable`
      Parameters:
        `fromIndex` - start index of sub set
        `toIndex` - index after last index
      Returns:
        indxable subset view of this indexable

    - #### sybSet

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

      Description copied from interface: `IntIndexable`
      Get an indexable subset. This is the Pythonesque version which allows negative indexes.
      Specified by:
        `sybSet` in interface `IntIndexable`
      Parameters:
        `fromIndex` - start index of sub set
        `toIndex` - end index of sub set
      Returns:
        indexable subset view of this indexable set

    - #### tailSet

          @NotNull
          default MutableIntIndexable.Base tailSet(int fromIndex)

      Description copied from interface: `IntIndexable`
      Create an indexable subset from the last elements of this indexable set. This already allows Pythonesquew indexing.
      Specified by:
        `tailSet` in interface `IntIndexable`
      Parameters:
        `fromIndex` - index to start with, negative counts from the back
      Returns:
        indexable subset view of this indexable set

    - #### headSet

          @NotNull
          default MutableIntIndexable.Base headSet(int toIndex)

      Description copied from interface: `IntIndexable`
      Create an indexable subset from the last elements of this indexable set. This already allows Pythonesquew indexing.
      Specified by:
        `headSet` in interface `IntIndexable`
      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 MutableIntIndexable.Base reverse()

      Description copied from interface: `IntIndexable`
      Get this indexable but with inverted order.
      Specified by:
        `reverse` in interface `IntIndexable`
      Returns:
        a view to this indexable which accesses the elements in reverse order

    - #### revert

          default void revert(int from,
                              int to)

      Revert the order of all elements in the given range. Attention: the `to` element is also included in the reversion to allow easy reversion at the end by using `-1`.
      Parameters:
        `from` - start element of reversion (Pythonesque), included
        `to` - end element of reversion (Pythonesque), included

    - #### revert

          default void revert()

      Revert the elements in this indexable. This reverts the order of all elements.

    - #### order

          default void order(@NotNull
                             IntOrdering ordering)

      Order the elements in this indexable by the given ordering. After this call the elements of this indexable are reordered so that `IntIndexable.isOrdered(IntOrdering)` returns `true` for the given `ordering`.

      If natural ordering is required use `order()` because in many cases this can avoid the overhead of invoking the ordering and sort much faster (typically 1.5x as fast).

      Parameters:
        `ordering` - ordering to apply

    - #### order

          default void order()

      Order the elements in this indexable in their natural order. This method is typically 1.5 times faster than `order(IntOrdering)` with `natural order`.

    - #### shuffle

          default void shuffle(@NotNull
                               java.util.Random random)

      Randomize the content of this mutable indexable. This will reorder the elements randomly.
      Parameters:
        `random` - random number generator

    - #### initByIndex

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

      Deprecated. use `fillFrom(IntUnaryOperator)` instead
      Set all values of this integer 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.Integer> 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 `IntIndexable`
      Returns:
        list allowing setting elements
      See Also:
        `IntIndexable.toList()`

    - #### getCopy

          @NotNull
          default MutableIntIndexable 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<MutableIntIndexable>`
      Returns:
        independent copy of this object

    - #### based

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

      View any mutable int indexable as a base int indexable. The latter provides various standard methods for comparison, output and hanshing.
      Parameters:
        `indexable` - mutable int indexable to view as a `MutableIntIndexable.Base` mutable int indexable
      Returns:
        base view of given indexable, or the indexable itself if it is already a Base

    - #### init

          @NotNull
          static MutableIntIndexable.Base init(int size,
                                                        @NotNull
                                                        java.util.function.IntSupplier 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, int)`

    - #### copyOf

          @NotNull
          static MutableIntIndexable.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> MutableIntIndexable.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 MutableIntIndexable.Base empty()

      Description copied from interface: `IntCountable`
      Get an empty countable. This is often preferable as a return result to indicate nothing instead of returning `null`.
      Specified by:
        `empty` in interface `IntCountable`
      Returns:
        empty countable

    - #### fromArray

          @NotNull
          static MutableIntIndexable.Base fromArray(@NotNull
                                                             int... elements)

      Create a mutable indexable which is initialized from elements of the given array.
      Parameters:
        `elements` - elements
      Returns:
        mutable indexable independent of `elements`

    - #### fromArray

          @NotNull
          static MutableIntIndexable.Base fromArray(@NotNull
                                                             int[] 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 independent of `elements`

    - #### viewArray

          @NotNull
          static MutableIntIndexable.Base viewArray(@NotNull
                                                             int[] 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 `IntIndexable`
      Parameters:
        `array` - array
      Returns:
        mutable indexable view of the given array

    - #### viewArray

          @NotNull
          static MutableIntIndexable.Base viewArray(@NotNull
                                                             int[] array,
                                                             int start,
                                                             int length)

      Mutable indexable view which operates on a part of the given array.
      Specified by:
        `viewArray` in interface `IntIndexable`
      Parameters:
        `array` - array
        `start` - start position in array
        `length` - length of returned indexable
      Returns:
        mutable int indexable view of the given part of the array

    - #### viewList

          @NotNull
          static MutableIntIndexable.Base viewList(@NotNull
                                                            java.util.List<java.lang.Integer> 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

    - #### fromIndexable

          @NotNull
          static MutableIntIndexable.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> MutableIntIndexable.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

    - #### viewIndexable

          @NotNull
          static <T> MutableIntIndexable.Base viewIndexable(@NotNull
                                                                     Indexable<T> indexable,
                                                                     @NotNull
                                                                     java.util.function.ToIntFunction<? super T> getter,
                                                                     @NotNull
                                                                     IntSetter<? super T> setter)

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

      This is useful if you have complex items, but are interested into only one (int) 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 int indexable view of the underlying indexable

    - #### fromDoubleIndexable

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

      Return a mutable int indexable initialized with the content of a standard double indexable. This will cast the incoming double values and result in a loss of accuracy.
      Parameters:
        `indexable` - double indexable
      Returns:
        mutable indexable initialized with the values of the given double indexable

    - #### fromFloatIndexable

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

      Return a mutable int 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 MutableIntIndexable.Base fromLongIndexable(@NotNull
                                                                     LongIndexable indexable)

      Return a mutable int indexable initialized with the content of a standard long indexable. This will cast long values to int.
      Parameters:
        `indexable` - long indexable
      Returns:
        mutable indexable initialized with the values of the given long indexable

    - #### fromIntIndexable

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

      Return a mutable int indexable initialized with the content of a standard int indexable. This will result in a loss of accuracy for various values.
      Parameters:
        `indexable` - int indexable
      Returns:
        mutable indexable initialized with the values of the given int indexable

    - #### fromShortIndexable

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

      Return a mutable int indexable initialized with the content of a standard short indexable.
      Parameters:
        `indexable` - short indexable
      Returns:
        mutable indexable initialized with the values of the given short indexable

    - #### fromByteIndexable

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

      Return a mutable int indexable initialized with the content of a standard byte indexable.
      Parameters:
        `indexable` - byte indexable
      Returns:
        mutable indexable initialized with the values of the given byte indexable

    - #### fromCharIndexable

          @NotNull
          static MutableIntIndexable.Base fromCharIndexable(@NotNull
                                                                     CharIndexable indexable)

      Return a mutable int indexable initialized with the content of a standard char indexable.
      Parameters:
        `indexable` - char indeable
      Returns:
        mutable indexable initialized with the values of the given char indexable

    - #### fromIterable

          @NotNull
          static MutableIntIndexable.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 MutableIntIndexable.Base zeroed(int size)

      Create a mutable int indexable with `size` `0.0` elements.
      Parameters:
        `size` - required size of returned mutable int indexable
      Returns:
        mutable int indexable of the given size initialized with `0.0`
      See Also:
        `init(int, int)`, `init(int, IntSupplier)`

    - #### init

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

      Create a mutable
      Specified by:
        `init` in interface `IntIndexable`
      Parameters:
        `size` - required size of returned mutable int indexable
        `value` - initial value of all elements
      Returns:
        mutable int indexable of the given size initialized with `value`
      See Also:
        `init(int, IntSupplier)`, `zeroed(int)`

    - #### initByIndex

          @NotNull
          static MutableIntIndexable.Base initByIndex(int size,
                                                               @NotNull
                                                               java.util.function.IntUnaryOperator producer)

      Get a mutable integer indexable of a given size which contains elements created by index.
      Specified by:
        `initByIndex` in interface `IntIndexable`
      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 boolean indexable with the given size with elements initialized by calling the `producer`
      See Also:
        `IntIndexable.viewByIndex(int, IntUnaryOperator)`