org.nd4j.linalg.indexing

## Class Indices

• public class Indices
extends Object
Indexing util.
Author:
• ### Constructor Detail

• #### Indices

public Indices()
• ### Method Detail

• #### rowNumber

public static int rowNumber(int index,
INDArray arr)
Compute the linear offset for an index in an ndarray. For c ordering this is just the index itself. For fortran ordering, the following algorithm is used. Assuming an ndarray is a list of vectors. The index of the vector relative to the given index is calculated. vectorAlongDimension is then used along the last dimension using the computed index. The offset + the computed column wrt the index: (index % the size of the last dimension) will render the given index in fortran ordering
Parameters:
index - the index
arr - the array
Returns:
the linear offset
• #### linearOffset

public static long linearOffset(int index,
INDArray arr)
Compute the linear offset for an index in an ndarray. For c ordering this is just the index itself. For fortran ordering, the following algorithm is used. Assuming an ndarray is a list of vectors. The index of the vector relative to the given index is calculated. vectorAlongDimension is then used along the last dimension using the computed index. The offset + the computed column wrt the index: (index % the size of the last dimension) will render the given index in fortran ordering
Parameters:
index - the index
arr - the array
Returns:
the linear offset
• #### offsets

public static long[] offsets(long[] shape,
INDArrayIndex... indices)
The offsets (begin index) for each index
Parameters:
indices - the indices
Returns:
the offsets for the given set of indices
• #### fillIn

public static INDArrayIndex[] fillIn(int[] shape,
INDArrayIndex... indexes)
Fill in the missing indices to be the same length as the original shape.

Think of this as what fills in the indices for numpy or matlab: Given a which is (4,3,2) in numpy:

a[1:3] is filled in by the rest to give back the full slice

This algorithm fills in that delta

Parameters:
shape - the original shape
indexes - the indexes to start from
Returns:
the filled in indices

public static INDArrayIndex[] adjustIndices(int[] originalShape,
INDArrayIndex... indexes)
Prunes indices of greater length than the shape and fills in missing indices if there are any
Parameters:
originalShape - the original shape to adjust to
indexes - the indexes to adjust
Returns:
• #### strides

public static int[] strides(char ordering,
NDArrayIndex... indexes)
Calculate the strides based on the given indices
Parameters:
ordering - the ordering to calculate strides for
indexes - the indices to calculate stride for
Returns:
the strides for the given indices
• #### shape

public static int[] shape(INDArrayIndex... indices)
Calculate the shape for the given set of indices.

The shape is defined as (for each dimension) the difference between the end index + 1 and the begin index

Parameters:
indices - the indices to calculate the shape for
Returns:
the shape for the given indices
• #### isContiguous

public static boolean isContiguous(int[] indices,
int diff)
Returns whether indices are contiguous by a certain amount or not
Parameters:
indices - the indices to test
diff - the difference considered to be contiguous
Returns:
whether the given indices are contiguous or not
• #### createFromStartAndEnd

public static INDArrayIndex[] createFromStartAndEnd(INDArray start,
INDArray end)
Create an n dimensional index based on the given interval indices. Start and end represent the begin and end of each interval
Parameters:
start - the start indexes
end - the end indexes
Returns:
the interval index relative to the given start and end indices
• #### createFromStartAndEnd

public static INDArrayIndex[] createFromStartAndEnd(INDArray start,
INDArray end,
boolean inclusive)
Create indices representing intervals along each dimension
Parameters:
start - the start index
end - the end index
inclusive - whether the last index should be included
Returns:
the ndarray indexes covering each dimension
• #### shape

public static int[] shape(int[] shape,
INDArrayIndex... indices)
Calculate the shape for the given set of indices and offsets.

The shape is defined as (for each dimension) the difference between the end index + 1 and the begin index

If specified, this will check for whether any of the indices are >= to end - 1 and if so, prune it down

Parameters:
shape - the original shape
indices - the indices to calculate the shape for
Returns:
the shape for the given indices
• #### shape

public static long[] shape(long[] shape,
INDArrayIndex... indices)
• #### stride

public static int[] stride(INDArray arr,
INDArrayIndex[] indexes,
int... shape)
Return the stride to be used for indexing
Parameters:
arr - the array to get the strides for
indexes - the indexes to use for computing stride
shape - the shape of the output
Returns:
the strides used for indexing
• #### isScalar

public static boolean isScalar(INDArray indexOver,
INDArrayIndex... indexes)
Check if the given indexes over the specified array are searching for a scalar
Parameters:
indexOver - the array to index over
indexes - the index query
Returns:
true if the given indexes are searching for a scalar false otherwise