public static INDArrayIndex interval(long begin, long stride, long end,long max, boolean inclusive) { assert begin <= end : "Beginning index in range must be less than end"; INDArrayIndex index = new IntervalIndex(inclusive, stride); index.init(begin, end); return index; }
/** * Represents collecting all elements * * @return an ndarray index * meaning collect * all elements */ public static INDArrayIndex all() { return new NDArrayIndexAll(true); }
private boolean allIndexGreatherThanZero(INDArrayIndex... indexes) { for (INDArrayIndex indArrayIndex : indexes) if (indArrayIndex.offset() == 0) return false; return true; }
static INDArrayIndex[] createIntervalOnDimension(int dimension, boolean inclusive, long... interval) { INDArrayIndex [] indexInterval = new INDArrayIndex[dimension + 1]; for(int i = 0; i <= dimension; i++) { indexInterval[i] = i != dimension ? NDArrayIndex.all() : NDArrayIndex.interval((int)interval[0], (int)interval[1], inclusive); } return indexInterval; } }
public static INDArrayIndex[] createCoveringShape(long[] shape) { INDArrayIndex[] ret = new INDArrayIndex[shape.length]; for (int i = 0; i < ret.length; i++) { ret[i] = NDArrayIndex.interval(0, shape[i]); } return ret; }
protected static INDArrayIndex validate(long size, INDArrayIndex index) { if ((index instanceof IntervalIndex || index instanceof PointIndex) && size <= index.current() && size > 1) throw new IllegalArgumentException("NDArrayIndex is out of range. Beginning index: " + index.current() + " must be less than its size: " + size); if (index instanceof IntervalIndex && size < index.end()) { long begin = ((IntervalIndex) index).begin; index = NDArrayIndex.interval(begin, index.stride(), size); } return index; }
/** * Create a range based on the given indexes. * This is similar to create covering shape in that it approximates * the length of each dimension (ignoring elements) and * reproduces an index of the same dimension and length. * * @param indexes the indexes to create the range for * @return the index ranges. */ public static INDArrayIndex[] rangeOfLength(INDArrayIndex[] indexes) { INDArrayIndex[] indexesRet = new INDArrayIndex[indexes.length]; for (int i = 0; i < indexes.length; i++) indexesRet[i] = NDArrayIndex.interval(0, indexes[i].length()); return indexesRet; }
/** * Add indexes for the given shape * @param shape the shape ot convert to indexes * @return the indexes for the given shape */ public static INDArrayIndex[] indexesFor(long... shape) { INDArrayIndex[] ret = new INDArrayIndex[shape.length]; for (int i = 0; i < shape.length; i++) { ret[i] = NDArrayIndex.point(shape[i]); } return ret; }
/** * Returns a point index * @param point the point index * @return the point index based * on the specified point */ public static INDArrayIndex point(long point) { return new PointIndex(point); }
/** * Given an all index and * the intended indexes, return an * index array containing a combination of all elements * for slicing and overriding particular indexes where necessary * @param arr the array to resolve indexes for * @param intendedIndexes the indexes specified by the user * @return the resolved indexes (containing all where nothing is specified, and the intended index * for a particular dimension otherwise) */ public static INDArrayIndex[] resolve(INDArray arr, INDArrayIndex... intendedIndexes) { return resolve(NDArrayIndex.allFor(arr), intendedIndexes); }
/** * Compute the offset given an array of offsets. * The offset is computed(for both fortran an d c ordering) as: * sum from i to n - 1 o[i] * s[i] * where i is the index o is the offset and s is the stride * Notice the -1 at the end. * @param arr the array to compute the offset for * @param indices the offsets for each dimension * @return the offset that should be used for indexing */ public static long offset(INDArray arr, INDArrayIndex... indices) { return offset(arr.stride(), Indices.offsets(arr.shape(), indices)); }
private boolean anyHaveStrideOne(INDArrayIndex... indexes) { for (INDArrayIndex indArrayIndex : indexes) if (indArrayIndex.stride() == 1) return true; return false; }
/** * Convert the given int indexes * to nd array indexes * @param indices the indices to convert * @return the converted indexes */ public static INDArrayIndex[] toIndexes(int[] indices) { INDArrayIndex[] ret = new INDArrayIndex[indices.length]; for (int i = 0; i < ret.length; i++) ret[i] = new NDArrayIndex(indices[i]); return ret; }
@Override public INDArray getWhere(INDArray comp, Condition condition) { return BooleanIndexing.chooseFrom(new INDArray[]{this,comp},condition); }
@Override public void init(INDArray arr, int dimension) { init(arr, 0, dimension); }
@Override public boolean hasNext() { return index < end(); }
/** * Generates an interval from begin (inclusive) to end (exclusive) * * @param begin the begin * @param end the end index * @return the interval */ public static INDArrayIndex interval(int begin, int end) { return interval(begin, 1, end, false); }
public static INDArrayIndex interval(long begin, long stride, long end, boolean inclusive) { assert begin <= end : "Beginning index in range must be less than end"; INDArrayIndex index = new IntervalIndex(inclusive, stride); index.init(begin, end); return index; }
/** * Generates an interval from begin (inclusive) to end (exclusive) * * @param begin the begin * @param end the end index * @param inclusive whether the end should be inclusive or not * @return the interval */ public static INDArrayIndex interval(int begin, int end, boolean inclusive) { return interval(begin, 1, end, inclusive); }
/** * Generates an interval from begin (inclusive) to end (exclusive) * * @param begin the begin * @param stride the stride at which to increment * @param end the end index * @param inclusive whether the end should be inclusive or not * @return the interval */ public static INDArrayIndex interval(int begin, int stride, int end, boolean inclusive) { assert begin <= end : "Beginning index in range must be less than end"; INDArrayIndex index = new IntervalIndex(inclusive, stride); index.init(begin, end); return index; }