deeplearning4j/deeplearning4j

View on GitHub

Showing 6,111 of 13,975 total issues

File Shape.java has 2479 lines of code (exceeds 250 allowed). Consider refactoring.
Open

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

    SDBaseOps has 332 methods (exceeds 20 allowed). Consider refactoring.
    Open

    public class SDBaseOps {
      protected SameDiff sd;
    
      public SDBaseOps(SameDiff sameDiff) {
        this.sd = sameDiff;

      File WordVectorSerializer.java has 2252 lines of code (exceeds 250 allowed). Consider refactoring.
      Open

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

        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 Libnd4jArgDescriptorSource.java has 2072 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

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

            File UpdateDecoder.java has 2025 lines of code (exceeds 250 allowed). Consider refactoring.
            Open

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

              SameDiff has 275 methods (exceeds 20 allowed). Consider refactoring.
              Open

              @Slf4j
              public class SameDiff extends SDBaseOps {
                  protected static final String GRAD_FN_KEY = "grad";
              
                  //Fields for graph structure and execution

                File SDMath.java has 1992 lines of code (exceeds 250 allowed). Consider refactoring.
                Open

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

                  Method SDImage has a Cognitive Complexity of 278 (exceeds 20 allowed). Consider refactoring.
                  Open

                  fun SDImage() =  Namespace("Image"){
                      val namespaceJavaPackage = "org.nd4j.linalg.api.ops.custom"
                      Op("CropAndResize") {
                          javaPackage = "org.nd4j.linalg.api.ops.impl.image"
                          javaOpClass = "CropAndResize"
                  Severity: Minor
                  Found in codegen/op-codegen/src/main/ops/org/nd4j/codegen/ops/Image.kt - About 5 days to fix

                  Cognitive Complexity

                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                  A method's cognitive complexity is based on a few simple rules:

                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                  • Code is considered more complex for each "break in the linear flow of the code"
                  • Code is considered more complex when "flow breaking structures are nested"

                  Further reading

                  File SDBaseOps.kt has 1949 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  /*
                   *  ******************************************************************************
                   *  *
                   *  *
                   *  * This program and the accompanying materials are made available under the
                  Severity: Major
                  Found in codegen/op-codegen/src/main/ops/org/nd4j/codegen/ops/SDBaseOps.kt - About 5 days to fix

                    File BaseDataBuffer.java has 1929 lines of code (exceeds 250 allowed). Consider refactoring.
                    Open

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

                      Method SDLoss has a Cognitive Complexity of 267 (exceeds 20 allowed). Consider refactoring.
                      Open

                      fun SDLoss() =  Namespace("Loss"){
                      
                          Op("absoluteDifference") {
                              javaPackage = "org.nd4j.linalg.api.ops.impl.loss"
                              javaOpClass = "AbsoluteDifferenceLoss"
                      Severity: Minor
                      Found in codegen/op-codegen/src/main/ops/org/nd4j/codegen/ops/SDLoss.kt - About 5 days to fix

                      Cognitive Complexity

                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                      A method's cognitive complexity is based on a few simple rules:

                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                      • Code is considered more complex for each "break in the linear flow of the code"
                      • Code is considered more complex when "flow breaking structures are nested"

                      Further reading

                      File SDBaseOps.java has 1790 lines of code (exceeds 250 allowed). Consider refactoring.
                      Open

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

                        Method output has a Cognitive Complexity of 227 (exceeds 5 allowed). Consider refactoring.
                        Open

                            public ExecutionResult output(@NonNull List<String> variables,
                                    Map<String, T> placeholderValues,
                                    Map<String, SDValue> otherPlaceHolderValues,
                                    MultiDataSet batch,
                                    Collection<String> requiredActivations,

                        Cognitive Complexity

                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                        A method's cognitive complexity is based on a few simple rules:

                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                        • Code is considered more complex for each "break in the linear flow of the code"
                        • Code is considered more complex when "flow breaking structures are nested"

                        Further reading

                        Method SDRNN has a Cognitive Complexity of 240 (exceeds 20 allowed). Consider refactoring.
                        Open

                        fun SDRNN() = Namespace("RNN") {
                        
                        
                            val LSTMConfiguration = Config("LSTMConfiguration") {
                        
                        
                        Severity: Minor
                        Found in codegen/op-codegen/src/main/ops/org/nd4j/codegen/ops/RNN.kt - About 4 days to fix

                        Cognitive Complexity

                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                        A method's cognitive complexity is based on a few simple rules:

                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                        • Code is considered more complex for each "break in the linear flow of the code"
                        • Code is considered more complex when "flow breaking structures are nested"

                        Further reading

                        File StaticInfoDecoder.java has 1703 lines of code (exceeds 250 allowed). Consider refactoring.
                        Open

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

                          Shape has 229 methods (exceeds 20 allowed). Consider refactoring.
                          Open

                          public class Shape {
                          
                          
                              private Shape() {}
                          
                          

                            Method importGraph has a Cognitive Complexity of 224 (exceeds 5 allowed). Consider refactoring.
                            Open

                                public static SameDiff importGraph(@NonNull GraphDef tfGraph, Map<String, TFImportOverride> importOverride, TFOpImportFilter opFilter) {
                            
                                    /*
                                    First, build an in-memory representation of the graph that allows us to build the graph incrementally
                                    If we can build the graph incrementally, we can make sure that the added variables are set up with the correct

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            File CudaExecutioner.java has 1612 lines of code (exceeds 250 allowed). Consider refactoring.
                            Open

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

                              Method Linalg has a Cognitive Complexity of 226 (exceeds 20 allowed). Consider refactoring.
                              Open

                              fun Linalg() =  Namespace("Linalg") {
                                  //val namespaceJavaPackage = "org.nd4j.linalg"
                              
                                  Op("Cholesky") {
                                      javaPackage = "org.nd4j.linalg.api.ops.impl.transforms"
                              Severity: Minor
                              Found in codegen/op-codegen/src/main/ops/org/nd4j/codegen/ops/Linalg.kt - About 4 days to fix

                              Cognitive Complexity

                              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                              A method's cognitive complexity is based on a few simple rules:

                              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                              • Code is considered more complex for each "break in the linear flow of the code"
                              • Code is considered more complex when "flow breaking structures are nested"

                              Further reading

                              Severity
                              Category
                              Status
                              Source
                              Language