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"
- Read upRead up
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
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"
- Read upRead up
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,
- Read upRead up
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") {
- Read upRead up
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
- Read upRead up
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"
- Read upRead up
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"