Nda (neureka 1.0.1 API)

Type Parameters:

V - The type of the items stored in the Nda.

All Superinterfaces:

java.lang.Iterable<V>, NDimensional

All Known Subinterfaces:

Tensor<V>
```
public interface Nda<V>
extends NDimensional, java.lang.Iterable<V>
```
Nda, which is an abbreviation of 'N-Dimensional-Array', represents a multidimensional, homogeneously filled fixed-size array of items.
Ndas should be constructed using the fluent builder API exposed by of(Class).

Nested Class Summary

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`Nda.Item<V>` Instances of this are being returned by the `at(int...)` method, and they allow you to get individual nd-array items

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`default boolean`	`any(java.util.function.Predicate<V> predicate)` Iterates over every element of this nd-array, and checks whether any element matches the provided lambda.
`Nda.Item<V>`	`at(int... indices)` This method exposes the `Nda.Item` API which allows you to get or set individual items within this nd-array targeted by an array of provided indices.
`Nda<V>`	`concatAt(int axis, Nda<V> other)` This method concatenates the provided nd-array together with this nd-array along a specified axis.
`Nda<V>`	`concatAt(int axis, Nda<V> other, Nda<V>... ndArrays)` This method concatenates the provided nd-arrays together with this nd-array along a specified axis.
`default int`	`count(java.util.function.Predicate<V> predicate)` Iterates over every element of this nd-array, and counts the number of times the provided lambda matches the items of this array.
`Nda<V>`	`deepCopy()` This method creates and returns a new nd-array instance which is not only a copy of the configuration of this nd-array but also a copy of the underlying data array.
`default boolean`	`every(java.util.function.Predicate<V> predicate)` Iterates over every element of this nd-array, and checks whether all elements are `true` according to the provided lambda.
`default java.util.stream.Stream<V>`	`filter(java.util.function.Predicate<V> predicate)` A convenience method for `stream().filter( predicate )`.
`default <R> java.util.stream.Stream<R>`	`flatMap(java.util.function.Function<V,java.util.stream.Stream<R>> mapper)` A convenience method for `nda.stream().flatMap( mapper )`, which turns this `Nda` into a `Stream` of its items.
`Nda<V>`	`get(int... indices)` The following method enables access to specific scalar elements within the nd-array.
`Nda<V>`	`get(int i)` This getter method creates and returns a slice of the original nd-array.
`Nda<V>`	`get(java.lang.Number i)` This getter method creates and returns a slice of the original nd-array.
`Nda<V>`	`get(java.lang.Object... args)` The following method enables the creation of nd-array slices which access the same underlying data (possibly from a different view).
`Nda<V>`	`get(java.lang.Object key)` This method enables nd-array slicing! It takes a key of various types and configures a slice nd-array which shares the same underlying data as the original nd-array.
`Nda<V>`	`getAt(int... indices)` The following method enables access to specific scalar elements within the nd-array.
`Nda<V>`	`getAt(int i)` This getter method creates and returns a slice of the original nd-array.
`Nda<V>`	`getAt(java.util.List<?> key)` This method enables nd-array slicing! It takes a key of various types and configures a slice nd-array which shares the same underlying data as the original nd-array.
`Nda<V>`	`getAt(java.util.Map<?,java.lang.Integer> rangToSteps)` This method is most useful when used in Groovy where defining maps is done through square brackets, making it possible to slice nd-arrays like so:
`Nda<V>`	`getAt(java.lang.Number i)` This getter method creates and returns a slice of the original nd-array.
`Nda<V>`	`getAt(java.lang.Object... args)` The following method enables the creation of nd-array slices which access the same underlying data (possibly from a different view).
`default <A> A`	`getDataAs(java.lang.Class<A> arrayTypeClass)` Use this to get the items of the underlying `Data` buffer of this nd-array as a primitive array of the specified type.
`V`	`getDataAt(int i)` Use this to access elements of the underlying data array without any index transformation applied to it.
`default V`	`getItem()` Equivalent to the `#item(0)` and `item()`.
`default java.util.List<V>`	`getItems()` A more verbose version of the `items()` method (best used by JVM languages with property support).
`default <A> A`	`getItemsAs(java.lang.Class<A> arrayTypeClass)` Use this to get the items of this nd-array as a primitive array of the specified type.
`java.lang.Class<V>`	`getItemType()`
`default java.lang.String`	`getLabel()` A nd-array can have a label.
`MutateNda<V>`	`getMut()` This method exposes an API for mutating the state of this tensor.
`java.lang.Object`	`getRawData()` This returns an unprocessed version of the underlying data of this nd-array.
`java.lang.Object`	`getRawItems()`
`default boolean`	`isFullSlice()` If this nd-array is a full slice of a parent nd-array then this method will yield true.
`boolean`	`isPartialSlice()` If this nd-array is a partial slice of a parent nd-array then this method will yield true.
`boolean`	`isShallowCopy()` If this nd-array is a shallow copy of a parent nd-array then this method will yield true.
`boolean`	`isSlice()` If this nd-array is a slice of a parent nd-array then this method will yield true.
`boolean`	`isSliceParent()` If slices have been derived from this nd-array then it is a "slice parent".
`default V`	`item()` Equivalent to the `#item(0)` and `getItem()`.
`default V`	`item(int... indices)` This method returns a raw value item within this nd-array targeted by an index array which is expected to hold an index for every dimension of the shape of this nd-array.
`default V`	`item(int i)` The following method returns a single item within this nd-array targeted by the provided integer index.
`default java.util.List<V>`	`items()` A more concise version of the `getItems()` method.
`default java.lang.Class<V>`	`itemType()`
`default java.lang.String`	`label()` A nd-array can have a label.
`Nda<V>`	`map(java.util.function.Function<V,V> mapper)` This method is a convenience method for mapping the items of this nd-array to another nd-array of the same type based on the provided lambda function, which will be applied to all items of this nd-array individually (element-wise).
`<T> Nda<T>`	`mapTo(java.lang.Class<T> typeClass, java.util.function.Function<V,T> mapper)` This is a convenience method for mapping a nd-array to a nd-array of new type based on a provided target item type and mapping lambda.
`default V`	`maxItem(java.util.Comparator<V> comparator)` Returns the maximum item of this nd-array according to the provided `Comparator`.
`default V`	`minItem(java.util.Comparator<V> comparator)` Returns the minimum item of this nd-array according to the provided `Comparator`.
`default MutateNda<V>`	`mut()` This method exposes an API for mutating the state of this tensor.
`default boolean`	`none(java.util.function.Predicate<V> predicate)` Iterates over every element of this nd-array, and checks whether none of the elements match the provided lambda.
`static Nda<java.lang.Boolean>`	`of(boolean... value)` Constructs a vector of booleans based on the provided array.
`static Nda<java.lang.Byte>`	`of(byte... value)` Constructs a vector of bytes based on the provided array.
`static <V> WithShapeOrScalarOrVector<V>`	`of(java.lang.Class<V> type)` This is the entry point to the fluent nd-array builder API for building `Nda` instances in a readable and type safe fashion.
`static Nda<java.lang.Double>`	`of(double... value)` Constructs a vector of doubles based on the provided array.
`static Nda<java.lang.Double>`	`of(double value)`
`static Nda<java.lang.Float>`	`of(float... value)` Constructs a vector of floats based on the provided array.
`static Nda<java.lang.Integer>`	`of(int... value)` Constructs a vector of ints based on the provided array.
`static <T> Nda<T>`	`of(java.lang.Iterable<T> values)` Constructs a vector of objects based on the provided iterable.
`static <T> Nda<T>`	`of(java.util.List<T> values)` Constructs a vector of objects based on the provided list.
`static Nda<java.lang.Long>`	`of(long... value)` Constructs a vector of longs based on the provided array.
`static Nda<java.lang.Boolean>`	`of(Shape shape, boolean... values)` Use this to construct and return a boolean based nd-array of the specified shape and initial values.
`static Nda<java.lang.Byte>`	`of(Shape shape, byte... values)` Use this to construct and return a byte based nd-array of the specified shape and initial values.
`static Nda<java.lang.Double>`	`of(Shape shape, double... values)` Use this to construct and return a double based nd-array of the specified shape and initial values.
`static Nda<java.lang.Float>`	`of(Shape shape, float... values)` Use this to construct and return a float based nd-array of the specified shape and initial values.
`static Nda<java.lang.Integer>`	`of(Shape shape, int... values)` Use this to construct and return a int based nd-array of the specified shape and initial values.
`static Nda<java.lang.Long>`	`of(Shape shape, long... values)` Use this to construct and return a long based nd-array of the specified shape and initial values.
`static Nda<java.lang.Short>`	`of(Shape shape, short... values)` Use this to construct and return a short based nd-array of the specified shape and initial values.
`static <T> Nda<T>`	`of(Shape shape, T... values)` Use this to construct and return an object based nd-array of the specified shape and initial values.
`static Nda<java.lang.Short>`	`of(short... value)` Constructs a vector of shorts based on the provided array.
`static <T> Nda<T>`	`of(T... values)` Constructs a vector of objects based on the provided array.
`static WithShapeOrScalarOrVector<java.math.BigDecimal>`	`ofBigDecimals()` This is a shortcut method for `Nda.of(BigDecimal.class)` used to build `Nda`s storing `BigDecimal`s.
`static WithShapeOrScalarOrVector<java.lang.Boolean>`	`ofBooleans()` This is a shortcut method for `Nda.of(Boolean.class)` used to build `Nda`s storing `Boolean`s.
`static WithShapeOrScalarOrVector<java.lang.Byte>`	`ofBytes()` This is a shortcut method for `Nda.of(Byte.class)` used to build `Nda`s storing `Byte`s.
`static WithShapeOrScalarOrVector<java.lang.Character>`	`ofChars()` This is a shortcut method for `Nda.of(Character.class)` used to build `Nda`s storing `Character`s.
`static WithShapeOrScalarOrVector<java.lang.Double>`	`ofDoubles()` This is a shortcut method for `Nda.of(Double.class)` used to build `Nda`s storing `Double`s.
`static WithShapeOrScalarOrVector<java.lang.Float>`	`ofFloats()` This is a shortcut method for `Nda.of(Float.class)` used to build `Nda`s storing `Float`s.
`static WithShapeOrScalarOrVector<java.lang.Integer>`	`ofInts()` This is a shortcut method for `Nda.of(Integer.class)` used to build `Nda`s storing `Integer`s.
`static WithShapeOrScalarOrVector<java.lang.Long>`	`ofLongs()` This is a shortcut method for `Nda.of(Long.class)` used to build `Nda`s storing `Long`s.
`static WithShapeOrScalarOrVector<java.lang.Number>`	`ofNumbers()` This is a shortcut method for `Nda.of(Number.class)` used to build `Nda`s storing `Number`s.
`static WithShapeOrScalarOrVector<java.lang.Object>`	`ofObjects()` This is a shortcut method for `Nda.of(Object.class)` used to build `Nda`s storing `Object`s.
`static WithShapeOrScalarOrVector<java.lang.Short>`	`ofShorts()` This is a shortcut method for `Nda.of(Short.class)` used to build `Nda`s storing `Short`s.
`static WithShapeOrScalarOrVector<java.lang.String>`	`ofStrings()` This is a shortcut method for `Nda.of(String.class)` used to build `Nda`s storing `String`s.
`Nda<V>`	`permute(int... dims)` Returns a view of the original tensor input with its dimensions permuted. Consider a 3-dimensional tensor x with shape (2×3×5), then calling x.permute(1, 0, 2) will return a 3-dimensional tensor of shape (3×2×5).
`Nda<V>`	`reshape(int... shape)` Returns a nd-array with the same data and number of elements as this nd-array, but with the specified shape.
`Nda<V>`	`shallowCopy()` This creates a copy where the underlying data is still the same.
`static <T> java.util.stream.Collector<T,?,Nda<T>>`	`shaped(int... shape)` Returns a `Collector` that accumulates the input elements into a new `Nda` with the specified shape.
`AxisOrGet<V>`	`slice()` This method returns a `SliceBuilder` instance exposing a simple builder API which enables the configuration of a slice of the current nd-array via method chaining.
`int`	`sliceCount()` This method returns the number of slices which have been created from this nd-array.
`default java.util.stream.Stream<V>`	`stream()`
`java.lang.String`	`toString()` This method returns a `String` representation of this nd-array.
`default java.lang.String`	`toString(java.util.function.Consumer<NDPrintSettings> config)` This allows you to provide a lambda which configures how this nd-array should be converted to `String` instances.
`default java.lang.String`	`toString(NDPrintSettings config)` Use this to turn this nd-array into a `String` instance based on the provided `NDPrintSettings` instance, which allows you to configure things like the number of chars per entry, delimiters, the number of items per line, etc.
`Nda<V>`	`transpose(int dim1, int dim2)` Returns a view of the original tensor input the targeted axes are swapped / transposed.
`Nda<V>`	`withLabel(java.lang.String label)`
`Nda<V>`	`withLabels(java.util.List<java.util.List<java.lang.Object>> labels)` This method receives a nested `String` list which ought to contain a label for the index of this nd-array.
`Nda<V>`	`withLabels(java.util.Map<java.lang.Object,java.util.List<java.lang.Object>> labels)` This method provides the ability to label not only the indices of the shape of this nd-array, but also the dimension of the shape.
`Nda<V>`	`withLabels(java.lang.String[]... labels)` This method receives a nested `String` array which ought to contain a label for the index of this nd-array.

Methods inherited from interface neureka.ndim.NDimensional
getNDConf, getRank, getShape, getSize, indexOfIndex, indexOfIndices, indicesMap, indicesOfIndex, offset, rank, shape, shape, size, spread, strides

Methods inherited from interface java.lang.Iterable
forEach, iterator, spliterator

- Method Detail
  - of
```
static <V> WithShapeOrScalarOrVector<V> of(java.lang.Class<V> type)
```
    This is the entry point to the fluent nd-array builder API for building Nda instances in a readable and type safe fashion. The returned WithShapeOrScalarOrVector is the next step in the fluent Nda builder API which will lead to the creation of an nd-array storing values defined by the provided type class. A simple usage example would be:
```
      Nda.of(Double.class)
            .withShape( 2, 3, 4 )
            .andFill( 5, 3, 5 )
   
```
    It is also possible to define a range using the API to populate the nd-array with values:
```
      Nda.of(Double.class)
            .withShape( 2, 3, 4 )
            .andFillFrom( 2 ).to( 9 ).step( 2 )
   
```
    If one needs a simple scalar then the following shortcut is possible:
```
      Nda.of(Float.class).scalar( 3f )
   
```
    This principle works for vectors as well:
```
       Nda.of(Byte.class).vector( 2, 5, 6, 7, 8 )
   
```
    For more fine-grained control over the initialization one can pass an initialization lambda to the API:
```
       Nda.of(Byte.class).withShape(2, 3).andWhere( (i, indices) -> i * 5 - 30 )
   
```
    Parameters:
    
    type - The type class of the items stored by the nd-array built by the exposed builder API.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofStrings
```
static WithShapeOrScalarOrVector<java.lang.String> ofStrings()
```
    This is a shortcut method for Nda.of(String.class) used to build Ndas storing Strings.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofInts
```
static WithShapeOrScalarOrVector<java.lang.Integer> ofInts()
```
    This is a shortcut method for Nda.of(Integer.class) used to build Ndas storing Integers.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofDoubles
```
static WithShapeOrScalarOrVector<java.lang.Double> ofDoubles()
```
    This is a shortcut method for Nda.of(Double.class) used to build Ndas storing Doubles.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofFloats
```
static WithShapeOrScalarOrVector<java.lang.Float> ofFloats()
```
    This is a shortcut method for Nda.of(Float.class) used to build Ndas storing Floats.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofLongs
```
static WithShapeOrScalarOrVector<java.lang.Long> ofLongs()
```
    This is a shortcut method for Nda.of(Long.class) used to build Ndas storing Longs.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofBooleans
```
static WithShapeOrScalarOrVector<java.lang.Boolean> ofBooleans()
```
    This is a shortcut method for Nda.of(Boolean.class) used to build Ndas storing Booleans.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofChars
```
static WithShapeOrScalarOrVector<java.lang.Character> ofChars()
```
    This is a shortcut method for Nda.of(Character.class) used to build Ndas storing Characters.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofBytes
```
static WithShapeOrScalarOrVector<java.lang.Byte> ofBytes()
```
    This is a shortcut method for Nda.of(Byte.class) used to build Ndas storing Bytes.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofShorts
```
static WithShapeOrScalarOrVector<java.lang.Short> ofShorts()
```
    This is a shortcut method for Nda.of(Short.class) used to build Ndas storing Shorts.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofObjects
```
static WithShapeOrScalarOrVector<java.lang.Object> ofObjects()
```
    This is a shortcut method for Nda.of(Object.class) used to build Ndas storing Objects.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofNumbers
```
static WithShapeOrScalarOrVector<java.lang.Number> ofNumbers()
```
    This is a shortcut method for Nda.of(Number.class) used to build Ndas storing Numbers.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - ofBigDecimals
```
static WithShapeOrScalarOrVector<java.math.BigDecimal> ofBigDecimals()
```
    This is a shortcut method for Nda.of(BigDecimal.class) used to build Ndas storing BigDecimals.
    
    Returns:
    
    The next step of the Nda builder API which exposes methods for defining shapes.
  - of
```
static Nda<java.lang.Double> of(double value)
```
    Parameters:
    
    value - The scalar value which ought to be represented as nd-array.
    
    Returns:
    
    A scalar double nd-array.
  - of
```
static Nda<java.lang.Float> of(float... value)
```
    Constructs a vector of floats based on the provided array.
    
    Parameters:
    
    value - The array of floats from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of floats.
  - of
```
static Nda<java.lang.Double> of(double... value)
```
    Constructs a vector of doubles based on the provided array.
    
    Parameters:
    
    value - The array of doubles from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of doubles.
  - of
```
static Nda<java.lang.Byte> of(byte... value)
```
    Constructs a vector of bytes based on the provided array.
    
    Parameters:
    
    value - The array of bytes from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of bytes.
  - of
```
static Nda<java.lang.Integer> of(int... value)
```
    Constructs a vector of ints based on the provided array.
    
    Parameters:
    
    value - The array of ints from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of ints.
  - of
```
static Nda<java.lang.Long> of(long... value)
```
    Constructs a vector of longs based on the provided array.
    
    Parameters:
    
    value - The array of longs from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of longs.
  - of
```
static Nda<java.lang.Short> of(short... value)
```
    Constructs a vector of shorts based on the provided array.
    
    Parameters:
    
    value - The array of shorts from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of shorts.
  - of
```
static Nda<java.lang.Boolean> of(boolean... value)
```
    Constructs a vector of booleans based on the provided array.
    
    Parameters:
    
    value - The array of booleans from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of shorts.
  - of
```
@SafeVarargs
static <T> Nda<T> of(T... values)
```
    Constructs a vector of objects based on the provided array.
    
    Parameters:
    
    values - The array of objects from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of objects.
  - of
```
static Nda<java.lang.Double> of(Shape shape,
                                double... values)
```
    Use this to construct and return a double based nd-array of the specified shape and initial values. The length of the provided array does not have to match the number of elements defined by the provided shape, the nd-array will be populated based on repeated iteration over the provided double array.
    
    Parameters:
    
    shape - The shape of the resulting nd-array consisting of any number of axis-sizes.
    
    values - The values which ought to be used to populate the tensor.
  - of
```
static Nda<java.lang.Float> of(Shape shape,
                               float... values)
```
    Use this to construct and return a float based nd-array of the specified shape and initial values. The length of the provided array does not have to match the number of elements defined by the provided shape, the nd-array will be populated based on repeated iteration over the provided float array.
    
    Parameters:
    
    shape - The shape of the resulting nd-array consisting of any number of axis-sizes.
    
    values - The values which ought to be used to populate the tensor.
  - of
```
static Nda<java.lang.Byte> of(Shape shape,
                              byte... values)
```
    Use this to construct and return a byte based nd-array of the specified shape and initial values. The length of the provided array does not have to match the number of elements defined by the provided shape, the nd-array will be populated based on repeated iteration over the provided byte array.
    
    Parameters:
    
    shape - The shape of the resulting nd-array consisting of any number of axis-sizes.
    
    values - The values which ought to be used to populate the tensor.
  - of
```
static Nda<java.lang.Integer> of(Shape shape,
                                 int... values)
```
    Use this to construct and return a int based nd-array of the specified shape and initial values. The length of the provided array does not have to match the number of elements defined by the provided shape, the nd-array will be populated based on repeated iteration over the provided int array.
    
    Parameters:
    
    shape - The shape of the resulting nd-array consisting of any number of axis-sizes.
    
    values - The values which ought to be used to populate the tensor.
  - of
```
static Nda<java.lang.Long> of(Shape shape,
                              long... values)
```
    Use this to construct and return a long based nd-array of the specified shape and initial values. The length of the provided array does not have to match the number of elements defined by the provided shape, the nd-array will be populated based on repeated iteration over the provided long array.
    
    Parameters:
    
    shape - The shape of the resulting nd-array consisting of any number of axis-sizes.
    
    values - The values which ought to be used to populate the tensor.
  - of
```
static Nda<java.lang.Short> of(Shape shape,
                               short... values)
```
    Use this to construct and return a short based nd-array of the specified shape and initial values. The length of the provided array does not have to match the number of elements defined by the provided shape, the nd-array will be populated based on repeated iteration over the provided short array.
    
    Parameters:
    
    shape - The shape of the resulting nd-array consisting of any number of axis-sizes.
    
    values - The values which ought to be used to populate the tensor.
  - of
```
static Nda<java.lang.Boolean> of(Shape shape,
                                 boolean... values)
```
    Use this to construct and return a boolean based nd-array of the specified shape and initial values. The length of the provided array does not have to match the number of elements defined by the provided shape, the nd-array will be populated based on repeated iteration over the provided boolean array.
    
    Parameters:
    
    shape - The shape of the resulting nd-array consisting of any number of axis-sizes.
    
    values - The values which ought to be used to populate the tensor.
  - of
```
@SafeVarargs
static <T> Nda<T> of(Shape shape,
                                  T... values)
```
    Use this to construct and return an object based nd-array of the specified shape and initial values. The length of the provided array does not have to match the number of elements defined by the provided shape, the nd-array will be populated based on repeated iteration over the provided object array.
    
    Parameters:
    
    shape - The shape of the resulting nd-array consisting of any number of axis-sizes.
    
    values - The values which ought to be used to populate the tensor.
  - of
```
static <T> Nda<T> of(java.lang.Iterable<T> values)
```
    Constructs a vector of objects based on the provided iterable.
    
    Parameters:
    
    values - The iterable of objects from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of objects.
  - of
```
static <T> Nda<T> of(java.util.List<T> values)
```
    Constructs a vector of objects based on the provided list.
    
    Parameters:
    
    values - The list of objects from which a 1D nd-array ought to be constructed.
    
    Returns:
    
    A vector / 1D nd-array of objects.
  - getLabel
```
default java.lang.String getLabel()
```
    A nd-array can have a label. This label is used for example when printing the nd-array. When loading a CSV file for example the label of the nd-array will be taken from the cell where the header row and the first column intersect.
    
    Returns:
    
    The label/name of the nd-array.
  - label
```
default java.lang.String label()
```
    A nd-array can have a label. This label is used for example when printing the nd-array. When loading a CSV file for example the label of the nd-array will be taken from the cell where the header row and the first column intersect. This is a shorter version of getLabel().
    
    Returns:
    
    The label/name of the nd-array.
  - isSlice
```
boolean isSlice()
```
    If this nd-array is a slice of a parent nd-array then this method will yield true. Slices can be created by calling the variations of the "getAt(int...)" method.
    
    Returns:
    
    The truth value determining if this nd-array is a slice of another nd-array.
    
    See Also:
    
    getAt(int...), slice()
  - isShallowCopy
```
boolean isShallowCopy()
```
    If this nd-array is a shallow copy of a parent nd-array then this method will yield true. Shallow copies can be created by calling the "shallowCopy()" method.
    
    Returns:
    
    The truth value determining if this nd-array is a shallow copy of another nd-array.
    
    See Also:
    
    shallowCopy()
  - isPartialSlice
```
boolean isPartialSlice()
```
    If this nd-array is a partial slice of a parent nd-array then this method will yield true. A partial slice is a slice which does not view all the parents items. Partial slices can be created by calling the variations of the "getAt(int...)" method. This is the inverse of isFullSlice().
    
    Returns:
    
    The truth value determining if this nd-array is a partial slice of another nd-array.
  - isFullSlice
```
default boolean isFullSlice()
```
    If this nd-array is a full slice of a parent nd-array then this method will yield true. A full slice is a slice which views all the parents items. Full slices can be created by calling the variations of the "getAt(int...)" method. This is the inverse of isPartialSlice().
    
    Returns:
    
    The truth value determining if this nd-array is a full slice of another nd-array.
  - sliceCount
```
int sliceCount()
```
    This method returns the number of slices which have been created from this nd-array. It does so by accessing the Relation component if present which internally keeps track of slices via weak references.
    
    Returns:
    
    The number of slices derived from this nd-array.
  - isSliceParent
```
boolean isSliceParent()
```
    If slices have been derived from this nd-array then it is a "slice parent". This is what this method will determine, in which case, it will return true.
    
    Returns:
    
    The truth value determining if slices have been derived from this nd-array.
  - getItemType
```
java.lang.Class<V> getItemType()
```
    Returns:
    
    The type class of individual value items within this nd-array.
  - itemType
```
default java.lang.Class<V> itemType()
```
    Returns:
    
    The type class of individual value items within this nd-array.
  - withLabel
```
Nda<V> withLabel(java.lang.String label)
```
    Returns:
    
    A new nd-array which is a shallow copy of this nd-array but with a different label.
  - withLabels
```
Nda<V> withLabels(java.lang.String[]... labels)
```
    This method receives a nested String array which ought to contain a label for the index of this nd-array. The index for a single element of this nd-array would be an array of numbers as long as the rank where every number is in the range of the corresponding shape dimension... Labeling an index means that for every dimension there must be a label for elements in this range array!
    For example the shape (2,3) could be labeled as follows:
    
    dim 0 : ["A", "B"]
    dim 1 : ["1", "2", "3"]
    
    Parameters:
    
    labels - A nested String array containing labels for indexes of the nd-array dimensions.
    
    Returns:
    
    This nd-array (method chaining).
  - withLabels
```
Nda<V> withLabels(java.util.List<java.util.List<java.lang.Object>> labels)
```
    This method receives a nested String list which ought to contain a label for the index of this nd-array. The index for a single element of this nd-array would be an array of numbers as long as the rank where every number is in the range of the corresponding shape dimension... Labeling an index means that for every dimension there must be a label for elements in this range array!
    For example the shape (2,3) could be labeled as follows:
    
    dim 0 : ["A", "B"]
    dim 1 : ["1", "2", "3"]
    
    Parameters:
    
    labels - A nested String list containing labels for indexes of the nd-array dimensions.
    
    Returns:
    
    This nd-array (method chaining).
  - withLabels
```
Nda<V> withLabels(java.util.Map<java.lang.Object,java.util.List<java.lang.Object>> labels)
```
    This method provides the ability to label not only the indices of the shape of this nd-array, but also the dimension of the shape. The first and only argument of the method expects a map instance where keys are the objects which ought to act as dimension labels and the values are lists of labels for the indices of said dimensions. For example the shape (2,3) could be labeled as follows:
    [
    "dim 0" : ["A", "B"],
    "dim 1" : ["1", "2", "3"]
    ]
    
    Parameters:
    
    labels - A map in which the keys are dimension labels and the values are lists of index labels for the dimension.
    
    Returns:
    
    This nd-array (method chaining).
  - stream
```
default java.util.stream.Stream<V> stream()
```
    Returns:
    
    A Stream of the items in this Nda.
  - filter
```
default java.util.stream.Stream<V> filter(java.util.function.Predicate<V> predicate)
```
    A convenience method for stream().filter( predicate ).
    
    Parameters:
    
    predicate - The predicate to filter the items of this Nda.
    
    Returns:
    
    A Stream of the items in this Nda which match the predicate.
  - flatMap
```
default <R> java.util.stream.Stream<R> flatMap(java.util.function.Function<V,java.util.stream.Stream<R>> mapper)
```
    A convenience method for nda.stream().flatMap( mapper ), which turns this Nda into a Stream of its items.
    Here an example of how to use this method :
```
    var nda = Nda.of( -2, -1, 0, 1, 2 );
    var list = nda.flatMap( i -> Stream.of( i * 2, i * 3 ) ).toList();
    // list = [-4, -6, -2, -3, 0, 0, 2, 3, 4, 6, 6, 9]
  
```
    Parameters:
    
    mapper - The mapper to map the items of this Nda.
    
    Returns:
    
    A Stream of the items in this Nda which match the predicate.
  - shaped
```
static <T> java.util.stream.Collector<T,?,Nda<T>> shaped(int... shape)
```
    Returns a Collector that accumulates the input elements into a new Nda with the specified shape.
    Usage example :
```
    var nda = Stream.of( 1, 2, 3, 4, 5, 6 )
                      .collect( Nda.shaped( 2, 3 ) );
 
```
    Type Parameters:
    
    T - the type of the input elements
    
    Parameters:
    
    shape - The shape of the nd-array to be returned.
    
    Returns:
    
    a Collector which collects all the input elements into a Nda, in encounter order.
  - every
```
default boolean every(java.util.function.Predicate<V> predicate)
```
    Iterates over every element of this nd-array, and checks whether all elements are true according to the provided lambda.
    
    Parameters:
    
    predicate - The lambda to check each element against.
    
    Returns:
    
    true if every item in the nd-array matches the predicate, false otherwise.
  - any
```
default boolean any(java.util.function.Predicate<V> predicate)
```
    Iterates over every element of this nd-array, and checks whether any element matches the provided lambda.
    
    Parameters:
    
    predicate - The lambda to check each element against.
    
    Returns:
    
    true if any item in the nd-array matches the predicate, false otherwise.
  - none
```
default boolean none(java.util.function.Predicate<V> predicate)
```
    Iterates over every element of this nd-array, and checks whether none of the elements match the provided lambda.
    
    Parameters:
    
    predicate - The lambda to check each element against.
    
    Returns:
    
    true if none of the items in the nd-array match the predicate, false otherwise.
  - count
```
default int count(java.util.function.Predicate<V> predicate)
```
    Iterates over every element of this nd-array, and counts the number of times the provided lambda matches the items of this array.
    Here is an example of counting the number of items in the array that are greater than 5 :
```
    var nda = Nda.of( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );
    var count = nda.count( i -> i > 5 );
    System.out.println( count ); // prints 5
  
```
    Parameters:
    
    predicate - The lambda to check each element against.
    
    Returns:
    
    The number of items in the nd-array that match the predicate.
  - minItem
```
default V minItem(java.util.Comparator<V> comparator)
```
    Returns the minimum item of this nd-array according to the provided Comparator. This is a special case of a reduction.
    
    Parameters:
    
    comparator - The Comparator to use to determine the order of the items in the nd-array.
    
    Returns:
    
    The minimum value in the nd-array.
  - maxItem
```
default V maxItem(java.util.Comparator<V> comparator)
```
    Returns the maximum item of this nd-array according to the provided Comparator. This is a special case of a reduction.
    
    Parameters:
    
    comparator - The Comparator to use to determine the order of the items in the nd-array.
    
    Returns:
    
    The maximum value in the nd-array.
  - getRawData
```
java.lang.Object getRawData()
```
    This returns an unprocessed version of the underlying data of this nd-array. If this nd-array is outsourced (stored on a device), then the data will be loaded into an array and returned by this method. Do not expect the returned array to be actually stored within the nd-array itself! Contrary to the getItems() method, this one will return the data in an unbiased form, where for example a virtual (see Tensor.isVirtual()) nd-array will have this method return an array of length 1.
    
    Returns:
    
    An unbiased copy of the underlying data of this nd-array.
  - getDataAt
```
V getDataAt(int i)
```
    Use this to access elements of the underlying data array without any index transformation applied to it. This is usually similar to the item(int) method, however for nd-arrays which are sliced or permuted views of the data of another nd-array, this method will always be unbiased access of the raw data...
    
    Parameters:
    
    i - The position of the targeted item within the raw data array of an NDArray implementation.
    
    Returns:
    
    The found object sitting at the specified index position.
  - getItems
```
default java.util.List<V> getItems()
```
    A more verbose version of the items() method (best used by JVM languages with property support).
    
    Returns:
    
    A list of the items in this nd-array.
  - items
```
default java.util.List<V> items()
```
    A more concise version of the getItems() method.
    
    Returns:
    
    A list of the items in this nd-array.
  - getRawItems
```
java.lang.Object getRawItems()
```
    Returns:
    
    The items of this nd-array as a (if possible) primitive array.
  - item
```
default V item(int i)
```
    The following method returns a single item within this nd-array targeted by the provided integer index.
    
    Parameters:
    
    i - The scalar index of the item which should be returned by the method.
    
    Returns:
    
    The item found at the targeted index.
  - item
```
default V item(int... indices)
```
    This method returns a raw value item within this nd-array targeted by an index array which is expected to hold an index for every dimension of the shape of this nd-array. So the provided array must have the same length as the rank of this nd-array!
    
    Parameters:
    
    indices - The index array which targets a single value item within this nd-array.
    
    Returns:
    
    The found raw value item targeted by the provided index array.
  - item
```
default V item()
```
    Equivalent to the #item(0) and getItem().
    
    Returns:
    
    The first item of this nd-array.
  - getItem
```
default V getItem()
```
    Equivalent to the #item(0) and item().
    
    Returns:
    
    The first item of this nd-array.
  - getItemsAs
```
default <A> A getItemsAs(java.lang.Class<A> arrayTypeClass)
```
    Use this to get the items of this nd-array as a primitive array of the specified type.
    
    Type Parameters:
    
    A - The type of the array to return.
    
    Parameters:
    
    arrayTypeClass - The class of the array type to return.
    
    Returns:
    
    The items of this nd-array as a primitive array of the specified type.
  - getDataAs
```
default <A> A getDataAs(java.lang.Class<A> arrayTypeClass)
```
    Use this to get the items of the underlying Data buffer of this nd-array as a primitive array of the specified type. Note that the length of the returned array may be different from the size of this nd-array. This is the case if this nd-array is a slice of another larger nd-array.
    
    Type Parameters:
    
    A - The type of the array to return.
    
    Parameters:
    
    arrayTypeClass - The class of the array type to return.
    
    Returns:
    
    The items of this nd-array as a primitive array of the specified type.
  - slice
```
AxisOrGet<V> slice()
```
    This method returns a SliceBuilder instance exposing a simple builder API which enables the configuration of a slice of the current nd-array via method chaining.
    The following code snippet slices a 3-dimensional nd-array into a nd-array of shape (2x1x3)
```
  myArray.slice()
          .axis(0).from(0).to(1)
          .axis(1).at(5) // equivalent to '.from(5).to(5)'
          .axis().from(0).to(2)
          .get();
 
```
    Returns:
    
    An instance of the SliceBuilder class exposing a readable builder API for creating slices.
  - concatAt
```
Nda<V> concatAt(int axis,
                Nda<V> other,
                Nda<V>... ndArrays)
```
    This method concatenates the provided nd-arrays together with this nd-array along a specified axis. The provided nd-arrays must have the same shape and data type as the current nd-array, except for the specified axis.
    
    Parameters:
    
    axis - The axis along which the provided nd-arrays should be concatenated. The axis must be within the range of the rank of the current nd-array.
    
    other - The other nd-arrays which should be concatenated with this nd-array.
    
    ndArrays - The non-null, non-empty nd-arrays which should be concatenated together with this and the other nd-array. The nd-arrays all must have the same shape as this nd-array, except for the specified axis. Also, it must have the same data type as the current nd-array.
    
    Returns:
    
    A new nd-array which is the concatenation of the current nd-array and the provided nd-arrays.
  - concatAt
```
Nda<V> concatAt(int axis,
                Nda<V> other)
```
    This method concatenates the provided nd-array together with this nd-array along a specified axis. The provided nd-array must have the same shape and data type as this nd-array, except for the specified axis.
    
    Parameters:
    
    axis - The axis along which the provided nd-arrays should be concatenated. The axis must be within the range of the rank of the current nd-array.
    
    other - The other nd-arrays which should be concatenated with this nd-array.
    
    Returns:
    
    A new nd-array which is the concatenation of the current nd-array and the provided nd-arrays.
  - getAt
```
Nda<V> getAt(int... indices)
```
    The following method enables access to specific scalar elements within the nd-array. The method name also translates to the subscription operator in Groovy.
    
    Parameters:
    
    indices - The index array of the element which should be returned.
    
    Returns:
    
    An element located at the provided index.
  - getAt
```
Nda<V> getAt(java.lang.Number i)
```
    This getter method creates and returns a slice of the original nd-array. The returned slice is a scalar nd-array wrapping a single value element which is being targeted by the provided integer index.
    
    Parameters:
    
    i - The index of the value item which should be returned as a nd-array instance.
    
    Returns:
    
    A nd-array holding a single value element which is internally still residing in the original nd-array.
  - get
```
Nda<V> get(int... indices)
```
    The following method enables access to specific scalar elements within the nd-array. The method name also translates to the subscription operator in Groovy.
    
    Parameters:
    
    indices - The index array of the element which should be returned.
    
    Returns:
    
    An element located at the provided index.
  - getAt
```
Nda<V> getAt(java.lang.Object... args)
```
    The following method enables the creation of nd-array slices which access the same underlying data (possibly from a different view). The method name also translates to the subscription operator in Groovy.
    
    Parameters:
    
    args - An arbitrary number of arguments which can be used for slicing.
    
    Returns:
    
    A slice nd-array created based on the passed keys.
  - get
```
Nda<V> get(java.lang.Object... args)
```
    The following method enables the creation of nd-array slices which access the same underlying data (possibly from a different view). The method name also translates to the subscription operator in Groovy.
    
    Parameters:
    
    args - An arbitrary number of arguments which can be used for slicing.
    
    Returns:
    
    A slice nd-array created based on the passed keys.
  - getAt
```
Nda<V> getAt(int i)
```
    This getter method creates and returns a slice of the original nd-array. The returned slice is a scalar nd-array wrapping a single value element which is being targeted by the provided integer index.
    
    Parameters:
    
    i - The index of the value item which should be returned as a nd-array instance.
    
    Returns:
    
    A nd-array holding a single value element which is internally still residing in the original nd-array.
  - get
```
Nda<V> get(int i)
```
    This getter method creates and returns a slice of the original nd-array. The returned slice is a scalar nd-array wrapping a single value element which is being targeted by the provided integer index.
    
    Parameters:
    
    i - The index of the value item which should be returned as a nd-array instance.
    
    Returns:
    
    A nd-array holding a single value element which is internally still residing in the original nd-array.
  - get
```
Nda<V> get(java.lang.Number i)
```
    This getter method creates and returns a slice of the original nd-array. The returned slice is a scalar nd-array wrapping a single value element which is being targeted by the provided integer index.
    
    Parameters:
    
    i - The index of the value item which should be returned as a nd-array instance.
    
    Returns:
    
    A nd-array holding a single value element which is internally still residing in the original nd-array.
  - get
```
Nda<V> get(java.lang.Object key)
```
    This method enables nd-array slicing! It takes a key of various types and configures a slice nd-array which shares the same underlying data as the original nd-array.
    
    Parameters:
    
    key - This object might be a wide range of objects including maps, lists or arrays...
    
    Returns:
    
    A slice nd-array or scalar value.
  - getAt
```
Nda<V> getAt(java.util.Map<?,java.lang.Integer> rangToSteps)
```
    This method is most useful when used in Groovy where defining maps is done through square brackets, making it possible to slice nd-arrays like so:
```
      var b = a[[[0..0]:1, [0..0]:1, [0..3]:2]]
  
```
    Here a single argument with the format '[i..j]:k' is equivalent to Pythons 'i:j:k' syntax for indexing! (numpy)
    i... start indexAlias.
    j... end indexAlias. (inclusive!)
    k... step size.
    Parameters:
    
    rangToSteps - A map where the keys define where axes should be sliced and values which define the steps for the specific axis.
    
    Returns:
    
    A nd-array slice with an offset based on the provided map keys and steps based on the provided map values.
  - getAt
```
Nda<V> getAt(java.util.List<?> key)
```
    This method enables nd-array slicing! It takes a key of various types and configures a slice nd-array which shares the same underlying data as the original nd-array.
    
    Parameters:
    
    key - This object might be a wide range of objects including maps, lists or arrays...
    
    Returns:
    
    A slice nd-array or scalar value.
  - mapTo
```
<T> Nda<T> mapTo(java.lang.Class<T> typeClass,
                 java.util.function.Function<V,T> mapper)
```
    This is a convenience method for mapping a nd-array to a nd-array of new type based on a provided target item type and mapping lambda. Here a simple example:
```
     Nda<String>  a = Nda.of(String.class).vector("1", "2", "3");
     Nda<Integer> b = a.mapTo(Integer.class, s -> Integer.parseInt(s));
 
```
    Note:
    The provided lambda cannot be executed anywhere else but the CPU. This is a problem if this nd-array lives somewhere other than the JVM. So, therefore, this method will temporally transfer this nd-array from where ever it may reside back to the JVM, execute the mapping lambda, and then transfer the result back to the original location.
    Type Parameters:
    
    T - The type parameter of the items of the returned nd-array.
    
    Parameters:
    
    typeClass - The class of the item type to which the items of this nd-array should be mapped.
    
    mapper - The lambda which maps the items of this nd-array to a new one.
    
    Returns:
    
    A new nd-array of type T.
  - map
```
Nda<V> map(java.util.function.Function<V,V> mapper)
```
    This method is a convenience method for mapping the items of this nd-array to another nd-array of the same type based on the provided lambda function, which will be applied to all items of this nd-array individually (element-wise).
    Here a simple example:
```
  Nda<String> a = Nda.of(String.class).vector("1", "2", "3");
  Nda<String> b = a.map( s -> s + "!" );
  
```
    Note:
    The provided lambda cannot be executed anywhere else but the CPU. This is a problem if this nd-array lives somewhere other than the JVM. So, therefore, this method will temporally transfer this nd-array from where ever it may reside back to the JVM, execute the mapping lambda, and then transfer the result back to the original location.
    Parameters:
    
    mapper - The lambda which maps the items of this nd-array to a new one.
    
    Returns:
    
    A new nd-array of type V.
  - deepCopy
```
Nda<V> deepCopy()
```
    This method creates and returns a new nd-array instance which is not only a copy of the configuration of this nd-array but also a copy of the underlying data array.
    (Note: the underlying nd-array will not be attached to any kind of computation graph)
    
    Returns:
    
    A new nd-array instance which is a deep copy of this nd-array.
  - shallowCopy
```
Nda<V> shallowCopy()
```
    This creates a copy where the underlying data is still the same.
    (Note: the underlying nd-array will not be attached to any kind of computation graph)
    
    Returns:
    
    A shallow copy where the underlying data is shared with this nd-array.
  - getMut
```
MutateNda<V> getMut()
```
    This method exposes an API for mutating the state of this tensor. The usage of methods exposed by this API is generally discouraged because the exposed state can easily lead to broken tensors and exceptional situations!
    
    Only use this if you know what you are doing and performance is critical!
    (Like in custom backend extensions for example)
    
    Returns:
    
    The unsafe API exposes methods for mutating the state of the tensor.
  - mut
```
default MutateNda<V> mut()
```
    This method exposes an API for mutating the state of this tensor. The usage of methods exposed by this API is generally discouraged because the exposed state can easily lead to broken tensors and exceptional situations!
    
    Only use this if you know what you are doing and performance is critical!
    (Like custom backend extensions for example)
    
    Returns:
    
    The unsafe API exposes methods for mutating the state of the tensor.
  - reshape
```
Nda<V> reshape(int... shape)
```
    Returns a nd-array with the same data and number of elements as this nd-array, but with the specified shape. When possible, the returned nd-array will be a view of this nd-array. A single dimension may be -1, in which case it’s inferred from the remaining dimensions and the number of elements in input. Keep in mind that the new shape must have the same number of elements as the original shape.
    
    This operation supports autograd.
    
    Parameters:
    
    shape - The new shape of the returned nd-array.
    
    Returns:
    
    A new nd-array instance with the same underlying data (~shallow copy) but with a different shape.
  - permute
```
Nda<V> permute(int... dims)
```
    Returns a view of the original tensor input with its dimensions permuted.
    Consider a 3-dimensional tensor x with shape (2×3×5), then calling x.permute(1, 0, 2) will return a 3-dimensional tensor of shape (3×2×5).
    
    Parameters:
    
    dims - The desired ordering of dimensions
    
    Returns:
    
    A new nd-array instance with the same underlying data (~shallow copy) but with a different shape.
  - transpose
```
Nda<V> transpose(int dim1,
                 int dim2)
```
    Returns a view of the original tensor input the targeted axes are swapped / transposed.
    
    Parameters:
    
    dim1 - The first dimension to be swapped.
    
    dim2 - The second dimension to be swapped.
    
    Returns:
    
    A new nd-array instance with the same underlying data (~shallow copy) but with a different shape.
  - at
```
Nda.Item<V> at(int... indices)
```
    This method exposes the Nda.Item API which allows you to get or set individual items within this nd-array targeted by an array of provided indices.
    
    Parameters:
    
    indices - An array of indices targeting a particular position in this nd-array...
    
    Returns:
    
    An object which allows you to get or set individual items within this nd-array.
  - toString
```
default java.lang.String toString(NDPrintSettings config)
```
    Use this to turn this nd-array into a String instance based on the provided NDPrintSettings instance, which allows you to configure things like the number of chars per entry, delimiters, the number of items per line, etc.
  - toString
```
default java.lang.String toString(java.util.function.Consumer<NDPrintSettings> config)
```
    This allows you to provide a lambda which configures how this nd-array should be converted to String instances. The provided Consumer will receive a NDPrintSettings instance which allows you to change various settings with the help of method chaining.
    Here is an example:
```
       t.toString(it ->
           it.setHasSlimNumbers(false)
             .setIsScientific(true)
             .setIsCellBound(true)
             .setIsMultiline(true)
             .setCellSize(15)
          );
  
```
    Parameters:
    
    config - A consumer of the NDPrintSettings ready to be configured.
    
    Returns:
    
    The String representation of this nd-array.
  - toString
```
java.lang.String toString()
```
    This method returns a String representation of this nd-array. The default settings are used for the conversion.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    
    The String representation of this nd-array.

Interface Nda<V>

Nested Class Summary

Method Summary

Methods inherited from interface neureka.ndim.NDimensional

Methods inherited from interface java.lang.Iterable

Method Detail

of

ofStrings

ofInts

ofDoubles

ofFloats

ofLongs

ofBooleans

ofChars

ofBytes

ofShorts

ofObjects

ofNumbers

ofBigDecimals

of

of

of

of

of

of

of

of

of

of

of

of

of

of

of

of

of

of

of

getLabel

label

isSlice

isShallowCopy

isPartialSlice

isFullSlice

sliceCount

isSliceParent

getItemType

itemType

withLabel

withLabels

withLabels

withLabels

stream

filter

flatMap

shaped

every

any

none

count

minItem

maxItem

getRawData

getDataAt

getItems

items

getRawItems

item

item

item

getItem

getItemsAs

getDataAs

slice

concatAt

concatAt

getAt

getAt

get

getAt