org.nd4j.linalg.indexing

Class Indices

java.lang.Object

org.nd4j.linalg.indexing.Indices

public class Indices
extends Object

Indexing util.

Author:

Adam Gibson

Constructor Summary

Constructors

Constructor and Description
Indices()

Method Summary

Modifier and Type	Method and Description
static INDArrayIndex[]	adjustIndices(int[] originalShape, INDArrayIndex... indexes) Prunes indices of greater length than the shape and fills in missing indices if there are any
static INDArrayIndex[]	createFromStartAndEnd(INDArray start, INDArray end) Create an n dimensional index based on the given interval indices.
static INDArrayIndex[]	createFromStartAndEnd(INDArray start, INDArray end, boolean inclusive) Create indices representing intervals along each dimension
static INDArrayIndex[]	fillIn(int[] shape, INDArrayIndex... indexes) Fill in the missing indices to be the same length as the original shape.
static boolean	isContiguous(int[] indices, int diff) Returns whether indices are contiguous by a certain amount or not
static boolean	isScalar(INDArray indexOver, INDArrayIndex... indexes) Check if the given indexes over the specified array are searching for a scalar
static int	linearOffset(int index, INDArray arr) Compute the linear offset for an index in an ndarray.
static int[]	offsets(int[] shape, INDArrayIndex... indices) The offsets (begin index) for each index
static int	rowNumber(int index, INDArray arr) Compute the linear offset for an index in an ndarray.
static int[]	shape(INDArrayIndex... indices) Calculate the shape for the given set of indices.
static int[]	shape(int[] shape, INDArrayIndex... indices) Calculate the shape for the given set of indices and offsets.
static int[]	stride(INDArray arr, INDArrayIndex[] indexes, int... shape) Return the stride to be used for indexing
static int[]	strides(char ordering, NDArrayIndex... indexes) Calculate the strides based on the given indices

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

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 int 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 int[] offsets(int[] 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

adjustIndices

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:

the adjusted indices

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

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