diff --git a/libnd4j/blas/NativeOps.h b/libnd4j/blas/NativeOps.h index ea2b0b8a5..a85473c7f 100755 --- a/libnd4j/blas/NativeOps.h +++ b/libnd4j/blas/NativeOps.h @@ -1734,6 +1734,7 @@ typedef nd4j::graph::RandomGenerator OpaqueRandomGenerator; ND4J_EXPORT OpaqueContext* createGraphContext(int nodeId); ND4J_EXPORT OpaqueRandomGenerator* getGraphContextRandomGenerator(OpaqueContext* ptr); ND4J_EXPORT void ctxAllowHelpers(OpaqueContext* ptr, bool reallyAllow); +ND4J_EXPORT void ctxShapeFunctionOverride(OpaqueContext* ptr, bool reallyOverride); ND4J_EXPORT void markGraphContextInplace(OpaqueContext* ptr, bool reallyInplace); ND4J_EXPORT void setGraphContextCudaContext(OpaqueContext* ptr, void *stream, void *reductionPointer, void *allocationPointer); ND4J_EXPORT void setGraphContextInputArray(OpaqueContext* ptr, int index, void *buffer, void *shapeInfo, void *specialBuffer, void *specialShapeInfo); diff --git a/libnd4j/blas/cpu/NativeOps.cpp b/libnd4j/blas/cpu/NativeOps.cpp index acb8fc24c..956802961 100644 --- a/libnd4j/blas/cpu/NativeOps.cpp +++ b/libnd4j/blas/cpu/NativeOps.cpp @@ -3104,6 +3104,10 @@ const char* lastErrorMessage() { return nd4j::LaunchContext::defaultContext()->errorReference()->errorMessage(); } +void ctxShapeFunctionOverride(OpaqueContext* ptr, bool reallyOverride) { + ptr->setShapeFunctionOverride(reallyOverride); +} + int binaryLevel() { #ifdef CPU_FEATURES diff --git a/libnd4j/blas/cuda/NativeOps.cu b/libnd4j/blas/cuda/NativeOps.cu index c8cb3a616..3d86d94f8 100755 --- a/libnd4j/blas/cuda/NativeOps.cu +++ b/libnd4j/blas/cuda/NativeOps.cu @@ -3559,6 +3559,10 @@ const char* lastErrorMessage() { return nd4j::LaunchContext::defaultContext()->errorReference()->errorMessage(); } +void ctxShapeFunctionOverride(OpaqueContext* ptr, bool reallyOverride) { + ptr->setShapeFunctionOverride(reallyOverride); +} + int binaryLevel() { return 0; } diff --git a/libnd4j/include/graph/Context.h b/libnd4j/include/graph/Context.h index d5b85b543..dc36e0704 100644 --- a/libnd4j/include/graph/Context.h +++ b/libnd4j/include/graph/Context.h @@ -64,6 +64,9 @@ namespace nd4j { std::vector _handles; bool _helpersAllowed = true; + + // in some cases we might be able to skip shape function for validation purposes + bool _shapeFunctionOverride = false; public: Context(ContextPrototype* prototype, VariableSpace* variableSpace); @@ -196,9 +199,11 @@ namespace nd4j { void setCudaContext(Nd4jPointer cudaStream, Nd4jPointer reductionPointer, Nd4jPointer allocationPointer); - void allowHelpers(bool reallyAllow); bool helpersAllowed(); + + void setShapeFunctionOverride(bool reallyOverride); + bool shapeFunctionOverride(); }; } } diff --git a/libnd4j/include/graph/impl/Context.cpp b/libnd4j/include/graph/impl/Context.cpp index ed9321ccd..c8c76c7df 100644 --- a/libnd4j/include/graph/impl/Context.cpp +++ b/libnd4j/include/graph/impl/Context.cpp @@ -484,6 +484,14 @@ namespace nd4j { for (auto b:bArgs) _bArgs.push_back(b); } + + void Context::setShapeFunctionOverride(bool reallyOverride) { + _shapeFunctionOverride = reallyOverride; + } + + bool Context::shapeFunctionOverride() { + return _shapeFunctionOverride; + } } } diff --git a/libnd4j/include/ops/declarable/impl/DeclarableOp.cpp b/libnd4j/include/ops/declarable/impl/DeclarableOp.cpp index 3aef09bcd..a7df3cbea 100644 --- a/libnd4j/include/ops/declarable/impl/DeclarableOp.cpp +++ b/libnd4j/include/ops/declarable/impl/DeclarableOp.cpp @@ -189,6 +189,11 @@ namespace nd4j { shapeStart = std::chrono::system_clock::now(); } + // if we override shape function, we'll return size of fastPath + if (ctx.isFastPath() && ctx.shapeFunctionOverride()) { + return (int) ctx.fastpath_out().size(); + } + auto outSha = this->calculateOutputShape(&inSha, ctx); results = outSha->size(); diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/OpContext.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/OpContext.java index e66d52f91..dda6aef24 100644 --- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/OpContext.java +++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/linalg/api/ops/OpContext.java @@ -136,4 +136,10 @@ public interface OpContext extends AutoCloseable { * @param reallyAllow */ void allowHelpers(boolean reallyAllow); + + /** + * This methos allows to disape outputs validation via shape function + * @param reallyOverride + */ + void shapeFunctionOverride(boolean reallyOverride); } diff --git a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-native-api/src/main/java/org/nd4j/nativeblas/NativeOps.java b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-native-api/src/main/java/org/nd4j/nativeblas/NativeOps.java index 741978a3c..edfb5afa3 100644 --- a/nd4j/nd4j-backends/nd4j-api-parent/nd4j-native-api/src/main/java/org/nd4j/nativeblas/NativeOps.java +++ b/nd4j/nd4j-backends/nd4j-api-parent/nd4j-native-api/src/main/java/org/nd4j/nativeblas/NativeOps.java @@ -1125,6 +1125,7 @@ public interface NativeOps { void setGraphContextIArguments(OpaqueContext ptr, LongPointer arguments, int numberOfArguments); void setGraphContextBArguments(OpaqueContext ptr, BooleanPointer arguments, int numberOfArguments); void ctxAllowHelpers(OpaqueContext ptr, boolean reallyAllow); + void ctxShapeFunctionOverride(OpaqueContext ptr, boolean reallyOverride); void deleteGraphContext(OpaqueContext ptr); OpaqueRandomGenerator createRandomGenerator(long rootSeed, long nodeSeed); diff --git a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaExecutioner.java b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaExecutioner.java index b99601732..dca1a61a9 100644 --- a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaExecutioner.java +++ b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaExecutioner.java @@ -2282,7 +2282,7 @@ public class CudaExecutioner extends DefaultOpExecutioner { Nd4j.getExecutioner().commit(); - // + boolean shapeOverride = false; if (op.numOutputArguments() == 0 && !op.isInplaceCall()) { try { val list = this.calculateOutputShape(op); @@ -2292,6 +2292,7 @@ public class CudaExecutioner extends DefaultOpExecutioner { for (val shape: list) op.addOutputArgument(Nd4j.create(shape)); + shapeOverride = true; } catch (Exception e) { throw new ND4JIllegalStateException("Op name " + op.opName() + " - no output arrays were provided and calculateOutputShape failed to execute", e); } @@ -2302,6 +2303,10 @@ public class CudaExecutioner extends DefaultOpExecutioner { val name = op.opName(); try (val context = (CudaOpContext) buildContext()) { + // optionally skip shape validation on op execution + if (shapeOverride) + context.shapeFunctionOverride(true); + context.markInplace(op.isInplaceCall()); // transferring rng state diff --git a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaOpContext.java b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaOpContext.java index b75f688fe..d37a0184d 100644 --- a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaOpContext.java +++ b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/linalg/jcublas/ops/executioner/CudaOpContext.java @@ -141,4 +141,9 @@ public class CudaOpContext extends BaseOpContext implements OpContext { public void allowHelpers(boolean reallyAllow) { nativeOps.ctxAllowHelpers(context, reallyAllow); } + + @Override + public void shapeFunctionOverride(boolean reallyOverride) { + nativeOps.ctxShapeFunctionOverride(context, reallyOverride); + } } diff --git a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/nativeblas/Nd4jCuda.java b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/nativeblas/Nd4jCuda.java index 94c5601c1..6dab1ab01 100644 --- a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/nativeblas/Nd4jCuda.java +++ b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-cuda/src/main/java/org/nd4j/nativeblas/Nd4jCuda.java @@ -3100,6 +3100,7 @@ public native void deleteShapeBuffer(OpaqueConstantDataBuffer ptr); public native OpaqueContext createGraphContext(int nodeId); public native OpaqueRandomGenerator getGraphContextRandomGenerator(OpaqueContext ptr); public native void ctxAllowHelpers(OpaqueContext ptr, @Cast("bool") boolean reallyAllow); +public native void ctxShapeFunctionOverride(OpaqueContext ptr, @Cast("bool") boolean reallyOverride); public native void markGraphContextInplace(OpaqueContext ptr, @Cast("bool") boolean reallyInplace); public native void setGraphContextCudaContext(OpaqueContext ptr, Pointer stream, Pointer reductionPointer, Pointer allocationPointer); public native void setGraphContextInputArray(OpaqueContext ptr, int index, Pointer buffer, Pointer shapeInfo, Pointer specialBuffer, Pointer specialShapeInfo); @@ -3634,25 +3635,7 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); // #include - @Namespace("nd4j") public static native @ByVal @Name("operator -") NDArray subtract(float arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator -") NDArray subtract(@Cast("const float16") short arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator -") NDArray subtract(double arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator -") NDArray subtract(int arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator +") NDArray add(float arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator +") NDArray add(@Cast("const float16") short arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator +") NDArray add(double arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator +") NDArray add(int arg0, @Const @ByRef NDArray arg1); - - @Namespace("nd4j") public static native @ByVal @Name("operator *") NDArray multiply(float arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator *") NDArray multiply(@Cast("const float16") short arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator *") NDArray multiply(double arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator *") NDArray multiply(int arg0, @Const @ByRef NDArray arg1); - - @Namespace("nd4j") public static native @ByVal @Name("operator /") NDArray divide(float arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator /") NDArray divide(@Cast("const float16") short arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator /") NDArray divide(double arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator /") NDArray divide(int arg0, @Const @ByRef NDArray arg1); @Namespace("nd4j") public static native @ByVal NDArray mmul(@Const @ByRef NDArray arg0, @Const @ByRef NDArray arg1); @@ -3903,9 +3886,9 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * axis - axis along which to repeat elements * repeats - number of repetitions */ - public native NDArray repeat(int axis, @StdVector IntPointer repeats); - public native NDArray repeat(int axis, @StdVector IntBuffer repeats); - public native NDArray repeat(int axis, @StdVector int[] repeats); + public native @ByVal NDArray repeat(int axis, @StdVector IntPointer repeats); + public native @ByVal NDArray repeat(int axis, @StdVector IntBuffer repeats); + public native @ByVal NDArray repeat(int axis, @StdVector int[] repeats); /** * This method fills this array with zeros @@ -3918,14 +3901,7 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * @param array * @return */ - public static native @ByVal NDArray quantize(@ByRef NDArray array); - - /** - * This method returns quantized copy of given array - * - * @param array - * @return - */ + public static native @ByVal NDArray quantize(@Const @ByRef NDArray array); /** * fill target array by repeating current array @@ -3946,10 +3922,9 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); /** * cast array elements to given dtype */ + public native @ByVal NDArray cast(@Cast("nd4j::DataType") int dtype); - public native NDArray cast(@Cast("nd4j::DataType") int dtype); - - public native void cast(NDArray target, @Cast("nd4j::DataType") int dtype); + public native void cast(@ByRef NDArray target, @Cast("nd4j::DataType") int dtype); /** * returns _context @@ -4120,26 +4095,12 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); /** * this method assigns given value to all elements in array */ - public native void assign(double value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(double value); - public native void assign(float value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(float value); - public native void assign(@Cast("const float16") short value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(@Cast("const float16") short value); - public native void assign(@Cast("const Nd4jLong") long value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(@Cast("const Nd4jLong") long value); - public native void assign(int value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(int value); - public native void assign(@Cast("const uint8_t") byte value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(@Cast("const uint8_t") byte value); - public native void assign(@Cast("const bool") boolean value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(@Cast("const bool") boolean value); /** * returns new copy of this array, optionally in different order */ - public native NDArray dup(byte newOrder/*='a'*/); - public native NDArray dup(); + public native @ByVal NDArray dup(byte newOrder/*='a'*/); + public native @ByVal NDArray dup(); /** * returns sum of all elements of array @@ -4176,9 +4137,9 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * index - the number of array to be returned among set of possible arrays * dimensions - array of dimensions to point on */ - public native NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector IntPointer dimensions); - public native NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector IntBuffer dimensions); - public native NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector int[] dimensions); + public native @ByVal NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector IntPointer dimensions); + public native @ByVal NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector IntBuffer dimensions); + public native @ByVal NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector int[] dimensions); /** * returns the number of arrays pointing on specified dimension(s) @@ -4200,54 +4161,54 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * add given row vector to all rows of this array * row - row vector to add */ - public native void addiRowVector(@Const NDArray row); + public native void addiRowVector(@Const @ByRef NDArray row); /** * add given row vector to all rows of this array, store result in target * row - row vector to add * target - where to store result */ - public native void addRowVector(@Const NDArray row, NDArray target); + public native void addRowVector(@Const @ByRef NDArray row, @ByRef NDArray target); /** * subtract given row vector from all rows of this array, store result in target * row - row vector to subtract * target - where to store result */ - public native void subRowVector(@Const NDArray row, NDArray target); + public native void subRowVector(@Const @ByRef NDArray row, @ByRef NDArray target); /** * multiply all rows of this array on given row vector, store result in target * row - row vector to multiply on * target - where to store result */ - public native void mulRowVector(@Const NDArray row, NDArray target); + public native void mulRowVector(@Const @ByRef NDArray row, @ByRef NDArray target); /** * divide all rows of this array on given row vector, store result in target * row - row vector to divide on * target - where to store result */ - public native void divRowVector(@Const NDArray row, NDArray target); + public native void divRowVector(@Const @ByRef NDArray row, @ByRef NDArray target); /** * add given column vector to all columns of this array, store result in target * column - column vector to add * target - where to store result */ - public native void addColumnVector(@Const NDArray column, NDArray target); + public native void addColumnVector(@Const @ByRef NDArray column, @ByRef NDArray target); /** * add given column vector to all columns of this array, this array becomes affected (in-place operation) * column - column vector to add */ - public native void addiColumnVector(@Const NDArray column); + public native void addiColumnVector(@Const @ByRef NDArray column); /** * multiply all columns of this array on given column vector, this array becomes affected (in-place operation) * column - column vector to multiply on */ - public native void muliColumnVector(@Const NDArray column); + public native void muliColumnVector(@Const @ByRef NDArray column); /** * returns number of bytes used by _buffer & _shapeInfo @@ -4283,9 +4244,9 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * * if permute have been applied before or there are weird strides, then new buffer is allocated for new array */ - public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector LongPointer shape); - public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector LongBuffer shape); - public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector long[] shape); + public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector LongPointer shape); + public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector LongBuffer shape); + public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector long[] shape); /** * calculate strides and set given order @@ -4324,12 +4285,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native void tile(@ByRef NDArray target); - /** - * returns an array which is result of broadcasting of this and other arrays - * other - input array - */ - public native NDArray broadcast(@Const @ByRef NDArray other); - /** * check whether array is identity matrix */ @@ -4340,7 +4295,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native @Cast("bool") boolean isUnitary(); - /** * operator returns subarray with buffer pointing at this->_buffer with offset defined by given intervals * idx - intervals of indexes which define the subarrays to point on, idx has form {dim0Start,dim0End, dim1Start,dim1End, ....} and length (2 * this->rankOf()) @@ -4386,25 +4340,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); public native void getSubArrShapeAndOffsets(@StdVector int[] dimsToExclude, @Cast("Nd4jLong*&") @ByPtrRef long[] subArrShapeInfo, @Cast("Nd4jLong*&") @ByPtrRef long[] subArrOffsets, @Cast("bool") boolean keepUnitiesInShape/*=false*/); public native void getSubArrShapeAndOffsets(@StdVector int[] dimsToExclude, @Cast("Nd4jLong*&") @ByPtrRef long[] subArrShapeInfo, @Cast("Nd4jLong*&") @ByPtrRef long[] subArrOffsets); - /** - * addition operator: array + other - * other - input array to add - */ - public native @ByVal @Name("operator +") NDArray add(@Const @ByRef NDArray other); - - /** - * addition operator: array + scalar - * scalar - input scalar to add - */ - - /** - * friend functions which implement addition operator: scalar + array - * scalar - input scalar to add - */ - //template - //friend NDArray nd4j::operator+(const T scalar, const NDArray& arr); - - /** * addition unary operator array += other * other - input array to add @@ -4417,39 +4352,11 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native @Name("operator -=") void subtractPut(@Const @ByRef NDArray other); - /** - * subtraction operator: array - other - * other - input array to subtract - */ - public native @ByVal @Name("operator -") NDArray subtract(@Const @ByRef NDArray other); - - /** - * subtraction operator: array - scalar - * scalar - input scalar to subtract - */ - /** * negative operator, it changes sign of all array elements on opposite */ public native @ByVal @Name("operator -") NDArray subtract(); - /** - * friend functions which implement subtraction operator: scalar - array - * scalar - input scalar to subtract - */ - //friend NDArray nd4j::operator-(const float scalar, const NDArray& arr); - - /** - * pairwise multiplication operator: array * other - * other - input array to multiply on - */ - public native @ByVal @Name("operator *") NDArray multiply(@Const @ByRef NDArray other); - - /** - * multiplication operator: array * scalar - * scalar - input scalar to multiply on - */ - /** * pairwise multiplication unary operator array *= other * other - input array to multiply on @@ -4461,17 +4368,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * scalar - input scalar to multiply on */ - /** - * pairwise division operator: array / other - * other - input array to divide on - */ - public native @ByVal @Name("operator /") NDArray divide(@Const @ByRef NDArray other); - - /** - * division operator: array / scalar - * scalar - input scalar to divide each array element on - */ - /** * pairwise division unary operator: array /= other * other - input array to divide on @@ -4510,7 +4406,7 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * return vector with buffer which points on corresponding diagonal elements of array * type - means of vector to be returned: column ('c') or row ('r') */ - public native NDArray diagonal(byte type ); + public native @ByVal NDArray diagonal(byte type ); /** * fill target matrix with given value in one or two directions from main diagonal: @@ -4533,13 +4429,13 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); public native @ByVal NDArray tileToShape(@Cast("const Nd4jLong*") LongPointer shapeInfo); public native @ByVal NDArray tileToShape(@Cast("const Nd4jLong*") LongBuffer shapeInfo); public native @ByVal NDArray tileToShape(@Cast("const Nd4jLong*") long[] shapeInfo); - public native void tileToShape(@Cast("Nd4jLong*") @StdVector LongPointer shape, NDArray target/*=nullptr*/); - public native void tileToShape(@Cast("Nd4jLong*") @StdVector LongBuffer shape, NDArray target/*=nullptr*/); - public native void tileToShape(@Cast("Nd4jLong*") @StdVector long[] shape, NDArray target/*=nullptr*/); + public native void tileToShape(@Cast("Nd4jLong*") @StdVector LongPointer shape, @ByRef NDArray target); + public native void tileToShape(@Cast("Nd4jLong*") @StdVector LongBuffer shape, @ByRef NDArray target); + public native void tileToShape(@Cast("Nd4jLong*") @StdVector long[] shape, @ByRef NDArray target); // #ifndef __JAVACPP_HACK__ // #endif - public native NDArray asT(@Cast("nd4j::DataType") int dtype); + public native @ByVal NDArray asT(@Cast("nd4j::DataType") int dtype); public native void linspace(double start); @@ -4551,17 +4447,15 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native double getTrace(); - public native ResultSet multipleTensorsAlongDimension(@StdVector IntPointer indices, @StdVector IntPointer dimensions); - public native ResultSet multipleTensorsAlongDimension(@StdVector IntBuffer indices, @StdVector IntBuffer dimensions); - public native ResultSet multipleTensorsAlongDimension(@StdVector int[] indices, @StdVector int[] dimensions); + public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector IntPointer indices, @StdVector IntPointer dimensions); + public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector IntBuffer indices, @StdVector IntBuffer dimensions); + public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector int[] indices, @StdVector int[] dimensions); - public native ResultSet allTensorsAlongDimension(@StdVector IntPointer dimensions); - public native ResultSet allTensorsAlongDimension(@StdVector IntBuffer dimensions); - public native ResultSet allTensorsAlongDimension(@StdVector int[] dimensions); + public native @ByVal ResultSet allTensorsAlongDimension(@StdVector IntPointer dimensions); + public native @ByVal ResultSet allTensorsAlongDimension(@StdVector IntBuffer dimensions); + public native @ByVal ResultSet allTensorsAlongDimension(@StdVector int[] dimensions); - //ResultSet allTensorsAlongDims(const std::vector& dimensions) const; - - public native ResultSet allExamples(); + public native @ByVal ResultSet allExamples(); /** * set _shapeInfo @@ -4669,7 +4563,7 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); /** * returns true if these two NDArrays have same rank, dimensions, strides, ews and order */ - public native @Cast("bool") boolean isSameShapeStrict(@Const NDArray other); + public native @Cast("bool") boolean isSameShapeStrict(@Const @ByRef NDArray other); /** * returns true if buffer && shapeInfo were defined (non nullptr) @@ -4728,11 +4622,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native void p(@Cast("const Nd4jLong") long i, @Cast("const Nd4jLong") long j, @Cast("const Nd4jLong") long k, @Cast("const Nd4jLong") long l, @Const @ByRef NDArray value); - /** - * creates array which points on certain sub-range of this array, sub-range is defined by given indices - */ - - /** * returns true if array is 2D */ @@ -4803,59 +4692,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native @Cast("bool") boolean isS(); - /** - * inline accessing operator for matrix, i - absolute index - */ - //FORCEINLINE NDArray operator()(const Nd4jLong i) const; - - /** - * inline modifying operator for matrix, i - absolute index - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong i); - - /** - * inline accessing operator for 2D array, i - row, j - column - */ - //FORCEINLINE NDArray operator()(const Nd4jLong i, const Nd4jLong j) const; - - /** - * inline modifying operator for 2D array, i - row, j - column - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong i, const Nd4jLong j); - - /** - * inline accessing operator for 3D array, i - height, j - width, k - depth - */ - //FORCEINLINE NDArray operator()(const Nd4jLong i, const Nd4jLong j, const Nd4jLong k) const; - - /** - * inline modifying operator for 3D array, i - height, j - width, k - depth - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong i, const Nd4jLong j, const Nd4jLong k); - - /** - * inline modifying operator for 4D array, i - height, j - width, k - depth - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong t, const Nd4jLong u, const Nd4jLong v, const Nd4jLong w); - - /** - * inline accessing operator for 4D array, i - height, j - width, k - depth - */ - //FORCEINLINE NDArray operator()(const Nd4jLong t, const Nd4jLong u, const Nd4jLong v, const Nd4jLong w) const; - - /** - * inline modifying operator for ND array - * idx - array with corresponding indexes, for example {2,10,0,5,...,8}, number of indexes should be equal to array rank - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong* idx); - - /** - * inline accessing operator for ND array - * idx - array with corresponding indexes, for example {2,10,0,5,...,8}, number of indexes should be equal to array rank - */ - //FORCEINLINE NDArray operator()(const Nd4jLong* idx) const; - - public native @Cast("bool") boolean isAttached(); public native NDArray detach(); @@ -4871,268 +4707,75 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); ////////////////////////////////////////////////////////////////////////// ///// IMLEMENTATION OF INLINE METHODS ///// ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - ////////////////////////////////////////////////////////////////////////// -// accessing operator for matrix, i - absolute index -/* -NDArray NDArray::operator()(const Nd4jLong i) const { - if (i >= shape::length(_shapeInfo)) - throw std::invalid_argument("NDArray::operator(i): input index is out of array length !"); - - auto ews = shape::elementWiseStride(_shapeInfo); - char order = ordering(); - - if(ews == 1 && order == 'c') { - auto cast = reinterpret_cast(_buffer) + (i * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } else if(ews > 1 && order == 'c') { - auto cast = reinterpret_cast(_buffer) + (i * ews * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } else { - Nd4jLong idx[MAX_RANK]; - shape::ind2subC(rankOf(), shapeOf(), i, idx); - auto xOffset = shape::getOffset(getShapeInfo(), idx); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } -} -*/ -////////////////////////////////////////////////////////////////////////// -// modifying operator for matrix, i - absolute index -/* -NDArray& NDArray::operator()(const Nd4jLong i) { - if (i >= shape::length(_shapeInfo)) - throw std::invalid_argument("NDArray::operator(i): input index is out of array length !"); - - auto ews = shape::elementWiseStride(_shapeInfo); - auto order = ordering(); - - if(ews == 1 && order == 'c') { - auto cast = reinterpret_cast(_buffer) + (i * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - - // FIXME: bad - return result; - } else if(ews > 1 && order == 'c') { - auto cast = reinterpret_cast(_buffer) + (i * ews * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } else { - Nd4jLong idx[MAX_RANK]; - shape::ind2subC(rankOf(), shapeOf(), i, idx); - auto xOffset = shape::getOffset(getShapeInfo(), idx); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } -}*/ ////////////////////////////////////////////////////////////////////////// -// accessing operator for 2D matrix, i - row, j - column -/* -NDArray NDArray::operator()(const Nd4jLong i, const Nd4jLong j) const { - if (rankOf() != 2 || i >= shapeOf()[0] || j >= shapeOf()[1]) - throw std::invalid_argument("NDArray::operator(i,j): one of input indexes is out of array length or rank!=2 !"); - - Nd4jLong coords[2] = {i, j}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - // TODO: do we really want a view here? - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ -////////////////////////////////////////////////////////////////////////// -// modifying operator for 2D matrix, i - row, j - column -/* -NDArray& NDArray::operator()(const Nd4jLong i, const Nd4jLong j) { - if (rankOf() != 2 || i >= shapeOf()[0] || j >= shapeOf()[1]) - throw std::invalid_argument("NDArray::operator(i,j): one of input indexes is out of array length or rank!=2 !"); - - Nd4jLong coords[2] = {i, j}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - - //FIXME: bad, will crash! - return result; -} -*/ ////////////////////////////////////////////////////////////////////////// -// accessing operator for 3D array, i - row, j - column -/* -NDArray NDArray::operator()(const Nd4jLong i, const Nd4jLong j, const Nd4jLong k) const { - if (rankOf() != 3 || i >= shapeOf()[0] || j >= shapeOf()[1] || j >= shapeOf()[2]) - throw std::invalid_argument("NDArray::operator(i,j,k): one of input indexes is out of array length or rank!=3 !"); - - Nd4jLong coords[3] = {i, j, k}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ ////////////////////////////////////////////////////////////////////////// -// modifying operator for 3D array -/* -NDArray& NDArray::operator()(const Nd4jLong i, const Nd4jLong j, const Nd4jLong k) { - if (rankOf() != 3 || i >= shapeOf()[0] || j >= shapeOf()[1] || k >= shapeOf()[2]) - throw std::invalid_argument("NDArray::operator(i,j,k): one of input indexes is out of array length or rank!=3 !"); - Nd4jLong coords[3] = {i, j, k}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - - //FIXME: bad, will crash! - return result; -} -*/ -/* -NDArray NDArray::operator()(const Nd4jLong t, const Nd4jLong u, const Nd4jLong v, const Nd4jLong w) const { - - if (rankOf() != 4 || t >= shapeOf()[0] || u >= shapeOf()[1] || v >= shapeOf()[2] || w >= shapeOf()[3]) - throw std::invalid_argument("NDArray::operator(t,u,v,w): one of input indexes is out of array length or rank!=4 !"); - - Nd4jLong coords[4] = {t, u, v, w}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ -/* -NDArray& NDArray::operator()(const Nd4jLong t, const Nd4jLong u, const Nd4jLong v, const Nd4jLong w) { - - if (rankOf() != 4 || t >= shapeOf()[0] || u >= shapeOf()[1] || v >= shapeOf()[2] || w >= shapeOf()[3]) - throw std::invalid_argument("NDArray::operator(t,u,v,w): one of input indexes is out of array length or rank!=4 !"); - - Nd4jLong coords[4] = {t, u, v, w}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - // FIXME - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ ////////////////////////////////////////////////////////////////////////// -/* -NDArray NDArray::operator()(const Nd4jLong* idx) const { - for(int i = 0; i < rankOf(); ++i) - if (idx[i] >= sizeAt(i)) - throw std::invalid_argument("NDArray::operator(const Nd4jLong* idx): input index is out of dimension length !"); - auto xOffset = shape::getOffset(getShapeInfo(), idx); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ ////////////////////////////////////////////////////////////////////////// -/* -NDArray& NDArray::operator()(const Nd4jLong* idx) { - - for(int i = 0; i < rankOf(); ++i) - if (idx[i] >= sizeAt(i)) - throw std::invalid_argument("NDArray::operator(const Nd4jLong* idx): input index is out of dimension length !"); - - auto xOffset = shape::getOffset(getShapeInfo(), idx); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - - // FIXME - return result; -} -*/ - ////////////////////////////////////////////////////////////////////////// - +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// +// still the definition of inline function must be in header file - ////////////////////////////////////////////////////////////////////////// - // still the definition of inline function must be in header file - ////////////////////////////////////////////////////////////////////////// @@ -6778,9 +6421,11 @@ NDArray& NDArray::operator()(const Nd4jLong* idx) { public native void setCudaContext(@Cast("Nd4jPointer") Pointer cudaStream, @Cast("Nd4jPointer") Pointer reductionPointer, @Cast("Nd4jPointer") Pointer allocationPointer); - public native void allowHelpers(@Cast("bool") boolean reallyAllow); public native @Cast("bool") boolean helpersAllowed(); + + public native void setShapeFunctionOverride(@Cast("bool") boolean reallyOverride); + public native @Cast("bool") boolean shapeFunctionOverride(); } @@ -10630,6 +10275,7 @@ public static final int PREALLOC_SIZE = 33554432; // #include // #include // #include +// #include // #include // #include // #include diff --git a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/CpuOpContext.java b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/CpuOpContext.java index 6700f9019..72f3e4553 100644 --- a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/CpuOpContext.java +++ b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/CpuOpContext.java @@ -110,4 +110,9 @@ public class CpuOpContext extends BaseOpContext implements OpContext { public void allowHelpers(boolean reallyAllow) { nativeOps.ctxAllowHelpers(context, reallyAllow); } + + @Override + public void shapeFunctionOverride(boolean reallyOverride) { + nativeOps.ctxShapeFunctionOverride(context, reallyOverride); + } } diff --git a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/NativeOpExecutioner.java b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/NativeOpExecutioner.java index 3ec9d34d7..c5e520ebc 100644 --- a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/NativeOpExecutioner.java +++ b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/linalg/cpu/nativecpu/ops/NativeOpExecutioner.java @@ -1691,6 +1691,7 @@ public class NativeOpExecutioner extends DefaultOpExecutioner { @Override public INDArray[] exec(@NonNull CustomOp op) { + boolean shapeOverride = false; if (op.numOutputArguments() == 0 && !op.isInplaceCall()) { try { val list = this.calculateOutputShape(op); @@ -1699,6 +1700,8 @@ public class NativeOpExecutioner extends DefaultOpExecutioner { for (LongShapeDescriptor shape : list) op.addOutputArgument(Nd4j.create(shape, false)); + + shapeOverride = true; } catch (ND4JIllegalStateException e){ throw e; } catch (Exception e) { @@ -1709,6 +1712,10 @@ public class NativeOpExecutioner extends DefaultOpExecutioner { val name = op.opName(); try (val context = buildContext()) { + // optionally skip shape validation on op execution + if (shapeOverride) + context.shapeFunctionOverride(true); + context.markInplace(op.isInplaceCall()); // transferring rng state diff --git a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/nativeblas/Nd4jCpu.java b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/nativeblas/Nd4jCpu.java index 0ba5d1293..f2da4dc19 100644 --- a/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/nativeblas/Nd4jCpu.java +++ b/nd4j/nd4j-backends/nd4j-backend-impls/nd4j-native/src/main/java/org/nd4j/nativeblas/Nd4jCpu.java @@ -3103,6 +3103,7 @@ public native void deleteShapeBuffer(OpaqueConstantDataBuffer ptr); public native OpaqueContext createGraphContext(int nodeId); public native OpaqueRandomGenerator getGraphContextRandomGenerator(OpaqueContext ptr); public native void ctxAllowHelpers(OpaqueContext ptr, @Cast("bool") boolean reallyAllow); +public native void ctxShapeFunctionOverride(OpaqueContext ptr, @Cast("bool") boolean reallyOverride); public native void markGraphContextInplace(OpaqueContext ptr, @Cast("bool") boolean reallyInplace); public native void setGraphContextCudaContext(OpaqueContext ptr, Pointer stream, Pointer reductionPointer, Pointer allocationPointer); public native void setGraphContextInputArray(OpaqueContext ptr, int index, Pointer buffer, Pointer shapeInfo, Pointer specialBuffer, Pointer specialShapeInfo); @@ -3637,25 +3638,7 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); // #include - @Namespace("nd4j") public static native @ByVal @Name("operator -") NDArray subtract(float arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator -") NDArray subtract(@Cast("const float16") short arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator -") NDArray subtract(double arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator -") NDArray subtract(int arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator +") NDArray add(float arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator +") NDArray add(@Cast("const float16") short arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator +") NDArray add(double arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator +") NDArray add(int arg0, @Const @ByRef NDArray arg1); - - @Namespace("nd4j") public static native @ByVal @Name("operator *") NDArray multiply(float arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator *") NDArray multiply(@Cast("const float16") short arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator *") NDArray multiply(double arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator *") NDArray multiply(int arg0, @Const @ByRef NDArray arg1); - - @Namespace("nd4j") public static native @ByVal @Name("operator /") NDArray divide(float arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator /") NDArray divide(@Cast("const float16") short arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator /") NDArray divide(double arg0, @Const @ByRef NDArray arg1); - @Namespace("nd4j") public static native @ByVal @Name("operator /") NDArray divide(int arg0, @Const @ByRef NDArray arg1); @Namespace("nd4j") public static native @ByVal NDArray mmul(@Const @ByRef NDArray arg0, @Const @ByRef NDArray arg1); @@ -3906,9 +3889,9 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * axis - axis along which to repeat elements * repeats - number of repetitions */ - public native NDArray repeat(int axis, @StdVector IntPointer repeats); - public native NDArray repeat(int axis, @StdVector IntBuffer repeats); - public native NDArray repeat(int axis, @StdVector int[] repeats); + public native @ByVal NDArray repeat(int axis, @StdVector IntPointer repeats); + public native @ByVal NDArray repeat(int axis, @StdVector IntBuffer repeats); + public native @ByVal NDArray repeat(int axis, @StdVector int[] repeats); /** * This method fills this array with zeros @@ -3921,14 +3904,7 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * @param array * @return */ - public static native @ByVal NDArray quantize(@ByRef NDArray array); - - /** - * This method returns quantized copy of given array - * - * @param array - * @return - */ + public static native @ByVal NDArray quantize(@Const @ByRef NDArray array); /** * fill target array by repeating current array @@ -3949,10 +3925,9 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); /** * cast array elements to given dtype */ + public native @ByVal NDArray cast(@Cast("nd4j::DataType") int dtype); - public native NDArray cast(@Cast("nd4j::DataType") int dtype); - - public native void cast(NDArray target, @Cast("nd4j::DataType") int dtype); + public native void cast(@ByRef NDArray target, @Cast("nd4j::DataType") int dtype); /** * returns _context @@ -4123,26 +4098,12 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); /** * this method assigns given value to all elements in array */ - public native void assign(double value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(double value); - public native void assign(float value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(float value); - public native void assign(@Cast("const float16") short value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(@Cast("const float16") short value); - public native void assign(@Cast("const Nd4jLong") long value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(@Cast("const Nd4jLong") long value); - public native void assign(int value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(int value); - public native void assign(@Cast("const uint8_t") byte value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(@Cast("const uint8_t") byte value); - public native void assign(@Cast("const bool") boolean value, @Cast("bool") boolean allowParallelism/*=true*/); - public native void assign(@Cast("const bool") boolean value); /** * returns new copy of this array, optionally in different order */ - public native NDArray dup(byte newOrder/*='a'*/); - public native NDArray dup(); + public native @ByVal NDArray dup(byte newOrder/*='a'*/); + public native @ByVal NDArray dup(); /** * returns sum of all elements of array @@ -4179,9 +4140,9 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * index - the number of array to be returned among set of possible arrays * dimensions - array of dimensions to point on */ - public native NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector IntPointer dimensions); - public native NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector IntBuffer dimensions); - public native NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector int[] dimensions); + public native @ByVal NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector IntPointer dimensions); + public native @ByVal NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector IntBuffer dimensions); + public native @ByVal NDArray tensorAlongDimension(@Cast("Nd4jLong") long index, @StdVector int[] dimensions); /** * returns the number of arrays pointing on specified dimension(s) @@ -4203,54 +4164,54 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * add given row vector to all rows of this array * row - row vector to add */ - public native void addiRowVector(@Const NDArray row); + public native void addiRowVector(@Const @ByRef NDArray row); /** * add given row vector to all rows of this array, store result in target * row - row vector to add * target - where to store result */ - public native void addRowVector(@Const NDArray row, NDArray target); + public native void addRowVector(@Const @ByRef NDArray row, @ByRef NDArray target); /** * subtract given row vector from all rows of this array, store result in target * row - row vector to subtract * target - where to store result */ - public native void subRowVector(@Const NDArray row, NDArray target); + public native void subRowVector(@Const @ByRef NDArray row, @ByRef NDArray target); /** * multiply all rows of this array on given row vector, store result in target * row - row vector to multiply on * target - where to store result */ - public native void mulRowVector(@Const NDArray row, NDArray target); + public native void mulRowVector(@Const @ByRef NDArray row, @ByRef NDArray target); /** * divide all rows of this array on given row vector, store result in target * row - row vector to divide on * target - where to store result */ - public native void divRowVector(@Const NDArray row, NDArray target); + public native void divRowVector(@Const @ByRef NDArray row, @ByRef NDArray target); /** * add given column vector to all columns of this array, store result in target * column - column vector to add * target - where to store result */ - public native void addColumnVector(@Const NDArray column, NDArray target); + public native void addColumnVector(@Const @ByRef NDArray column, @ByRef NDArray target); /** * add given column vector to all columns of this array, this array becomes affected (in-place operation) * column - column vector to add */ - public native void addiColumnVector(@Const NDArray column); + public native void addiColumnVector(@Const @ByRef NDArray column); /** * multiply all columns of this array on given column vector, this array becomes affected (in-place operation) * column - column vector to multiply on */ - public native void muliColumnVector(@Const NDArray column); + public native void muliColumnVector(@Const @ByRef NDArray column); /** * returns number of bytes used by _buffer & _shapeInfo @@ -4286,9 +4247,9 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * * if permute have been applied before or there are weird strides, then new buffer is allocated for new array */ - public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector LongPointer shape); - public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector LongBuffer shape); - public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector long[] shape); + public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector LongPointer shape); + public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector LongBuffer shape); + public native @ByVal NDArray reshape(byte order, @Cast("Nd4jLong*") @StdVector long[] shape); /** * calculate strides and set given order @@ -4327,12 +4288,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native void tile(@ByRef NDArray target); - /** - * returns an array which is result of broadcasting of this and other arrays - * other - input array - */ - public native NDArray broadcast(@Const @ByRef NDArray other); - /** * check whether array is identity matrix */ @@ -4343,7 +4298,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native @Cast("bool") boolean isUnitary(); - /** * operator returns subarray with buffer pointing at this->_buffer with offset defined by given intervals * idx - intervals of indexes which define the subarrays to point on, idx has form {dim0Start,dim0End, dim1Start,dim1End, ....} and length (2 * this->rankOf()) @@ -4389,25 +4343,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); public native void getSubArrShapeAndOffsets(@StdVector int[] dimsToExclude, @Cast("Nd4jLong*&") @ByPtrRef long[] subArrShapeInfo, @Cast("Nd4jLong*&") @ByPtrRef long[] subArrOffsets, @Cast("bool") boolean keepUnitiesInShape/*=false*/); public native void getSubArrShapeAndOffsets(@StdVector int[] dimsToExclude, @Cast("Nd4jLong*&") @ByPtrRef long[] subArrShapeInfo, @Cast("Nd4jLong*&") @ByPtrRef long[] subArrOffsets); - /** - * addition operator: array + other - * other - input array to add - */ - public native @ByVal @Name("operator +") NDArray add(@Const @ByRef NDArray other); - - /** - * addition operator: array + scalar - * scalar - input scalar to add - */ - - /** - * friend functions which implement addition operator: scalar + array - * scalar - input scalar to add - */ - //template - //friend NDArray nd4j::operator+(const T scalar, const NDArray& arr); - - /** * addition unary operator array += other * other - input array to add @@ -4420,39 +4355,11 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native @Name("operator -=") void subtractPut(@Const @ByRef NDArray other); - /** - * subtraction operator: array - other - * other - input array to subtract - */ - public native @ByVal @Name("operator -") NDArray subtract(@Const @ByRef NDArray other); - - /** - * subtraction operator: array - scalar - * scalar - input scalar to subtract - */ - /** * negative operator, it changes sign of all array elements on opposite */ public native @ByVal @Name("operator -") NDArray subtract(); - /** - * friend functions which implement subtraction operator: scalar - array - * scalar - input scalar to subtract - */ - //friend NDArray nd4j::operator-(const float scalar, const NDArray& arr); - - /** - * pairwise multiplication operator: array * other - * other - input array to multiply on - */ - public native @ByVal @Name("operator *") NDArray multiply(@Const @ByRef NDArray other); - - /** - * multiplication operator: array * scalar - * scalar - input scalar to multiply on - */ - /** * pairwise multiplication unary operator array *= other * other - input array to multiply on @@ -4464,17 +4371,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * scalar - input scalar to multiply on */ - /** - * pairwise division operator: array / other - * other - input array to divide on - */ - public native @ByVal @Name("operator /") NDArray divide(@Const @ByRef NDArray other); - - /** - * division operator: array / scalar - * scalar - input scalar to divide each array element on - */ - /** * pairwise division unary operator: array /= other * other - input array to divide on @@ -4513,7 +4409,7 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); * return vector with buffer which points on corresponding diagonal elements of array * type - means of vector to be returned: column ('c') or row ('r') */ - public native NDArray diagonal(byte type ); + public native @ByVal NDArray diagonal(byte type ); /** * fill target matrix with given value in one or two directions from main diagonal: @@ -4536,13 +4432,13 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); public native @ByVal NDArray tileToShape(@Cast("const Nd4jLong*") LongPointer shapeInfo); public native @ByVal NDArray tileToShape(@Cast("const Nd4jLong*") LongBuffer shapeInfo); public native @ByVal NDArray tileToShape(@Cast("const Nd4jLong*") long[] shapeInfo); - public native void tileToShape(@Cast("Nd4jLong*") @StdVector LongPointer shape, NDArray target/*=nullptr*/); - public native void tileToShape(@Cast("Nd4jLong*") @StdVector LongBuffer shape, NDArray target/*=nullptr*/); - public native void tileToShape(@Cast("Nd4jLong*") @StdVector long[] shape, NDArray target/*=nullptr*/); + public native void tileToShape(@Cast("Nd4jLong*") @StdVector LongPointer shape, @ByRef NDArray target); + public native void tileToShape(@Cast("Nd4jLong*") @StdVector LongBuffer shape, @ByRef NDArray target); + public native void tileToShape(@Cast("Nd4jLong*") @StdVector long[] shape, @ByRef NDArray target); // #ifndef __JAVACPP_HACK__ // #endif - public native NDArray asT(@Cast("nd4j::DataType") int dtype); + public native @ByVal NDArray asT(@Cast("nd4j::DataType") int dtype); public native void linspace(double start); @@ -4554,17 +4450,15 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native double getTrace(); - public native ResultSet multipleTensorsAlongDimension(@StdVector IntPointer indices, @StdVector IntPointer dimensions); - public native ResultSet multipleTensorsAlongDimension(@StdVector IntBuffer indices, @StdVector IntBuffer dimensions); - public native ResultSet multipleTensorsAlongDimension(@StdVector int[] indices, @StdVector int[] dimensions); + public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector IntPointer indices, @StdVector IntPointer dimensions); + public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector IntBuffer indices, @StdVector IntBuffer dimensions); + public native @ByVal ResultSet multipleTensorsAlongDimension(@StdVector int[] indices, @StdVector int[] dimensions); - public native ResultSet allTensorsAlongDimension(@StdVector IntPointer dimensions); - public native ResultSet allTensorsAlongDimension(@StdVector IntBuffer dimensions); - public native ResultSet allTensorsAlongDimension(@StdVector int[] dimensions); + public native @ByVal ResultSet allTensorsAlongDimension(@StdVector IntPointer dimensions); + public native @ByVal ResultSet allTensorsAlongDimension(@StdVector IntBuffer dimensions); + public native @ByVal ResultSet allTensorsAlongDimension(@StdVector int[] dimensions); - //ResultSet allTensorsAlongDims(const std::vector& dimensions) const; - - public native ResultSet allExamples(); + public native @ByVal ResultSet allExamples(); /** * set _shapeInfo @@ -4672,7 +4566,7 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); /** * returns true if these two NDArrays have same rank, dimensions, strides, ews and order */ - public native @Cast("bool") boolean isSameShapeStrict(@Const NDArray other); + public native @Cast("bool") boolean isSameShapeStrict(@Const @ByRef NDArray other); /** * returns true if buffer && shapeInfo were defined (non nullptr) @@ -4731,11 +4625,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native void p(@Cast("const Nd4jLong") long i, @Cast("const Nd4jLong") long j, @Cast("const Nd4jLong") long k, @Cast("const Nd4jLong") long l, @Const @ByRef NDArray value); - /** - * creates array which points on certain sub-range of this array, sub-range is defined by given indices - */ - - /** * returns true if array is 2D */ @@ -4806,59 +4695,6 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); */ public native @Cast("bool") boolean isS(); - /** - * inline accessing operator for matrix, i - absolute index - */ - //FORCEINLINE NDArray operator()(const Nd4jLong i) const; - - /** - * inline modifying operator for matrix, i - absolute index - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong i); - - /** - * inline accessing operator for 2D array, i - row, j - column - */ - //FORCEINLINE NDArray operator()(const Nd4jLong i, const Nd4jLong j) const; - - /** - * inline modifying operator for 2D array, i - row, j - column - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong i, const Nd4jLong j); - - /** - * inline accessing operator for 3D array, i - height, j - width, k - depth - */ - //FORCEINLINE NDArray operator()(const Nd4jLong i, const Nd4jLong j, const Nd4jLong k) const; - - /** - * inline modifying operator for 3D array, i - height, j - width, k - depth - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong i, const Nd4jLong j, const Nd4jLong k); - - /** - * inline modifying operator for 4D array, i - height, j - width, k - depth - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong t, const Nd4jLong u, const Nd4jLong v, const Nd4jLong w); - - /** - * inline accessing operator for 4D array, i - height, j - width, k - depth - */ - //FORCEINLINE NDArray operator()(const Nd4jLong t, const Nd4jLong u, const Nd4jLong v, const Nd4jLong w) const; - - /** - * inline modifying operator for ND array - * idx - array with corresponding indexes, for example {2,10,0,5,...,8}, number of indexes should be equal to array rank - */ - //FORCEINLINE NDArray& operator()(const Nd4jLong* idx); - - /** - * inline accessing operator for ND array - * idx - array with corresponding indexes, for example {2,10,0,5,...,8}, number of indexes should be equal to array rank - */ - //FORCEINLINE NDArray operator()(const Nd4jLong* idx) const; - - public native @Cast("bool") boolean isAttached(); public native NDArray detach(); @@ -4874,268 +4710,75 @@ public native @Cast("bool") boolean isOptimalRequirementsMet(); ////////////////////////////////////////////////////////////////////////// ///// IMLEMENTATION OF INLINE METHODS ///// ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - - - ////////////////////////////////////////////////////////////////////////// - ////////////////////////////////////////////////////////////////////////// -// accessing operator for matrix, i - absolute index -/* -NDArray NDArray::operator()(const Nd4jLong i) const { - if (i >= shape::length(_shapeInfo)) - throw std::invalid_argument("NDArray::operator(i): input index is out of array length !"); - - auto ews = shape::elementWiseStride(_shapeInfo); - char order = ordering(); - - if(ews == 1 && order == 'c') { - auto cast = reinterpret_cast(_buffer) + (i * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } else if(ews > 1 && order == 'c') { - auto cast = reinterpret_cast(_buffer) + (i * ews * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } else { - Nd4jLong idx[MAX_RANK]; - shape::ind2subC(rankOf(), shapeOf(), i, idx); - auto xOffset = shape::getOffset(getShapeInfo(), idx); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } -} -*/ -////////////////////////////////////////////////////////////////////////// -// modifying operator for matrix, i - absolute index -/* -NDArray& NDArray::operator()(const Nd4jLong i) { - if (i >= shape::length(_shapeInfo)) - throw std::invalid_argument("NDArray::operator(i): input index is out of array length !"); - - auto ews = shape::elementWiseStride(_shapeInfo); - auto order = ordering(); - - if(ews == 1 && order == 'c') { - auto cast = reinterpret_cast(_buffer) + (i * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - - // FIXME: bad - return result; - } else if(ews > 1 && order == 'c') { - auto cast = reinterpret_cast(_buffer) + (i * ews * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } else { - Nd4jLong idx[MAX_RANK]; - shape::ind2subC(rankOf(), shapeOf(), i, idx); - auto xOffset = shape::getOffset(getShapeInfo(), idx); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; - } -}*/ ////////////////////////////////////////////////////////////////////////// -// accessing operator for 2D matrix, i - row, j - column -/* -NDArray NDArray::operator()(const Nd4jLong i, const Nd4jLong j) const { - if (rankOf() != 2 || i >= shapeOf()[0] || j >= shapeOf()[1]) - throw std::invalid_argument("NDArray::operator(i,j): one of input indexes is out of array length or rank!=2 !"); - - Nd4jLong coords[2] = {i, j}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - // TODO: do we really want a view here? - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ -////////////////////////////////////////////////////////////////////////// -// modifying operator for 2D matrix, i - row, j - column -/* -NDArray& NDArray::operator()(const Nd4jLong i, const Nd4jLong j) { - if (rankOf() != 2 || i >= shapeOf()[0] || j >= shapeOf()[1]) - throw std::invalid_argument("NDArray::operator(i,j): one of input indexes is out of array length or rank!=2 !"); - - Nd4jLong coords[2] = {i, j}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - - //FIXME: bad, will crash! - return result; -} -*/ ////////////////////////////////////////////////////////////////////////// -// accessing operator for 3D array, i - row, j - column -/* -NDArray NDArray::operator()(const Nd4jLong i, const Nd4jLong j, const Nd4jLong k) const { - if (rankOf() != 3 || i >= shapeOf()[0] || j >= shapeOf()[1] || j >= shapeOf()[2]) - throw std::invalid_argument("NDArray::operator(i,j,k): one of input indexes is out of array length or rank!=3 !"); - - Nd4jLong coords[3] = {i, j, k}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ ////////////////////////////////////////////////////////////////////////// -// modifying operator for 3D array -/* -NDArray& NDArray::operator()(const Nd4jLong i, const Nd4jLong j, const Nd4jLong k) { - if (rankOf() != 3 || i >= shapeOf()[0] || j >= shapeOf()[1] || k >= shapeOf()[2]) - throw std::invalid_argument("NDArray::operator(i,j,k): one of input indexes is out of array length or rank!=3 !"); - Nd4jLong coords[3] = {i, j, k}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - - //FIXME: bad, will crash! - return result; -} -*/ -/* -NDArray NDArray::operator()(const Nd4jLong t, const Nd4jLong u, const Nd4jLong v, const Nd4jLong w) const { - - if (rankOf() != 4 || t >= shapeOf()[0] || u >= shapeOf()[1] || v >= shapeOf()[2] || w >= shapeOf()[3]) - throw std::invalid_argument("NDArray::operator(t,u,v,w): one of input indexes is out of array length or rank!=4 !"); - - Nd4jLong coords[4] = {t, u, v, w}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ -/* -NDArray& NDArray::operator()(const Nd4jLong t, const Nd4jLong u, const Nd4jLong v, const Nd4jLong w) { - - if (rankOf() != 4 || t >= shapeOf()[0] || u >= shapeOf()[1] || v >= shapeOf()[2] || w >= shapeOf()[3]) - throw std::invalid_argument("NDArray::operator(t,u,v,w): one of input indexes is out of array length or rank!=4 !"); - - Nd4jLong coords[4] = {t, u, v, w}; - auto xOffset = shape::getOffset(getShapeInfo(), coords); - - // FIXME - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ ////////////////////////////////////////////////////////////////////////// -/* -NDArray NDArray::operator()(const Nd4jLong* idx) const { - for(int i = 0; i < rankOf(); ++i) - if (idx[i] >= sizeAt(i)) - throw std::invalid_argument("NDArray::operator(const Nd4jLong* idx): input index is out of dimension length !"); - auto xOffset = shape::getOffset(getShapeInfo(), idx); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - return result; -} -*/ ////////////////////////////////////////////////////////////////////////// -/* -NDArray& NDArray::operator()(const Nd4jLong* idx) { - - for(int i = 0; i < rankOf(); ++i) - if (idx[i] >= sizeAt(i)) - throw std::invalid_argument("NDArray::operator(const Nd4jLong* idx): input index is out of dimension length !"); - - auto xOffset = shape::getOffset(getShapeInfo(), idx); - - auto cast = reinterpret_cast(_buffer) + (xOffset * this->sizeOfT()); - NDArray result(cast, nd4j::ShapeBuilders::createScalarShapeInfo(this->dataType(), this->getWorkspace())); - - // FIXME - return result; -} -*/ - ////////////////////////////////////////////////////////////////////////// - +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// + + + +////////////////////////////////////////////////////////////////////////// + + +////////////////////////////////////////////////////////////////////////// +// still the definition of inline function must be in header file - ////////////////////////////////////////////////////////////////////////// - // still the definition of inline function must be in header file - ////////////////////////////////////////////////////////////////////////// @@ -6781,9 +6424,11 @@ NDArray& NDArray::operator()(const Nd4jLong* idx) { public native void setCudaContext(@Cast("Nd4jPointer") Pointer cudaStream, @Cast("Nd4jPointer") Pointer reductionPointer, @Cast("Nd4jPointer") Pointer allocationPointer); - public native void allowHelpers(@Cast("bool") boolean reallyAllow); public native @Cast("bool") boolean helpersAllowed(); + + public native void setShapeFunctionOverride(@Cast("bool") boolean reallyOverride); + public native @Cast("bool") boolean shapeFunctionOverride(); } @@ -11193,7 +10838,9 @@ public static final int TAD_THRESHOLD = TAD_THRESHOLD(); // #if defined(_MSC_VER) || defined(_WIN64) || defined(_WIN32) || defined(__CLION_IDE__) || defined(__VSCODE__) // #define NOT_EXCLUDED(NAME) 1>0 // #else -// #define NOT_EXCLUDED(NAME) defined(LIBND4J_ALL_OPS) || defined(NAME) +// for now we don't want minifier mechanics working +//#define NOT_EXCLUDED(NAME) defined(LIBND4J_ALL_OPS) || defined(NAME) +// #define NOT_EXCLUDED(NAME) 1>0 // #endif // #ifdef __JAVACPP_HACK__ @@ -12368,6 +12015,7 @@ public static final int TAD_THRESHOLD = TAD_THRESHOLD(); // #include // #include // #include +// #include // #include // #include // #include @@ -17115,19 +16763,20 @@ public static final int TAD_THRESHOLD = TAD_THRESHOLD(); * This operation calculates hash code, optionally along dimension */ // #if NOT_EXCLUDED(OP_hashcode) - @Namespace("nd4j::ops") public static class hashcode extends DeclarableReductionOp { - static { Loader.load(); } - /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ - public hashcode(Pointer p) { super(p); } - /** Native array allocator. Access with {@link Pointer#position(long)}. */ - public hashcode(long size) { super((Pointer)null); allocateArray(size); } - private native void allocateArray(long size); - @Override public hashcode position(long position) { - return (hashcode)super.position(position); - } - + @Namespace("nd4j::ops") public static class hashcode extends DeclarableCustomOp { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public hashcode(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public hashcode(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public hashcode position(long position) { + return (hashcode)super.position(position); + } + public hashcode() { super((Pointer)null); allocate(); } private native void allocate(); + public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block); } // #endif @@ -19345,6 +18994,38 @@ public static final int TAD_THRESHOLD = TAD_THRESHOLD(); } // #endif + /** + * lu op. - make LUP decomposition of given batch of 2D square matricies + * + * input params: + * 0 - float tensor with dimension (x * y * z * ::: * M * M) + * + * return value: + * 0 - float tensor with dimension (x * y * z * ::: * M * M) with LU M x M matricies in it + * 1 - int (32 or 64) batched vector of permutations with length M - shape (x * y * z * ::: * M) + * + * int argument: + * 0 - data type of output permutaion vector (int32 or int64), optional, default INT32 + */ + +// #if NOT_EXCLUDED(OP_matrix_inverse) + @Namespace("nd4j::ops") public static class lu extends DeclarableCustomOp { + static { Loader.load(); } + /** Pointer cast constructor. Invokes {@link Pointer#Pointer(Pointer)}. */ + public lu(Pointer p) { super(p); } + /** Native array allocator. Access with {@link Pointer#position(long)}. */ + public lu(long size) { super((Pointer)null); allocateArray(size); } + private native void allocateArray(long size); + @Override public lu position(long position) { + return (lu)super.position(position); + } + + public lu() { super((Pointer)null); allocate(); } + private native void allocate(); + public native ShapeList calculateOutputShape(ShapeList inputShape, @ByRef Context block); + } +// #endif + /** * sequence_mask op. - make mask for given tensor filled by (j > x[i_1, i_2,...,i_n]) -> z[i_1, i_2,...,i_n,j] *