Sign upLogin

q-optimize/c3

View on GitHub
Star
c3/libraries/algorithms.py

Summary

Maintainability
F
4 days
Test Coverage

File algorithms.py has 561 lines of code (exceeds 250 allowed). Consider refactoring.
Open

"""
Collection of (optimization) algorithms. All entries share a common signature with
optional arguments.
"""
Severity: Major
Found in c3/libraries/algorithms.py - About 1 day to fix

    Function cmaes has a Cognitive Complexity of 39 (exceeds 5 allowed). Consider refactoring.
    Open

    def cmaes(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    Wrapper for the pycma implementation of CMA-Es. See also:

    http://cma.gforge.inria.fr/apidocs-pycma/
    Severity: Minor
    Found in c3/libraries/algorithms.py - About 5 hrs to fix

    Cognitive Complexity

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

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

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

    Further reading

    Cyclomatic complexity is too high in function cmaes. (21)
    Open

    @algo_reg_deco
def cmaes(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    Wrapper for the pycma implementation of CMA-Es. See also:
    Severity: Minor
    Found in c3/libraries/algorithms.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function gcmaes has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
    Open

    def gcmaes(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    EXPERIMENTAL CMA-Es where every point in the cloud is optimized with LBFG-S and the
    resulting cloud and results are used for the CMA update.
    """
    Severity: Minor
    Found in c3/libraries/algorithms.py - About 3 hrs to fix

    Cognitive Complexity

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

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

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

    Further reading

    Cyclomatic complexity is too high in function gcmaes. (15)
    Open

    @algo_reg_deco
def gcmaes(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    EXPERIMENTAL CMA-Es where every point in the cloud is optimized with LBFG-S and the
    resulting cloud and results are used for the CMA update.
    Severity: Minor
    Found in c3/libraries/algorithms.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in function sweep. (10)
    Open

    @algo_reg_deco
def sweep(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    One dimensional scan of the function values around the initial point.
    Severity: Minor
    Found in c3/libraries/algorithms.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function sweep has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
    Open

    def sweep(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    One dimensional scan of the function values around the initial point.

    Parameters
    Severity: Minor
    Found in c3/libraries/algorithms.py - About 2 hrs to fix

    Cognitive Complexity

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

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

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

    Further reading

    Cyclomatic complexity is too high in function adaptive_scan. (8)
    Open

    @algo_reg_deco
def adaptive_scan(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    One dimensional scan of the function values around the initial point, using
    adaptive sampling
    Severity: Minor
    Found in c3/libraries/algorithms.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Cyclomatic complexity is too high in function cma_pre_lbfgs. (8)
    Open

    @algo_reg_deco
def cma_pre_lbfgs(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    Performs a CMA-Es optimization and feeds the result into LBFG-S for further
    refinement.
    Severity: Minor
    Found in c3/libraries/algorithms.py by radon

    Cyclomatic Complexity

    Cyclomatic Complexity corresponds to the number of decisions a block of code contains plus 1. This number (also called McCabe number) is equal to the number of linearly independent paths through the code. This number can be used as a guide when testing conditional logic in blocks.

    Radon analyzes the AST tree of a Python program to compute Cyclomatic Complexity. Statements have the following effects on Cyclomatic Complexity:

    Construct Effect on CC Reasoning
    if +1 An if statement is a single decision.
    elif +1 The elif statement adds another decision.
    else +0 The else statement does not cause a new decision. The decision is at the if.
    for +1 There is a decision at the start of the loop.
    while +1 There is a decision at the while statement.
    except +1 Each except branch adds a new conditional path of execution.
    finally +0 The finally block is unconditionally executed.
    with +1 The with statement roughly corresponds to a try/except block (see PEP 343 for details).
    assert +1 The assert statement internally roughly equals a conditional statement.
    Comprehension +1 A list/set/dict comprehension of generator expression is equivalent to a for loop.
    Boolean Operator +1 Every boolean operator (and, or) adds a decision point.

    Source: http://radon.readthedocs.org/en/latest/intro.html

    Function cma_pre_lbfgs has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
    Open

    def cma_pre_lbfgs(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    Performs a CMA-Es optimization and feeds the result into LBFG-S for further
    refinement.
    Severity: Minor
    Found in c3/libraries/algorithms.py - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

    Function adaptive_scan has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    def adaptive_scan(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    One dimensional scan of the function values around the initial point, using
    adaptive sampling
    Severity: Minor
    Found in c3/libraries/algorithms.py - About 1 hr to fix

    Cognitive Complexity

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

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

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

    Further reading

    Function grid2D has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
    Open

    def grid2D(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    """
    Two dimensional scan of the function values around the initial point.

    Parameters
    Severity: Minor
    Found in c3/libraries/algorithms.py - About 55 mins to fix

    Cognitive Complexity

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

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

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

    Further reading

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

    def adaptive_scan(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
    Severity: Minor
    Found in c3/libraries/algorithms.py - About 35 mins to fix

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

      def gcmaes(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
      Severity: Minor
      Found in c3/libraries/algorithms.py - About 35 mins to fix

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

        def tf_adadelta(
        Severity: Minor
        Found in c3/libraries/algorithms.py - About 35 mins to fix

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

          def tf_rmsprop(
          Severity: Minor
          Found in c3/libraries/algorithms.py - About 35 mins to fix

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

            def cmaes(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
            Severity: Minor
            Found in c3/libraries/algorithms.py - About 35 mins to fix

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

              def tf_sgd(
              Severity: Minor
              Found in c3/libraries/algorithms.py - About 35 mins to fix

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

                def tf_adam(
                Severity: Minor
                Found in c3/libraries/algorithms.py - About 35 mins to fix

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

                  def grid2D(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                  Severity: Minor
                  Found in c3/libraries/algorithms.py - About 35 mins to fix

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

                    def cma_pre_lbfgs(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                    Severity: Minor
                    Found in c3/libraries/algorithms.py - About 35 mins to fix

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

                      def single_eval(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                      Severity: Minor
                      Found in c3/libraries/algorithms.py - About 35 mins to fix

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

                        def sweep(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                        Severity: Minor
                        Found in c3/libraries/algorithms.py - About 35 mins to fix

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

                          def lbfgs(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                          Severity: Minor
                          Found in c3/libraries/algorithms.py - About 35 mins to fix

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

                            def lbfgs_grad_free(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                            Severity: Minor
                            Found in c3/libraries/algorithms.py - About 35 mins to fix

                              Refactor this function to reduce its Cognitive Complexity from 26 to the 15 allowed.
                              Open

                              def gcmaes(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                              Severity: Critical
                              Found in c3/libraries/algorithms.py by sonar-python

                              Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                              See

                              Refactor this function to reduce its Cognitive Complexity from 39 to the 15 allowed.
                              Open

                              def cmaes(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                              Severity: Critical
                              Found in c3/libraries/algorithms.py by sonar-python

                              Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                              See

                              Refactor this function to reduce its Cognitive Complexity from 18 to the 15 allowed.
                              Open

                              def sweep(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                              Severity: Critical
                              Found in c3/libraries/algorithms.py by sonar-python

                              Cognitive Complexity is a measure of how hard the control flow of a function is to understand. Functions with high Cognitive Complexity will be difficult to maintain.

                              See

                              Merge this if statement with the enclosing one.
                              Open

                                              if all(
                              Severity: Major
                              Found in c3/libraries/algorithms.py by sonar-python

                              Merging collapsible if statements increases the code's readability.

                              Noncompliant Code Example

                              if condition1:
    if condition2:
        # ...

                              Compliant Solution

                              if condition1 and condition2:
    # ...

                              Merge this if statement with the enclosing one.
                              Open

                                          if es.sigma < stop_sigma:
                              Severity: Major
                              Found in c3/libraries/algorithms.py by sonar-python

                              Merging collapsible if statements increases the code's readability.

                              Noncompliant Code Example

                              if condition1:
    if condition2:
        # ...

                              Compliant Solution

                              if condition1 and condition2:
    # ...

                              Merge this if statement with the enclosing one.
                              Open

                                              if all(
                              Severity: Major
                              Found in c3/libraries/algorithms.py by sonar-python

                              Merging collapsible if statements increases the code's readability.

                              Noncompliant Code Example

                              if condition1:
    if condition2:
        # ...

                              Compliant Solution

                              if condition1 and condition2:
    # ...

                              Merge this if statement with the enclosing one.
                              Open

                                          if es.sigma < stop_sigma:
                              Severity: Major
                              Found in c3/libraries/algorithms.py by sonar-python

                              Merging collapsible if statements increases the code's readability.

                              Noncompliant Code Example

                              if condition1:
    if condition2:
        # ...

                              Compliant Solution

                              if condition1 and condition2:
    # ...

                              Rename function "grid2D" to match the regular expression ^[a-z_][a-z0-9_]{2,}$.
                              Invalid

                              def grid2D(x_init, fun=None, fun_grad=None, grad_lookup=None, options={}):
                              Severity: Major
                              Found in c3/libraries/algorithms.py by sonar-python

                              Shared coding conventions allow teams to collaborate efficiently. This rule checks that all function names match a provided regular expression.

                              Noncompliant Code Example

                              With the default provided regular expression: ^[a-z_][a-z0-9_]{2,30}$

                              def MyFunction(a,b):
    ...

                              Compliant Solution

                              def my_function(a,b):
    ...

                              There are no issues that match your filters.

                              Category
                              Status