deeplearning4j/deeplearning4j

View on GitHub
nd4j/nd4j-backends/nd4j-api-parent/nd4j-api/src/main/java/org/nd4j/nativeblas/NativeOps.java

Summary

Maintainability
F
2 wks
Test Coverage

NativeOps has 299 methods (exceeds 20 allowed). Consider refactoring.
Open

public interface NativeOps {
    int contextNumInputs(Pointer execTrace);
    int contextNumOutputs(Pointer execTrace);

    int numInputs(Pointer execTrace);

    File NativeOps.java has 758 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /*
     *  ******************************************************************************
     *  *
     *  *
     *  * This program and the accompanying materials are made available under the

      Method execReduce3Tad has 19 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          void execReduce3Tad(PointerPointer extraPointers,
                              int opNum,
                              OpaqueDataBuffer x,
                               LongPointer xShapeInfo,
                               LongPointer dxShapeInfo,

        Method execScalarBoolTad has 19 arguments (exceeds 4 allowed). Consider refactoring.
        Open

            void execScalarBoolTad(PointerPointer extraPointers,
                                   int opNum,
                                   OpaqueDataBuffer x,
                                    LongPointer xShapeInfo,
                                    LongPointer dxShapeInfo,

          Method scatterUpdate has 19 arguments (exceeds 4 allowed). Consider refactoring.
          Open

              void scatterUpdate(PointerPointer extraPointers, int opCode, int numOfUpdates,
                                 Pointer hX,  LongPointer hXShapeInfo,  LongPointer hxOffsets,
                                 Pointer dX,  LongPointer dXShapeInfo,  LongPointer dxOffsets,
                                 Pointer hY,  LongPointer hYShapeInfo,  LongPointer hyOffsets,
                                 Pointer dY,  LongPointer dYShapeInfo,  LongPointer dyOffsets,

            Method execScalarTad has 19 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                void execScalarTad(PointerPointer extraPointers,
                                   int opNum,
                                   OpaqueDataBuffer x,
                                    LongPointer xShapeInfo,
                                    LongPointer dxShapeInfo,

              Method execReduce3All has 19 arguments (exceeds 4 allowed). Consider refactoring.
              Open

                  void execReduce3All(PointerPointer extraPointers,
                                      int opNum,
                                      OpaqueDataBuffer x,
                                       LongPointer xShapeInfo,
                                       LongPointer dxShapeInfo,

                Method execSummaryStatsTad has 15 arguments (exceeds 4 allowed). Consider refactoring.
                Open

                    void execSummaryStatsTad(PointerPointer extraPointers,
                                             int opNum,
                                             OpaqueDataBuffer x,
                                              LongPointer xShapeInfo,
                                              LongPointer dxShapeInfo,

                  Method execCustomOp has 15 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                      int execCustomOp(PointerPointer extraPointers, long opHashCode, PointerPointer inputBuffers, PointerPointer inputShapes, int numInput, PointerPointer outputBuffers, PointerPointer outputShapes, int numOutputs, DoublePointer tArgs, int numTArgs,  LongPointer iArgs, int numIArgs,  BooleanPointer bArgs, int numBArgs, boolean isInplace);

                    Method execBroadcastBool has 15 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                        void execBroadcastBool(PointerPointer extraPointers,
                                               int opNum,
                                               OpaqueDataBuffer x,
                                                LongPointer xShapeInfo,
                                                LongPointer dxShapeInfo,

                      Method execBroadcast has 14 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                          void execBroadcast(PointerPointer extraPointers,
                                             int opNum,
                                             OpaqueDataBuffer x,
                                              LongPointer xShapeInfo,
                                              LongPointer dxShapeInfo,

                        Method execRandom3 has 13 arguments (exceeds 4 allowed). Consider refactoring.
                        Open

                            void execRandom3(PointerPointer extraPointers,
                                             int opNum,
                                             Pointer state,
                                             OpaqueDataBuffer x,
                                              LongPointer xShapeBuffer,

                          Method pullRows has 13 arguments (exceeds 4 allowed). Consider refactoring.
                          Open

                              void pullRows(PointerPointer extraPointers,
                                            OpaqueDataBuffer x,
                                             LongPointer xShapeInfo,
                                             LongPointer dxShapeInfo,
                                            OpaqueDataBuffer z,

                            Method shuffle has 13 arguments (exceeds 4 allowed). Consider refactoring.
                            Open

                                void shuffle(PointerPointer extraPointers,
                                             PointerPointer x,  PointerPointer xShapeInfo,
                                             PointerPointer dx,  PointerPointer dxShapeInfo,
                                             PointerPointer z,  PointerPointer zShapeInfo,
                                             PointerPointer dz,  PointerPointer dzShapeInfo,

                              Method calculateOutputShapes2 has 13 arguments (exceeds 4 allowed). Consider refactoring.
                              Open

                                  OpaqueShapeList calculateOutputShapes2(PointerPointer extraPointers, long hash, PointerPointer inputBunffers, PointerPointer inputShapes, int numInputShapes, DoublePointer tArgs, int numTArgs,  LongPointer iArgs, int numIArgs,  BooleanPointer bArgs, int numBArgs,  IntPointer dArgs, int numDArgs);

                                Method calculateOutputShapes3 has 13 arguments (exceeds 4 allowed). Consider refactoring.
                                Open

                                    org.nd4j.nativeblas.OpaqueShapeList calculateOutputShapes3(PointerPointer extraPointers,  long hash,
                                                                                               PointerPointer inputBuffers,
                                                                                               PointerPointer inputShapes, int numInputShapes, DoublePointer tArgs, int numTArgs,
                                                                                               LongPointer iArgs, int numIArgs,  BooleanPointer bArgs, int numBArgs, IntPointer dArgs,
                                                                                               int numDArgs);

                                  Method execAggregate has 13 arguments (exceeds 4 allowed). Consider refactoring.
                                  Open

                                      void execAggregate(PointerPointer extras, int opNum,
                                                         PointerPointer arguments,
                                                         int numArguments,
                                                         @Cast("sd::LongType **") PointerPointer shapes,
                                                         int numShapes,

                                    Method execReduceFloat2 has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                    Open

                                        void execReduceFloat2(PointerPointer extraPointers,
                                                              int opNum,
                                                              OpaqueDataBuffer x,
                                                               LongPointer xShapeInfo,
                                                               LongPointer dxShapeInfo,

                                      Method execScalar has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                      Open

                                          void execScalar(PointerPointer extraPointers,
                                                          int opNum,
                                                          OpaqueDataBuffer x,
                                                           LongPointer xShapeInfo,
                                                           LongPointer dxShapeInfo,

                                        Method sortTadByKey has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                        Open

                                            void sortTadByKey( PointerPointer extraPointers, Pointer x, long[] xShapeInfo, Pointer dX,
                                                               long[] dXShapeInfo, Pointer y, long[] yShapeInfo, Pointer dy,
                                                               long[] dyShapeInfo,  long[] dimension, long dimensionLength,  boolean descending);

                                          Method execReduceLong2 has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                          Open

                                              void execReduceLong2(PointerPointer extraPointers,
                                                                   int opNum,
                                                                   OpaqueDataBuffer x,
                                                                    LongPointer xShapeInfo,
                                                                    LongPointer dxShapeInfo,

                                            Method execReduce3Scalar has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                            Open

                                                void execReduce3Scalar(PointerPointer extraPointers, int opNum,
                                                                       OpaqueDataBuffer x,
                                                                        LongPointer xShapeInfo,
                                                                        LongPointer dxShapeInfo,
                                                                       Pointer extraParamsVals,

                                              Method execScalarBool has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                              Open

                                                  void execScalarBool(PointerPointer extraPointers,
                                                                      int opNum,
                                                                      OpaqueDataBuffer x,
                                                                       LongPointer xShapeInfo,
                                                                       LongPointer dxShapeInfo,

                                                Method execPairwiseTransformBool has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                Open

                                                    void execPairwiseTransformBool(PointerPointer extraPointers,
                                                                                   int opNum,
                                                                                   OpaqueDataBuffer x,
                                                                                    LongPointer xShapeInfo,
                                                                                    LongPointer dxShapeInfo,

                                                  Method execReduceSame2 has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                  Open

                                                      void execReduceSame2(PointerPointer extraPointers,
                                                                           int opNum,
                                                                           OpaqueDataBuffer x,
                                                                            LongPointer xShapeInfo,
                                                                            LongPointer dxShapeInfo,

                                                    Method sortTadByValue has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                    Open

                                                        void sortTadByValue( PointerPointer extraPointers, Pointer x, LongPointer xShapeInfo, Pointer dx,
                                                                             LongPointer dxShapeInfo, Pointer y, LongPointer yShapeInfo, Pointer dy,
                                                                             LongPointer dyShapeInfo,  LongPointer dimension,
                                                                             long dimensionLength,
                                                                             boolean descending);

                                                      Method execReduce3 has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                      Open

                                                          void execReduce3(PointerPointer extraPointers,
                                                                           int opNum,
                                                                           OpaqueDataBuffer x,
                                                                            LongPointer xShapeInfo,
                                                                            LongPointer dxShapeInfo,

                                                        Method execPairwiseTransform has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                        Open

                                                            void execPairwiseTransform(PointerPointer extraPointers,
                                                                                       int opNum,
                                                                                       OpaqueDataBuffer x,
                                                                                        LongPointer xShapeInfo,
                                                                                        LongPointer dxShapeInfo,

                                                          Method execIndexReduce has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                          Open

                                                              void execIndexReduce(PointerPointer extraPointers,
                                                                                   int opNum,
                                                                                   OpaqueDataBuffer x,
                                                                                    LongPointer xShapeInfo,
                                                                                    LongPointer dXShapeInfo,

                                                            Method average has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                            Open

                                                                void average(PointerPointer extraPointers,
                                                                             PointerPointer x,  LongPointer xShapeInfo,
                                                                             PointerPointer dx,  LongPointer dxShapeInfo,
                                                                             Pointer z,  LongPointer zShapeInfo,
                                                                             Pointer dz,  LongPointer dzShapeInfo,

                                                              Method sortTadByKey has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                              Open

                                                                  void sortTadByKey( PointerPointer extraPointers, Pointer x, LongPointer xShapeInfo, Pointer dX,
                                                                                     LongPointer dXShapeInfo, Pointer y, LongPointer yShapeInfo, Pointer dy,
                                                                                     LongPointer dyShapeInfo,  LongPointer dimension, long dimensionLength,boolean descending);

                                                                Method sortTadByValue has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                                Open

                                                                    void sortTadByValue( PointerPointer extraPointers, Pointer x, LongBuffer xShapeInfo, Pointer dx,
                                                                                         LongBuffer dxShapeInfo, Pointer y, LongBuffer yShapeInfo, Pointer dy,
                                                                                         LongBuffer dyShapeInfo,  LongBuffer dimension,
                                                                                         long dimensionLength,
                                                                                         boolean descending);

                                                                  Method sortTadByKey has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                                  Open

                                                                      void sortTadByKey(PointerPointer extraPointers, Pointer x, LongBuffer xShapeInfo, Pointer dX,
                                                                                        LongBuffer dXShapeInfo, Pointer y, LongBuffer yShapeInfo, Pointer dy,
                                                                                        LongBuffer dyShapeInfo,LongBuffer dimension, long dimensionLength,  boolean descending);

                                                                    Method execReduceBool2 has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                                    Open

                                                                        void execReduceBool2(PointerPointer extraPointers,
                                                                                             int opNum,
                                                                                             OpaqueDataBuffer x,
                                                                                              LongPointer xShapeInfo,
                                                                                              LongPointer dxShapeInfo,

                                                                      Method sortTadByValue has 12 arguments (exceeds 4 allowed). Consider refactoring.
                                                                      Open

                                                                          void sortTadByValue( PointerPointer extraPointers, Pointer x, long[] xShapeInfo, Pointer dx,
                                                                                               long[] dxShapeInfo, Pointer y, long[] yShapeInfo, Pointer dy,
                                                                                               long[] dyShapeInfo,  long[] dimension,
                                                                                               long dimensionLength,
                                                                                               boolean descending);

                                                                        Method accumulate has 11 arguments (exceeds 4 allowed). Consider refactoring.
                                                                        Open

                                                                            void accumulate(PointerPointer extraPointers,
                                                                                            PointerPointer x,  LongPointer xShapeInfo,
                                                                                            PointerPointer dx,  LongPointer dxShapeInfo,
                                                                                            Pointer z,  LongPointer zShapeInfo,
                                                                                            Pointer dz,  LongPointer dzShapeInfo,

                                                                          Method execAggregateBatch has 11 arguments (exceeds 4 allowed). Consider refactoring.
                                                                          Open

                                                                              void execAggregateBatch(PointerPointer extras, int numAggregates, int opNum, int maxArgs,
                                                                                                      int maxShapes, int maxIntArrays, int maxIntArraySize, int maxIdx, int maxReals,
                                                                                                      Pointer ptrToArguments, @Cast("nd4j::DataType") int dataType);

                                                                            Method execCustomOpWithScope has 11 arguments (exceeds 4 allowed). Consider refactoring.
                                                                            Open

                                                                                int execCustomOpWithScope(PointerPointer extraPointers, Pointer state, long opHash, long[] scopes, int numScopes, PointerPointer inputBuffers, PointerPointer inputShapes, int numInputs, PointerPointer outputBuffers, PointerPointer outputShapes, int numOutputs);

                                                                              Method execSummaryStats has 10 arguments (exceeds 4 allowed). Consider refactoring.
                                                                              Open

                                                                                  void execSummaryStats(PointerPointer extraPointers,
                                                                                                        int opNum,
                                                                                                        OpaqueDataBuffer x,
                                                                                                         LongPointer xShapeInfo,
                                                                                                         LongPointer dxShapeInfo,

                                                                                Method execRandom2 has 10 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                Open

                                                                                    void execRandom2(PointerPointer extraPointers,
                                                                                                     int opNum,
                                                                                                     Pointer state,
                                                                                                     OpaqueDataBuffer x,
                                                                                                      LongPointer xShapeBuffer,

                                                                                  Method execSummaryStatsScalar has 10 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                  Open

                                                                                      void execSummaryStatsScalar(PointerPointer extraPointers,
                                                                                                                  int opNum,
                                                                                                                  OpaqueDataBuffer x,
                                                                                                                   LongPointer xShapeInfo,
                                                                                                                   LongPointer dxShapeInfo,

                                                                                    Method sortTad has 10 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                    Open

                                                                                        void sortTad( PointerPointer extraPointers, Pointer hX, long[] hXShapeInfo, Pointer dX,
                                                                                                      long[] dXShapeInfo, long[] dimension,long dimensionLength,
                                                                                                      long[] tadShapeInfo, long[] tadOffsets, boolean descending);

                                                                                      Method sortTad has 10 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                      Open

                                                                                          void sortTad( PointerPointer extraPointers, Pointer hX, LongBuffer hXShapeInfo, Pointer dX,
                                                                                                        LongBuffer dXShapeInfo, LongBuffer dimension,  long dimensionLength,
                                                                                                        LongBuffer tadShapeInfo, LongBuffer tadOffsets,  boolean descending);

                                                                                        Method sortTad has 10 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                        Open

                                                                                            void sortTad( PointerPointer extraPointers, Pointer hX, LongPointer hXShapeInfo, Pointer dX,
                                                                                                          LongPointer dXShapeInfo, LongPointer dimension,  long dimensionLength,
                                                                                                          LongPointer tadShapeInfo, LongPointer tadOffsets,  boolean descending);

                                                                                          Method execTransformSame has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                          Open

                                                                                              void execTransformSame(PointerPointer extraPointers,
                                                                                                                     int opNum,
                                                                                                                     OpaqueDataBuffer x,
                                                                                                                      LongPointer xShapeInfo,
                                                                                                                      LongPointer dxShapeInfo,

                                                                                            Method execReduceLong has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                            Open

                                                                                                void execReduceLong(PointerPointer extraPointers,
                                                                                                                    int opNum,
                                                                                                                    OpaqueDataBuffer x,
                                                                                                                     LongPointer xShapeInfo,
                                                                                                                     LongPointer dxShapeInfo,

                                                                                              Method execTransformStrict has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                              Open

                                                                                                  void execTransformStrict(PointerPointer extraPointers,
                                                                                                                           int opNum,
                                                                                                                           OpaqueDataBuffer x,
                                                                                                                            LongPointer xShapeInfo,
                                                                                                                            LongPointer dxShapeInfo,

                                                                                                Method execIndexReduceScalar has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                Open

                                                                                                    void execIndexReduceScalar(PointerPointer extraPointers,
                                                                                                                               int opNum,
                                                                                                                               OpaqueDataBuffer x,
                                                                                                                                LongPointer xShapeInfo,
                                                                                                                                LongPointer dXShapeInfo,

                                                                                                  Method execTransformBool has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                      void execTransformBool(PointerPointer extraPointers,
                                                                                                                             int opNum,
                                                                                                                             OpaqueDataBuffer x,
                                                                                                                              LongPointer xShapeInfo,
                                                                                                                              LongPointer dxShapeInfo,

                                                                                                    Method specialConcat has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                    Open

                                                                                                        void specialConcat(PointerPointer extraPointers,
                                                                                                                           int dimension,
                                                                                                                           int numArrays,
                                                                                                                           PointerPointer data, PointerPointer inputShapeInfo,
                                                                                                                           Pointer results,  LongPointer resultShapeInfo,

                                                                                                      Method execTransformAny has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                      Open

                                                                                                          void execTransformAny(PointerPointer extraPointers,
                                                                                                                                int opNum,
                                                                                                                                OpaqueDataBuffer x,
                                                                                                                                 LongPointer xShapeInfo,
                                                                                                                                 LongPointer dxShapeInfo,

                                                                                                        Method execReduceBool has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                        Open

                                                                                                            void execReduceBool(PointerPointer extraPointers,
                                                                                                                                int opNum,
                                                                                                                                OpaqueDataBuffer x,
                                                                                                                                 LongPointer xShapeInfo,
                                                                                                                                 LongPointer dxShapeInfo,

                                                                                                          Method execReduceSame has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                          Open

                                                                                                              void execReduceSame(PointerPointer extraPointers,
                                                                                                                                  int opNum,
                                                                                                                                  OpaqueDataBuffer x,
                                                                                                                                   LongPointer xShapeInfo,
                                                                                                                                   LongPointer dxShapeInfo,

                                                                                                            Method execReduceFloat has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                            Open

                                                                                                                void execReduceFloat(PointerPointer extraPointers,
                                                                                                                                     int opNum,
                                                                                                                                     OpaqueDataBuffer x,
                                                                                                                                      LongPointer xShapeInfo,
                                                                                                                                      LongPointer dxShapeInfo,

                                                                                                              Method execTransformFloat has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                              Open

                                                                                                                  void execTransformFloat(PointerPointer extraPointers,
                                                                                                                                          int opNum,
                                                                                                                                          OpaqueDataBuffer x,
                                                                                                                                           LongPointer xShapeInfo,
                                                                                                                                           LongPointer dxShapeInfo,

                                                                                                                Method tear has 8 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                Open

                                                                                                                    void tear(PointerPointer extras,
                                                                                                                              OpaqueDataBuffer tensor,
                                                                                                                              LongPointer xShapeInfo,
                                                                                                                              LongPointer dxShapeInfo,
                                                                                                                              PointerPointer targets,

                                                                                                                  Method calculateOutputShapes has 8 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                  Open

                                                                                                                      OpaqueShapeList calculateOutputShapes(PointerPointer extraPointers, long hash, PointerPointer inputShapes, int numInputShapes, DoublePointer tArgs, int numTArgs,  LongPointer iArgs, int numIArgs);

                                                                                                                    Method shapeBufferEx has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                    Open

                                                                                                                        OpaqueConstantShapeBuffer shapeBufferEx(int rank, LongPointer shape, LongPointer strides, int dtype, char order, long ews, long extras);

                                                                                                                      Method shapeBuffer has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                      Open

                                                                                                                          OpaqueConstantShapeBuffer shapeBuffer(int rank, LongPointer shape, LongPointer strides, int dtype, char order, long ews, boolean empty);

                                                                                                                        Method execRandom has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                        Open

                                                                                                                            void execRandom(PointerPointer extraPointers,
                                                                                                                                            int opNum,
                                                                                                                                            Pointer state,
                                                                                                                                            OpaqueDataBuffer z,
                                                                                                                                             LongPointer zShapeBuffer,

                                                                                                                          Method convertTypes has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                          Open

                                                                                                                              void convertTypes(PointerPointer extras, int srcType, Pointer x, long N, int dstType, Pointer z);

                                                                                                                            Method inspectArray has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                            Open

                                                                                                                                void inspectArray(PointerPointer extraPointers, Pointer buffer,  LongPointer shapeInfo, Pointer specialBuffer,  LongPointer specialShapeInfo, @Cast("nd4j::DebugInfo *") Pointer debugInfo);

                                                                                                                              Method setShapeBuffer has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                              Open

                                                                                                                                  void setShapeBuffer( long[] inputShapeData, int dt, long[] bufferToSet,char order/*='c'*/,int elementWiseStride/*=1*/, boolean isEmpty/*=false*/);

                                                                                                                                Method setGraphContextInputArrays has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                Open

                                                                                                                                    void setGraphContextInputArrays(org.nd4j.nativeblas.OpaqueContext ptr, int numArrays, PointerPointer buffer, PointerPointer shapeInfo,
                                                                                                                                                                    PointerPointer specialBuffer, PointerPointer specialShapeInfo);

                                                                                                                                  Method setGraphContextOutputArrays has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                  Open

                                                                                                                                      void setGraphContextOutputArrays(org.nd4j.nativeblas.OpaqueContext ptr, int numArrays, PointerPointer buffer, PointerPointer shapeInfo,
                                                                                                                                                                       PointerPointer specialBuffer, PointerPointer specialShapeInfo);

                                                                                                                                    Method executeStoredGraph has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                    Open

                                                                                                                                        OpaqueVariablesSet executeStoredGraph(PointerPointer extraPointers, long graphId, PointerPointer inputBuffers, PointerPointer inputShapes, IntPointer inputIndices, int numInputs);

                                                                                                                                      Method sort has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                      Open

                                                                                                                                          void sort(PointerPointer extraPointers,
                                                                                                                                                    Pointer x, LongPointer xShapeInfo,
                                                                                                                                                    Pointer dx, LongPointer dxShapeInfo,
                                                                                                                                                    boolean descending);

                                                                                                                                        Method ravelMultiIndex has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                        Open

                                                                                                                                            void ravelMultiIndex(PointerPointer extraPointers,  LongPointer indices,  LongPointer flatIndices, long length,  LongPointer shapeInfo, int mode);

                                                                                                                                          Method setShapeBuffer has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                          Open

                                                                                                                                              void setShapeBuffer( LongPointer inputShapeData, int dt, LongPointer bufferToSet,char order/*='c'*/,int elementWiseStride/*=1*/, boolean isEmpty/*=false*/);

                                                                                                                                            Method setShapeBuffer has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                            Open

                                                                                                                                                void setShapeBuffer( LongBuffer inputShapeData, int dt, LongBuffer bufferToSet,char order/*='c'*/,int elementWiseStride/*=1*/, boolean isEmpty/*=false*/);

                                                                                                                                              Method sortCooIndices has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                              Open

                                                                                                                                                  void sortCooIndices(PointerPointer extraPointers,  LongPointer indices, Pointer x, long length,  LongPointer shapeInfo);

                                                                                                                                                Method setGraphContextInputBuffer has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                Open

                                                                                                                                                    void setGraphContextInputBuffer(OpaqueContext ptr, int index, OpaqueDataBuffer databuffer, OpaqueDataBuffer shapeInfo, OpaqueDataBuffer specialShapeInfo);

                                                                                                                                                  Method memsetSync has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                  Open

                                                                                                                                                      int memsetSync(Pointer dst, int value, long size, int flags, Pointer reserved);

                                                                                                                                                    Method saveNpy has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                    Open

                                                                                                                                                        void saveNpy( BytePointer fname, org.nd4j.nativeblas.OpaqueDataBuffer data,  IntPointer shape,  int ndims,
                                                                                                                                                                      BytePointer mode/*="w"*/);

                                                                                                                                                      Method saveNpy has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                      Open

                                                                                                                                                          void saveNpy( String fname, org.nd4j.nativeblas.OpaqueDataBuffer data,  IntBuffer shape,  int ndims,
                                                                                                                                                                        String mode/*="w"*/);

                                                                                                                                                        Method saveNpy has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                        Open

                                                                                                                                                            void saveNpy( BytePointer fname, org.nd4j.nativeblas.OpaqueDataBuffer data,  IntBuffer shape,  int ndims,
                                                                                                                                                                          BytePointer mode/*="w"*/);

                                                                                                                                                          Method memcpySync has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                          Open

                                                                                                                                                              int memcpySync(Pointer dst, Pointer src, long size, int flags, Pointer reserved);

                                                                                                                                                            Method setGraphContextInputBuffers has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                            Open

                                                                                                                                                                void setGraphContextInputBuffers(org.nd4j.nativeblas.OpaqueContext ptr, int numArrays, PointerPointer buffer, PointerPointer shapeInfo,
                                                                                                                                                                                                 PointerPointer specialShapeInfo);

                                                                                                                                                              Method copyBuffer has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  void copyBuffer(org.nd4j.nativeblas.OpaqueDataBuffer target, long n,  org.nd4j.nativeblas.OpaqueDataBuffer from, long fromOffset, long targetOffset);

                                                                                                                                                                Method setGraphContextOutputBuffer has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                Open

                                                                                                                                                                    void setGraphContextOutputBuffer(OpaqueContext ptr, int index, OpaqueDataBuffer databuffer, OpaqueDataBuffer shapeInfo, OpaqueDataBuffer specialShapeInfo);

                                                                                                                                                                  Method saveNpy has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                  Open

                                                                                                                                                                      void saveNpy( String fname, org.nd4j.nativeblas.OpaqueDataBuffer data,  int[] shape,  int ndims,
                                                                                                                                                                                    String mode/*="w"*/);

                                                                                                                                                                    Method memcpyConstantAsync has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                    Open

                                                                                                                                                                        int memcpyConstantAsync(long dst, Pointer src, long size, int flags, Pointer reserved);

                                                                                                                                                                      Method unravelIndex has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                      Open

                                                                                                                                                                          void unravelIndex(PointerPointer extraPointers,  LongPointer indices,  LongPointer flatIndices, long length,  LongPointer shapeInfo);

                                                                                                                                                                        Method memcpyAsync has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                        Open

                                                                                                                                                                            int memcpyAsync(Pointer dst, Pointer src, long size, int flags, Pointer reserved);

                                                                                                                                                                          Method setGraphContextOutputBuffers has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                          Open

                                                                                                                                                                              void setGraphContextOutputBuffers(org.nd4j.nativeblas.OpaqueContext ptr, int numArrays, PointerPointer buffer, PointerPointer shapeInfo,
                                                                                                                                                                                                                PointerPointer specialShapeInfo);

                                                                                                                                                                            Method saveNpy has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                            Open

                                                                                                                                                                                void saveNpy( BytePointer fname, org.nd4j.nativeblas.OpaqueDataBuffer data,  int[] shape,  int ndims,
                                                                                                                                                                                              BytePointer mode/*="w"*/);

                                                                                                                                                                              Method estimateThreshold has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                              Open

                                                                                                                                                                                  int estimateThreshold(PointerPointer extraPointers, Pointer x, LongPointer xShapeInfo, int N, float threshold);

                                                                                                                                                                                Method saveNpy has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                Open

                                                                                                                                                                                    void saveNpy( String fname, org.nd4j.nativeblas.OpaqueDataBuffer data,  IntPointer shape,  int ndims,
                                                                                                                                                                                                  String mode/*="w"*/);

                                                                                                                                                                                  Method memsetAsync has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                  Open

                                                                                                                                                                                      int memsetAsync(Pointer dst, int value, long size, int flags, Pointer reserved);

                                                                                                                                                                                    There are no issues that match your filters.

                                                                                                                                                                                    Category
                                                                                                                                                                                    Status