people/a/AlammarJay/js/nn_calc.js

Summary

Maintainability
F
3 wks
Test Coverage

File nn_calc.js has 1464 lines of code (exceeds 250 allowed). Consider refactoring.
Open

(function (global, factory) {
  typeof exports === "object" && typeof module !== "undefined" ? factory() :
    typeof define === "function" && define.amd ? define(factory) :
      (factory())
}(this, (function () {
Severity: Major
Found in people/a/AlammarJay/js/nn_calc.js - About 3 days to fix

    Function draw has 89 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        draw: function (layer, properties, activeRegionSVGGroup, layerInputs, tooltipDiv) {
          console.log("layer", layer)
          var data = layer.nodeRenderingDetails,
            containerElement = properties.containerElement
    
    
    Severity: Major
    Found in people/a/AlammarJay/js/nn_calc.js - About 3 hrs to fix

      Function graphNode has 82 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        function graphNode(data) {
      
          var grapher = this
          // JOIN
          var inputGroups = this.neuralNetworkG.selectAll(this.svgElement + " .output-group")
      Severity: Major
      Found in people/a/AlammarJay/js/nn_calc.js - About 3 hrs to fix

        Function graphSoftmax has 82 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          function graphSoftmax(data) {
        
            var softmax = this.neuralNetworkG.selectAll(this.svgElement + " .softmax")
              .data([data])
        
        
        Severity: Major
        Found in people/a/AlammarJay/js/nn_calc.js - About 3 hrs to fix

          Function graphWeightNodes has 81 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

            function graphWeightNodes(data) {
              var radius = this.nodeRadius * this.weightNodeSizeScale
              var grapher = this
              var t = d3.transition()
                .duration(750)
          Severity: Major
          Found in people/a/AlammarJay/js/nn_calc.js - About 3 hrs to fix

            Function graphSigmoid has 79 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

              function graphSigmoid(data) {
            
                var sigmoid = this.neuralNetworkG.selectAll(this.svgElement + " .sigmoid")
                  .data([data])
            
            
            Severity: Major
            Found in people/a/AlammarJay/js/nn_calc.js - About 3 hrs to fix

              Function graphSoftmaxToOutputArrows has 73 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                function graphSoftmaxToOutputArrows(data) {
              
                  var inputToBiasLines = this.neuralNetworkG.selectAll(this.svgElement + " .softmax-to-output-line")
                    .data(data)
              
              
              Severity: Major
              Found in people/a/AlammarJay/js/nn_calc.js - About 2 hrs to fix

                Function draw has 69 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    draw: function (layer, properties, activeRegionSVGGroup) {
                      var data = layer.nodeRenderingDetails,
                        containerElement = properties.containerElement
                      var inputGroups = activeRegionSVGGroup.selectAll(properties.containerElement + " .input-group")
                        .data(data)
                Severity: Major
                Found in people/a/AlammarJay/js/nn_calc.js - About 2 hrs to fix

                  Function graphInputNodes has 68 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    function graphInputNodes(data) {
                  
                      var grapher = this
                      // JOIN
                      var inputGroups = this.neuralNetworkG.selectAll(this.svgElement + " .input-group")
                  Severity: Major
                  Found in people/a/AlammarJay/js/nn_calc.js - About 2 hrs to fix

                    Function initializeTable has 51 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                      neuralNetworkCalculationViz.prototype.initializeTable = function (trainingSet) {
                    
                    
                        var viz = this
                        var table = d3.select(this.tableElement)
                    Severity: Major
                    Found in people/a/AlammarJay/js/nn_calc.js - About 2 hrs to fix

                      Function graphLayerInputs has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                        function graphLayerInputs(layerInputsArray, layerNumber) {
                      
                      
                          var layerInputs = layerInputsArray[layerNumber], layerInputsObjects = []
                      
                      
                      Severity: Minor
                      Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                        Function neuralNetworkCalculationViz has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                          var neuralNetworkCalculationViz = function (inputs, inputNodeCount, outputNodeCount, activation, containerElement, weights, biases, tableElement,
                                                                      trainingSet, classes) {
                        
                        
                            this.properties = {
                        Severity: Minor
                        Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                          Function graphInputToBiasLines has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                            function graphInputToBiasLines(data) {
                          
                              var inputToBiasLines = this.neuralNetworkG.selectAll(this.svgElement + " .input-to-bias-line")
                                .data(data)
                          
                          
                          Severity: Minor
                          Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                            Function activate has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                var activate = function (d) {
                                  if (viz.layerValues[1]) {
                                    // Set up the tooltip to show the inputs and their sum
                                    var rows = "<table class=\"softmax-calculation\">", total = 0
                                    rows = rows + "<tr>" +
                            Severity: Minor
                            Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                              Function getWeightNodeCoordinates has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                function getWeightNodeCoordinates(inputLayerNodeCount,
                                                                  inputNodeCount, outputNodeCount,
                                                                  inputLayerCoordinates, weightLayerXCoordinates,
                                                                  outputLayerCoordinates,
                                                                  biasLayerX, inputLayerX) {
                              Severity: Minor
                              Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                                Function graphBiasToSoftmaxArrows has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                  function graphBiasToSoftmaxArrows(data) {
                                
                                    var inputToBiasLines = this.neuralNetworkG.selectAll(this.svgElement + " .bias-to-softmax-line")
                                      .data(data)
                                
                                
                                Severity: Minor
                                Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                                  Function graphSoftmaxOutputs has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                    function graphSoftmaxOutputs(softmaxOutputs) {
                                      var grapher = this
                                      var data = []
                                      for (var i = 0; i < this.softmaxOutputs.length; i++) {
                                        data.push({
                                  Severity: Minor
                                  Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                                    Function drawGraphOld has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                      neuralNetworkCalculationViz.prototype.drawGraphOld = function () {
                                    
                                        var grapher = this
                                        // Let's calculate our coordinates for all the nodes
                                        // Let's start with the X coordiantes for each layer
                                    Severity: Minor
                                    Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                                      Function activate has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                          var activate = function (d) {
                                            console.log("INSIDE", viz.layerValues[1])
                                            if (viz.layerValues[1]) {
                                              // Set up the tooltip to show the inputs and their sum
                                              var rows = "<table class=\"softmax-calculation\">", total = 0,
                                      Severity: Minor
                                      Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                                        Function draw has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                                        Open

                                            draw: function (layer, properties, activeRegionSVGGroup) {
                                        
                                              // JOIN
                                              // Each node has an SVG group of its own. In that group is an SVG circle and SVG text label
                                              var nodeGroups = activeRegionSVGGroup.selectAll(properties.containerElement + " .layer-" + layer.index)
                                        Severity: Minor
                                        Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                                          Function neuralNetworkCalculationViz has 10 arguments (exceeds 4 allowed). Consider refactoring.
                                          Open

                                            var neuralNetworkCalculationViz = function (inputs, inputNodeCount, outputNodeCount, activation, containerElement, weights, biases, tableElement,
                                                                                        trainingSet, classes) {
                                          Severity: Major
                                          Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                                            Function getWeightNodeCoordinates has 8 arguments (exceeds 4 allowed). Consider refactoring.
                                            Open

                                              function getWeightNodeCoordinates(inputLayerNodeCount,
                                                                                inputNodeCount, outputNodeCount,
                                                                                inputLayerCoordinates, weightLayerXCoordinates,
                                                                                outputLayerCoordinates,
                                                                                biasLayerX, inputLayerX) {
                                            Severity: Major
                                            Found in people/a/AlammarJay/js/nn_calc.js - About 1 hr to fix

                                              Function getSoftmaxtoOutputLinesData has 6 arguments (exceeds 4 allowed). Consider refactoring.
                                              Open

                                                function getSoftmaxtoOutputLinesData(outputNodeCount, activationLayerX, nodeRadius, outputLayerCoordinates,
                                                                                     outputLayerX, classes) {
                                              Severity: Minor
                                              Found in people/a/AlammarJay/js/nn_calc.js - About 45 mins to fix

                                                Function draw has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                Open

                                                    draw: function (layer, properties, activeRegionSVGGroup, layerInputs, tooltipDiv) {
                                                Severity: Minor
                                                Found in people/a/AlammarJay/js/nn_calc.js - About 35 mins to fix

                                                  Function getLayerXScale has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                  Open

                                                    function getLayerXScale(numberOfLayers, layersRegionWidth, outputRegionWidth, marginLeft, nodeRadius) {
                                                  Severity: Minor
                                                  Found in people/a/AlammarJay/js/nn_calc.js - About 35 mins to fix

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                      function graphBiasToSoftmaxArrows(data) {
                                                    
                                                        var inputToBiasLines = this.neuralNetworkG.selectAll(this.svgElement + " .bias-to-softmax-line")
                                                          .data(data)
                                                    
                                                    
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 day to fix
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 429..472

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 267.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                      softmax = function (input) {
                                                    
                                                        if (!(input instanceof Array))
                                                          throw (TypeError("Input passed into softmax() is not an array. softmax() expects an array. Input: " + input, "nnVizUtils.js"))
                                                    
                                                    
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 7 hrs to fix
                                                    people/a/AlammarJay/js/nnVizUtils.js on lines 71..90

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 190.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        this.neuralNetworkMargin = {top: 10, right: 10, bottom: 10, left: 10},
                                                          this.neuralNetworkWidth = +this.nnGraphHolder.attr("width") - this.neuralNetworkMargin.left - this.neuralNetworkMargin.right,
                                                          this.neuralNetworkHeight = +this.nnGraphHolder.attr("height") - this.neuralNetworkMargin.top - this.neuralNetworkMargin.bottom,
                                                          this.neuralNetworkG = this.nnGraphHolder.append("g")
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 5 hrs to fix
                                                    people/a/AlammarJay/js/simple_nn.js on lines 695..698

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 148.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                        var inputs = inputGroups.enter()
                                                          .append("g")
                                                          .attr("class", "input-group")
                                                          .attr("transform", function (d) {
                                                            return "translate(" +
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 5 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1249..1270
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1249..1284

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 146.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                          var inputs = inputGroups.enter()
                                                            .append("g")
                                                            .attr("class", "input-group")
                                                            .attr("transform", function (d) {
                                                              return "translate(" +
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 5 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 36..74
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1249..1284

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 146.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                          inputs.append("text")
                                                            .attr("id", "input-name")
                                                            .attr("class", "node-text")
                                                            .attr("text-anchor", "middle")
                                                            .attr("x", 0)
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 4 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 86..99

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 117.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        inputs.append("text")
                                                          .attr("id", "input-name")
                                                          .attr("class", "node-text")
                                                          .attr("text-anchor", "middle")
                                                          .attr("x", 0)
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 4 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1296..1309

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 117.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        softmaxGroup
                                                          .append("rect")
                                                          .attr("class", "outlined-softmax-node nn-node")
                                                          .attr("width", this.nodeRadius * 1.5)
                                                          .attr("height", this.neuralNetworkHeight)
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 3 hrs to fix
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 529..537

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 112.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        var inputLayerX = this.neuralNetworkMargin.left + this.nodeRadius, // X value of input layer
                                                          biasLayerX = this.neuralNetworkWidth * 2 / 3 - 20, //
                                                          outputLayerX = this.neuralNetworkWidth - this.nodeRadius + this.neuralNetworkMargin.left,
                                                          activationLayerX = (outputLayerX + biasLayerX) / 2
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 2 hrs to fix
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 60..63

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 89.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                    Open

                                                        defs.append("marker")
                                                          .attrs({
                                                            "id": "arrow",
                                                            "viewBox": "0 -5 10 10",
                                                            "refX": 5,
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 4 other locations - About 2 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1737..1749
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 38..50
                                                    people/a/AlammarJay/js/simple_nn.js on lines 706..718
                                                    people/a/AlammarJay/js/two_variable_nn.js on lines 289..301

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 81.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 5 locations. Consider refactoring.
                                                    Open

                                                        defs.append("marker")
                                                          .attrs({
                                                            "id": "arrow",
                                                            "viewBox": "0 -5 10 10",
                                                            "refX": 5,
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 4 other locations - About 2 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1703..1715
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 38..50
                                                    people/a/AlammarJay/js/simple_nn.js on lines 706..718
                                                    people/a/AlammarJay/js/two_variable_nn.js on lines 289..301

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 81.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                        var inputs = inputGroups.enter()
                                                          .append("g")
                                                          .attr("class", "output-group")
                                                          .attr("transform", function (d) {
                                                            return "translate(" +
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 2 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 36..58
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1249..1270

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 80.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        softmaxOutputGroups.select("text")
                                                          .attr("class", function (d) {
                                                            if (d.value == maxValueIndex)
                                                              return "highlighted-softmax-output"
                                                            else
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 2 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 696..706

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 79.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                          var nodes = nodeGroups.enter()
                                                            .append("g")
                                                            .attr("class", "layer-" + layer.index + " layer-group")
                                                            .attr("transform", function (d) {
                                                              return "translate(" +
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 2 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1442..1450

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 79.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                          var inputs = nodeGroups.enter()
                                                            .append("g")
                                                            .attr("class", ".layer-" + layer.index + " layer-group")
                                                            .attr("transform", function (d) {
                                                              return "translate(" +
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 2 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1357..1365

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 79.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        softmaxOutputElements.append("text")
                                                          .attr("class", function (d) {
                                                            if (d.value == maxValueIndex)
                                                              return "highlighted-softmax-output"
                                                            else
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 2 hrs to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 674..684

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 79.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        softmaxGroup.append("text")
                                                          .attr("id", "biasValue")
                                                          .attr("text-anchor", "middle")
                                                          .attr("x", this.neuralNetworkHeight / 2)
                                                          .attr("y", -2)
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 539..545

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 74.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        var sigmoidGroup = sigmoid.enter()
                                                          .append("g")
                                                          .attr("class", "sigmoid activation")
                                                          .attr("transform", function (d) {
                                                            return "translate(" +
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 522..527

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 73.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        var outputLayerCoordinates = d3.range(outputNodeCount).map(function (i) {
                                                          var y = getYCoordinateOfNodeInOutputLayer(i)
                                                          return { x: biasLayerX, y: y, index: i, type: 'input' }
                                                        }.bind(this))
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 118..121

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 71.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        var inputLayerCoordinates = d3.range(inputNodeCount).map(function (i) {
                                                          var y = getYCoordinateOfNodeInInputLayer(i)
                                                          return { x: inputLayerX, y: y, index: i, type: 'input' }
                                                        }.bind(this))
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 453..456

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 71.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        this.nnGraphHolder = d3.select(this.svgElement) // select the 'body' element
                                                          .append("svg")           // append an SVG element to the body
                                                          .attr("width", this.graphWidth)      // make the SVG element 449 pixels wide
                                                          .attr("height", this.graphHeight)    // make the SVG element 249 pixels high
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/simple_nn.js on lines 189..192

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 71.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                    Open

                                                          inputGroups.attr("class", "input-group")
                                                            .attr("transform", function (d) {
                                                              return "translate(" +
                                                                (d.x)
                                                                + ","
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 4 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 21..27
                                                    people/a/AlammarJay/js/nn_calc.js on lines 322..328
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 181..184
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 333..336

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 64.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                    Open

                                                        inputGroups.attr("class", "input-group")
                                                          .attr("transform", function (d) {
                                                            return "translate(" +
                                                              (d.x)
                                                              + ","
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 4 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 322..328
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1234..1240
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 181..184
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 333..336

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 64.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 5 locations. Consider refactoring.
                                                    Open

                                                        inputGroups.attr("class", "output-group")
                                                          .attr("transform", function (d) {
                                                            return "translate(" +
                                                              (d.x)
                                                              + ","
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 4 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 21..27
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1234..1240
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 181..184
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 333..336

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 64.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        var inputLayerCoordinates = d3.range(inputNodeCount).map(function (i) {
                                                          var y = getYCoordinateOfNodeInInputLayer(i)
                                                          return { x: inputLayerX, y: y, index: i, type: 'input' }
                                                        })
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1556..1559

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 63.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        var nodeLayerCoordinates = d3.range(nodeCount).map(function (i) {
                                                          var y = getYCoordinateOfNodeLayer(i)
                                                          return { x: layerXCoordinate, y: y, index: i, type: 'input' }
                                                        })
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1318..1321

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 63.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            viz.tooltipDiv.html(html)
                                                              .style("left", (d3.event.pageX - 250) + "px")
                                                              .style("top", (d3.event.pageY) + "px")
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 816..818

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 61.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            viz.tooltipDiv.html(rows)
                                                              .style("left", (d3.event.pageX - 250) + "px")
                                                              .style("top", (d3.event.pageY) + "px")
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 826..828

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 61.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                        groups
                                                          .append("ellipse")
                                                          .attr("class", function (d) {
                                                            if (d.type == "weight") return "outlined-weight-node nn-node"
                                                            else if (d.type == "bias") return "outlined-bias-node nn-node"
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 76..82
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1286..1292

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 60.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                        inputs
                                                          .append("circle")
                                                          .attr("class", function (d) {
                                                            if (d.type == "input") return "outlined-input-node nn-node"
                                                            else if (d.type == "bias") return "outlined-bias-node nn-node"
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 227..233
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1286..1292

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 60.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                          inputs
                                                            .append("circle")
                                                            .attr("class", function (d) {
                                                              if (d.type == "input") return "outlined-input-node nn-node"
                                                              else if (d.type == "bias") return "outlined-bias-node nn-node"
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 76..82
                                                    people/a/AlammarJay/js/nn_calc.js on lines 227..233

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 60.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        groupElements.select("#weight0Value")
                                                          .text(function (d) {
                                                            return "W" + (d.outputIndex + 1) + "," + (d.inputIndex + 1)
                                                          })
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 240..243

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 58.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                            grapher.tooltipDiv.html(rows)
                                                              .style("left", (d3.event.pageX) + "px")
                                                              .style("top", (d3.event.pageY) + "px")
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 606..608
                                                    people/a/AlammarJay/js/nn_calc.js on lines 615..617

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 57.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                            viz.tooltipDiv.html(html)
                                                              .style("left", (d3.event.pageX) + "px")
                                                              .style("top", (d3.event.pageY) + "px")
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 391..393
                                                    people/a/AlammarJay/js/nn_calc.js on lines 606..608

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 57.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                            viz.tooltipDiv.html(rows)
                                                              .style("left", (d3.event.pageX) + "px")
                                                              .style("top", (d3.event.pageY) + "px")
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 391..393
                                                    people/a/AlammarJay/js/nn_calc.js on lines 615..617

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 57.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                          inputs.append("text")
                                                            .attr("id", "output-name")
                                                            .attr("class", "node-text")
                                                            .attr("text-anchor", "middle")
                                                            .attr("x", 0)
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 429..434

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 55.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        inputs.append("text")
                                                          .attr("id", "output-name")
                                                          .attr("class", "node-text")
                                                          .attr("text-anchor", "middle")
                                                          .attr("x", 0)
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 1 hr to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1541..1546

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 55.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        sigmoidOutputGroups.select("text")
                                                          .attr("class", "sigmoid-output")
                                                          .text(function (d) {
                                                            return numberFormatter(d.value * 100, 2) + "%"
                                                          })
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 55 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 893..897

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 54.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        sigmoidOutputElements.append("text")
                                                          .attr("class", "sigmoid-output")
                                                          .text(function (d) {
                                                            return numberFormatter(d.value * 100, 2) + "%"
                                                          })
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 55 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 878..882

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 54.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            var sum_term = viz.layerValues[1].map(function (d) {
                                                              return 'e^{' + numberFormatter(d, 2) + '}'
                                                            }).join(" + ")
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 55 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 795..797

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 53.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            var sum_term = viz.layerValues[1].map(function (d) {
                                                              return 'e^{' + numberFormatter(d, 2) + '}'
                                                            }).join(" + ")
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 55 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 582..584

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 53.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 3 locations. Consider refactoring.
                                                    Open

                                                        inputs
                                                          .append("circle")
                                                          .attr("class", "outlined-output-node nn-node")
                                                          .attr("r", this.nodeRadius)
                                                          .attr("cx", 0)
                                                    Severity: Major
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 2 other locations - About 50 mins to fix
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 199..204
                                                    people/a/AlammarJay/js/shallow_nn_grapher.js on lines 351..356

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 51.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        this.neuralNetworkWidth = +nnGraphHolder.attr("width") - this.properties.margins.left -
                                                          this.properties.margins.right,
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 50 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1694..1695

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 51.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            transform: function (d) {
                                                              return "translate(" + (grapher.softmaxOutputsX - 8) + ", " + (grapher.getYCoordinateOfNodeInOutputLayer(d.index) + 5) + ")"
                                                            }
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 50 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 690..692

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 51.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                          this.neuralNetworkHeight = +nnGraphHolder.attr("height") - this.properties.margins.top -
                                                            this.properties.margins.bottom,
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 50 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1692..1693

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 51.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Similar blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            transform: function (d) {
                                                              return "translate(" + (grapher.softmaxOutputsX - 8) + ", " + (grapher.getYCoordinateOfNodeInOutputLayer(d.index) + 5) + ")"
                                                            }
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 50 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 888..890

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 51.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                            var matrix = this.getScreenCTM()
                                                              .translate(+this.getAttribute("cx"), +this.getAttribute("cy"))
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 35 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 1489..1490

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 47.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                                  var matrix = this.getScreenCTM()
                                                                    .translate(+this.getAttribute("cx"), +this.getAttribute("cy"))
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 35 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 382..383

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 47.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        var deactivate = function (d) {
                                                          viz.tooltipDiv.transition()
                                                            .duration(200)
                                                            .style("opacity", 0)
                                                        }
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 35 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 622..626

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 46.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    Identical blocks of code found in 2 locations. Consider refactoring.
                                                    Open

                                                        var deactivate = function (d) {
                                                          viz.tooltipDiv.transition()
                                                            .duration(200)
                                                            .style("opacity", 0)
                                                        }
                                                    Severity: Minor
                                                    Found in people/a/AlammarJay/js/nn_calc.js and 1 other location - About 35 mins to fix
                                                    people/a/AlammarJay/js/nn_calc.js on lines 833..837

                                                    Duplicated Code

                                                    Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                    Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                    When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                    Tuning

                                                    This issue has a mass of 46.

                                                    We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                    The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                    If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                    See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                    Refactorings

                                                    Further Reading

                                                    There are no issues that match your filters.

                                                    Category
                                                    Status