Shape (nd4j-api 0.4-rc3.8 API)

java.lang.Object
- org.nd4j.linalg.api.shape.Shape

```
public class Shape
extends Object
```
Encapsulates all shape related logic (vector of 0 dimension is a scalar is equivalent to a vector of length 1...)

Author:

Adam Gibson

Constructor Summary

Constructors
Constructor and Description

Shape()

Constructors
Constructor and Description
`Shape()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`assertShapeLessThan(int[] shape, int[] lessThan)` Assert the both shapes are the same length and shape[i] < lessThan[i]
`static void`	`assignArray(INDArray destination, INDArray source)`
`static int[]`	`broadcastStrides(int nDim, int[] shape, int numStrideDimensions, int[] strideShape, int[] strides)` Broadcasts strides to match the given dimensions.
`static INDArray`	`copyArrayWithWholeBuffer(INDArray arr)` Copy the whole buffer whole sale
`static boolean`	`cOrFortranOrder(int[] shape, int[] stride, int elementStride)` Infer order from
`static int[]`	`createConcatStrides(INDArray... arrays)` A port of numpy's stride resolution algorithm for multiple arrays
`static StridePermutation[]`	`createSortedStrides(int[] strides)` Creates sorted strides whlie retaining the permutation
`static void`	`forEachOffset(INDArray[] arr, CoordinateFunction coordinateFunction)` Iterates over each possible offset of an ndarray
`static void`	`forEachOffset(INDArray arr, CoordinateFunction coordinateFunction)` Iterates over each possible offset of an ndarray
`static double`	`getDouble(INDArray arr, int... indices)` Get a double based on the array and given indices
`static int`	`getOffset(int baseOffset, int[] shape, int[] stride, int... indices)` Get an offset for retrieval from a data buffer based on the given shape stride and given indices
`static char`	`getOrder(INDArray arr)` Infer the order for the ndarray based on the array's strides
`static char`	`getOrder(int[] shape, int[] stride, int elementStride)` Infer order from
`static int[]`	`ind2sub(INDArray arr, int index)` Convert a linear index to the equivalent nd index based on the shape of the specified ndarray.
`static int[]`	`ind2sub(int[] shape, int index)` Convert a linear index to the equivalent nd index.
`static int[]`	`ind2sub(int[] shape, int index, int numIndices)` Convert a linear index to the equivalent nd index
`static int[]`	`ind2subC(INDArray arr, int index)` Convert a linear index to the equivalent nd index based on the shape of the specified ndarray.
`static int[]`	`ind2subC(int[] shape, int index)` Convert a linear index to the equivalent nd index.
`static int[]`	`ind2subC(int[] shape, int index, int numIndices)` Convert a linear index to the equivalent nd index
`static boolean`	`isColumnVectorShape(int[] shape)` Returns true if the given shape is length 2 and the size at element 1 is 1
`static boolean`	`isContiguousInBuffer(INDArray in)` Are the elements in the buffer contiguous for this NDArray?
`static boolean`	`isMatrix(int[] shape)` Returns whether the passed in shape is a matrix
`static boolean`	`isRowVectorShape(int[] shape)` Returns true if the given shape is of length 1 or provided the shape length is 2: element 0 is 1
`static boolean`	`isVector(int[] shape)` Returns whether the given shape is a vector
`static void`	`iterate(INDArray arr, CoordinateFunction coordinateFunction)` Iterate over 2 coordinate spaces given 2 arrays
`static void`	`iterate(INDArray arr, INDArray arr2, CoordinateFunction coordinateFunction)` Iterate over 2 coordinate spaces given 2 arrays
`static void`	`iterate(int dimension, int n, int[] size, int[] res, CoordinateFunction func)` Iterate over a pair of coordinates
`static void`	`iterate(int dimension, int n, int[] size, int[] res, int dimension2, int n2, int[] size2, int[] res2, CoordinateFunction func)` Iterate over a pair of coordinates
`static int[]`	`leadingAndTrailingOnes(int[] original)` Get rid ones in the shape when its not a vector
`static int[]`	`moveOnesToEnd(int[] shape)` Returns a permutation of the dimensions with all 1s moved to end
`static int[]`	`newOffsets(int[] offsets, int newLength, INDArrayIndex[] indexes)`
`static INDArray`	`newShapeNoCopy(INDArray arr, int[] newShape, boolean isFOrder)` A port of numpy's reshaping algorithm that leverages no copy where possible and returns null if the reshape couldn't happen without copying
`static int[]`	`newStrides(int[] strides, int newLength, INDArrayIndex[] indexes)`
`static int[]`	`nonOneDimensions(int[] dimensions, int[] shape)` Keep all the non one dimensions
`static int`	`offsetFor(INDArray arr, int index)` Compute the offset for a given index
`static int`	`offsetFor(INDArray arr, int[] indexes)` Compute the offset for the given array given the indices
`static boolean`	`opIsWholeBufferWithMatchingStrides(Op op)` Checks the following: each x,y,z is offset zero op.n() is == data buffer.length() all strides are equal
`static boolean`	`opIsWithMatchingStrides(Op op)` Checks the following: each x,y,z is offset zero op.n() is == data buffer.length() all strides are equal
`static RawArrayIterationInformation1`	`prepareRawArrayIter(INDArray dst)` Prepares two arrays for raw iteration linearly through the data.
`static RawArrayIterationInformation2`	`prepareTwoRawArrayIter(INDArray dst, INDArray src)` Prepares two arrays for raw iteration linearly through the data.
`static int[]`	`raw2dLoop(int idim, int ndim, int[] coord, int[] shape, int dataA, int[] stridesA, int dataB, int[] stridesB, RawArrayIterationInformation2 info, LoopFunction2 loopFunction2)` Raw 2 dimensional loop over a data buffer given some strides.
`static int[]`	`raw3dLoop(int idim, int ndim, int[] coord, int[] shape, int dataA, int[] stridesA, int dataB, int[] stridesB, int dataC, int[] stridesC, RawArrayIterationInformation3 info, LoopFunction3 loopFunction3)` 3 dimensional loop Credit to: https://github.com/numpy/numpy/blob/master/numpy/core/src/private/lowlevel_strided_loops.h#L548
`static int[]`	`raw4DLoop(int idim, int ndim, int[] coord, int[] shape, int dataA, int[] stridesA, int dataB, int[] stridesB, int dataC, int[] stridesC, int dataD, int[] stridesD, RawArrayIterationInformation4 info, LoopFunction4 loopFunction4)` 4 dimensional loop Credit to: https://github.com/numpy/numpy/blob/master/numpy/core/src/private/lowlevel_strided_loops.h#L548
`static boolean`	`scalarEquals(int[] shape1, int[] shape2)` Returns true if the given shapes are both scalars (0 dimension or shape[0] == 1)
`static boolean`	`shapeEquals(int[] shape1, int[] shape2)` Returns whether 2 shapes are equals by checking for dimension semantics as well as array equality
`static int[]`	`sizeForAxes(int[] axes, int[] shape)` Output an int array for a particular dimension
`static int[]`	`squeeze(int[] shape)` Gets rid of any singleton dimensions of the given array
`static boolean`	`squeezeEquals(int[] test1, int[] test2)` Returns true for the case where singleton dimensions are being compared
`static int[]`	`squeezeOffsets(int[] shape, int[] offsets)`
`static boolean`	`strideDescendingCAscendingF(INDArray array)` Check if strides are in order suitable for non-strided mmul etc.
`static int`	`sub2Ind(int[] shape, int[] indices)` Convert the given index (such as 1,1) to a linear index
`static INDArrayIndex[]`	`toIndexes(int[] indices)` Convert the given int indexes to nd array indexes
`static INDArray`	`toMmulCompatible(INDArray input)` Idea: make an matrix compatible for mmul without needing to be copied first A matrix is compatible for mmul if its values are contiguous in memory.
`static INDArray`	`toOffsetZero(INDArray arr)` Create a copy of the matrix where the new offset is zero
`static INDArray`	`toOffsetZeroCopy(INDArray arr)` Create a copy of the ndarray where the new offset is zero
`static INDArray`	`toOffsetZeroCopy(INDArray arr, char order)` Create a copy of the ndarray where the new offset is zero, and has specified order
`static INDArray`	`toOffsetZeroCopyAnyOrder(INDArray arr)` Create a copy of the ndarray where the new offset is zero.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - Shape
```
public Shape()
```
- Method Detail
  - toOffsetZero
```
public static INDArray toOffsetZero(INDArray arr)
```
    Create a copy of the matrix where the new offset is zero
    
    Parameters:
    
    arr - the array to copy to offset 0
    
    Returns:
    
    the same array if offset is zero otherwise a copy of the array with elements set to zero
  - copyArrayWithWholeBuffer
```
public static INDArray copyArrayWithWholeBuffer(INDArray arr)
```
    Copy the whole buffer whole sale
    
    Parameters:
    
    arr -
    
    Returns:
  - toOffsetZeroCopy
```
public static INDArray toOffsetZeroCopy(INDArray arr)
```
    Create a copy of the ndarray where the new offset is zero
    
    Parameters:
    
    arr - the array to copy to offset 0
    
    Returns:
    
    a copy of the array with elements set to zero offset
  - toOffsetZeroCopy
```
public static INDArray toOffsetZeroCopy(INDArray arr,
                                        char order)
```
    Create a copy of the ndarray where the new offset is zero, and has specified order
    
    Parameters:
    
    arr - the array to copy to offset 0
    
    order - the order of the returned array
    
    Returns:
    
    a copy of the array with elements set to zero offset, and with specified order
  - toOffsetZeroCopyAnyOrder
```
public static INDArray toOffsetZeroCopyAnyOrder(INDArray arr)
```
    Create a copy of the ndarray where the new offset is zero. Unlike toOffsetZeroCopy(INDArray) (which always returns arrays of order Nd4j.order()), and toOffsetZeroCopy(INDArray,char) (which always returns arrays of a specified order) this method returns NDArrays of any order (sometimes c, sometimes f).
    This method may be faster than the other two toOffsetZeroCopyAnyOrder methods as a result, however no performance benefit (or cost) relative to them will be observed in many cases. If a copy is necessary, the output will have order Nd4j.order()
    
    Parameters:
    
    arr - NDArray to duplicate
    
    Returns:
    
    Copy with offset 0, but order might be c, or might be f
  - toMmulCompatible
```
public static INDArray toMmulCompatible(INDArray input)
```
    Idea: make an matrix compatible for mmul without needing to be copied first
    A matrix is compatible for mmul if its values are contiguous in memory. Offset is OK. Returns the input array if input can be used in mmul without additional copy overhead Otherwise returns a copy of the input ndarray that can be used in mmul without additional copy overhead
    This is useful for example if a matrix is going to be used in multiple mmul operations, so that we only have the overhead of copying at most once (rather than in every mmul operation)
    
    Parameters:
    
    input - Input ndarray
    
    Returns:
    
    ndarray that can be used in mmul without copy overhead
  - getDouble
```
public static double getDouble(INDArray arr,
                               int... indices)
```
    Get a double based on the array and given indices
    
    Parameters:
    
    arr - the array to retrieve the double from
    
    indices - the indices to iterate over
    
    Returns:
    
    the double at the specified index
  - iterate
```
public static void iterate(INDArray arr,
                           CoordinateFunction coordinateFunction)
```
    Iterate over 2 coordinate spaces given 2 arrays
    
    Parameters:
    
    arr - the first array
    
    coordinateFunction - the coordinate function to use
  - iterate
```
public static void iterate(INDArray arr,
                           INDArray arr2,
                           CoordinateFunction coordinateFunction)
```
    Iterate over 2 coordinate spaces given 2 arrays
    
    Parameters:
    
    arr - the first array
    
    arr2 - the second array
    
    coordinateFunction - the coordinate function to use
  - iterate
```
public static void iterate(int dimension,
                           int n,
                           int[] size,
                           int[] res,
                           int dimension2,
                           int n2,
                           int[] size2,
                           int[] res2,
                           CoordinateFunction func)
```
    Iterate over a pair of coordinates
    
    Parameters:
    
    dimension -
    
    n -
    
    size -
    
    res -
    
    dimension2 -
    
    n2 -
    
    size2 -
    
    res2 -
    
    func -
  - forEachOffset
```
public static void forEachOffset(INDArray[] arr,
                                 CoordinateFunction coordinateFunction)
```
    Iterates over each possible offset of an ndarray
    
    Parameters:
    
    arr -
    
    coordinateFunction -
  - forEachOffset
```
public static void forEachOffset(INDArray arr,
                                 CoordinateFunction coordinateFunction)
```
    Iterates over each possible offset of an ndarray
    
    Parameters:
    
    arr -
    
    coordinateFunction -
  - iterate
```
public static void iterate(int dimension,
                           int n,
                           int[] size,
                           int[] res,
                           CoordinateFunction func)
```
    Iterate over a pair of coordinates
    
    Parameters:
    
    dimension -
    
    n -
    
    size -
  - raw2dLoop
```
public static int[] raw2dLoop(int idim,
                              int ndim,
                              int[] coord,
                              int[] shape,
                              int dataA,
                              int[] stridesA,
                              int dataB,
                              int[] stridesB,
                              RawArrayIterationInformation2 info,
                              LoopFunction2 loopFunction2)
```
    Raw 2 dimensional loop over a data buffer given some strides. Credit to: https://github.com/numpy/numpy/blob/master/numpy/core/src/private/lowlevel_strided_loops.h#L548
    
    Parameters:
    
    idim - the current dimension
    
    ndim - the number of dimensions
    
    coord - the current coordinate
    
    shape - the oerall shape of the array
    
    dataA - the offset for data a
    
    stridesA - the strides for a
    
    dataB - the offset for data b
    
    stridesB - the strides for b
  - raw3dLoop
```
public static int[] raw3dLoop(int idim,
                              int ndim,
                              int[] coord,
                              int[] shape,
                              int dataA,
                              int[] stridesA,
                              int dataB,
                              int[] stridesB,
                              int dataC,
                              int[] stridesC,
                              RawArrayIterationInformation3 info,
                              LoopFunction3 loopFunction3)
```
    3 dimensional loop Credit to: https://github.com/numpy/numpy/blob/master/numpy/core/src/private/lowlevel_strided_loops.h#L548
    
    Parameters:
    
    idim -
    
    ndim -
    
    coord -
    
    shape -
    
    dataA -
    
    stridesA -
    
    dataB -
    
    stridesB -
    
    dataC -
    
    stridesC -
  - raw4DLoop
```
public static int[] raw4DLoop(int idim,
                              int ndim,
                              int[] coord,
                              int[] shape,
                              int dataA,
                              int[] stridesA,
                              int dataB,
                              int[] stridesB,
                              int dataC,
                              int[] stridesC,
                              int dataD,
                              int[] stridesD,
                              RawArrayIterationInformation4 info,
                              LoopFunction4 loopFunction4)
```
    4 dimensional loop Credit to: https://github.com/numpy/numpy/blob/master/numpy/core/src/private/lowlevel_strided_loops.h#L548
    
    Parameters:
    
    idim -
    
    ndim -
    
    coord -
    
    shape -
    
    dataA -
    
    stridesA -
    
    dataB -
    
    stridesB -
    
    dataC -
    
    stridesC -
    
    dataD -
    
    stridesD -
  - getOffset
```
public static int getOffset(int baseOffset,
                            int[] shape,
                            int[] stride,
                            int... indices)
```
    Get an offset for retrieval from a data buffer based on the given shape stride and given indices
    
    Parameters:
    
    baseOffset - the offset to start from
    
    shape - the shape of the array
    
    stride - the stride of the array
    
    indices - the indices to iterate over
    
    Returns:
    
    the double at the specified index
  - sizeForAxes
```
public static int[] sizeForAxes(int[] axes,
                                int[] shape)
```
    Output an int array for a particular dimension
    
    Parameters:
    
    axes - the axes
    
    shape - the current shape
    
    Returns:
  - isVector
```
public static boolean isVector(int[] shape)
```
    Returns whether the given shape is a vector
    
    Parameters:
    
    shape - the shape to test
    
    Returns:
    
    whether the given shape is a vector
  - isMatrix
```
public static boolean isMatrix(int[] shape)
```
    Returns whether the passed in shape is a matrix
    
    Parameters:
    
    shape - whether the passed in shape is a matrix
    
    Returns:
    
    true if the shape is a matrix false otherwise
  - squeeze
```
public static int[] squeeze(int[] shape)
```
    Gets rid of any singleton dimensions of the given array
    
    Parameters:
    
    shape - the shape to squeeze
    
    Returns:
    
    the array with all of the singleton dimensions removed
  - nonOneDimensions
```
public static int[] nonOneDimensions(int[] dimensions,
                                     int[] shape)
```
    Keep all the non one dimensions
    
    Parameters:
    
    dimensions - the dimensions to start with
    
    shape - the shapes to inspect
    
    Returns:
    
    the non one dimensions of the given input
  - leadingAndTrailingOnes
```
public static int[] leadingAndTrailingOnes(int[] original)
```
    Get rid ones in the shape when its not a vector
    
    Parameters:
    
    original - the original shape to prune
    
    Returns:
    
    the pruned array
  - shapeEquals
```
public static boolean shapeEquals(int[] shape1,
                                  int[] shape2)
```
    Returns whether 2 shapes are equals by checking for dimension semantics as well as array equality
    
    Parameters:
    
    shape1 - the first shape for comparison
    
    shape2 - the second shape for comparison
    
    Returns:
    
    whether the shapes are equivalent
  - scalarEquals
```
public static boolean scalarEquals(int[] shape1,
                                   int[] shape2)
```
    Returns true if the given shapes are both scalars (0 dimension or shape[0] == 1)
    
    Parameters:
    
    shape1 - the first shape for comparison
    
    shape2 - the second shape for comparison
    
    Returns:
    
    whether the 2 shapes are equal based on scalar rules
  - isRowVectorShape
```
public static boolean isRowVectorShape(int[] shape)
```
    Returns true if the given shape is of length 1 or provided the shape length is 2: element 0 is 1
    
    Parameters:
    
    shape - the shape to check
    
    Returns:
    
    true if the above conditions hold,false otherwise
  - isColumnVectorShape
```
public static boolean isColumnVectorShape(int[] shape)
```
    Returns true if the given shape is length 2 and the size at element 1 is 1
    
    Parameters:
    
    shape - the shape to check
    
    Returns:
    
    true if the above listed conditions hold false otherwise
  - createConcatStrides
```
public static int[] createConcatStrides(INDArray... arrays)
```
    A port of numpy's stride resolution algorithm for multiple arrays
    
    Parameters:
    
    arrays - the arrays to get concat strides for
    
    Returns:
    
    the resolved strides for concat
  - assignArray
```
public static void assignArray(INDArray destination,
                               INDArray source)
```
  - broadcastStrides
```
public static int[] broadcastStrides(int nDim,
                                     int[] shape,
                                     int numStrideDimensions,
                                     int[] strideShape,
                                     int[] strides)
```
    Broadcasts strides to match the given dimensions. Used for setting up a raw iteration
    
    Parameters:
    
    nDim - the number of dimensions to iterate through
    
    shape - the shape to compare broadcasting strides against
    
    numStrideDimensions - the number of stride dimensions to broadcast
    
    strideShape - the shape of the stride to broadcast
    
    strides - the strides to broadcast
    
    Returns:
    
    the new strides
  - prepareRawArrayIter
```
public static RawArrayIterationInformation1 prepareRawArrayIter(INDArray dst)
```
    Prepares two arrays for raw iteration linearly through the data. It uses the same data for allocation
    
    Parameters:
    
    dst - the first array
  - prepareTwoRawArrayIter
```
public static RawArrayIterationInformation2 prepareTwoRawArrayIter(INDArray dst,
                                                                   INDArray src)
```
    Prepares two arrays for raw iteration linearly through the data. It uses the same data for allocation
    
    Parameters:
    
    dst - the first array
    
    src - the second array
  - createSortedStrides
```
public static StridePermutation[] createSortedStrides(int[] strides)
```
    Creates sorted strides whlie retaining the permutation
    
    Parameters:
    
    strides - the strides
    
    Returns:
    
    the ordered strides with the permutation/order retained
  - newShapeNoCopy
```
public static INDArray newShapeNoCopy(INDArray arr,
                                      int[] newShape,
                                      boolean isFOrder)
```
    A port of numpy's reshaping algorithm that leverages no copy where possible and returns null if the reshape couldn't happen without copying
    
    Parameters:
    
    arr - the array to reshape
    
    newShape - the new shape
    
    isFOrder - whether the array will be fortran ordered or not
    
    Returns:
    
    null if a reshape isn't possible, or a new ndarray
  - cOrFortranOrder
```
public static boolean cOrFortranOrder(int[] shape,
                                      int[] stride,
                                      int elementStride)
```
    Infer order from
    
    Parameters:
    
    shape - the shape to infer by
    
    stride - the stride to infer by
    
    elementStride - the element stride to start at
    
    Returns:
    
    the storage order given shape and element stride
  - getOrder
```
public static char getOrder(int[] shape,
                            int[] stride,
                            int elementStride)
```
    Infer order from
    
    Parameters:
    
    shape - the shape to infer by
    
    stride - the stride to infer by
    
    elementStride - the element stride to start at
    
    Returns:
    
    the storage order given shape and element stride
  - getOrder
```
public static char getOrder(INDArray arr)
```
    Infer the order for the ndarray based on the array's strides
    
    Parameters:
    
    arr - the array to get the ordering for
    
    Returns:
    
    the ordering for the given array
  - sub2Ind
```
public static int sub2Ind(int[] shape,
                          int[] indices)
```
    Convert the given index (such as 1,1) to a linear index
    
    Parameters:
    
    shape - the shape of the indexes to convert
    
    indices - the index to convert
    
    Returns:
    
    the linear index given the shape and indices
  - ind2sub
```
public static int[] ind2sub(int[] shape,
                            int index,
                            int numIndices)
```
    Convert a linear index to the equivalent nd index
    
    Parameters:
    
    shape - the shape of the dimensions
    
    index - the index to map
    
    numIndices - the number of total indices (typically prod of shape(
    
    Returns:
    
    the mapped indexes along each dimension
  - ind2sub
```
public static int[] ind2sub(int[] shape,
                            int index)
```
    Convert a linear index to the equivalent nd index. Infers the number of indices from the specified shape.
    
    Parameters:
    
    shape - the shape of the dimensions
    
    index - the index to map
    
    Returns:
    
    the mapped indexes along each dimension
  - ind2sub
```
public static int[] ind2sub(INDArray arr,
                            int index)
```
    Convert a linear index to the equivalent nd index based on the shape of the specified ndarray. Infers the number of indices from the specified shape.
    
    Parameters:
    
    arr - the array to compute the indexes based on
    
    index - the index to map
    
    Returns:
    
    the mapped indexes along each dimension
  - ind2subC
```
public static int[] ind2subC(int[] shape,
                             int index,
                             int numIndices)
```
    Convert a linear index to the equivalent nd index
    
    Parameters:
    
    shape - the shape of the dimensions
    
    index - the index to map
    
    numIndices - the number of total indices (typically prod of shape(
    
    Returns:
    
    the mapped indexes along each dimension
  - opIsWholeBufferWithMatchingStrides
```
public static boolean opIsWholeBufferWithMatchingStrides(Op op)
```
    Checks the following: each x,y,z is offset zero op.n() is == data buffer.length() all strides are equal
    
    Parameters:
    
    op - the op to check
    
    Returns:
    
    true if the above conditions are met
  - opIsWithMatchingStrides
```
public static boolean opIsWithMatchingStrides(Op op)
```
    Checks the following: each x,y,z is offset zero op.n() is == data buffer.length() all strides are equal
    
    Parameters:
    
    op - the op to check
    
    Returns:
    
    true if the above conditions are met
  - ind2subC
```
public static int[] ind2subC(int[] shape,
                             int index)
```
    Convert a linear index to the equivalent nd index. Infers the number of indices from the specified shape.
    
    Parameters:
    
    shape - the shape of the dimensions
    
    index - the index to map
    
    Returns:
    
    the mapped indexes along each dimension
  - ind2subC
```
public static int[] ind2subC(INDArray arr,
                             int index)
```
    Convert a linear index to the equivalent nd index based on the shape of the specified ndarray. Infers the number of indices from the specified shape.
    
    Parameters:
    
    arr - the array to compute the indexes based on
    
    index - the index to map
    
    Returns:
    
    the mapped indexes along each dimension
  - offsetFor
```
public static int offsetFor(INDArray arr,
                            int[] indexes)
```
    Compute the offset for the given array given the indices
    
    Parameters:
    
    arr - the array to compute the offset for
    
    indexes - the indexes along each dimension to create the offset for
    
    Returns:
    
    the offset for the given array and indexes
  - offsetFor
```
public static int offsetFor(INDArray arr,
                            int index)
```
    Compute the offset for a given index
    
    Parameters:
    
    arr - the array to compute the offset for
    
    index - the linear index to compute the offset for
    
    Returns:
    
    the offset for the given linear index
  - assertShapeLessThan
```
public static void assertShapeLessThan(int[] shape,
                                       int[] lessThan)
```
    Assert the both shapes are the same length and shape[i] < lessThan[i]
    
    Parameters:
    
    shape - the shape to check
    
    lessThan - the shape to assert against
  - moveOnesToEnd
```
public static int[] moveOnesToEnd(int[] shape)
```
    Returns a permutation of the dimensions with all 1s moved to end
    
    Parameters:
    
    shape - the shape to permute
    
    Returns:
    
    the permuted axes with all moving towards end
  - toIndexes
```
public static INDArrayIndex[] toIndexes(int[] indices)
```
    Convert the given int indexes to nd array indexes
    
    Parameters:
    
    indices - the indices to convert
    
    Returns:
    
    the converted indexes
  - newStrides
```
public static int[] newStrides(int[] strides,
                               int newLength,
                               INDArrayIndex[] indexes)
```
  - newOffsets
```
public static int[] newOffsets(int[] offsets,
                               int newLength,
                               INDArrayIndex[] indexes)
```
  - squeezeOffsets
```
public static int[] squeezeOffsets(int[] shape,
                                   int[] offsets)
```
  - squeezeEquals
```
public static boolean squeezeEquals(int[] test1,
                                    int[] test2)
```
    Returns true for the case where singleton dimensions are being compared
    
    Parameters:
    
    test1 - the first to test
    
    test2 - the second to test
    
    Returns:
    
    true if the arrays are equal with the singleton dimension omitted
  - strideDescendingCAscendingF
```
public static boolean strideDescendingCAscendingF(INDArray array)
```
    Check if strides are in order suitable for non-strided mmul etc. Returns true if c order and strides are descending [100,10,1] etc Returns true if f order and strides are ascending [1,10,100] etc False otherwise.
    
    Returns:
    
    true if c+descending, f+ascending, false otherwise
  - isContiguousInBuffer
```
public static boolean isContiguousInBuffer(INDArray in)
```
    Are the elements in the buffer contiguous for this NDArray?

Class Shape

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Shape

Method Detail

toOffsetZero

copyArrayWithWholeBuffer

toOffsetZeroCopy

toOffsetZeroCopy

toOffsetZeroCopyAnyOrder

toMmulCompatible

getDouble

iterate

iterate

iterate

forEachOffset

forEachOffset

iterate

raw2dLoop

raw3dLoop

raw4DLoop

getOffset

sizeForAxes

isVector

isMatrix

squeeze

nonOneDimensions

leadingAndTrailingOnes

shapeEquals

scalarEquals

isRowVectorShape

isColumnVectorShape

createConcatStrides

assignArray

broadcastStrides

prepareRawArrayIter

prepareTwoRawArrayIter

createSortedStrides

newShapeNoCopy

cOrFortranOrder

getOrder

getOrder

sub2Ind

ind2sub

ind2sub

ind2sub

ind2subC

opIsWholeBufferWithMatchingStrides

opIsWithMatchingStrides

ind2subC

ind2subC

offsetFor

offsetFor

assertShapeLessThan

moveOnesToEnd

toIndexes

newStrides

newOffsets

squeezeOffsets

squeezeEquals

strideDescendingCAscendingF

isContiguousInBuffer