/** * Returns an ndarray with 1 if the element is epsilon equals * * @param other the number to compare * @return a ndarray with the given * binary conditions */ @Override public INDArray epsi(Number other) { INDArray otherArr = Nd4j.valueArrayOf(shape(), other.doubleValue()); return epsi(otherArr); }
/** * Test whether a matrix is scalar. */ @Override public boolean isScalar() { if (Shape.rank(javaShapeInformation) == 0) { return true; } else if (Shape.rank(javaShapeInformation) > 2) { return false; } else if (Shape.rank(javaShapeInformation) == 1) { return shapeOf().getInt(0) == 1; } else if (Shape.rank(javaShapeInformation) == 2) { return shape()[0] == 1 && shape()[1] == 1 || length() == 1; } else return false; }
@Override public INDArray remainder(INDArray denominator) { return remainder(denominator, Nd4j.createUninitialized(this.shape())); }
@Override public INDArray fmod(Number denominator) { return fmod(denominator, Nd4j.createUninitialized(this.shape())); }
@Override public INDArray fmod(INDArray denominator) { return fmod(denominator, Nd4j.createUninitialized(this.shape())); }
@Override public INDArray remainder(Number denominator) { return remainder(denominator, Nd4j.createUninitialized(this.shape())); }
/** * Mainly here for people coming from numpy. * This is equivalent to a call to permute * * @param dimension the dimension to swap * @param with the one to swap it with * @return the swapped axes view */ @Override public INDArray swapAxes(int dimension, int with) { int[] shape = ArrayUtil.range(0, shape().length); shape[dimension] = with; shape[with] = dimension; return permute(shape); }
@Override public INDArray rdiv(Number n) { //return dup().rdivi(n); return rdivi(n, Nd4j.createUninitialized(this.shape(), this.ordering())); }
/** * in place (element wise) division of two matrices * * @param other the second ndarray to divide * @return the result of the divide */ @Override public INDArray div(INDArray other) { return divi(other, Nd4j.createUninitialized(this.shape(), this.ordering())); }
/** * copy (element wise) multiplication of two matrices * * @param other the second ndarray to multiply * @return the result of the addition */ @Override public INDArray mul(INDArray other) { return muli(other, Nd4j.createUninitialized(this.shape(), this.ordering())); }
@Override public INDArray rsub(Number n) { //return dup().rsubi(n); return rsubi(n, Nd4j.createUninitialized(this.shape(), this.ordering())); }
@Override public INDArray div(Number n) { //return dup().divi(n); return divi(n, Nd4j.createUninitialized(this.shape(), this.ordering())); }
@Override public INDArray sub(Number n) { //return dup().subi(n); return subi(n, Nd4j.createUninitialized(this.shape(), this.ordering())); }
@Override public INDArray add(Number n) { //return dup().addi(n); return addi(n, Nd4j.createUninitialized(this.shape(), this.ordering())); }
@Override public INDArray mul(Number n) { // return dup().muli(n); return muli(n, Nd4j.createUninitialized(this.shape(), this.ordering())); }
@Override public void setOrder(char order) { setShapeInformation(Nd4j.getShapeInfoProvider().createShapeInformation(shape(), stride(), 0, elementWiseStride(), order)); }
@Override public void setStride(long[] stride) { setShapeInformation(Nd4j.getShapeInfoProvider().createShapeInformation(shape(), stride, 0, elementWiseStride(), ordering())); }
/** * Negate each element. */ @Override public INDArray neg() { return Nd4j.getExecutioner().exec(new Negative(this, Nd4j.createUninitialized(this.shape(), this.ordering()))) .z(); }
@Override public void setStride(int[] stride) { setShapeInformation(Nd4j.getShapeInfoProvider().createShapeInformation(shape(), ArrayUtil.toLongArray(stride), 0, elementWiseStride(), ordering())); }
@Override public double getDouble(long i) { Nd4j.getCompressor().autoDecompress(this); if (i >= length()) { throw new IllegalArgumentException("Unable to get linear index >= " + length()); } autoProcessScalarCall(); if (i == 0) return data().getDouble(i); long[] dimensions = ordering() == 'c' ? Shape.ind2subC(this, i) : Shape.ind2sub(this, i); Shape.assertShapeLessThan(dimensions, shape()); return getDouble(dimensions); }