Java Code Examples for org.nd4j.linalg.factory.Nd4j#getStrides()

@Override
public INDArray createUninitializedDetached(DataType dataType, char ordering, long... shape){
    MemoryWorkspace workspace = Nd4j.getMemoryManager().getCurrentWorkspace();
    Nd4j.getMemoryManager().setCurrentWorkspace(null);
    INDArray ret = new NDArray(dataType, shape, Nd4j.getStrides(shape, ordering), 0, ordering, false);
    Nd4j.getMemoryManager().setCurrentWorkspace(workspace);
    return ret;
}
 

/**
 *
 * @param data
 * @param ordering
 */
public BaseNDArray(float[][] data, char ordering) {
    this(internalCreateBuffer(ordering == 'c' ? ArrayUtil.flatten(data) : ArrayUtil.flattenF(data)),
            new int[] {data.length, data[0].length},
            Nd4j.getStrides(new int[] {data.length, data[0].length}, ordering), 0, ordering);

    int c = columns();
    for (int r = 0; r < rows(); r++) {
        Preconditions.checkState(data[r].length == c, "data[%s].length=%s must be equal to number of columns %s", r, data[r].length, c );
    }
}
 

/**
 *
 * @param buffer
 */
public BaseNDArray(DataBuffer buffer) {
    this.data = buffer;
    if (buffer.length() >= Integer.MAX_VALUE)
        throw new IllegalArgumentException("Length of buffer can not be >= Integer.MAX_VALUE");
    long[] shape = {1, (int) buffer.length()};
    long[] stride = Nd4j.getStrides(shape);
    setShapeInformation(Nd4j.getShapeInfoProvider().createShapeInformation(shape, stride,  1, Nd4j.order(), buffer.dataType(), false));
    init(shape, stride);
}
 

/**
 *
 * @param floatBuffer
 * @param order
 */
public BaseNDArray(DataBuffer floatBuffer, char order) {
    this(floatBuffer, new int[] {(int) floatBuffer.length()},
            Nd4j.getStrides(new int[] {(int) floatBuffer.length()}, order), 0, order);
    if (floatBuffer.length() >= Integer.MAX_VALUE)
        throw new IllegalArgumentException("Length of buffer can not be >= Integer.MAX_VALUE");
}
 

/**
 *
 * @param data
 * @param ordering
 */
public BaseNDArray(double[][] data, char ordering) {
    this(internalCreateBuffer(ordering == 'c' ? ArrayUtil.flatten(data) : ArrayUtil.flattenF(data)),
            new int[] {data.length, data[0].length},
            Nd4j.getStrides(new int[] {data.length, data[0].length}, ordering), 0, ordering);

    int c = columns();
    for (int r = 0; r < rows(); r++) {
        Preconditions.checkState(data[r].length == c, "data[%s].length=%s must be equal to number of columns %s", r, data[r].length, c );
    }
}
 

@Override
public INDArray createUninitializedDetached(long[] shape, char ordering) {
    MemoryWorkspace workspace = Nd4j.getMemoryManager().getCurrentWorkspace();
    Nd4j.getMemoryManager().setCurrentWorkspace(null);
    INDArray ret = new NDArray(shape, Nd4j.getStrides(shape, ordering), 0, ordering, false);
    Nd4j.getMemoryManager().setCurrentWorkspace(workspace);
    return ret;
}
 

public BaseNDArray(List<INDArray> slices, long[] shape, char ordering) {
    this(slices, shape, Nd4j.getStrides(shape, ordering), ordering);
}
 

public BaseNDArray(DataBuffer buffer, long[] shape, char ordering) {
    this(buffer, shape, Nd4j.getStrides(shape, ordering), 0, ordering);
}
 

protected int[] getStrides(int[] shape, char ordering) {
    return Nd4j.getStrides(shape, ordering);
}
 

@Override
public INDArray createUninitialized(long[] shape, char ordering) {
    return new NDArray(shape, Nd4j.getStrides(shape, ordering), 0, ordering, false);
}
 

public BaseNDArray(DataBuffer buffer, long[] shape, char ordering) {
    this(buffer, shape, Nd4j.getStrides(shape, ordering), 0, ordering);
}
 

@Override
public INDArray createUninitialized(int[] shape, char ordering) {
    return new NDArray(shape, Nd4j.getStrides(shape, ordering), 0, ordering, false);
}
 

@Override
public INDArray create(DataType dataType, long[] shape, char ordering, MemoryWorkspace workspace) {
    return new NDArray(dataType, shape, Nd4j.getStrides(shape, ordering), 0, ordering, workspace);
}
 

@Override
public INDArray create(double[] data, long[] shape, long offset, Character order) {
    return new JCublasNDArray(data, shape, Nd4j.getStrides(shape, order), offset, order);
}
 

public BaseNDArray(DataBuffer data, long[] shape) {
    this(data, shape, Nd4j.getStrides(shape, Nd4j.order()), 0, Nd4j.order());
}
 

/**
 *
 * @param shape
 * @param offset
 * @param ordering
 */
public BaseNDArray(int[] shape, long offset, char ordering) {
    this(shape, Nd4j.getStrides(shape, ordering), offset, ordering);
}
 

/**
 *
 * @param data
 * @param shape
 */
public BaseNDArray(DataBuffer data, int[] shape) {
    this(data, shape, Nd4j.getStrides(shape, Nd4j.order()), 0, Nd4j.order());
}
 

/**
 * Creates an ndarray with the specified shape
 *
 * @param list
 * @param shape the shape of the ndarray
 * @return the instance
 */
@Override
public INDArray create(List<INDArray> list, int[] shape) {
    return new NDArray(list, shape, Nd4j.getStrides(shape));
}
 

/**
 * Create an ndarray from the specified slices.
 * This will go through and merge all of the
 * data from each slice in to one ndarray
 * which will then take the specified shape
 *
 * @param slices the slices to merge
 * @param shape  the shape of the ndarray
 */
public BaseNDArray(List<INDArray> slices, int[] shape, char ordering) {
    this(slices, shape, Nd4j.getStrides(shape, ordering), ordering);
}
 

/**
 * Calculate the strides based on the given indices
 *
 * @param ordering the ordering to calculate strides for
 * @param indexes  the indices to calculate stride for
 * @return the strides for the given indices
 */
public static int[] strides(char ordering, NDArrayIndex... indexes) {
    return Nd4j.getStrides(shape(indexes), ordering);
}